@prisma-next/cli 0.10.0 → 0.11.0-dev.1

package/README.md

@@ -1060,7 +1060,7 @@ 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 `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.
+The scaffolded `migration.ts` calls `MigrationCLI.run(import.meta.url, ...)` from `@prisma-next/cli/migration-cli` when invoked as the entrypoint. (Postgres and SQLite scaffolds re-export `MigrationCLI` through `@prisma-next/postgres/migration` or `@prisma-next/sqlite/migration` so a `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.
 

package/dist/{cli-errors-CF60g2cG.mjs → cli-errors-Djtz98Vm.mjs}

@@ -1,4 +1,4 @@
-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 { CliStructuredError as CliStructuredError$1, errorConfigValidation as errorConfigValidation$1, errorContractConfigMissing as errorContractConfigMissing$1, errorContractValidationFailed, errorDatabaseConnectionRequired, errorDriverRequired, errorFileNotFound, errorInvalidOutputFormat, errorMigrationPlanningFailed, errorOutputFormatMutex, 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
@@ -66,6 +66,6 @@ function mapRefResolutionError(error) {
 	}
 }
 //#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, mapRefResolutionError as y };
+export { errorTargetMigrationNotSupported as _, errorContractValidationFailed as a, mapMigrationToolsError as b, errorDriverRequired as c, errorInvalidOutputFormat as d, errorMarkerMissing as f, errorRuntime$1 as g, errorRunnerFailed as h, errorContractConfigMissing$1 as i, errorFileNotFound as l, errorOutputFormatMutex as m, ERROR_CODE_DESTRUCTIVE_CHANGES as n, errorDatabaseConnectionRequired as o, errorMigrationPlanningFailed as p, errorConfigValidation$1 as r, errorDestructiveChanges as s, CliStructuredError$1 as t, errorHashMismatch as u, errorTargetMismatch as v, mapRefResolutionError as x, errorUnexpected$1 as y };
 
-//# sourceMappingURL=cli-errors-CF60g2cG.mjs.map
+//# sourceMappingURL=cli-errors-Djtz98Vm.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cli-errors-Djtz98Vm.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  errorInvalidOutputFormat,\n  errorMigrationCliInvalidConfigArg,\n  errorMigrationCliUnknownFlag,\n  errorMigrationPlanningFailed,\n  errorOutputFormatMutex,\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';\nimport type { RefResolutionError } from '@prisma-next/migration-tools/ref-resolution';\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';\nexport {\n  CliStructuredError,\n  errorConfigFileNotFound,\n  errorConfigValidation,\n  errorContractConfigMissing,\n  errorContractMissingExtensionPacks,\n  errorContractValidationFailed,\n  errorDatabaseConnectionRequired,\n  errorDriverRequired,\n  errorFamilyReadMarkerSqlRequired,\n  errorFileNotFound,\n  errorInvalidOutputFormat,\n  errorMigrationCliInvalidConfigArg,\n  errorMigrationCliUnknownFlag,\n  errorMigrationPlanningFailed,\n  errorOutputFormatMutex,\n  errorQueryRunnerFactoryRequired,\n  errorTargetMigrationNotSupported,\n  errorUnexpected,\n};\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\n/**\n * Maps a `RefResolutionError` from the contract/migration reference\n * resolver into a CLI structured error envelope.\n */\nexport function mapRefResolutionError(error: RefResolutionError): CliStructuredError {\n  switch (error.kind) {\n    case 'not-found':\n      return errorRuntime(`Not a known ${error.grammar} reference: \"${error.input}\"`, {\n        why: `No ${error.grammar} matching \"${error.input}\" exists in the migration graph or refs index.`,\n        fix:\n          error.grammar === 'contract'\n            ? 'Provide a valid contract hash, ref name, or migration directory name.'\n            : 'Provide a valid migration directory name or migration hash.',\n        meta: { input: error.input, grammar: error.grammar },\n      });\n    case 'ambiguous':\n      return errorRuntime(`Ambiguous ${error.grammar} reference: \"${error.input}\"`, {\n        why: `\"${error.input}\" matches multiple ${error.grammar}s: ${error.candidates.join(', ')}`,\n        fix: 'Provide a longer prefix or use the full hash to disambiguate.',\n        meta: { input: error.input, candidates: error.candidates, grammar: error.grammar },\n      });\n    case 'wrong-grammar':\n      return errorRuntime(error.message, {\n        why: error.message,\n        fix: error.fix,\n        meta: { input: error.input, expectedGrammar: error.expectedGrammar },\n      });\n    case 'invalid-format':\n      return errorRuntime(`Invalid reference format: \"${error.input}\"`, {\n        why: error.reason,\n        fix: 'Provide a valid contract hash, ref name, or migration directory name.',\n        meta: { input: error.input },\n      });\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAqFA,SAAgB,uBAAuB,OAAgD;CACrF,OAAO,aAAa,MAAM,SAAS;EACjC,KAAK,MAAM;EACX,KAAK,MAAM;EACX,MAAM;GAAE,MAAM,MAAM;GAAM,GAAI,MAAM,WAAW,EAAE;GAAG;EACrD,CAAC;;;;;;AAOJ,SAAgB,sBAAsB,OAA+C;CACnF,QAAQ,MAAM,MAAd;EACE,KAAK,aACH,OAAO,aAAa,eAAe,MAAM,QAAQ,eAAe,MAAM,MAAM,IAAI;GAC9E,KAAK,MAAM,MAAM,QAAQ,aAAa,MAAM,MAAM;GAClD,KACE,MAAM,YAAY,aACd,0EACA;GACN,MAAM;IAAE,OAAO,MAAM;IAAO,SAAS,MAAM;IAAS;GACrD,CAAC;EACJ,KAAK,aACH,OAAO,aAAa,aAAa,MAAM,QAAQ,eAAe,MAAM,MAAM,IAAI;GAC5E,KAAK,IAAI,MAAM,MAAM,qBAAqB,MAAM,QAAQ,KAAK,MAAM,WAAW,KAAK,KAAK;GACxF,KAAK;GACL,MAAM;IAAE,OAAO,MAAM;IAAO,YAAY,MAAM;IAAY,SAAS,MAAM;IAAS;GACnF,CAAC;EACJ,KAAK,iBACH,OAAO,aAAa,MAAM,SAAS;GACjC,KAAK,MAAM;GACX,KAAK,MAAM;GACX,MAAM;IAAE,OAAO,MAAM;IAAO,iBAAiB,MAAM;IAAiB;GACrE,CAAC;EACJ,KAAK,kBACH,OAAO,aAAa,8BAA8B,MAAM,MAAM,IAAI;GAChE,KAAK,MAAM;GACX,KAAK;GACL,MAAM,EAAE,OAAO,MAAM,OAAO;GAC7B,CAAC"}

package/dist/cli.mjs

@@ -1,27 +1,397 @@
 #!/usr/bin/env node
-import { _ as parseGlobalFlags, d as setCommandDescriptions, f as setCommandExamples, t as addGlobalOptions, v as formatCommandHelp, y as formatRootHelp } from "./command-helpers-D3vL5yi8.mjs";
-import { t as createContractEmitCommand } from "./contract-emit-C3STUIBg.mjs";
-import { n as installShutdownHandlers } from "./terminal-ui-XtOQsqe9.mjs";
-import { t as createContractInferCommand } from "./contract-infer-Cnj8G1E2.mjs";
+import { a as isCI, n as installShutdownHandlers } from "./terminal-ui-BiB_8KNo.mjs";
+import { _ as parseGlobalFlags, b as formatCommandHelp, d as setCommandDescriptions, f as setCommandExamples, t as addGlobalOptions, v as parseGlobalFlagsOrExit, x as formatRootHelp } from "./command-helpers-DtavI0wJ.mjs";
+import { t as createContractEmitCommand } from "./contract-emit-uwT-Mj8-.mjs";
+import { t as createContractInferCommand } from "./contract-infer-pKkiCt7C.mjs";
 import { createDbInitCommand } from "./commands/db-init.mjs";
 import { createDbSchemaCommand } from "./commands/db-schema.mjs";
 import { createDbSignCommand } from "./commands/db-sign.mjs";
 import { createDbUpdateCommand } from "./commands/db-update.mjs";
-import { t as createDbVerifyCommand } from "./db-verify-D7cyH_zz.mjs";
+import { t as createDbVerifyCommand } from "./db-verify-AoIUriL4.mjs";
 import { createMigrateCommand } from "./commands/migrate.mjs";
 import { createMigrationCheckCommand } from "./commands/migration-check.mjs";
 import { createMigrationGraphCommand } from "./commands/migration-graph.mjs";
 import { createMigrationListCommand } from "./commands/migration-list.mjs";
 import { createMigrationLogCommand } from "./commands/migration-log.mjs";
 import { createMigrationNewCommand } from "./commands/migration-new.mjs";
-import { t as createMigrationPlanCommand } from "./migration-plan-CHyUlBV0.mjs";
+import { t as createMigrationPlanCommand } from "./migration-plan-C2jeH1J5.mjs";
 import { createMigrationShowCommand } from "./commands/migration-show.mjs";
 import { createMigrationStatusCommand } from "./commands/migration-status.mjs";
 import { createRefCommand } from "./commands/ref.mjs";
 import { Command } from "commander";
+import { ifDefined } from "@prisma-next/utils/defined";
+import { DEFAULT_CONTRACT_SOURCE_DIR } from "@prisma-next/config/config-types";
+import { fileURLToPath } from "node:url";
+import { readUserConfig, resolveGating, runTelemetry } from "@prisma-next/cli-telemetry";
 import { distance } from "closest-match";
 //#region package.json
-var version = "0.10.0";
+var version = "0.11.0-dev.1";
+//#endregion
+//#region src/utils/telemetry.ts
+/**
+* Resolve the commander command path from a leaf `Command`, walking up
+* the parent chain. Result is rooted at the program name and ends at
+* the leaf — `['prisma-next', 'migration', 'new']` for
+* `prisma-next migration new …`.
+*/
+function commandPathFor(actionCommand) {
+	const path = [];
+	let cursor = actionCommand;
+	while (cursor !== null) {
+		path.unshift(cursor.name());
+		cursor = cursor.parent;
+	}
+	return path;
+}
+function commanderOptionSnapshots(actionCommand) {
+	return actionCommand.options.map((option) => {
+		const attributeName = option.attributeName();
+		return {
+			attributeName,
+			longName: option.long ?? null,
+			source: actionCommand.getOptionValueSource(attributeName) ?? null
+		};
+	});
+}
+/**
+* Project commander's leaf `Command` into the wire-shape snapshot the
+* telemetry sanitiser consumes. Pure projection — no env, no I/O.
+*/
+function commanderSnapshotForTelemetry(actionCommand) {
+	return {
+		commandPath: commandPathFor(actionCommand),
+		positionalArgs: actionCommand.args,
+		options: commanderOptionSnapshots(actionCommand)
+	};
+}
+function resolveTelemetryGate() {
+	if (isCI()) return {
+		enabled: false,
+		outcome: {
+			spawned: false,
+			reason: "ci"
+		}
+	};
+	const userConfig = readUserConfig();
+	if (!resolveGating({
+		env: process.env,
+		config: userConfig
+	}).enabled) return {
+		enabled: false,
+		outcome: {
+			spawned: false,
+			reason: "gated-off"
+		}
+	};
+	return {
+		enabled: true,
+		userConfig
+	};
+}
+/**
+* Path to the compiled sender script inside `@prisma-next/cli-telemetry`'s
+* `dist/`. Resolved off this module's `import.meta.url` via the package
+* specifier `@prisma-next/cli-telemetry/sender`, so the consumer pays
+* no attention to internal package layout.
+*/
+function senderPath() {
+	return fileURLToPath(new URL(import.meta.resolve("@prisma-next/cli-telemetry/sender")));
+}
+function fireTelemetry(actionCommand, userConfig, overrides = {}) {
+	return runTelemetry({
+		command: commanderSnapshotForTelemetry(actionCommand),
+		version,
+		projectRoot: process.cwd(),
+		senderPath: senderPath(),
+		isCI: isCI(),
+		env: process.env,
+		userConfig,
+		...ifDefined("databaseTarget", overrides.databaseTarget)
+	});
+}
+/**
+* preAction-stage entry point. Synchronous by construction: resolve
+* env/CI/user-consent gates (cheap, all in-memory and a single tiny
+* user-config read), then — only when enabled — `fork()` the detached
+* sender script. The forked child loads `prisma-next.config.*` via
+* c12 on its own (see `loadProjectConfig` in cli-telemetry); the
+* parent does no project-config I/O on the command's hot path.
+*
+* Privacy invariant: gate resolution always happens before any project
+* config touches disk. The child loading user TS code is acceptable
+* only because it's gated behind the same resolved-enabled signal.
+*/
+function fireTelemetryFromPreAction(actionCommand) {
+	const gate = resolveTelemetryGate();
+	if (!gate.enabled) return gate.outcome;
+	return fireTelemetry(actionCommand, gate.userConfig);
+}
+/**
+* Manual one-shot telemetry path for the first `init` run where the user
+* explicitly answers Yes to the consent prompt. The preAction hook for
+* that same run has already resolved before consent existed, so it is
+* default-off. After consent is persisted, `runInit` calls this helper
+* exactly for that first affirmative answer; subsequent init runs skip
+* it because the prompt is not shown again.
+*
+* The child's c12 load would return `databaseTarget: null` for this
+* specific invocation because `prisma-next.config.*` is not yet on
+* disk (init writes it later in the same run). To preserve the
+* prompt-chosen target in the first-init telemetry event, this
+* helper forwards the value as a parent-side IPC override on
+* `ParentToSenderPayload.databaseTarget` — the child consults the
+* override first and falls back to its c12 result when absent.
+*/
+function fireTelemetryAfterInitConsent(actionCommand, inputs) {
+	return fireTelemetry(actionCommand, readUserConfig(), { databaseTarget: inputs.databaseTarget });
+}
+//#endregion
+//#region src/commands/init/templates/code-templates.ts
+function targetPackageName(target) {
+	return target === "postgres" ? "@prisma-next/postgres" : "@prisma-next/mongo";
+}
+function targetLabel(target) {
+	return target === "postgres" ? "PostgreSQL" : "MongoDB";
+}
+function defaultSchemaPath(authoring) {
+	if (authoring === "typescript") return `${DEFAULT_CONTRACT_SOURCE_DIR}/contract.ts`;
+	return `${DEFAULT_CONTRACT_SOURCE_DIR}/contract.prisma`;
+}
+function starterSchema(target, authoring) {
+	if (authoring === "typescript") return target === "mongo" ? starterSchemaTsMongo() : starterSchemaTsPostgres();
+	return target === "mongo" ? starterSchemaPslMongo() : starterSchemaPslPostgres();
+}
+/**
+* Renders a short authoring-appropriate schema sample (FR5.1) for embedding
+* in `prisma-next.md`. Returns a complete fenced markdown code block.
+*
+* The sample intentionally shows just one model: it's illustrative, not
+* a substitute for the full scaffolded contract file. The TS samples use
+* the same outer shape as `starterSchemaTs*` (FR5.3) so a user reading
+* the doc and the file side-by-side sees the same structure.
+*/
+function schemaSample(target, authoring) {
+	if (authoring === "typescript") return target === "mongo" ? schemaSampleTsMongo() : schemaSampleTsPostgres();
+	return target === "mongo" ? schemaSamplePslMongo() : schemaSamplePslPostgres();
+}
+function schemaSamplePslPostgres() {
+	return `\`\`\`prisma
+model User {
+  id       Int     @id @default(autoincrement())
+  email    String  @unique
+  username String?
+  name     String?
+}
+\`\`\``;
+}
+function schemaSamplePslMongo() {
+	return `\`\`\`prisma
+model User {
+  id       ObjectId @id @map("_id")
+  email    String   @unique
+  username String?
+  name     String?
+  @@map("users")
+}
+\`\`\``;
+}
+function schemaSampleTsPostgres() {
+	return `\`\`\`typescript
+import { defineContract } from '@prisma-next/postgres/contract-builder';
+
+export const contract = defineContract(
+  {},
+  ({ field, model }) => ({
+    models: {
+      User: model('User', {
+        fields: {
+          id: field.id.uuidv7(),
+          email: field.text().unique(),
+          username: field.text().optional(),
+          name: field.text().optional(),
+        },
+      }),
+    },
+  }),
+);
+\`\`\``;
+}
+function schemaSampleTsMongo() {
+	return `\`\`\`typescript
+import { defineContract } from '@prisma-next/mongo/contract-builder';
+
+export const contract = defineContract(
+  {},
+  ({ field, model }) => ({
+    models: {
+      User: model('User', {
+        collection: 'users',
+        fields: {
+          _id: field.objectId(),
+          email: field.string(),
+          username: field.string().optional(),
+          name: field.string().optional(),
+        },
+      }),
+    },
+  }),
+);
+\`\`\``;
+}
+function starterSchemaPslPostgres() {
+	return `// use prisma-next
+
+model User {
+  id        Int      @id @default(autoincrement())
+  email     String   @unique
+  username  String?
+  name      String?
+  posts     Post[]
+  createdAt DateTime @default(now())
+  updatedAt temporal.updatedAt()
+}
+
+model Post {
+  id        Int      @id @default(autoincrement())
+  title     String
+  content   String?
+  author    User     @relation(fields: [authorId], references: [id])
+  authorId  Int
+  createdAt DateTime @default(now())
+  updatedAt temporal.updatedAt()
+}
+`;
+}
+function starterSchemaPslMongo() {
+	return `// use prisma-next
+
+model User {
+  id       ObjectId @id @map("_id")
+  email    String   @unique
+  username String?
+  name     String?
+  posts    Post[]
+  @@map("users")
+}
+
+model Post {
+  id       ObjectId @id @map("_id")
+  title    String
+  content  String?
+  author   User     @relation(fields: [authorId], references: [id])
+  authorId ObjectId
+  @@map("posts")
+}
+`;
+}
+function starterSchemaTsPostgres() {
+	return `import { defineContract } from '@prisma-next/postgres/contract-builder';
+
+export const contract = defineContract(
+  {},
+  ({ field, model, rel }) => ({
+    models: {
+      User: model('User', {
+        fields: {
+          id: field.id.uuidv7(),
+          email: field.text().unique(),
+          username: field.text().optional(),
+          name: field.text().optional(),
+          createdAt: field.temporal.createdAt(),
+          updatedAt: field.temporal.updatedAt(),
+        },
+        relations: {
+          posts: rel.hasMany('Post', { by: 'authorId' }),
+        },
+      }),
+
+      Post: model('Post', {
+        fields: {
+          id: field.id.uuidv7(),
+          title: field.text(),
+          content: field.text().optional(),
+          authorId: field.uuid(),
+          createdAt: field.temporal.createdAt(),
+          updatedAt: field.temporal.updatedAt(),
+        },
+        relations: {
+          author: rel.belongsTo('User', { from: 'authorId', to: 'id' }),
+        },
+      }),
+    },
+  }),
+);
+`;
+}
+function starterSchemaTsMongo() {
+	return `import { defineContract } from '@prisma-next/mongo/contract-builder';
+
+export const contract = defineContract(
+  {},
+  ({ field, model, rel }) => ({
+    models: {
+      User: model('User', {
+        collection: 'users',
+        fields: {
+          _id: field.objectId(),
+          email: field.string(),
+          username: field.string().optional(),
+          name: field.string().optional(),
+        },
+        relations: {
+          posts: rel.hasMany('Post', { from: '_id', to: 'authorId' }),
+        },
+      }),
+
+      Post: model('Post', {
+        collection: 'posts',
+        fields: {
+          _id: field.objectId(),
+          title: field.string(),
+          content: field.string().optional(),
+          authorId: field.objectId(),
+        },
+        relations: {
+          author: rel.belongsTo('User', { from: 'authorId', to: '_id' }),
+        },
+      }),
+    },
+  }),
+);
+`;
+}
+function configFile(target, contractPath) {
+	return `import 'dotenv/config';
+import { defineConfig } from '${targetPackageName(target)}/config';
+
+export default defineConfig({
+  contract: ${JSON.stringify(contractPath)},
+  db: {
+    connection: process.env['DATABASE_URL']!,
+  },
+});
+`;
+}
+function dbFile(target) {
+	if (target === "postgres") return `import postgres from '@prisma-next/postgres/runtime';
+import type { Contract } from './contract.d';
+import contractJson from './contract.json' with { type: 'json' };
+
+export const db = postgres<Contract>({
+  contractJson,
+  url: process.env['DATABASE_URL']!,
+});
+`;
+	return `import mongo from '@prisma-next/mongo/runtime';
+import type { Contract } from './contract.d';
+import contractJson from './contract.json' with { type: 'json' };
+
+export const db = mongo<Contract>({
+  contractJson,
+  url: process.env['DATABASE_URL']!,
+});
+`;
+}
 //#endregion
 //#region src/commands/init/index.ts
 function createInitCommand() {
@@ -40,11 +410,11 @@ Exit codes (see CLI Style Guide § Exit Codes):
 		"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",
-		"prisma-next init --no-skill                                         # skip the agent-skill install (air-gapped / restricted env)"
+		"prisma-next init --no-skill                                         # skip the skills install (air-gapped / restricted env)"
 	]);
-	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").option("--no-skill", "Skip Prisma Next skills install (air-gapped CI, restricted registries, etc.)").action(async (options) => {
-		const { runInit } = await import("./init-eh2z5Tl6.mjs");
-		const flags = parseGlobalFlags(options);
+	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: ${defaultSchemaPath("psl")})`).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").option("--no-skill", "Skip Prisma Next skills install (air-gapped CI, restricted registries, etc.)").action(async (options, actionCommand) => {
+		const { runInit } = await import("./init-YX6lCJpG.mjs");
+		const flags = parseGlobalFlagsOrExit(options);
 		const canPrompt = deriveCanPrompt({
 			flagsInteractive: flags.interactive,
 			optionInteractive: options.interactive,
@@ -53,7 +423,10 @@ Exit codes (see CLI Style Guide § Exit Codes):
 		const exitCode = await runInit(process.cwd(), {
 			options,
 			flags,
-			canPrompt
+			canPrompt,
+			afterFirstTelemetryConsent: (inputs) => {
+				fireTelemetryAfterInitConsent(actionCommand, { databaseTarget: inputs.target });
+			}
 		});
 		process.exit(exitCode);
 	});
@@ -137,6 +510,11 @@ function formatSuggestion(input, candidates) {
 }
 const program = new Command();
 program.name("prisma-next").description("Prisma Next CLI").version(version);
+program.hook("preAction", (_thisCommand, actionCommand) => {
+	try {
+		fireTelemetryFromPreAction(actionCommand);
+	} catch {}
+});
 const versionOption = program.options.find((opt) => opt.flags.includes("--version"));
 if (versionOption) versionOption.description = "Output the version number";
 program.configureOutput({
@@ -272,6 +650,15 @@ program.addCommand(contractCommand);
 program.addCommand(dbCommand);
 program.addCommand(migrationCommand);
 program.addCommand(refCommand);
+const TELEMETRY_CRASH_TEST_SLEEP_MS = 200;
+if (process.env["PRISMA_NEXT_ENABLE_TEST_COMMANDS"] === "1") {
+	const telemetryCrashTestCommand = new Command("__telemetry-crash-test").description("Internal: deliberately throw for the telemetry e2e suite.").action(async () => {
+		await new Promise((settle) => setTimeout(settle, TELEMETRY_CRASH_TEST_SLEEP_MS));
+		throw new Error("__telemetry-crash-test: intentional crash for e2e coverage");
+	});
+	telemetryCrashTestCommand.configureHelp({ visibleCommands: () => [] });
+	program.addCommand(telemetryCrashTestCommand, { hidden: true });
+}
 const helpCommand = new Command("help").description("Show usage instructions").configureHelp({ formatHelp: (cmd) => {
 	return formatCommandHelp({
 		command: cmd,
@@ -342,6 +729,6 @@ if (args.length > 0) {
 }
 program.parse();
 //#endregion
-export { version as t };
+export { starterSchema as a, version as c, schemaSample as i, dbFile as n, targetLabel as o, defaultSchemaPath as r, targetPackageName as s, configFile as t };
 
 //# sourceMappingURL=cli.mjs.map