@prisma/orm-toolchain 0.16.0

package/dist/bin__prisma-next.mjs

@@ -0,0 +1,800 @@
+#!/usr/bin/env node
+import { J as installShutdownHandlers, P as formatCommandHelp, U as formatRootHelp, Y as isCI$1, ct as setCommandExamples, et as parseGlobalFlags, r as addGlobalOptions, s as deriveCanPrompt, st as setCommandDescriptions, tt as parseGlobalFlagsOrExit } from "./command-helpers-CAoXqAY9-DWUBcTXM.mjs";
+import { i as createScaffoldSpecifierResolver } from "./import-roots-NDOIEDVj.mjs";
+import { t as createContractEmitCommand } from "./contract-emit-0hSjbuxp-BBOKldTZ.mjs";
+import { t as createFormatCommand } from "./format-ByDm2goZ-DKLyhNHo.mjs";
+import { t as createDbInitCommand } from "./db-init-Vbkb_TKZ.mjs";
+import { t as createDbUpdateCommand } from "./db-update-BQlrqtDD.mjs";
+import { t as createDbSchemaCommand } from "./db-schema-ClQCu3xY.mjs";
+import { t as createDbSignCommand } from "./db-sign-jjXDgQ1u.mjs";
+import { t as createDbVerifyCommand } from "./db-verify-CKPsRFrj-3udprZQD.mjs";
+import { t as createContractInferCommand } from "./contract-infer-BnkqpftN-DVM2eKJ3.mjs";
+import { t as createMigrationNewCommand } from "./migration-new-BurCjyaQ.mjs";
+import { t as createMigrationPlanCommand } from "./migration-plan-q_L84PN1-BWE0LTH6.mjs";
+import { t as createMigrationShowCommand } from "./migration-show-Bx5I5aW9.mjs";
+import { t as createMigrationListCommand } from "./migration-list-BFBeo1_X-c0kqYokL.mjs";
+import { r as createMigrationStatusCommand } from "./migration-status-CE7cQLDq-B1jDVmqG.mjs";
+import { t as createMigrationLogCommand } from "./migration-log-CS5IWcNq-BQ-32Low.mjs";
+import { t as createMigrationGraphCommand } from "./migration-graph-DkoCC0Qy.mjs";
+import { t as createMigrationCheckCommand } from "./migration-check-DcwUnadt-B6Qoh0ot.mjs";
+import { t as createMigrateCommand } from "./migrate-Cb_iv264.mjs";
+import { t as createRefCommand } from "./ref-B6cTthTi.mjs";
+import { a as resolveGating, i as readUserConfig, r as ensureInstallationId, s as runTelemetry, u as userConfigPath } from "./exports-BN0vFTxG.mjs";
+import { t as createTelemetryCommand } from "./telemetry-CmbCa3Ld-CmE5zcIG.mjs";
+import { DEFAULT_CONTRACT_SOURCE_DIR } from "@prisma/orm-framework/config/config-types";
+import { keepInternalSpecifiers } from "@prisma/orm-framework/components/emission";
+import { Command } from "commander";
+import { fileURLToPath } from "node:url";
+import { distance } from "closest-match";
+//#region ../../../1-framework/3-tooling/cli/dist/cli.mjs
+var version = "0.16.0";
+/**
+* The resolver a scaffold for `target` is written against.
+*
+* A scaffold is always on the facade root: `init` writes an application around
+* one database package, and the workspace names are not published, so a project
+* scaffolded against them could not install (ADR 242). Both the files `init`
+* writes and the dependency it adds go through this, so they cannot disagree.
+*/
+function scaffoldSpecifierResolverFor(target) {
+	return createScaffoldSpecifierResolver({
+		mode: "facade",
+		facade: target === "postgres" ? "@prisma/orm-postgres" : "@prisma/orm-mongo"
+	});
+}
+/**
+* The package name a scaffolded project depends on and imports from, for the
+* import root it is being scaffolded against.
+*
+* Every specifier the scaffold writes derives from this one, and `init` builds
+* a single resolver and hands it to both the file templates and the dependency
+* it installs — so the two cannot disagree. The one caller that deliberately
+* does not thread a resolver is the re-init cleanup in `inputs.ts`, which
+* inspects a manifest an earlier run wrote rather than writing one.
+*
+* Resolvers for scaffolding should come from `createScaffoldSpecifierResolver`
+* in the publish-surface package, which rejects the roots a facade-shaped
+* scaffold cannot express. (Named without its scope on purpose: JSDoc survives
+* into the published bundle, where an internal package name would trip the
+* shell tarball checks.)
+*/
+function targetPackageName(target, resolveImportSpecifier = keepInternalSpecifiers) {
+	return resolveImportSpecifier(target === "postgres" ? "@internal/postgres" : "@internal/mongo");
+}
+/** One entrypoint of the scaffolded project's target package. */
+function targetEntrypoint(target, subpath, resolveImportSpecifier = keepInternalSpecifiers) {
+	return resolveImportSpecifier(`${target === "postgres" ? "@internal/postgres" : "@internal/mongo"}/${subpath}`);
+}
+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, resolveImportSpecifier = keepInternalSpecifiers) {
+	if (authoring === "typescript") {
+		const builder = targetEntrypoint(target, "contract-builder", resolveImportSpecifier);
+		return target === "mongo" ? starterSchemaTsMongo(builder) : starterSchemaTsPostgres(builder);
+	}
+	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, resolveImportSpecifier = keepInternalSpecifiers) {
+	if (authoring === "typescript") {
+		const builder = targetEntrypoint(target, "contract-builder", resolveImportSpecifier);
+		return target === "mongo" ? schemaSampleTsMongo(builder) : schemaSampleTsPostgres(builder);
+	}
+	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(builder) {
+	return `\`\`\`typescript
+import { defineContract } from '${builder}';
+
+export const contract = defineContract(
+  {},
+  ({ field, model }) => ({
+    models: {
+      User: model('User', {
+        fields: {
+          id: field.id.uuidv7String(),
+          email: field.text().unique(),
+          username: field.text().optional(),
+          name: field.text().optional(),
+        },
+      }),
+    },
+  }),
+);
+\`\`\``;
+}
+function schemaSampleTsMongo(builder) {
+	return `\`\`\`typescript
+import { defineContract } from '${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(builder) {
+	return `import { defineContract } from '${builder}';
+
+export const contract = defineContract(
+  {},
+  ({ field, model, rel }) => ({
+    models: {
+      User: model('User', {
+        fields: {
+          id: field.id.uuidv7String(),
+          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.uuidv7String(),
+          title: field.text(),
+          content: field.text().optional(),
+          authorId: field.uuidString(),
+          createdAt: field.temporal.createdAt(),
+          updatedAt: field.temporal.updatedAt(),
+        },
+        relations: {
+          author: rel.belongsTo('User', { from: 'authorId', to: 'id' }),
+        },
+      }),
+    },
+  }),
+);
+`;
+}
+function starterSchemaTsMongo(builder) {
+	return `import { defineContract } from '${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, resolveImportSpecifier = keepInternalSpecifiers) {
+	return `import 'dotenv/config';
+import { defineConfig } from '${targetEntrypoint(target, "config", resolveImportSpecifier)}';
+
+export default defineConfig({
+  contract: ${JSON.stringify(contractPath)},
+  db: {
+    connection: process.env['DATABASE_URL']!,
+  },
+});
+`;
+}
+function dbFile(target, resolveImportSpecifier = keepInternalSpecifiers) {
+	const runtime = targetEntrypoint(target, "runtime", resolveImportSpecifier);
+	if (target === "postgres") return `import postgres from '${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 '${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']!,
+});
+`;
+}
+function createInitCommand() {
+	const command = new Command("init");
+	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):
+  0   OK                    Init succeeded.\n  1   INTERNAL_ERROR        Unexpected bug in prisma-next (please report).\n  2   PRECONDITION          Bad flags / missing prerequisite (e.g. no package.json).\n  3   USER_ABORTED          User cancelled an interactive prompt.\n  4   INSTALL_FAILED        Dependency installation failed (init-specific).\n  5   EMIT_FAILED           \`contract emit\` failed after install (init-specific).\n  6   SKILL_INSTALL_FAILED  Agent-skill install failed (re-run with --no-skill to skip).`);
+	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",
+		"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: ${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) => {
+		const { runInit } = await import("./init-DHctXAI9-DSlaaYXN.mjs");
+		const flags = parseGlobalFlagsOrExit(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);
+	});
+}
+function createLspCommand() {
+	const command = new Command("lsp");
+	setCommandDescriptions(command, "Start the Prisma Next language server", "Launches a Language Server Protocol server that publishes PSL parse diagnostics\nand handles whole-document PSL formatting for the schema inputs declared in\nyour config (contract.source.inputs). Formatting uses the Prisma Next PSL\nformatter and the formatter block from the project config.\nCommunicates over stdio; intended to be spawned by an\neditor, not run interactively. The server keeps running until the editor client\ndisconnects.");
+	setCommandExamples(command, ["prisma-next lsp --stdio"]);
+	addGlobalOptions(command).option("--stdio", "Communicate with the editor over stdio (the default and only transport)").action(async () => {
+		const { startServer } = await import("./exports-B_xhKZmC.mjs");
+		startServer();
+	});
+	return command;
+}
+/**
+* Suggests similar command names for a mistyped input.
+*
+* Uses Levenshtein distance to find close matches. Only suggests commands
+* within a reasonable distance threshold (40% of the input length, minimum 2).
+* Returns up to 3 suggestions in case of ties.
+*
+* @returns Array of suggested command names (empty if nothing is close enough).
+*/
+function suggestCommands(input, candidates) {
+	if (candidates.length === 0) return [];
+	const maxDistance = Math.max(2, Math.ceil(input.length * .4));
+	const scored = candidates.map((name) => ({
+		name,
+		dist: distance(input, name)
+	})).filter((entry) => entry.dist <= maxDistance).sort((a, b) => a.dist - b.dist);
+	if (scored.length === 0) return [];
+	const bestDist = scored[0].dist;
+	return scored.filter((entry) => entry.dist === bestDist).slice(0, 3).map((entry) => entry.name);
+}
+/**
+* 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$1()) 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 `@internal/cli-telemetry`'s
+* `dist/`. Resolved off this module's `import.meta.url` via the package
+* specifier `@internal/cli-telemetry/sender`, so the consumer pays
+* no attention to internal package layout.
+*/
+function senderPath() {
+	return fileURLToPath(new URL(import.meta.resolve("@internal/cli-telemetry/sender")));
+}
+function fireTelemetry(actionCommand, userConfig) {
+	return runTelemetry({
+		command: commanderSnapshotForTelemetry(actionCommand),
+		version,
+		projectRoot: process.cwd(),
+		senderPath: senderPath(),
+		isCI: isCI$1(),
+		env: process.env,
+		userConfig
+	});
+}
+/**
+* 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.
+*/
+/**
+* Builds the one-time first-run disclosure. The resolved absolute path to
+* the user-level config file is substituted in so the user can see exactly
+* which file to edit (it must not be confused with `prisma-next.config.ts`).
+* `prisma-next telemetry disable` is named as the primary, friendliest
+* opt-out, alongside the env vars and the config edit.
+*/
+function firstRunNotice(configPath) {
+	return [
+		"Prisma Next collects anonymous CLI usage data, enabled by default.",
+		"What's collected and why: https://prisma-next.dev/docs/cli/telemetry.",
+		"Opt out: run \"prisma-next telemetry disable\", set DO_NOT_TRACK=1 or",
+		`PRISMA_NEXT_DISABLE_TELEMETRY=1, or set "enableTelemetry": false in ${configPath}.`
+	].join(" ");
+}
+/**
+* Best-effort first-run disclosure + installationId mint. Runs only on the
+* gating-enabled path. Prints the notice to stderr (never stdout) and mints
+* a persistent id without touching `enableTelemetry`, so the opt-out default
+* stays intact and no unasked-for consent is recorded.
+*
+* Every step is wrapped so an un-writable config dir (or any other failure)
+* never throws and never blocks the command. Returns the minted (or
+* pre-existing) id so the caller can forward it to `runTelemetry` without a
+* redundant disk read. On mint failure it returns `undefined`: the notice may
+* reprint next run, and `runTelemetry` no-ops on the missing id.
+*/
+function discloseAndMintOnFirstRun() {
+	try {
+		process.stderr.write(`${firstRunNotice(userConfigPath())}\n`);
+	} catch {}
+	try {
+		return ensureInstallationId();
+	} catch {}
+}
+/**
+* True when the run is the `telemetry` command (or one of its
+* subcommands). The usage-telemetry preAction fire is exempted for it:
+* it would be absurd for `telemetry disable` to send a usage event before
+* disabling, or for `telemetry status` to mint an id + send while merely
+* reporting state. This is the only command-specific exemption.
+*
+* The check is rooted at the program: the path must be
+* `['prisma-next', 'telemetry', …]`, so it matches the top-level
+* `telemetry` command and its subcommands without matching a hypothetical
+* nested `… telemetry` elsewhere.
+*/
+function isTelemetryCommand(actionCommand) {
+	return commandPathFor(actionCommand)[1] === "telemetry";
+}
+function fireTelemetryFromPreAction(actionCommand) {
+	if (isTelemetryCommand(actionCommand)) return {
+		spawned: false,
+		reason: "gated-off"
+	};
+	const gate = resolveTelemetryGate();
+	if (!gate.enabled) return gate.outcome;
+	const storedId = gate.userConfig.installationId;
+	if (typeof storedId !== "string" || storedId.length === 0) {
+		const installationId = discloseAndMintOnFirstRun();
+		return fireTelemetry(actionCommand, installationId === void 0 ? gate.userConfig : {
+			...gate.userConfig,
+			installationId
+		});
+	}
+	return fireTelemetry(actionCommand, gate.userConfig);
+}
+installShutdownHandlers();
+/**
+* Lookup table mapping removed subcommands to their replacement verbs.
+* Keyed by `<parent>:<subcommand>` (e.g. `migration:apply`).
+* The handler consults this before falling back to the fuzzy suggest engine.
+*/
+const removedVerbRedirects = {
+	"migration:apply": "Use `prisma-next migrate --to <contract>` instead.",
+	"migration:ref": "Use `prisma-next ref set|list|delete` instead."
+};
+/**
+* Removed flags on specific subcommands. Keyed by `<parent>:<sub>:<flag>`.
+* Checked during the pre-parse argv scan before commander sees the flags.
+*/
+const removedFlagRedirects = {
+	"migration:status:graph": "Use `prisma-next migration graph` to view the migration graph.",
+	"migration:status:all": "Use `prisma-next migration log --db <url>` to view the full execution history.",
+	"migration:status:limit": "Use `prisma-next migration log --db <url>` to view the full execution history.",
+	"migration:status:ref": "Use `--to <contract>` instead of `--ref`."
+};
+/**
+* Formats the "Did you mean ...?" hint for an unknown command.
+*/
+function formatSuggestion(input, candidates) {
+	const suggestions = suggestCommands(input, candidates.map((c) => c));
+	if (suggestions.length === 0) return "";
+	if (suggestions.length === 1) return `\nDid you mean ${suggestions[0]}?\n`;
+	return `\nDid you mean one of these?\n${suggestions.map((s) => `  ${s}`).join("\n")}\n`;
+}
+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({
+	writeErr: () => {},
+	writeOut: (str) => {
+		process.stdout.write(str);
+	}
+});
+const rootHelpFormatter = (cmd) => {
+	return formatRootHelp({
+		program: cmd,
+		flags: parseGlobalFlags({})
+	});
+};
+program.configureHelp({
+	formatHelp: rootHelpFormatter,
+	subcommandDescription: () => ""
+});
+program.exitOverride((err) => {
+	if (err) {
+		const errorCode = err.code;
+		const errorMessage = String(err.message ?? "");
+		const errorName = err.name ?? "";
+		if (errorCode === "commander.unknownCommand" || errorCode === "commander.unknownArgument" || errorName === "CommanderError" && (errorMessage.includes("unknown command") || errorMessage.includes("unknown argument"))) {
+			const flags = parseGlobalFlags({});
+			const match = errorMessage.match(/unknown command ['"]([^'"]+)['"]/);
+			const commandName = match ? match[1] : process.argv[3] || process.argv[2] || "unknown";
+			const firstArg = process.argv[2];
+			const parentCommand = firstArg ? program.commands.find((cmd) => cmd.name() === firstArg) : void 0;
+			if (parentCommand && commandName !== firstArg) {
+				const subNames = parentCommand.commands.map((c) => c.name());
+				process.stderr.write(`Unknown command: ${commandName}${formatSuggestion(commandName, subNames)}\n`);
+				const helpText = formatCommandHelp({
+					command: parentCommand,
+					flags
+				});
+				process.stderr.write(`${helpText}\n`);
+			} else {
+				const topNames = program.commands.map((c) => c.name());
+				process.stderr.write(`Unknown command: ${commandName}${formatSuggestion(commandName, topNames)}\n`);
+				const helpText = formatRootHelp({
+					program,
+					flags
+				});
+				process.stderr.write(`${helpText}\n`);
+			}
+			process.exit(2);
+			return;
+		}
+		if (errorCode === "commander.help" || errorCode === "commander.helpDisplayed" || errorCode === "outputHelp" || errorMessage === "(outputHelp)" || errorMessage.includes("outputHelp") || errorName === "CommanderError" && errorMessage.includes("outputHelp")) {
+			process.exit(0);
+			return;
+		}
+		if (errorCode === "commander.missingArgument" || errorCode === "commander.missingMandatoryOptionValue" || errorName === "CommanderError" && (errorMessage.includes("missing") || errorMessage.includes("required"))) {
+			process.exit(2);
+			return;
+		}
+		process.stderr.write(`Unhandled error: ${err.message}\n`);
+		if (err.stack) process.stderr.write(`${err.stack}\n`);
+		process.exit(1);
+	}
+	process.exit(0);
+});
+const contractCommand = new Command("contract");
+setCommandDescriptions(contractCommand, "Contract management commands", "Define and emit your application data contract. The contract describes your schema as a\ndeclarative data structure that can be signed and verified against your database.");
+contractCommand.configureHelp({
+	formatHelp: (cmd) => {
+		return formatCommandHelp({
+			command: cmd,
+			flags: parseGlobalFlags({})
+		});
+	},
+	subcommandDescription: () => ""
+});
+const contractEmitCommand = createContractEmitCommand();
+contractCommand.addCommand(contractEmitCommand);
+const contractInferCommand = createContractInferCommand();
+contractCommand.addCommand(contractInferCommand);
+const dbCommand = new Command("db");
+setCommandDescriptions(dbCommand, "Database management commands", "Verify and sign your database with your contract. Ensure your database schema matches\nyour contract, and sign it to record the contract hash for future verification.");
+dbCommand.configureHelp({
+	formatHelp: (cmd) => {
+		return formatCommandHelp({
+			command: cmd,
+			flags: parseGlobalFlags({})
+		});
+	},
+	subcommandDescription: () => ""
+});
+const dbVerifyCommand = createDbVerifyCommand();
+dbCommand.addCommand(dbVerifyCommand);
+const dbInitCommand = createDbInitCommand();
+dbCommand.addCommand(dbInitCommand);
+const dbUpdateCommand = createDbUpdateCommand();
+dbCommand.addCommand(dbUpdateCommand);
+const dbSchemaCommand = createDbSchemaCommand();
+dbCommand.addCommand(dbSchemaCommand);
+const dbSignCommand = createDbSignCommand();
+dbCommand.addCommand(dbSignCommand);
+const migrationCommand = new Command("migration");
+setCommandDescriptions(migrationCommand, "On-disk migration management commands", "Plan, apply, and scaffold on-disk migration packages. Migrations are\ncontract-to-contract edges stored as versioned directories under migrations/.");
+migrationCommand.configureHelp({
+	formatHelp: (cmd) => {
+		return formatCommandHelp({
+			command: cmd,
+			flags: parseGlobalFlags({})
+		});
+	},
+	subcommandDescription: () => ""
+});
+const migrationPlanCommand = createMigrationPlanCommand();
+migrationCommand.addCommand(migrationPlanCommand);
+const migrationNewCommand = createMigrationNewCommand();
+migrationCommand.addCommand(migrationNewCommand);
+const migrationShowCommand = createMigrationShowCommand();
+migrationCommand.addCommand(migrationShowCommand);
+const migrationStatusCommand = createMigrationStatusCommand();
+migrationCommand.addCommand(migrationStatusCommand);
+const migrationLogCommand = createMigrationLogCommand();
+migrationCommand.addCommand(migrationLogCommand);
+const migrationListCommand = createMigrationListCommand();
+migrationCommand.addCommand(migrationListCommand);
+const migrationGraphCommand = createMigrationGraphCommand();
+migrationCommand.addCommand(migrationGraphCommand);
+const migrationCheckCommand = createMigrationCheckCommand();
+migrationCommand.addCommand(migrationCheckCommand);
+const migrateCommand = createMigrateCommand();
+const refCommand = createRefCommand();
+const telemetryCommand = createTelemetryCommand();
+const initCommand = createInitCommand();
+const formatCommand = createFormatCommand();
+const lspCommand = createLspCommand();
+program.addCommand(initCommand);
+program.addCommand(migrateCommand);
+program.addCommand(formatCommand);
+program.addCommand(lspCommand);
+program.addCommand(contractCommand);
+program.addCommand(dbCommand);
+program.addCommand(migrationCommand);
+program.addCommand(refCommand);
+program.addCommand(telemetryCommand);
+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,
+		flags: parseGlobalFlags({})
+	});
+} }).action(() => {
+	const flags = parseGlobalFlags({});
+	const helpText = formatRootHelp({
+		program,
+		flags
+	});
+	process.stdout.write(`${helpText}\n`);
+	process.exit(0);
+});
+program.addCommand(helpCommand);
+program.action(() => {
+	const flags = parseGlobalFlags({});
+	const helpText = formatRootHelp({
+		program,
+		flags
+	});
+	process.stderr.write(`${helpText}\n`);
+	process.exit(0);
+});
+const args = process.argv.slice(2);
+if (args.length > 0) {
+	const commandName = args[0];
+	if (commandName === "--version" || commandName === "-V") {
+		process.stdout.write(`${program.version()}\n`);
+		process.exit(0);
+	}
+	if (!(commandName === "--help" || commandName === "-h")) {
+		const command = program.commands.find((cmd) => cmd.name() === commandName);
+		if (!command) {
+			const flags = parseGlobalFlags({});
+			const topNames = program.commands.map((c) => c.name());
+			process.stderr.write(`Unknown command: ${commandName}${formatSuggestion(commandName, topNames)}\n`);
+			const helpText = formatRootHelp({
+				program,
+				flags
+			});
+			process.stderr.write(`${helpText}\n`);
+			process.exit(2);
+		} else if (command.commands.length > 0 && args.length >= 2) {
+			const subcommandName = args[1];
+			const redirect = removedVerbRedirects[`${commandName}:${subcommandName}`];
+			if (redirect) {
+				process.stderr.write(`Unknown command: ${subcommandName}\n${redirect}\n`);
+				process.exit(2);
+			}
+			for (let i = 2; i < args.length; i++) {
+				const arg = args[i];
+				if (!arg.startsWith("--")) continue;
+				const flagRedirect = removedFlagRedirects[`${commandName}:${subcommandName}:${arg.slice(2)}`];
+				if (flagRedirect) {
+					process.stderr.write(`Unknown option: ${arg}\n${flagRedirect}\n`);
+					process.exit(2);
+				}
+			}
+		}
+		if (command.commands.length > 0 && args.length === 1) {
+			const helpText = formatCommandHelp({
+				command,
+				flags: parseGlobalFlags({})
+			});
+			process.stderr.write(`${helpText}\n`);
+			process.exit(0);
+		}
+	}
+}
+program.parse();
+//#endregion
+export { schemaSample as a, targetLabel as c, scaffoldSpecifierResolverFor as i, targetPackageName as l, dbFile as n, starterSchema as o, defaultSchemaPath as r, targetEntrypoint as s, configFile as t, version as u };
+
+//# sourceMappingURL=bin__prisma-next.mjs.map