@prisma-next/cli 0.5.0-dev.4 → 0.5.0-dev.40

package/README.md

@@ -951,12 +951,12 @@ prisma-next migration plan [--config <path>] [--name <slug>] [--from <hash>] [--
 2. Reads existing migrations from `config.migrations.dir` (default: `migrations/`)
 3. Determines the starting point: `--from <hash>` if provided, otherwise the latest migration target
 4. Diffs the starting contract against the new contract using the target's migration planner
-5. Scaffolds a new migration package: `migration.ts` (containing `placeholder(...)` lambdas for any data transforms), `migration.json` (with a content-addressed `migrationId` over the planned ops, or over `[]` when the planner could not lower any calls because of placeholders), `ops.json` (the planned ops, or `[]` in the placeholder-blocked case), and contract bookends. The package is **always** fully attested — there is no draft state on disk.
-6. If the plan has unfilled `placeholder(...)` slots, the command returns a successful `pendingPlaceholders` envelope (a warning, not a failure) asking the developer to fill in the slots before re-emitting. The on-disk `ops.json` is `[]` and `migrationId` is the hash of `(manifest, [])`, so applying the migration as-written will not advance the storage hash to the intended destination — the runner's destination-hash post-check surfaces this as a state mismatch. After filling in the placeholders, run `node migrations/<dir>/migration.ts` to re-emit `ops.json` and the corresponding `migrationId`. `PN-MIG-2001` is raised only at self-emit time when a slot is still unfilled.
+5. Scaffolds a new migration package: `migration.ts` (containing `placeholder(...)` lambdas for any data transforms), `migration.json` (with a content-addressed `migrationHash` over the planned ops, or over `[]` when the planner could not lower any calls because of placeholders), `ops.json` (the planned ops, or `[]` in the placeholder-blocked case), and contract bookends. The package is **always** fully attested — there is no draft state on disk.
+6. If the plan has unfilled `placeholder(...)` slots, the command returns a successful `pendingPlaceholders` envelope (a warning, not a failure) asking the developer to fill in the slots before re-emitting. The on-disk `ops.json` is `[]` and `migrationHash` is the hash of `(metadata, [])`, so applying the migration as-written will not advance the storage hash to the intended destination — the runner's destination-hash post-check surfaces this as a state mismatch. After filling in the placeholders, run `node migrations/<dir>/migration.ts` to re-emit `ops.json` and the corresponding `migrationHash`. `PN-MIG-2001` is raised only at self-emit time when a slot is still unfilled.
 
 **Outputs:**
 - `migrations/<dir>/migration.ts` — editable migration source (with `placeholder(...)` slots when the planner inserted them)
-- `migrations/<dir>/migration.json` — fully attested manifest (`migrationId: string`, never null)
+- `migrations/<dir>/migration.json` — fully attested metadata (`migrationHash: string`, never null)
 - `migrations/<dir>/ops.json` — planned operations (empty list `[]` if placeholders blocked the planner)
 - `migrations/<dir>/start-contract.{json,d.ts}` — bookend from the "from" side (when applicable)
 - `migrations/<dir>/end-contract.{json,d.ts}` — bookend from the "to" side
@@ -965,14 +965,14 @@ prisma-next migration plan [--config <path>] [--name <slug>] [--from <hash>] [--
 
 ### `prisma-next migration show`
 
-Display a migration package's operations, DDL preview, and metadata. Accepts a directory path, a hash prefix (git-style matching against `migrationId`), or defaults to the latest migration.
+Display a migration package's operations, DDL preview, and metadata. Accepts a directory path, a hash prefix (git-style matching against `migrationHash`), or defaults to the latest migration.
 
 ```bash
 prisma-next migration show [target] [--config <path>] [--json] [-v] [-q] [--color/--no-color]
 ```
 
 **Options:**
-- `[target]`: Migration directory path or migrationId hash prefix (defaults to latest)
+- `[target]`: Migration directory path or `migrationHash` prefix (defaults to latest)
 - `--config <path>`: Path to `prisma-next.config.ts`
 - `--json`: Output as JSON object
 - `-q, --quiet`: Quiet mode (errors only)
@@ -980,7 +980,7 @@ prisma-next migration show [target] [--config <path>] [--json] [-v] [-q] [--colo
 
 **What it does:**
 1. If `target` is a path (contains `/` or `\`), reads that directory directly
-2. If `target` is a hash prefix, scans all attested migrations and matches against `migrationId`
+2. If `target` is a hash prefix, scans all attested migrations and matches against `migrationHash`
 3. If no target, defaults to the latest migration
 4. Displays operations with operation class badges, destructive warnings, and DDL preview
 
@@ -1034,15 +1034,14 @@ prisma-next migration apply [--db <url>] [--ref <name>] [--config <path>] [--jso
 - `-v, --verbose`: Verbose output (debug info, timings)
 
 **What it does:**
-1. Reads migration packages from `config.migrations.dir` (every package is attested — there is no on-disk draft state)
-2. **Defense in depth:** rehashes `(manifest, ops)` for each loaded bundle and confirms it matches the stored `migrationId`. If a bundle has been hand-edited or partially written since emit, apply aborts with a structured runtime error pointing at the offending directory and asks the developer to re-run `node migrations/<dir>/migration.ts` (or restore from version control).
-3. Reconstructs the migration graph from all loaded bundles
-4. Determines the destination hash: from `--ref` (via `refs.json`) or from `contract.json`
-5. Connects to the database and reads the current marker hash
-6. Finds the shortest path from the marker hash to the destination using graph pathfinding
-7. Executes each pending migration in order using the target's `MigrationRunner`
-8. Each migration runs in its own transaction with prechecks, postchecks, and idempotency checks enabled
-9. After each migration, the runner verifies the schema and updates the marker/ledger
+1. Reads migration packages from `config.migrations.dir`. Every package is attested — there is no on-disk draft state. The loader (`readMigrationPackage` in `@prisma-next/migration-tools/io`) rehashes `(metadata, ops)` for each `MigrationPackage` it returns and confirms the result matches the stored `migrationHash`. If a package has been hand-edited or partially written since emit, the load fails with `MIGRATION.HASH_MISMATCH` pointing at the offending directory and asks the developer to re-run `node migrations/<dir>/migration.ts` (or restore from version control).
+2. Reconstructs the migration graph from all loaded packages
+3. Determines the destination hash: from `--ref` (via `refs.json`) or from `contract.json`
+4. Connects to the database and reads the current marker hash
+5. Finds the shortest path from the marker hash to the destination using graph pathfinding
+6. Executes each pending migration in order using the target's `MigrationRunner`
+7. Each migration runs in its own transaction with prechecks, postchecks, and idempotency checks enabled
+8. After each migration, the runner verifies the schema and updates the marker/ledger
 
 **Config requirements:** Requires `driver` and `db.connection` (or `--db`). `migrations.dir` is optional and defaults to `migrations/`.
 
@@ -1050,7 +1049,7 @@ prisma-next migration apply [--db <url>] [--ref <name>] [--config <path>] [--jso
 
 **Ref-based routing:** With `--ref`, apply targets the ref's hash instead of the contract hash. This enables multi-environment workflows where staging and production track different points in the migration graph.
 
-### Emitting `ops.json` and computing `migrationId`
+### Emitting `ops.json` and computing `migrationHash`
 
 There is no dedicated CLI command for emitting a migration — migrations
 self-emit. After scaffolding (via `migration plan` or `migration new`),
@@ -1061,7 +1060,9 @@ run `migration.ts` directly with Node to produce `ops.json` and attest
 node migrations/<dir>/migration.ts
 ```
 
-The scaffolded `migration.ts` calls `MigrationCLI.run(import.meta.url, ...)` from `@prisma-next/cli/migration-cli` when invoked as the entrypoint. (Postgres scaffolds re-export `MigrationCLI` through `@prisma-next/target-postgres/migration` so a Postgres `migration.ts` only needs the single facade import; Mongo scaffolds still pull from `@prisma-next/cli/migration-cli` directly.) The CLI entrypoint loads `prisma-next.config.ts`, assembles a `ControlStack`, instantiates the migration with that stack (so `dataTransform` and other adapter-aware helpers can materialize a real adapter), and serializes operations to `ops.json` while writing the content-addressed `migrationId` into `migration.json`. If `migration.ts` contains unfilled `placeholder()` slots, the script exits with `PN-MIG-2001` and reports the slot to fill in.
+The scaffolded `migration.ts` calls `MigrationCLI.run(import.meta.url, ...)` from `@prisma-next/cli/migration-cli` when invoked as the entrypoint. (Postgres scaffolds re-export `MigrationCLI` through `@prisma-next/target-postgres/migration` so a Postgres `migration.ts` only needs the single facade import; Mongo scaffolds still pull from `@prisma-next/cli/migration-cli` directly.) The CLI entrypoint loads `prisma-next.config.ts`, assembles a `ControlStack`, instantiates the migration with that stack (so `dataTransform` and other adapter-aware helpers can materialize a real adapter), and serializes operations to `ops.json` while writing the content-addressed `migrationHash` into `migration.json`. If `migration.ts` contains unfilled `placeholder()` slots, the script exits with `PN-MIG-2001` and reports the slot to fill in.
+
+`MigrationCLI.run` accepts an optional third argument `{ argv?, stdout?, stderr? }` for in-process testability (default: `process.argv` / `process.stdout` / `process.stderr`) and returns the exit code as a `Promise<number>`. The flag surface is `--help` / `--dry-run` / `--config <path>`, parsed by [`clipanion`](https://github.com/arcanis/clipanion). The main multi-command surface (`prisma-next contract emit`, `db verify`, etc.) uses Commander; the per-migration `MigrationCLI.run` entrypoint uses clipanion to keep authored migration files lightweight and in-process testable.
 
 ### `prisma-next migration ref`
 
@@ -1093,17 +1094,22 @@ flowchart TD
     CMD_EMIT[Emit Command]
     CMD_DB[DB Commands]
     CMD_MIG[Migration Commands]
-    LOAD[TS Contract Loader]
+    EXEC_EMIT[executeContractEmit]
+    PUBLISH[publishContractArtifactPair]
     EMIT[Emitter]
     CTRL[Control Client]
     MIG_TOOLS["@prisma-next/migration-tools"]
     FS[File System]
+    VITE["@prisma-next/vite-plugin-contract-emit"]
 
     CLI --> CMD_EMIT
     CLI --> CMD_DB
     CLI --> CMD_MIG
-    CMD_EMIT --> LOAD
-    LOAD --> EMIT
+    CMD_EMIT --> EXEC_EMIT
+    VITE --> EXEC_EMIT
+    EXEC_EMIT --> EMIT
+    EXEC_EMIT --> PUBLISH
+    PUBLISH --> FS
     CMD_DB --> CTRL
     CMD_MIG --> CTRL
     CMD_MIG --> MIG_TOOLS
@@ -1111,6 +1117,35 @@ flowchart TD
     CTRL --> FS
 ```
 
+## Canonical Contract Emit Path
+
+> **For agents/contributors**: `executeContractEmit` is the SINGLE publication path
+> for `contract.json` + `contract.d.ts`. The CLI command (`prisma-next contract
+> emit`) and the Vite plugin (`@prisma-next/vite-plugin-contract-emit`) both
+> call into it. Do NOT re-implement the load → emit → publish dance in a new
+> caller; if you need additional behavior, extend `ContractEmitOptions` /
+> `ContractEmitResult` and update `executeContractEmit` itself.
+
+How it composes:
+
+- The whole flow (load config → resolve source → emit bytes → publish) is
+  serialized per output JSON path via `queueEmitByOutput`
+  (`src/utils/emit-queue.ts`). Concurrent calls for the same output line up
+  FIFO; concurrent calls for distinct outputs run in parallel. Last submission
+  wins on disk.
+- Within a single emit, `publishContractArtifactPair`
+  (`src/utils/publish-contract-artifact-pair.ts`) stages temp files, renames
+  `contract.d.ts` before `contract.json`, and attempts to restore the previous
+  pair if either rename fails — so type-only consumers never observe a
+  mismatched pair.
+- Long-lived hosts (Vite dev server, watch CLIs) must call `disposeEmitQueue`
+  on shutdown to drop the per-output queue state, otherwise the module-global
+  queue map leaks one entry per unique output path.
+
+The `validateContractDeps` warning is returned in `ContractEmitResult.validationWarning`
+rather than written to stderr by the operation — callers (CLI, Vite plugin) decide
+how to render it (`ui.warn`, plugin logger, etc.).
+
 ## Config Validation and Normalization
 
 The `defineConfig()` function validates and normalizes configs using Arktype:
@@ -1266,7 +1301,7 @@ export default defineConfig({
 - **`commander`**: CLI argument parsing and command routing
 - **`esbuild`**: Bundling TypeScript contract files with import allowlisting
 - **`@prisma-next/emitter`**: Contract emission engine (returns strings)
-- **`@prisma-next/migration-tools`**: On-disk migration I/O, attestation, and history reconstruction
+- **`@prisma-next/migration-tools`**: On-disk migration I/O, hash verification, and history reconstruction
 - **`@prisma-next/framework-components`**: Control plane types, migration operation types, control stack (via `./control`)
 - **`@prisma-next/errors`**: Error types and factories (via `./control`)
 

package/dist/agent-skill-mongo.md

@@ -4,7 +4,7 @@ This project uses **Prisma Next** with **MongoDB** via `@prisma-next/mongo`. Pri
 
 ## Files
 
-- **Contract**: `{{schemaPath}}` — the user's data models. Edit this to add or change models.
+- **Contract**: `{{schemaPath}}` ({{authoringLabel}} authoring) — the user's data models. Edit this to add or change models.
 - **Config**: `prisma-next.config.ts` — tells the CLI where the contract is and how to connect to the database. Loads `.env` via `dotenv/config`.
 - **Database client**: `{{schemaDir}}/db.ts` — `import { db } from '{{dbImportPath}}'`. This is the entry point for all queries.
 - **Generated files** (do not edit by hand):
@@ -23,71 +23,103 @@ This project uses **Prisma Next** with **MongoDB** via `@prisma-next/mongo`. Pri
 
 ## How to write queries
 
-Always use the ORM (`db.orm`). Only fall back to `db.sql` if the user explicitly asks for raw queries or the ORM doesn't support the operation.
+Use the ORM (`db.orm`). Each root accessor is the lowercased plural form emitted by `prisma-next contract emit` (typically the `@@map`-ped collection name) — for `model User { @@map("users") }` use `db.orm.users`, for `model Post { @@map("posts") }` use `db.orm.posts`. The Mongo facade has no raw-SQL surface. Two escape hatches exist for cases the ORM can't express; both are covered under "Escape hatches" below.
 
 ```typescript
 import { db } from '{{dbImportPath}}';
 
 // Find one record
-const user = await db.orm.User
-  .where(user => user.email.eq('alice@example.com'))
+const user = await db.orm.users
+  .where({ email: 'alice@example.com' })
   .first();
-// Returns { id: ObjectId; email: string; ... } | null
+// Returns { _id: ObjectId; email: string; ... } | null
 
-// Find multiple records
-const users = await db.orm.User
-  .select('id', 'email')
+// Find multiple records — `.all()` returns an AsyncIterableResult, consume
+// either as an async iterable (below) or by `await`ing it to materialise an Array.
+for await (const user of db.orm.users
+  .select('_id', 'email')
   .take(10)
-  .all();
-// Returns Array<{ id: ObjectId; email: string }>
+  .all()) {
+  // Each `user` is { _id: ObjectId; email: string }
+}
+// Returns AsyncIterableResult<{ _id: ObjectId; email: string }>
 
 // Filter, order, limit
-const recentPosts = await db.orm.Post
-  .where(post => post.authorId.eq(userId))
-  .orderBy(post => post.createdAt.desc())
-  .select('id', 'title', 'createdAt')
+const recentPosts = await db.orm.posts
+  .where({ authorId: userId })
+  .orderBy({ createdAt: -1 })
+  .select('_id', 'title', 'createdAt')
   .take(50)
   .all();
 
-// Include relations
-const usersWithPosts = await db.orm.User
-  .select('id', 'email')
-  .include('posts', post =>
-    post.select('id', 'title').orderBy(p => p.createdAt.desc()).take(5)
-  )
+// Include relations (reference relations only — embedded relations come back automatically)
+const usersWithPosts = await db.orm.users
+  .select('_id', 'email')
+  .include('posts')
   .take(10)
   .all();
 ```
 
 ### Key ORM methods
 
-- `.where(predicate)` — filter records. Predicate receives a model accessor with `.eq()`, `.neq()`, `.ilike()`, `.lt()`, `.gt()`, etc.
+- `.where({ field: value, ... })` — filter records by an equality object. Pass a raw filter expression for `$gt`/`$in`/`$regex` etc.
 - `.select('field1', 'field2', ...)` — pick which fields to return
-- `.orderBy(accessor => accessor.field.asc()` or `.desc())` — sort results
-- `.take(n)` — limit number of results
-- `.all()` — execute and return all matching records as an array
-- `.first()` — execute and return the first matching record, or `null`
-- `.first({ id: value })` — find a single record by primary key, or `null`
-- `.include('relation', builder => ...)` — eager-load a relation
+- `.orderBy({ field: 1 | -1 })` — sort results (1 = ascending, -1 = descending)
+- `.take(n)` / `.skip(n)` — limit and offset
+- `.all()` — execute and return all matching records as an `AsyncIterableResult`
+- `.first()` — execute with limit 1 and return the first matching row, or `null`
+- `.include('relationName')` — eager-load a reference relation (`$lookup`); embedded relations are already part of the row
+- `.variant('VariantName')` — narrow a polymorphic collection to a discriminator value
+
+## Escape hatches
+
+The ORM covers the common cases. When you genuinely need something it can't express, prefer these — in order — over reaching for `db.runtime()` (which is an internal executor surface, not a `mongodb`-driver handle):
+
+1. **Typed raw aggregations — `db.query`.** The facade exposes a `db.query` builder that runs aggregation pipelines through the same runtime + middleware + codec stack as `db.orm`, so results stay typed against the contract. Use this for `$lookup`/`$facet`/`$graphLookup`/window-function pipelines that the ORM doesn't surface.
+
+2. **Direct `mongodb` driver control — `mongoClient` binding.** If you need a raw `MongoClient` (e.g. for transactions, change streams, sessions, or a driver feature Prisma Next doesn't expose), construct one yourself and pass it to `mongo({ mongoClient, dbName, contractJson })`. Your code keeps the `MongoClient` reference and uses it directly, while the same `db` object still gives you the typed ORM surface:
+
+   ```typescript
+   import { MongoClient } from 'mongodb';
+   import mongo from '@prisma-next/mongo/runtime';
+   import type { Contract } from './contract.d';
+   import contractJson from './contract.json' with { type: 'json' };
+
+   const client = new MongoClient(process.env['DATABASE_URL']!);
+   await client.connect();
+
+   export const db = mongo<Contract>({ contractJson, mongoClient: client, dbName: 'mydb' });
+
+   const session = client.startSession();
+   try {
+     await session.withTransaction(async () => {
+       await db.orm.users.createAll([{ /* ... */ }]);
+     });
+   } finally {
+     await session.endSession();
+   }
+   ```
 
 ## Rules
 
 - **Never hand-edit** `contract.json` or `contract.d.ts`. Always regenerate them with `contract emit`.
 - **Always emit after contract changes.** When you modify `{{schemaPath}}`, run `{{pkgRun}} contract emit` before writing any code that depends on the new or changed models.
-- **Don't restructure `db.ts`.** It's scaffolded by init and works as-is.
-- **Use `db.orm` for queries**, not `db.sql`. The ORM is the primary query surface.
+- **Don't restructure `db.ts`.** It's scaffolded by init and works as-is. `db` connects lazily on the first query — there is no `db.connect(...)` step.
+- **Root accessors are emitter-driven.** Use the lowercased plural collection name (e.g. `db.orm.users`, `db.orm.posts`) — not the PascalCase model name. Re-run `{{pkgRun}} contract emit` if a new model's accessor isn't appearing on `db.orm`.
 - **Connection string** is `DATABASE_URL` in `.env`. If the user reports connection errors, check this value and the `.env` file.
+- **Transactions and change streams** require a MongoDB **replica set**. The Mongo facade does not yet expose `db.transaction(...)` — for now, use the `mongoClient` escape hatch above to drive transactions/sessions directly. See the quick reference for dev-environment options; the typed transaction API is tracked under [TML-2313](https://linear.app/prisma-company/issue/TML-2313/mongo-dev-replica-set-story-is-missing-transactions-change-streams).
+- **Don't reach for `db.runtime()`** as an escape hatch. It returns the internal executor (`MongoRuntime`), not a `mongodb` `MongoClient` or `Db`. Use `db.query` for raw aggregations and the `mongoClient` binding for direct driver control.
 
 ## Workflow for common tasks
 
 **User wants to add a new model or field:**
 1. Edit `{{schemaPath}}`
 2. Run `{{pkgRun}} contract emit`
-3. Write query code using `db.orm.ModelName`
+3. Write query code using `db.orm.<collection>` (lowercased plural, see Rules above)
 
 **User wants to query data:**
 1. Import `db` from `{{dbImportPath}}`
-2. Use `db.orm.ModelName` with `.where()`, `.select()`, `.all()`, `.first()`, etc.
+2. Use `db.orm.<collection>` with `.where()`, `.select()`, `.all()`, `.first()`, etc.
 
 **User wants to set up or change the database connection:**
 1. Edit `DATABASE_URL` in `.env`

package/dist/agent-skill-postgres.md

@@ -4,7 +4,7 @@ This project uses **Prisma Next** with **PostgreSQL** via `@prisma-next/postgres
 
 ## Files
 
-- **Contract**: `{{schemaPath}}` — the user's data models. Edit this to add or change models.
+- **Contract**: `{{schemaPath}}` ({{authoringLabel}} authoring) — the user's data models. Edit this to add or change models.
 - **Config**: `prisma-next.config.ts` — tells the CLI where the contract is and how to connect to the database. Loads `.env` via `dotenv/config`.
 - **Database client**: `{{schemaDir}}/db.ts` — `import { db } from '{{dbImportPath}}'`. This is the entry point for all queries.
 - **Generated files** (do not edit by hand):

package/dist/cli-errors-By1iVE3z.mjs

@@ -0,0 +1,34 @@
+import { CliStructuredError as CliStructuredError$1, errorConfigValidation as errorConfigValidation$1, errorContractConfigMissing as errorContractConfigMissing$1, errorContractValidationFailed, errorDatabaseConnectionRequired, errorDriverRequired, errorFileNotFound, errorMigrationPlanningFailed, errorTargetMigrationNotSupported, errorUnexpected as errorUnexpected$1 } from "@prisma-next/errors/control";
+import { ERROR_CODE_DESTRUCTIVE_CHANGES, errorDestructiveChanges, errorHashMismatch, errorMarkerMissing, errorRunnerFailed, errorRuntime, errorRuntime as errorRuntime$1, errorTargetMismatch } from "@prisma-next/errors/execution";
+import "@prisma-next/errors/migration";
+
+//#region src/utils/cli-errors.ts
+/**
+* Maps a `MigrationToolsError` raised by the migration-tools loader/graph
+* surface (`readMigrationPackage`, `readMigrationsDir`, `readRefs`,
+* `resolveRef`, `reconstructGraph`, ...) into a CLI `errorRuntime` envelope.
+*
+* The full `error.details` payload is forwarded into `meta` so machine
+* consumers (`--json`) see structural fields like `dir`, `storedHash`,
+* `computedHash` (for `MIGRATION.HASH_MISMATCH`) alongside the stable
+* `code`. The user-visible `summary`/`why`/`fix` text is unchanged.
+*
+* Callers are expected to gate on `MigrationToolsError.is(error)` first
+* (mirroring the original inline pattern); non-`MigrationToolsError`
+* values are caller-classified (rethrow, wrap with command-specific
+* `errorUnexpected`, etc.).
+*/
+function mapMigrationToolsError(error) {
+	return errorRuntime(error.message, {
+		why: error.why,
+		fix: error.fix,
+		meta: {
+			code: error.code,
+			...error.details ?? {}
+		}
+	});
+}
+
+//#endregion
+export { errorUnexpected$1 as _, errorContractValidationFailed as a, errorDriverRequired as c, errorMarkerMissing as d, errorMigrationPlanningFailed as f, errorTargetMismatch as g, errorTargetMigrationNotSupported as h, errorContractConfigMissing$1 as i, errorFileNotFound as l, errorRuntime$1 as m, ERROR_CODE_DESTRUCTIVE_CHANGES as n, errorDatabaseConnectionRequired as o, errorRunnerFailed as p, errorConfigValidation$1 as r, errorDestructiveChanges as s, CliStructuredError$1 as t, errorHashMismatch as u, mapMigrationToolsError as v };
+//# sourceMappingURL=cli-errors-By1iVE3z.mjs.map

package/dist/cli-errors-By1iVE3z.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli-errors-By1iVE3z.mjs","names":[],"sources":["../src/utils/cli-errors.ts"],"sourcesContent":["/**\n * Re-export all domain error factories from @prisma-next/errors for convenience.\n * CLI-specific errors (e.g., Commander argument validation in the main CLI, or\n * clipanion parse errors in the migration-file CLI) can be added here if needed.\n */\nexport type { CliErrorConflict, CliErrorEnvelope } from '@prisma-next/errors/control';\n\nimport {\n  CliStructuredError,\n  errorConfigFileNotFound,\n  errorConfigValidation,\n  errorContractConfigMissing,\n  errorContractMissingExtensionPacks,\n  errorContractValidationFailed,\n  errorDatabaseConnectionRequired,\n  errorDriverRequired,\n  errorFamilyReadMarkerSqlRequired,\n  errorFileNotFound,\n  errorMigrationCliInvalidConfigArg,\n  errorMigrationCliUnknownFlag,\n  errorMigrationPlanningFailed,\n  errorQueryRunnerFactoryRequired,\n  errorTargetMigrationNotSupported,\n  errorUnexpected,\n} from '@prisma-next/errors/control';\nimport { errorRuntime } from '@prisma-next/errors/execution';\nimport type { MigrationToolsError } from '@prisma-next/migration-tools/errors';\n\nexport {\n  CliStructuredError,\n  errorConfigFileNotFound,\n  errorConfigValidation,\n  errorContractConfigMissing,\n  errorContractMissingExtensionPacks,\n  errorContractValidationFailed,\n  errorDatabaseConnectionRequired,\n  errorDriverRequired,\n  errorFamilyReadMarkerSqlRequired,\n  errorFileNotFound,\n  errorMigrationCliInvalidConfigArg,\n  errorMigrationCliUnknownFlag,\n  errorMigrationPlanningFailed,\n  errorQueryRunnerFactoryRequired,\n  errorTargetMigrationNotSupported,\n  errorUnexpected,\n};\nexport {\n  ERROR_CODE_DESTRUCTIVE_CHANGES,\n  errorDestructiveChanges,\n  errorHashMismatch,\n  errorMarkerMissing,\n  errorMarkerRequired,\n  errorRunnerFailed,\n  errorRuntime,\n  errorSchemaVerificationFailed,\n  errorTargetMismatch,\n} from '@prisma-next/errors/execution';\nexport {\n  errorMigrationFileMissing,\n  errorMigrationInvalidDefaultExport,\n  errorMigrationPlanNotArray,\n  errorUnfilledPlaceholder,\n  placeholder,\n} from '@prisma-next/errors/migration';\n\n/**\n * Maps a `MigrationToolsError` raised by the migration-tools loader/graph\n * surface (`readMigrationPackage`, `readMigrationsDir`, `readRefs`,\n * `resolveRef`, `reconstructGraph`, ...) into a CLI `errorRuntime` envelope.\n *\n * The full `error.details` payload is forwarded into `meta` so machine\n * consumers (`--json`) see structural fields like `dir`, `storedHash`,\n * `computedHash` (for `MIGRATION.HASH_MISMATCH`) alongside the stable\n * `code`. The user-visible `summary`/`why`/`fix` text is unchanged.\n *\n * Callers are expected to gate on `MigrationToolsError.is(error)` first\n * (mirroring the original inline pattern); non-`MigrationToolsError`\n * values are caller-classified (rethrow, wrap with command-specific\n * `errorUnexpected`, etc.).\n */\nexport function mapMigrationToolsError(error: MigrationToolsError): CliStructuredError {\n  return errorRuntime(error.message, {\n    why: error.why,\n    fix: error.fix,\n    meta: { code: error.code, ...(error.details ?? {}) },\n  });\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAgFA,SAAgB,uBAAuB,OAAgD;AACrF,QAAO,aAAa,MAAM,SAAS;EACjC,KAAK,MAAM;EACX,KAAK,MAAM;EACX,MAAM;GAAE,MAAM,MAAM;GAAM,GAAI,MAAM,WAAW,EAAE;GAAG;EACrD,CAAC"}

package/dist/{cli-errors-C0JhVj0c.d.mts → cli-errors-DDeVsP2Y.d.mts}

@@ -1,4 +1,5 @@
 import { CliStructuredError as CliStructuredError$1 } from "@prisma-next/errors/control";
 import "@prisma-next/errors/execution";
 import "@prisma-next/errors/migration";
+import { MigrationToolsError } from "@prisma-next/migration-tools/errors";
 export { CliStructuredError$1 as t };

package/dist/cli.mjs

@@ -1,10 +1,10 @@
 #!/usr/bin/env node
 
-import "./config-loader-_W4T21X1.mjs";
-import { d as setCommandExamples, g as formatRootHelp, h as formatCommandHelp, m as parseGlobalFlags, u as setCommandDescriptions } from "./result-handler-BJwA7ufw.mjs";
-import { t as createContractEmitCommand } from "./contract-emit-DpPjuFy-.mjs";
-import { n as installShutdownHandlers } from "./terminal-ui-C5k88MmW.mjs";
-import { t as createContractInferCommand } from "./contract-infer-BS4kIX9c.mjs";
+import "./config-loader-ih8ViDb_.mjs";
+import { n as installShutdownHandlers } from "./terminal-ui-u2YgKghu.mjs";
+import { _ as formatCommandHelp, d as setCommandDescriptions, f as setCommandExamples, g as parseGlobalFlags, n as addGlobalOptions, v as formatRootHelp } from "./result-handler-Ch6hVnOo.mjs";
+import { t as createContractEmitCommand } from "./contract-emit-rt_Nmdwq.mjs";
+import { t as createContractInferCommand } from "./contract-infer-Cf5J2wVg.mjs";
 import { createDbInitCommand } from "./commands/db-init.mjs";
 import { createDbSchemaCommand } from "./commands/db-schema.mjs";
 import { createDbSignCommand } from "./commands/db-sign.mjs";
@@ -15,20 +15,126 @@ import { createMigrationNewCommand } from "./commands/migration-new.mjs";
 import { createMigrationPlanCommand } from "./commands/migration-plan.mjs";
 import { createMigrationRefCommand } from "./commands/migration-ref.mjs";
 import { createMigrationShowCommand } from "./commands/migration-show.mjs";
-import { t as createMigrationStatusCommand } from "./migration-status-Ry3TnEya.mjs";
+import { t as createMigrationStatusCommand } from "./migration-status-DoPrFIOQ.mjs";
 import { Command } from "commander";
 import { distance } from "closest-match";
 
+//#region src/commands/init/exit-codes.ts
+/**
+* Stable exit codes for the `init` command.
+*
+* These are part of the command's public contract. AI agents and CI scripts
+* branch on them (FR1.6), so the values must remain stable across versions.
+*
+* Codes 0–3 are the CLI-wide reserved values per the [CLI Style Guide
+* Exit Codes section](../../../../../../../docs/CLI%20Style%20Guide.md#exit-codes):
+* `OK = 0`, `INTERNAL_ERROR = 1`, `PRECONDITION = 2`, `USER_ABORTED = 3`.
+* Codes 4 and 5 are command-specific outcomes for `init`'s two fallible
+* side effects (install + emit). Documented in `--help` via
+* `setCommandDescriptions` in `./index.ts`.
+*/
+const INIT_EXIT_OK = 0;
+/**
+* Anything we did not anticipate — a bug in prisma-next, not something
+* the caller did wrong. Includes the structured error code `5009`
+* (invalid output document) and any unrecognised internal error code,
+* so callers can distinguish "tool is broken" from "your invocation
+* was wrong" (`PRECONDITION = 2`). Maps to the generic "RUN" error
+* domain.
+*/
+const INIT_EXIT_INTERNAL_ERROR = 1;
+/**
+* Preconditions not met. The caller asked for something we cannot do
+* without more input or a different environment. Examples:
+*   - missing `package.json` / `deno.json`
+*   - non-interactive mode without enough flags to proceed
+*   - re-init without `--force` in non-interactive mode
+*/
+const INIT_EXIT_PRECONDITION = 2;
+/**
+* The user actively aborted an interactive prompt (Ctrl-C, declined the
+* re-init confirmation, etc.). Distinct from PRECONDITION because the user
+* was given the choice and made it; no diagnostic is needed.
+*/
+const INIT_EXIT_USER_ABORTED = 3;
+/**
+* Dependency installation step failed without a recoverable fallback.
+* `init` automatically falls back from `pnpm` to `npm` on a recognised
+* workspace/catalog leak (FR7.2); this code is returned only when the
+* fallback also fails, or when the package manager is not pnpm and the
+* single attempt failed. Files written before the install step (config,
+* schema, db client, etc.) remain on disk so the user can fix the
+* environment and re-run; the error envelope's `meta.filesWritten` lists
+* them.
+*/
+const INIT_EXIT_INSTALL_FAILED = 4;
+/**
+* Contract emit step failed after a successful install. Files written
+* before emit (including any installed dependencies) are still on disk;
+* the user can fix the underlying issue (typically a contract syntax
+* error or a missing extension pack) and re-run `prisma-next contract
+* emit` manually.
+*/
+const INIT_EXIT_EMIT_FAILED = 5;
+
+//#endregion
 //#region src/commands/init/index.ts
 function createInitCommand() {
 	const command = new Command("init");
-	setCommandDescriptions(command, "Initialize a new Prisma Next project", "Scaffolds config, schema, and runtime files, installs dependencies,\nand emits the contract. Gets you from zero to typed queries in one step.");
-	setCommandExamples(command, ["prisma-next init", "prisma-next init --no-install"]);
-	command.option("--no-install", "Skip dependency installation and contract emission").action(async (options) => {
-		const { runInit } = await import("./init-CQfo_4Ro.mjs");
-		await runInit(process.cwd(), { noInstall: !options.install });
+	setCommandDescriptions(command, "Initialize a new Prisma Next project", `Scaffolds config, schema, and runtime files, installs dependencies,
+and emits the contract. Gets you from zero to typed queries in one step.
+
+Run interactively for a guided experience, or supply --target / --authoring
+and --yes for a fully scriptable run (CI, AI coding agents, automation).
+
+Exit codes (see CLI Style Guide § Exit Codes):
+  ${INIT_EXIT_OK}   OK                    Init succeeded.\n  ${INIT_EXIT_INTERNAL_ERROR}   INTERNAL_ERROR        Unexpected bug in prisma-next (please report).\n  ${INIT_EXIT_PRECONDITION}   PRECONDITION          Bad flags / missing prerequisite (e.g. no package.json).\n  ${INIT_EXIT_USER_ABORTED}   USER_ABORTED          User cancelled an interactive prompt.\n  ${INIT_EXIT_INSTALL_FAILED}   INSTALL_FAILED        Dependency installation failed (init-specific).\n  ${INIT_EXIT_EMIT_FAILED}   EMIT_FAILED           \`contract emit\` failed after install (init-specific).`);
+	setCommandExamples(command, [
+		"prisma-next init",
+		"prisma-next init --yes --target postgres --authoring psl",
+		"prisma-next init --yes --target mongodb --authoring typescript --json",
+		"prisma-next init --yes --force --target postgres --authoring psl  # overwrite an existing scaffold",
+		"prisma-next init --no-install                                       # skip pnpm/npm install + emit"
+	]);
+	return addGlobalOptions(command).option("--target <db>", "Database target: postgres or mongodb").option("--authoring <style>", "Schema authoring style: psl or typescript").option("--schema-path <path>", "Where to write the starter schema (default: prisma/contract.prisma)").option("--force", "Overwrite an existing scaffold without prompting").option("--write-env", "Write a .env file from .env.example (gitignored; default: only .env.example)").option("--probe-db", "Connect to DATABASE_URL once and check the server version against the target minimum (opt-in; off by default)").option("--strict-probe", "Treat a failed --probe-db as fatal (no-op without --probe-db; init is offline-by-default)").option("--no-install", "Skip dependency installation and contract emission").action(async (options) => {
+		const { runInit } = await import("./init-C7dE9KOJ.mjs");
+		const flags = parseGlobalFlags(options);
+		const canPrompt = deriveCanPrompt({
+			flagsInteractive: flags.interactive,
+			optionInteractive: options.interactive,
+			stdinIsTTY: Boolean(process.stdin.isTTY)
+		});
+		const exitCode = await runInit(process.cwd(), {
+			options,
+			flags,
+			canPrompt
+		});
+		process.exit(exitCode);
 	});
-	return command;
+}
+/**
+* Bridges the action handler's two TTY checks (stdout via `flags`, stdin
+* via `process.stdin.isTTY`) into the `canPrompt` boolean `runInit`
+* consumes.
+*
+* Per the [Style Guide § Interactivity](../../../../../../../docs/CLI%20Style%20Guide.md#interactivity):
+*
+* - `flags.interactive` governs *decoration* (TerminalUI, intro/outro,
+*   spinners) and is derived from stdout-TTY by `parseGlobalFlags`,
+*   honouring `--interactive` / `--no-interactive`.
+* - Prompting additionally requires a stdin TTY — closing stdin is a
+*   common signal in CI / agent environments even when stdout stays
+*   attached.
+* - `--interactive` is the explicit override: when the user passes it,
+*   we honour it (e.g. testing flows where stdin is stubbed).
+*
+* Exported so callers and tests can derive the same value without
+* touching `process` globals — F14 of the M1/M2 review.
+*/
+function deriveCanPrompt(opts) {
+	if (opts.optionInteractive === true) return true;
+	if (opts.flagsInteractive === false) return false;
+	return opts.stdinIsTTY;
 }
 
 //#endregion
@@ -72,7 +178,9 @@ const versionOption = program.options.find((opt) => opt.flags.includes("--versio
 if (versionOption) versionOption.description = "Output the version number";
 program.configureOutput({
 	writeErr: () => {},
-	writeOut: () => {}
+	writeOut: (str) => {
+		process.stdout.write(str);
+	}
 });
 const rootHelpFormatter = (cmd) => {
 	return formatRootHelp({
@@ -203,7 +311,7 @@ const helpCommand = new Command("help").description("Show usage instructions").c
 		program,
 		flags: parseGlobalFlags({})
 	});
-	process.stderr.write(`${helpText}\n`);
+	process.stdout.write(`${helpText}\n`);
 	process.exit(0);
 });
 program.addCommand(helpCommand);
@@ -247,5 +355,5 @@ if (args.length > 0) {
 program.parse();
 
 //#endregion
-export {  };
+export { INIT_EXIT_PRECONDITION as a, INIT_EXIT_OK as i, INIT_EXIT_INSTALL_FAILED as n, INIT_EXIT_USER_ABORTED as o, INIT_EXIT_INTERNAL_ERROR as r, INIT_EXIT_EMIT_FAILED as t };
 //# sourceMappingURL=cli.mjs.map