feat: typed prisma.compute.ts compute config

Adds a typed, committed deploy configuration for Prisma Compute and makes
the whole app command surface config-aware.

Config:
- prisma.compute.ts (.mts/.js/.mjs/.cjs) with defineComputeConfig from the
  new @prisma/cli/config export; single `app` or multi-target `apps` with
  name, root, framework, entry, httpPort, env, and build per app
- compile-time safety (literal unions, app/apps exclusivity, typo
  suggestions) plus runtime validation reporting every issue at once
- loaded via jiti with an alias so configs resolve @prisma/cli/config even
  when the package is not installed locally

Resolution:
- upward discovery from cwd to the source root (.git/workspace markers);
  nearest config wins and discovery never escapes the repository
- the config directory is the project directory: local pin, state cache,
  and the --db schema scan anchor there; config-relative paths (root,
  env.file) resolve from the config file
- target inference: commands run inside a target's root select it
- app selection precedence: --app > PRISMA_APP_ID > config target >
  remembered selection > inference

Command surface:
- app deploy/build/run and every management command (show, open, logs,
  list-deploys, promote, rollback, remove, domain *) accept an [app]
  target argument
- bare app deploy with a multi-app config deploys every target in
  declaration order, fail-fast with already-live/not-attempted reporting;
  per-app flags are rejected in deploy-all
- run/build share deploy's framework detection (one detection, three
  commands), driven by a framework capability registry that replaces
  scattered framework literals

Build settings:
- the config build block owns build settings; otherwise they are inferred
  with sources shown; prisma.app.json is no longer read or written -
  leftover matching files warn, customized files fail with
  BUILD_SETTINGS_MIGRATION_REQUIRED including the exact build block
- workspace builds: package-manager detection walks up to the workspace
  root, ancestor node_modules/.bin dirs join the build PATH, and Next.js
  standalone staging flattens bun's isolated store alongside pnpm's

Database (--db flag flow, no config surface in this PR):
- provision-only: deploy creates the branch database and wires
  DATABASE_URL/DIRECT_URL but never runs schema, migration, or generate
  commands; it suggests the detected command and a one-time connection URL
  via database connection create instead

Packaging:
- exports map with ./config (+ d.ts), jiti dependency, publish-prep now
  carries exports into the published manifest

Spec updated across command-spec, resource-model, output- and
error-conventions. 462 tests.

Author: AmanVarshney01

docs/product/command-spec.md

@@ -223,7 +223,8 @@ Recommended meanings:
 - `LOCAL_STATE_WRITE_FAILED`: the CLI could not save local Project binding state such as `.prisma/local.json` or the matching `.gitignore` entry; callers should fix directory permissions or filesystem state before retrying
 - `LOCAL_STATE_STALE`: local Project pin no longer matches platform data and continuing would be ambiguous
 - `BRANCH_NOT_DEPLOYABLE`: command tried to deploy to a non-deployable branch context
-- `APP_CONFIG_INVALID`: `prisma.app.json` is missing required build settings, has invalid JSON, or points outside the app root
+- `COMPUTE_CONFIG_INVALID`: `prisma.compute.ts` failed to load or validate
+- `BUILD_SETTINGS_MIGRATION_REQUIRED`: a legacy `prisma.app.json` contains custom build settings that must move into the `build` block of `prisma.compute.ts`
 - `FRAMEWORK_NOT_DETECTED`: app deploy could not detect a supported Beta framework and no explicit framework/build type was provided
 - `DEPLOYMENT_NOT_FOUND`: requested deployment id does not exist
 - `NO_DEPLOYMENTS`: command resolved a branch or app but found no deployments

docs/product/error-conventions.md

@@ -338,7 +338,7 @@ Examples:
 - `app deploy` should state the resolved target that matters in the current slice
 - first local `app deploy` binding should make the Project choice explicit before work begins
 - subsequent `app deploy` calls should use a compact target header such as `Deploying ./j1 to j1 / main / j1`
-- config-backed `app deploy` builds should show whether they created or used `prisma.app.json` before build starts: `Build Command` with its source when inferred, and `Output Directory` as a literal path such as `.next/standalone` rather than an opaque framework default label
+- config-backed `app deploy` builds should show the resolved build settings before build starts: `Build Command` and `Output Directory` with their sources (`prisma.compute.ts` or inference), `Output Directory` as a literal path such as `.next/standalone` rather than an opaque framework default label
 - `app logs` should state the deployment it resolved
 - `app list-deploys` should state which app or branch is being listed
 

docs/product/output-conventions.md

@@ -38,7 +38,7 @@ Rules:
 - `project` is not the same thing as `app`
 - Public Beta does not read or write committed config files such as `prisma.config.ts` or `.prisma/settings.json` for project resolution
 - `.prisma/local.json` is a gitignored local pin/cache for Workspace and Project IDs; it is not a declarative repo config file
-- `prisma.app.json` is a committed app build-settings file only; it must not contain Workspace, Project, Branch, App, env, or secret resolution state
+- `prisma.compute.ts` is a committed deploy-defaults file; it must not contain Workspace, Project, Branch, env-secret, or credential resolution state
 - Project setup is explicit: users choose an existing Project or explicitly create a new one before remote work starts
 - `app deploy` may orchestrate Project setup, but it must not silently choose or create Project scope
 - everything under a project happens in a branch
@@ -104,7 +104,7 @@ Rules:
 - the runtime app service is scoped by branch in the platform model
 - the app may be selected or created as part of app deployment workflows
 - app selection is local CLI state when needed for the beta package
-- app build settings may live in `prisma.app.json` beside `package.json`; v1 fields are `buildCommand` and `outputDirectory`
+- app build settings live in the `build` block of `prisma.compute.ts` (`command`, `outputDirectory`); `prisma.app.json` is legacy and no longer read
 
 ### Deployment
 

docs/product/resource-model.md

@@ -6,6 +6,13 @@
   "bin": {
     "prisma-cli": "./dist/cli.js"
   },
+  "exports": {
+    "./config": {
+      "types": "./dist/config.d.ts",
+      "default": "./dist/config.js"
+    },
+    "./package.json": "./package.json"
+  },
   "files": [
     "dist",
     "README.md",
@@ -49,6 +56,7 @@
     "colorette": "^2.0.20",
     "commander": "^14.0.3",
     "dotenv": "^17.4.2",
+    "jiti": "^2.7.0",
     "magicast": "^0.5.3",
     "open": "^11.0.0",
     "string-width": "^8.2.1",

packages/cli/package.json

@@ -0,0 +1,67 @@
+/**
+ * Public typed config surface for `prisma.compute.ts`.
+ *
+ * This module is published as `@prisma/cli/config` and must stay free of
+ * runtime dependencies so user config files can import it cheaply.
+ */
+
+export const COMPUTE_FRAMEWORKS = ["nextjs", "hono", "tanstack-start", "bun"] as const;
+
+export type ComputeFramework = (typeof COMPUTE_FRAMEWORKS)[number];
+
+export interface ComputeEnvConfig {
+  /** Dotenv file path(s) resolved relative to the config file directory. */
+  file?: string | string[];
+  /** Inline environment variable assignments. Values are deployed as-is. */
+  vars?: Record<string, string>;
+}
+
+export interface ComputeBuildConfig {
+  /** Build command run in the app root. `null` skips the build step. */
+  command?: string | null;
+  /** Framework output path relative to the app root, e.g. ".next/standalone". */
+  outputDirectory?: string;
+}
+
+
+export interface ComputeAppConfig {
+  /** Deployed app name. Defaults to the `apps` key, then package/directory inference. */
+  name?: string;
+  /** App directory relative to the config file. Defaults to the config file directory. */
+  root?: string;
+  /** Framework to deploy. Defaults to detection from the app directory. */
+  framework?: ComputeFramework;
+  /** Entrypoint path for Bun (and Hono) deploys, relative to the app root. */
+  entry?: string;
+  /** HTTP port the deployed app listens on. Defaults to the framework default. */
+  httpPort?: number;
+  /** Environment variables for the deploy. A string is shorthand for `{ file }`. */
+  env?: string | ComputeEnvConfig;
+  /** Build settings. When present, these own the app's build configuration. */
+  build?: ComputeBuildConfig;
+}
+
+/**
+ * `prisma.compute.ts` accepts exactly one of:
+ *
+ * - `app` — a repository that deploys a single app
+ * - `apps` — a monorepo or multi-app repository, keyed by deploy target
+ */
+export type ComputeConfig =
+  | { app: ComputeAppConfig; apps?: never }
+  | { apps: Record<string, ComputeAppConfig>; app?: never };
+
+/**
+ * Identity helper that gives `prisma.compute.ts` full type checking:
+ *
+ * ```ts
+ * import { defineComputeConfig } from "@prisma/cli/config";
+ *
+ * export default defineComputeConfig({
+ *   app: { framework: "hono", httpPort: 8080 },
+ * });
+ * ```
+ */
+export function defineComputeConfig(config: ComputeConfig): ComputeConfig {
+  return config;
+}