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

package/dist/init-C7dE9KOJ.mjs

@@ -0,0 +1,2062 @@
+import { t as CliStructuredError } from "./cli-errors-By1iVE3z.mjs";
+import { i as formatErrorOutput, r as formatErrorJson, t as TerminalUI } from "./terminal-ui-u2YgKghu.mjs";
+import { a as INIT_EXIT_PRECONDITION, i as INIT_EXIT_OK, n as INIT_EXIT_INSTALL_FAILED, o as INIT_EXIT_USER_ABORTED, r as INIT_EXIT_INTERNAL_ERROR, t as INIT_EXIT_EMIT_FAILED } from "./cli.mjs";
+import { i as renderInitOutro, n as buildNextSteps, r as formatInitJson, t as InitOutputSchema } from "./output-BpcQrnnq.mjs";
+import { createRequire } from "node:module";
+import { dirname, extname, isAbsolute, join, normalize } from "pathe";
+import * as clack from "@clack/prompts";
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { detect } from "package-manager-detector/detect";
+import { applyEdits, modify, parse, printParseErrorCode } from "jsonc-parser";
+
+//#region src/commands/init/detect-package-manager.ts
+const KNOWN = new Set([
+	"pnpm",
+	"npm",
+	"yarn",
+	"bun",
+	"deno"
+]);
+async function detectPackageManager(cwd) {
+	const result = await detect({ cwd });
+	if (result && KNOWN.has(result.name)) return result.name;
+	return "npm";
+}
+function hasProjectManifest(cwd) {
+	return existsSync(join(cwd, "package.json")) || existsSync(join(cwd, "deno.json")) || existsSync(join(cwd, "deno.jsonc"));
+}
+function formatRunCommand(pm, bin, args) {
+	if (pm === "npm") return `npx ${bin} ${args}`;
+	if (pm === "deno") return `deno run npm:${bin} ${args}`;
+	return `${pm} ${bin} ${args}`;
+}
+function formatAddArgs(pm, packages) {
+	if (pm === "deno") return ["add", ...packages.map((p) => `npm:${p}`)];
+	return ["add", ...packages];
+}
+function formatAddDevArgs(pm, packages) {
+	if (pm === "deno") return [
+		"add",
+		"--dev",
+		...packages.map((p) => `npm:${p}`)
+	];
+	return [
+		"add",
+		"-D",
+		...packages
+	];
+}
+
+//#endregion
+//#region src/commands/init/detect-pnpm-catalog.ts
+/**
+* Walks up from `baseDir` looking for `pnpm-workspace.yaml`, then scans
+* its top-level `catalog:` block for entries that match any of `packages`.
+*
+* Implements FR7.3 / Spec Decision 8 (honour-and-warn): when `init` runs
+* inside a pnpm workspace whose catalog overrides one of the packages it
+* installs, surface a structured warning so the user knows the catalog
+* version (not the published `latest`) is what ended up in their
+* `node_modules`. pnpm itself does this silently; the warning closes the
+* "looks fine, must be wrong version six months later" gap.
+*
+* Notes / scope:
+*
+* - We only inspect the unnamed top-level `catalog:` block. pnpm also
+*   supports `catalogs:` (plural — *named* catalogs referenced via
+*   `catalog:foo` specifiers); those don't apply to a vanilla
+*   `pnpm add prisma-next` invocation, so we skip them.
+* - We don't validate YAML syntax exhaustively. The file format pnpm
+*   ships is line-oriented and well-known; a minimal regex is more
+*   robust than depending on a YAML parser for one warning.
+* - We don't compare against the registry's `latest` — pnpm uses the
+*   catalog version regardless, so the warning fires whenever a match
+*   exists. The user-facing copy explains how to opt out.
+*/
+function detectPnpmCatalogOverrides(baseDir, packages) {
+	const workspaceFile = findNearestPnpmWorkspaceFile(baseDir);
+	if (workspaceFile === null) return null;
+	const catalog = extractCatalogBlock(readFileSync(workspaceFile, "utf-8"));
+	if (catalog === null) return {
+		workspaceFile,
+		entries: []
+	};
+	const wanted = new Set(packages);
+	const entries = [];
+	for (const [name, version] of catalog) if (wanted.has(name)) entries.push({
+		name,
+		version
+	});
+	return {
+		workspaceFile,
+		entries
+	};
+}
+function findNearestPnpmWorkspaceFile(baseDir) {
+	let dir = baseDir;
+	let prev = "";
+	while (dir !== prev) {
+		const candidate = join(dir, "pnpm-workspace.yaml");
+		if (existsSync(candidate)) return candidate;
+		prev = dir;
+		dir = dirname(dir);
+	}
+	return null;
+}
+/**
+* Returns the entries inside the top-level `catalog:` block as `[name, version]`
+* pairs in document order, or `null` when no `catalog:` block exists.
+*
+* The parser is intentionally minimal: it reads line-by-line, locates the
+* top-level `catalog:` line (no leading whitespace), then collects every
+* subsequent indented line of the form `<key>: <value>` until the next
+* top-level key (or end of file). Quotes around `<key>` and `<value>`
+* are stripped; comments (`#…`) are ignored.
+*/
+function extractCatalogBlock(contents) {
+	const lines = contents.split(/\r?\n/);
+	const startIdx = lines.findIndex((line) => /^catalog\s*:\s*$/.test(line));
+	if (startIdx === -1) return null;
+	const entries = [];
+	for (let i = startIdx + 1; i < lines.length; i++) {
+		const raw = lines[i] ?? "";
+		if (raw.trim() === "" || /^\s*#/.test(raw)) continue;
+		if (!/^\s/.test(raw)) break;
+		const match = raw.match(/^\s+(?:'([^']+)'|"([^"]+)"|([^:\s'"]+))\s*:\s*(.*?)\s*(?:#.*)?$/);
+		if (!match) continue;
+		const name = match[1] ?? match[2] ?? match[3];
+		if (name === void 0) continue;
+		const version = stripQuotes((match[4] ?? "").trim());
+		if (version === "") continue;
+		entries.push([name, version]);
+	}
+	return entries;
+}
+function stripQuotes(value) {
+	if (value.length >= 2) {
+		const first = value[0];
+		const last = value[value.length - 1];
+		if (first === "\"" && last === "\"" || first === "'" && last === "'") return value.slice(1, -1);
+	}
+	return value;
+}
+
+//#endregion
+//#region src/commands/init/errors.ts
+/**
+* No `package.json` / `deno.json` / `deno.jsonc` in the target directory.
+*
+* `init` cannot bootstrap a fresh project from a bare directory (NG1) — that
+* gap is tracked separately. The fix is for the user to run `npm init` (or
+* the equivalent for their package manager) first.
+*/
+function errorInitMissingManifest() {
+	return new CliStructuredError("5001", "No project manifest found", {
+		domain: "CLI",
+		why: "No package.json or deno.json found in the target directory. `prisma-next init` requires an existing project to attach to.",
+		fix: "Initialize your project first (e.g. `npm init -y` or `deno init`), then re-run `prisma-next init`.",
+		docsUrl: "https://prisma-next.dev/docs/cli/init"
+	});
+}
+/**
+* Re-init in non-interactive mode without `--force`. Distinct from the
+* decline-the-prompt path (which is `errorInitUserAborted`) because here
+* the user was never given the choice — `--force` is the contract.
+*/
+function errorInitReinitNeedsForce() {
+	return new CliStructuredError("5002", "Project is already initialized", {
+		domain: "CLI",
+		why: "A `prisma-next.config.ts` already exists in this directory. Re-running `init` would overwrite the scaffolded files; in non-interactive mode `init` will not do that without `--force`.",
+		fix: "Pass `--force` to overwrite the existing scaffold, or run `init` interactively to confirm.",
+		docsUrl: "https://prisma-next.dev/docs/cli/init"
+	});
+}
+/**
+* Non-interactive mode is missing one or more required inputs. Lists every
+* missing flag in the error so an agent / CI script can react without
+* needing to parse English.
+*
+* @param missing — kebab-case flag names without leading dashes
+* @param why — additional context (e.g. "stdin is not a TTY") that helps
+*              the user understand why interactive fallback was skipped.
+*/
+function errorInitMissingFlags(options) {
+	const flagList = options.missing.map((flag) => `--${flag}`).join(", ");
+	const fixList = options.missing.map((flag) => {
+		switch (flag) {
+			case "target": return "--target postgres|mongodb";
+			case "authoring": return "--authoring psl|typescript";
+			case "schema-path": return "--schema-path <path>";
+			default: return `--${flag} <value>`;
+		}
+	}).join(" ");
+	return new CliStructuredError("5003", "Missing required flags", {
+		domain: "CLI",
+		why: `${options.why} Missing required flag(s): ${flagList}.`,
+		fix: `Re-run with the missing flag(s) supplied, e.g. \`prisma-next init --yes ${fixList}\`. Use \`prisma-next init --help\` to see every flag.`,
+		docsUrl: "https://prisma-next.dev/docs/cli/init",
+		meta: { missingFlags: options.missing }
+	});
+}
+/**
+* A flag value was supplied but is not in the allowed set. Lists the
+* allowed values in `meta` for machine-readable consumption.
+*/
+function errorInitInvalidFlagValue(options) {
+	return new CliStructuredError("5004", `Invalid value for --${options.flag}`, {
+		domain: "CLI",
+		why: `\`--${options.flag} ${options.value}\` is not one of: ${options.allowed.join(", ")}.`,
+		fix: `Use one of: ${options.allowed.map((v) => `--${options.flag} ${v}`).join(", ")}.`,
+		docsUrl: "https://prisma-next.dev/docs/cli/init",
+		meta: {
+			flag: options.flag,
+			value: options.value,
+			allowed: options.allowed
+		}
+	});
+}
+/**
+* The user cancelled an interactive prompt (Ctrl-C, escape, declined a
+* selection). Distinct from `errorInitReinitNeedsForce` because that path
+* applies to non-interactive mode where the user was never given the
+* choice; this one is the generic "user said no" path. Maps to exit code
+* 3 (USER_ABORTED).
+*/
+function errorInitUserAborted() {
+	return new CliStructuredError("5006", "Init cancelled", {
+		domain: "CLI",
+		why: "The interactive prompt was cancelled before all required inputs were supplied. No files were modified.",
+		fix: "Re-run `prisma-next init` and complete the prompts, or pass the required inputs as flags (see `--help`) for a non-interactive run.",
+		severity: "info"
+	});
+}
+/**
+* `--strict-probe` was supplied without `--probe-db`. Per FR8.3 / NFR9
+* (offline-by-default), `--strict-probe` is a no-op without `--probe-db` —
+* but rather than silently ignoring it we tell the user what they probably
+* meant. Without this guard, the flag combination silently does nothing,
+* which is exactly the kind of "looks like it worked" trap that a strict
+* mode is supposed to prevent.
+*/
+function errorInitStrictProbeWithoutProbe() {
+	return new CliStructuredError("5005", "`--strict-probe` requires `--probe-db`", {
+		domain: "CLI",
+		why: "`--strict-probe` only changes how a *failed* probe is reported; without `--probe-db` no probe is attempted in the first place. (`init` is offline-by-default — it never opens a connection to your database without explicit consent.)",
+		fix: "Add `--probe-db` to opt in to the probe, or drop `--strict-probe` if you do not need the version check.",
+		docsUrl: "https://prisma-next.dev/docs/cli/init"
+	});
+}
+/**
+* Dependency installation failed and the pnpm → npm fallback (FR7.2)
+* either did not apply (pm ≠ pnpm or stderr did not match a recognised
+* leak) or also failed. Files scaffolded before the install step are
+* already on disk; `meta.filesWritten` carries the list so a follow-up
+* agent can resume manually. Maps to exit code `4 = INSTALL_FAILED`.
+*/
+function errorInitInstallFailed(options) {
+	const trimmed = options.stderrLines.map((s) => s.trim()).filter(Boolean);
+	return new CliStructuredError("5007", "Failed to install dependencies", {
+		domain: "CLI",
+		why: trimmed.length === 0 ? "The package manager exited with an error and no recoverable fallback applied." : `The package manager exited with: ${trimmed[0]}`,
+		fix: `Install manually:\n  ${options.addCommand}\n  ${options.addDevCommand}\nThen run \`${options.emitCommand}\` to emit the contract.`,
+		docsUrl: "https://prisma-next.dev/docs/cli/init",
+		meta: {
+			filesWritten: options.filesWritten,
+			stderr: trimmed
+		}
+	});
+}
+/**
+* The user's project manifest (typically `package.json`) failed to parse
+* as JSON. Init reads the manifest to merge `scripts` (FR3.5) and to
+* skip `@types/node` when it is already declared (FR2.1); a malformed
+* file would otherwise surface as an `INTERNAL_ERROR` with a raw
+* `SyntaxError` stack, which violates the FR1.6 contract that every
+* documented failure mode maps to a stable exit code.
+*
+* Maps to exit code `2 = PRECONDITION` — the user can fix the manifest
+* and re-run.
+*/
+function errorInitInvalidManifest(options) {
+	return new CliStructuredError("5010", `Failed to parse ${options.path}`, {
+		domain: "CLI",
+		why: `\`${options.path}\` is not valid JSON: ${options.cause}`,
+		fix: `Fix the JSON syntax in \`${options.path}\` (a missing comma or unbalanced brace is the most common cause), then re-run \`prisma-next init\`.`,
+		docsUrl: "https://prisma-next.dev/docs/cli/init",
+		meta: {
+			path: options.path,
+			cause: options.cause
+		}
+	});
+}
+/**
+* The user's existing `tsconfig.json` could not be parsed even with JSONC
+* tolerance (comments + trailing commas) enabled. Init merges the
+* minimum compiler options the scaffolded files need (FR2.2), so an
+* unparseable tsconfig is a hard precondition failure: we cannot
+* faithfully edit a file we cannot read.
+*
+* Init must surface this **before** writing any scaffold file so the
+* user's working tree stays byte-identical (FR6.2 / NFR3) — see
+* `runInit` for the precondition gate.
+*
+* Maps to exit code `2 = PRECONDITION` — the user can fix the file and
+* re-run.
+*/
+function errorInitInvalidTsconfig(options) {
+	return new CliStructuredError("5011", `Failed to parse ${options.path}`, {
+		domain: "CLI",
+		why: `\`${options.path}\` is not valid JSON or JSONC: ${options.cause}`,
+		fix: `Fix the syntax in \`${options.path}\` and re-run \`prisma-next init\`. \`init\` accepts JSONC (comments and trailing commas) but cannot recover from unbalanced braces or missing commas.`,
+		docsUrl: "https://prisma-next.dev/docs/cli/init",
+		meta: {
+			path: options.path,
+			cause: options.cause
+		}
+	});
+}
+/**
+* `--probe-db` was supplied along with `--strict-probe` and the probe
+* could not complete (no `DATABASE_URL`, network/auth error, the target
+* driver was not installed, …). Without `--strict-probe` the probe
+* surfaces these as warnings; `--strict-probe` escalates them to
+* fatal so a CI gate can rely on "init exit code 2 means something
+* about the runtime environment is wrong" (FR8.3).
+*
+* Maps to exit code `2 = PRECONDITION`. The caller's project files
+* are already on disk by this point — the probe runs after the write
+* phase — but the install/emit steps may or may not have completed
+* depending on `--no-install` and the exact failure mode; `meta`
+* carries `filesWritten` so a follow-up agent can resume manually.
+*/
+function errorInitProbeFailed(options) {
+	return new CliStructuredError("5012", "Database probe failed", {
+		domain: "CLI",
+		why: `\`--probe-db\` could not complete and \`--strict-probe\` was set: ${options.cause}`,
+		fix: "Confirm `DATABASE_URL` points at a reachable server, or drop `--strict-probe` to treat probe failures as warnings.",
+		docsUrl: "https://prisma-next.dev/docs/cli/init",
+		meta: {
+			filesWritten: options.filesWritten,
+			cause: options.cause
+		}
+	});
+}
+/**
+* `prisma-next contract emit` failed after a successful install. Surface
+* the underlying error so the user can fix it and re-run; files and
+* dependencies remain on disk untouched. Maps to exit code
+* `5 = EMIT_FAILED`.
+*/
+function errorInitEmitFailed(options) {
+	return new CliStructuredError("5008", "Failed to emit contract", {
+		domain: "CLI",
+		why: `\`prisma-next contract emit\` failed: ${options.cause}`,
+		fix: `Inspect your contract file, fix the underlying issue, then re-run \`${options.emitCommand}\`. Pass \`-v\` for the full error envelope.`,
+		docsUrl: "https://prisma-next.dev/docs/cli/contract-emit",
+		meta: {
+			filesWritten: options.filesWritten,
+			cause: options.cause
+		}
+	});
+}
+
+//#endregion
+//#region src/commands/init/hygiene-gitattributes.ts
+/**
+* The schema-relative `.gitattributes` entries written for a freshly
+* initialised project (FR3.4). Mirrors the relevant subset of the
+* repo-root [`.gitattributes`](../../../../../../../../.gitattributes):
+*
+* - **Today**: `contract.json`, `contract.d.ts` are emitted on every
+*   `prisma-next contract emit`. Marking them `linguist-generated`
+*   keeps GitHub's diff stats honest and collapses the file in code
+*   review by default.
+* - **Forward-looking**: `end-contract.*`, `start-contract.*`, `ops.json`,
+*   `migration.json` are not yet emitted by `init` flows but will be
+*   produced by adjacent commands (lower / migration tooling). Adding
+*   them now matches Decision 5 (forward-looking subset) so the file
+*   does not need to be amended every time a new artefact lands.
+*
+* Patterns are written relative to the schema directory so a user
+* who runs `init --schema-path db/contract.prisma` gets
+* `db/contract.json linguist-generated` — not the workspace-glob form
+* `<glob>/contract.json` (which would over-match any unrelated
+* `contract.json` the user has elsewhere) and not the absolute
+* `prisma/contract.json` (which would silently break for a non-default
+* schema path).
+*/
+const ARTEFACT_FILENAMES$1 = [
+	"contract.json",
+	"contract.d.ts",
+	"end-contract.json",
+	"end-contract.d.ts",
+	"start-contract.json",
+	"start-contract.d.ts",
+	"ops.json",
+	"migration.json"
+];
+const ATTRIBUTE = "linguist-generated";
+/**
+* Computes the `.gitattributes` lines this scaffold expects to own. Each
+* line has the shape `<path> linguist-generated`. The `target` parameter
+* is currently unused but accepted for symmetry with the other hygiene
+* helpers and to leave room for target-specific entries (e.g. a future
+* Mongo-only artefact) without a signature break.
+*/
+function requiredGitattributesLines(schemaDir, _target) {
+	const dir = schemaDir === "." ? "" : schemaDir.replace(/\/+$/, "");
+	const prefix = dir === "" ? "" : `${dir}/`;
+	return ARTEFACT_FILENAMES$1.map((file) => `${prefix}${file} ${ATTRIBUTE}`);
+}
+/**
+* Idempotent `.gitattributes` merge (FR3.4 / FR9.3). Returns the new file
+* content given the existing content (or `undefined` if the file does
+* not yet exist).
+*
+* Equivalence is exact-line: a user-customised line like
+* `prisma/*.json linguist-generated` is *not* recognised as covering
+* `prisma/contract.json linguist-generated`. We accept that
+* over-specification — preserving the user's broad pattern *and*
+* appending the narrow one — because the narrow lines are what the
+* acceptance criteria pin (FR3.4 AC).
+*
+* Returns `null` when no changes are required (file already contains
+* every required entry).
+*/
+function mergeGitattributes(existing, required) {
+	if (existing === void 0) return `${required.join("\n")}\n`;
+	const presentLines = new Set(existing.split("\n").map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#")));
+	const missing = required.filter((line) => !presentLines.has(line));
+	if (missing.length === 0) return null;
+	return `${existing}${existing.length === 0 || existing.endsWith("\n") ? "" : "\n"}${missing.join("\n")}\n`;
+}
+
+//#endregion
+//#region src/commands/init/hygiene-gitignore.ts
+/**
+* The minimal `.gitignore` lines a Prisma Next scaffold needs (FR3.3).
+* Order matches what Node tooling typically writes today.
+*
+* `node_modules/` first because it's the byte-largest miss; `dist/`
+* because the scaffolded `tsconfig.json` writes there; `.env` last so
+* the secret-bearing file is the one most-recently visible in any diff
+* (a paranoid-correct ordering — humans skim from the top).
+*/
+const REQUIRED_GITIGNORE_ENTRIES = [
+	"node_modules/",
+	"dist/",
+	".env"
+];
+/**
+* Idempotent `.gitignore` merge (FR3.3 / FR9.3). Returns the new file
+* content given the existing content (or `undefined` if the file does
+* not yet exist). Adds only entries that are not already present and
+* never duplicates a line. Existing comments and blank lines are
+* preserved verbatim — `.gitignore` is parsed by `git` without a tree,
+* so any line modification risks changing semantics.
+*
+* Pattern equivalence is line-literal: `node_modules/` and `node_modules`
+* are treated as different entries. This is intentional — `git` treats
+* them differently (the trailing slash restricts the match to
+* directories), and the AC pins the trailing-slash form.
+*
+* Returns `null` when no changes are required (file already contains
+* every required entry). The caller can use this to decide whether to
+* include `.gitignore` in `filesWritten`.
+*/
+function mergeGitignore(existing) {
+	if (existing === void 0) return `${REQUIRED_GITIGNORE_ENTRIES.join("\n")}\n`;
+	const present = new Set(existing.split("\n").map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("#")));
+	const missing = REQUIRED_GITIGNORE_ENTRIES.filter((entry) => !present.has(entry));
+	if (missing.length === 0) return null;
+	return `${existing}${existing.length === 0 || existing.endsWith("\n") ? "" : "\n"}${missing.join("\n")}\n`;
+}
+
+//#endregion
+//#region src/commands/init/hygiene-package-scripts.ts
+const REQUIRED_SCRIPTS = [{
+	name: "contract:emit",
+	command: "prisma-next contract emit"
+}];
+/**
+* Idempotent `package.json#scripts` merge with collision detection
+* (FR3.5 / FR9.3):
+*
+* - If a required script is **missing**, append it.
+* - If a required script is **already present and identical**, leave
+*   the file alone (idempotency).
+* - If a required script is **present but maps to a different command**,
+*   skip the write for that script and surface a structured warning.
+*   The user's override is sacred — `init` should never silently
+*   overwrite a custom build pipeline.
+*
+* Preserves the existing key order (so a user who has alphabetised
+* their scripts does not see them reshuffled) and appends new entries
+* at the end.
+*
+* The `package.json` is parsed and re-stringified through `JSON` —
+* comments are not preserved (package.json does not support them per
+* spec). Trailing newline matches the original input's trailing
+* newline behaviour.
+*/
+function mergePackageScripts(existing, required = REQUIRED_SCRIPTS) {
+	const parsed = JSON.parse(existing);
+	const scripts = typeof parsed["scripts"] === "object" && parsed["scripts"] !== null ? { ...parsed["scripts"] } : {};
+	const warnings = [];
+	let mutated = false;
+	for (const { name, command } of required) {
+		const existingValue = scripts[name];
+		if (existingValue === void 0) {
+			scripts[name] = command;
+			mutated = true;
+			continue;
+		}
+		if (existingValue !== command) warnings.push(`package.json already has a "${name}" script with a different command — keeping yours.\n  existing: ${existingValue}\n  expected: ${command}\nIf you want the default, remove your "${name}" script and re-run \`init\`.`);
+	}
+	if (!mutated) return {
+		content: null,
+		warnings
+	};
+	parsed["scripts"] = scripts;
+	const trailingNewline = existing.endsWith("\n") ? "\n" : "";
+	return {
+		content: `${JSON.stringify(parsed, null, 2)}${trailingNewline}`,
+		warnings
+	};
+}
+
+//#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 "prisma/contract.ts";
+	return "prisma/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
+  name  String?
+}
+\`\`\``;
+}
+function schemaSamplePslMongo() {
+	return `\`\`\`prisma
+model User {
+  id    ObjectId @id @map("_id")
+  email String   @unique
+  name  String?
+  @@map("users")
+}
+\`\`\``;
+}
+function schemaSampleTsPostgres() {
+	return `\`\`\`typescript
+import sqlFamily from '@prisma-next/family-sql/pack';
+import { defineContract } from '@prisma-next/sql-contract-ts/contract-builder';
+import postgresPack from '@prisma-next/target-postgres/pack';
+
+export const contract = defineContract(
+  { family: sqlFamily, target: postgresPack },
+  ({ field, model }) => ({
+    models: {
+      User: model('User', {
+        fields: {
+          id: field.id.uuidv7(),
+          email: field.text().unique(),
+          name: field.text().optional(),
+        },
+      }),
+    },
+  }),
+);
+\`\`\``;
+}
+function schemaSampleTsMongo() {
+	return `\`\`\`typescript
+import mongoFamily from '@prisma-next/family-mongo/pack';
+import { defineContract } from '@prisma-next/mongo-contract-ts/contract-builder';
+import mongoTarget from '@prisma-next/target-mongo/pack';
+
+export const contract = defineContract(
+  { family: mongoFamily, target: mongoTarget },
+  ({ field, model }) => ({
+    models: {
+      User: model('User', {
+        collection: 'users',
+        fields: {
+          _id: field.objectId(),
+          email: field.string(),
+          name: field.string().optional(),
+        },
+      }),
+    },
+  }),
+);
+\`\`\``;
+}
+function starterSchemaPslPostgres() {
+	return `model User {
+  id        Int      @id @default(autoincrement())
+  email     String   @unique
+  name      String?
+  posts     Post[]
+  createdAt DateTime @default(now())
+}
+
+model Post {
+  id        Int      @id @default(autoincrement())
+  title     String
+  content   String?
+  author    User     @relation(fields: [authorId], references: [id])
+  authorId  Int
+  createdAt DateTime @default(now())
+}
+`;
+}
+function starterSchemaPslMongo() {
+	return `model User {
+  id    ObjectId @id @map("_id")
+  email String   @unique
+  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 sqlFamily from '@prisma-next/family-sql/pack';
+import { defineContract } from '@prisma-next/sql-contract-ts/contract-builder';
+import postgresPack from '@prisma-next/target-postgres/pack';
+
+export const contract = defineContract(
+  { family: sqlFamily, target: postgresPack },
+  ({ field, model, rel }) => ({
+    models: {
+      User: model('User', {
+        fields: {
+          id: field.id.uuidv7(),
+          email: field.text().unique(),
+          name: field.text().optional(),
+          createdAt: field.createdAt(),
+        },
+        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.createdAt(),
+        },
+        relations: {
+          author: rel.belongsTo('User', { from: 'authorId', to: 'id' }),
+        },
+      }),
+    },
+  }),
+);
+`;
+}
+function starterSchemaTsMongo() {
+	return `import mongoFamily from '@prisma-next/family-mongo/pack';
+import { defineContract } from '@prisma-next/mongo-contract-ts/contract-builder';
+import mongoTarget from '@prisma-next/target-mongo/pack';
+
+export const contract = defineContract(
+  { family: mongoFamily, target: mongoTarget },
+  ({ field, model, rel }) => ({
+    models: {
+      User: model('User', {
+        collection: 'users',
+        fields: {
+          _id: field.objectId(),
+          email: field.string(),
+          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 });
+`;
+	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/inputs.ts
+const TARGET_ALIASES = new Map([
+	["postgres", "postgres"],
+	["postgresql", "postgres"],
+	["mongo", "mongo"],
+	["mongodb", "mongo"]
+]);
+const AUTHORING_VALUES = new Map([
+	["psl", "psl"],
+	["typescript", "typescript"],
+	["ts", "typescript"]
+]);
+/**
+* Resolves every required input for `runInit`. In interactive mode, missing
+* inputs are prompted via clack; in non-interactive mode, missing required
+* inputs throw a structured error listing exactly which flags are missing
+* (FR1.4). Throws `CliStructuredError` on any unrecoverable input issue.
+*
+* `canPrompt` is decoupled from `flags.interactive` so the action handler
+* (`./index.ts`) owns the merge of stdout-TTY (decoration) and stdin-TTY
+* (prompts). `flags.interactive` continues to gate `TerminalUI` decoration
+* — see [Style Guide § Interactivity](../../../../../../../docs/CLI%20Style%20Guide.md#interactivity).
+*/
+async function resolveInitInputs(ctx) {
+	const { baseDir, options, flags, canPrompt } = ctx;
+	const force = Boolean(options.force);
+	const autoAcceptPrompts = Boolean(flags.yes);
+	if (options.strictProbe && !options.probeDb) throw errorInitStrictProbeWithoutProbe();
+	const reinit = await resolveReinit({
+		baseDir,
+		force,
+		canPrompt,
+		autoAcceptPrompts
+	});
+	const target = resolveTarget(options.target);
+	const authoring = resolveAuthoring(options.authoring);
+	const missing = [];
+	if (target === void 0) missing.push("target");
+	if (authoring === void 0) missing.push("authoring");
+	if (!canPrompt && missing.length > 0) throw errorInitMissingFlags({
+		missing,
+		why: process.stdin.isTTY ? "Non-interactive mode is active (`--no-interactive` or stdout is piped)." : "stdin is not a TTY, so `init` cannot prompt interactively."
+	});
+	const finalTarget = target ?? await promptTarget();
+	const finalAuthoring = authoring ?? await promptAuthoring();
+	const finalSchemaPath = options.schemaPath !== void 0 ? validateSchemaPath(options.schemaPath, finalAuthoring) : canPrompt ? await promptSchemaPath(finalAuthoring) : defaultSchemaPath(finalAuthoring);
+	const writeEnv = await resolveWriteEnv({
+		flag: options.writeEnv,
+		canPrompt,
+		autoAcceptPrompts
+	});
+	const removePreviousFacade = await resolveRemovePreviousFacade({
+		baseDir,
+		target: finalTarget,
+		reinit,
+		force,
+		canPrompt,
+		autoAcceptPrompts
+	});
+	return {
+		target: finalTarget,
+		authoring: finalAuthoring,
+		schemaPath: finalSchemaPath,
+		install: options.install !== false,
+		writeEnv,
+		probeDb: Boolean(options.probeDb),
+		strictProbe: Boolean(options.strictProbe),
+		reinit,
+		removePreviousFacade
+	};
+}
+async function resolveWriteEnv(opts) {
+	if (opts.flag !== void 0) return Boolean(opts.flag);
+	if (!opts.canPrompt || opts.autoAcceptPrompts) return false;
+	const result = await clack.confirm({
+		message: "Also write a .env file from .env.example? (gitignored)",
+		initialValue: false,
+		output: process.stderr
+	});
+	if (clack.isCancel(result)) throw errorInitUserAborted();
+	return Boolean(result);
+}
+/**
+* FR9.2 — detects whether re-init is switching targets (the previous
+* facade differs from the chosen target's facade) and resolves the
+* remove-or-keep question.
+*
+* The non-interactive contract is the same as the `--force` re-init
+* gate above: a non-interactive run that reaches this helper always
+* has `--force` (otherwise `resolveReinit` would have thrown 5002), so
+* the removal proceeds without further prompting. Interactive runs see
+* a `clack.confirm` with `initialValue: true` — the destructive default
+* is correct because keeping both facades produces a project that
+* imports from one but pays for both in the lockfile, which is a
+* silent foot-gun the user almost never wants.
+*
+* Returns the previous facade package name when the user consented (or
+* was force-ed) to remove it, otherwise `null`. Parse failures on
+* `package.json` resolve to `null` here — `runInit`'s precondition
+* gate surfaces a structured 5010 error for the same file shortly
+* after, so we avoid double-reporting and keep this helper side-effect
+* free under hostile inputs.
+*/
+async function resolveRemovePreviousFacade(opts) {
+	if (!opts.reinit) return null;
+	const packageJsonPath = join(opts.baseDir, "package.json");
+	if (!existsSync(packageJsonPath)) return null;
+	const otherTarget = opts.target === "postgres" ? "mongo" : "postgres";
+	const otherFacade = targetPackageName(otherTarget);
+	let parsed;
+	try {
+		parsed = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+	} catch {
+		return null;
+	}
+	const deps = parsed["dependencies"];
+	if (deps === null || typeof deps !== "object" || Array.isArray(deps)) return null;
+	if (!Object.hasOwn(deps, otherFacade)) return null;
+	if (opts.force || opts.canPrompt && opts.autoAcceptPrompts) return otherFacade;
+	if (!opts.canPrompt) return otherFacade;
+	const result = await clack.confirm({
+		message: `Switching from ${targetLabel(otherTarget)} to ${targetLabel(opts.target)} — remove ${otherFacade} from package.json dependencies?`,
+		initialValue: true,
+		output: process.stderr
+	});
+	if (clack.isCancel(result)) throw errorInitUserAborted();
+	return result === true ? otherFacade : null;
+}
+async function resolveReinit(opts) {
+	if (!existsSync(join(opts.baseDir, "prisma-next.config.ts"))) return false;
+	if (opts.force) return true;
+	if (!opts.canPrompt) throw errorInitReinitNeedsForce();
+	if (opts.autoAcceptPrompts) return true;
+	const result = await clack.confirm({
+		message: "This project is already initialized. Re-initialize? This will overwrite all generated files.",
+		initialValue: false,
+		output: process.stderr
+	});
+	if (clack.isCancel(result) || result !== true) throw errorInitUserAborted();
+	return true;
+}
+function resolveTarget(value) {
+	if (value === void 0) return void 0;
+	const mapped = TARGET_ALIASES.get(value.toLowerCase());
+	if (mapped === void 0) throw errorInitInvalidFlagValue({
+		flag: "target",
+		value,
+		allowed: ["postgres", "mongodb"]
+	});
+	return mapped;
+}
+function resolveAuthoring(value) {
+	if (value === void 0) return void 0;
+	const mapped = AUTHORING_VALUES.get(value.toLowerCase());
+	if (mapped === void 0) throw errorInitInvalidFlagValue({
+		flag: "authoring",
+		value,
+		allowed: ["psl", "typescript"]
+	});
+	return mapped;
+}
+/**
+* Validates `--schema-path` against the chosen `--authoring` style: PSL
+* authoring requires a `.prisma` file and TypeScript authoring requires a
+* `.ts` file. Mismatched combinations would silently scaffold PSL content
+* into a `.ts` file (or vice versa); this validator surfaces the mistake
+* as a precondition error naming both flags.
+*/
+function validateSchemaPath(value, authoring) {
+	const trimmed = value.trim();
+	if (trimmed.length === 0) throw errorInitInvalidFlagValue({
+		flag: "schema-path",
+		value,
+		allowed: ["<non-empty file path with .prisma or .ts extension>"]
+	});
+	if (trimmed.endsWith("/") || trimmed.endsWith("\\")) throw errorInitInvalidFlagValue({
+		flag: "schema-path",
+		value,
+		allowed: ["<file path, not a directory>"]
+	});
+	const ext = extname(trimmed).toLowerCase();
+	const expected = authoring === "typescript" ? ".ts" : ".prisma";
+	if (ext !== expected) throw errorInitInvalidFlagValue({
+		flag: "schema-path",
+		value,
+		allowed: [`<file path ending in ${expected} for --authoring ${authoring}>`]
+	});
+	return normalize(trimmed);
+}
+async function promptTarget() {
+	const result = await clack.select({
+		message: "What database are you using?",
+		options: [{
+			value: "postgres",
+			label: "PostgreSQL"
+		}, {
+			value: "mongo",
+			label: "MongoDB"
+		}],
+		output: process.stderr
+	});
+	if (clack.isCancel(result)) throw errorInitUserAborted();
+	return result;
+}
+async function promptAuthoring() {
+	const result = await clack.select({
+		message: "How do you want to write your schema?",
+		options: [{
+			value: "psl",
+			label: "Prisma Schema Language (.prisma)"
+		}, {
+			value: "typescript",
+			label: "TypeScript (.ts)"
+		}],
+		output: process.stderr
+	});
+	if (clack.isCancel(result)) throw errorInitUserAborted();
+	return result;
+}
+async function promptSchemaPath(authoring) {
+	const expectedExt = authoring === "typescript" ? ".ts" : ".prisma";
+	const result = await clack.text({
+		message: "Where should the schema file go?",
+		initialValue: defaultSchemaPath(authoring),
+		validate(value = "") {
+			const trimmed = value.trim();
+			if (trimmed.length === 0) return "Path cannot be empty";
+			if (trimmed.endsWith("/") || trimmed.endsWith("\\")) return "Path must be a file, not a directory";
+			const ext = extname(trimmed).toLowerCase();
+			if (ext === "") return "Path must include a file extension (e.g. .prisma or .ts)";
+			if (ext !== expectedExt) return `Schema path must end in ${expectedExt} for --authoring ${authoring} (got ${ext}).`;
+		},
+		output: process.stderr
+	});
+	if (clack.isCancel(result)) throw errorInitUserAborted();
+	return validateSchemaPath(result, authoring);
+}
+
+//#endregion
+//#region src/commands/init/probe-db.ts
+/**
+* Connects (when configured) to the user's database and returns a
+* structured outcome describing whether the server meets the declared
+* minimum (FR8.1). Pure with respect to its inputs: no I/O happens
+* unless `databaseUrl` is set.
+*
+* The outcome is shaped so that `--strict-probe` can branch on the
+* `kind`/`meetsMinimum` pair without re-stringifying the message:
+*
+* - `ok` — informational; `init` continues.
+* - `below-minimum` — warning; `init` continues regardless of
+*   `--strict-probe` (the spec scopes strict-probe to "probe
+*   *failures*", and a successful probe that finds an old server is
+*   not a failure).
+* - `no-database-url` / `connection-failed` / `driver-missing` —
+*   warning by default, fatal under `--strict-probe`.
+*/
+async function probeServerVersion(ctx, overrides = {}) {
+	const { databaseUrl, minVersion, target } = ctx;
+	if (databaseUrl === void 0 || databaseUrl.trim().length === 0) return {
+		kind: "no-database-url",
+		minVersion,
+		meetsMinimum: null,
+		message: "Skipped --probe-db: DATABASE_URL is not set in the current shell environment. (init does not read .env for the probe; export the variable or drop --probe-db.)"
+	};
+	let driverResult;
+	try {
+		if (target === "postgres") driverResult = overrides.probePostgres !== void 0 ? await overrides.probePostgres(databaseUrl) : await defaultProbePostgres(databaseUrl, ctx.baseDir, overrides);
+		else driverResult = overrides.probeMongo !== void 0 ? await overrides.probeMongo(databaseUrl) : await defaultProbeMongo(databaseUrl, ctx.baseDir, overrides);
+	} catch (err) {
+		if (err instanceof DriverMissingError) return {
+			kind: "driver-missing",
+			minVersion,
+			meetsMinimum: null,
+			cause: err.message,
+			message: `Skipped --probe-db: ${err.message}. (Run with install enabled, or install the driver yourself, then re-run \`prisma-next init --probe-db\`.)`
+		};
+		const cause = redactDatabaseUrlSecrets(causeMessage$1(err));
+		return {
+			kind: "connection-failed",
+			minVersion,
+			meetsMinimum: null,
+			cause,
+			message: `--probe-db could not connect: ${cause}.`
+		};
+	}
+	if (compareVersionPrefix(driverResult.serverVersion, minVersion) < 0) return {
+		kind: "below-minimum",
+		serverVersion: driverResult.serverVersion,
+		minVersion,
+		meetsMinimum: false,
+		message: `--probe-db: server reports version ${driverResult.serverVersion}, below the declared minimum (${minVersion}). Some queries may fail until the server is upgraded.`
+	};
+	return {
+		kind: "ok",
+		serverVersion: driverResult.serverVersion,
+		minVersion,
+		meetsMinimum: true,
+		message: `--probe-db: server reports version ${driverResult.serverVersion} (>= ${minVersion}).`
+	};
+}
+/**
+* Compares two semver-prefix strings ("14", "14.2", "6.0", …) by
+* numeric components left-to-right. Returns a negative number when `a`
+* is older than `b`, zero when both versions agree on every numeric
+* component (treating missing trailing components as `0`), and a
+* positive number when `a` is newer.
+*
+* The loop runs over the **longer** of the two prefixes so that
+* `'14'` compares less than `'14.1'` — without that, the shorter
+* prefix would be silently accepted whenever the configured minimum
+* has a non-zero minor or patch.
+*
+* Exported for unit tests.
+*/
+function compareVersionPrefix(a, b) {
+	const aParts = parseNumericParts(a);
+	const bParts = parseNumericParts(b);
+	const len = Math.max(aParts.length, bParts.length);
+	for (let i = 0; i < len; i += 1) {
+		const aPart = aParts[i] ?? 0;
+		const bPart = bParts[i] ?? 0;
+		if (aPart !== bPart) return aPart - bPart;
+	}
+	return 0;
+}
+function parseNumericParts(version) {
+	const match = version.match(/^[^\d]*(\d+(?:\.\d+){0,3})/);
+	if (match === null) return [];
+	return (match[1] ?? "").split(".").map((part) => Number.parseInt(part, 10));
+}
+var DriverMissingError = class extends Error {};
+function causeMessage$1(err) {
+	if (err instanceof Error) return err.message;
+	return String(err);
+}
+/**
+* Strips `user:password@` userinfo from any URL-shaped substring before
+* we surface the cause to the user. Mirrors `redactSecrets` in
+* `init.ts` — the probe path has its own redactor because the inputs
+* here include the raw connection string by construction (driver
+* errors echo the URL back).
+*
+* Exported for unit tests.
+*/
+function redactDatabaseUrlSecrets(text) {
+	if (!text) return text;
+	return text.replace(/([a-zA-Z][a-zA-Z0-9+.-]*:\/\/)([^/@\s]+)@/g, "$1***@");
+}
+async function defaultProbePostgres(databaseUrl, baseDir, overrides) {
+	const client = new (requirePeer("pg", baseDir, overrides)).Client({ connectionString: databaseUrl });
+	await client.connect();
+	try {
+		const result = await client.query("SELECT version() as version");
+		return { serverVersion: parsePostgresVersion(String(result?.rows?.[0]?.version ?? "")) };
+	} finally {
+		await client.end().catch(() => void 0);
+	}
+}
+/**
+* Extracts the numeric prefix from a Postgres `version()` row, e.g.
+*
+*   `PostgreSQL 14.10 on x86_64-pc-linux-gnu, ...`  → `"14.10"`
+*   `PostgreSQL 16beta1 on …`                       → `"16"` (we
+*      conservatively drop the suffix; minimum-version comparisons
+*      treat 16beta1 as 16, which is what every reasonable user
+*      expects).
+*
+* Exported for unit tests.
+*/
+function parsePostgresVersion(versionString) {
+	const match = versionString.match(/PostgreSQL\s+(\d+(?:\.\d+)?)/i);
+	if (match === null || match[1] === void 0) throw new Error(`Could not parse PostgreSQL version from \`${versionString}\``);
+	return match[1];
+}
+async function defaultProbeMongo(databaseUrl, baseDir, overrides) {
+	const client = new (requirePeer("mongodb", baseDir, overrides)).MongoClient(databaseUrl);
+	await client.connect();
+	try {
+		const buildInfo = await client.db().admin().command({ buildInfo: 1 });
+		const versionString = String(buildInfo.version ?? "");
+		if (versionString.length === 0) throw new Error("buildInfo did not include a `version` field");
+		return { serverVersion: versionString };
+	} finally {
+		await client.close().catch(() => void 0);
+	}
+}
+/**
+* Loads a peer driver (`pg` / `mongodb`) from the user's project
+* `node_modules`. We deliberately resolve from `baseDir` rather than
+* from the CLI bundle — the CLI does not depend on `pg` or `mongodb`
+* directly, but the user's `init`-generated `package.json` does (via
+* the target facade). Failure to resolve is folded into a typed
+* `DriverMissingError` so `probeServerVersion` can map it to a
+* `driver-missing` outcome rather than letting a `MODULE_NOT_FOUND`
+* leak as a generic connection failure.
+*/
+function requirePeer(moduleId, baseDir, overrides) {
+	try {
+		if (overrides.requireFromBaseDir !== void 0) return overrides.requireFromBaseDir(baseDir, moduleId);
+		return createRequire(join(baseDir, "package.json"))(moduleId);
+	} catch (err) {
+		throw new DriverMissingError(`\`${moduleId}\` is not installed in this project (resolved from ${baseDir}; cause: ${causeMessage$1(err)})`);
+	}
+}
+
+//#endregion
+//#region src/commands/init/reinit-cleanup.ts
+/**
+* Filenames the contract pipeline emits next to the user's schema source
+* (`<schemaDir>/contract.json`, `<schemaDir>/contract.d.ts`, …). Mirrors
+* `ARTEFACT_FILENAMES` in `hygiene-gitattributes.ts`; kept as a separate
+* constant here because the cleanup contract is target-agnostic and we
+* deliberately do not want a stale `start-contract.json` from a previous
+* target lingering after a re-init.
+*
+* If a future emit pipeline produces an additional artefact, add it here
+* **and** to the gitattributes list — the two stay in lockstep so the
+* file `init` advertises as `linguist-generated` is exactly the file
+* `init` is willing to delete on re-init.
+*/
+const ARTEFACT_FILENAMES = [
+	"contract.json",
+	"contract.d.ts",
+	"end-contract.json",
+	"end-contract.d.ts",
+	"start-contract.json",
+	"start-contract.d.ts",
+	"ops.json",
+	"migration.json"
+];
+/**
+* Returns the schema-relative paths of stale contract artefacts the
+* previous `init` run (or a `contract emit`) left behind in `schemaDir`.
+* Paths are returned relative to `baseDir` so the caller can plumb them
+* into `filesWritten`-style logging without re-deriving the path.
+*
+* Pure function: no filesystem mutation. Used by `runInit`'s precondition
+* phase (FR6.2 / NFR3 atomicity) so a downstream parse failure leaves
+* the artefacts on disk and the project byte-identical to its pre-init
+* state.
+*/
+function findStaleArtefacts(baseDir, schemaDir) {
+	const result = [];
+	for (const filename of ARTEFACT_FILENAMES) {
+		const rel = join(schemaDir, filename);
+		if (existsSync(join(baseDir, rel))) result.push(rel);
+	}
+	return result;
+}
+/**
+* Drops a single key from `package.json#dependencies`, returning the new
+* file content. Returns `null` when the dependency was already absent —
+* the caller can skip the write to keep re-init idempotent (FR9.3).
+*
+* Used by `runInit` for the FR9.2 target-switch path: when the user
+* re-inits a project from `--target postgres` to `--target mongodb` (or
+* vice versa), the previous facade is removed from `dependencies` so the
+* resulting project depends only on the chosen target's facade.
+*
+* Devs/peers/optional dep groups are intentionally *not* touched — the
+* facades are only ever in `dependencies` (FR4 / FR7), and broadening
+* the search would risk clobbering an unrelated dep with the same name
+* in `peerDependencies`.
+*
+* Throws `SyntaxError` if `existing` is not parseable as JSON; the
+* caller (`runInit`) already guards on that with a structured 5010
+* error before this helper is reached.
+*/
+function removeDependency(existing, depName) {
+	const parsed = JSON.parse(existing);
+	const deps = parsed["dependencies"];
+	if (deps === null || typeof deps !== "object" || Array.isArray(deps)) return null;
+	if (!Object.hasOwn(deps, depName)) return null;
+	const next = { ...deps };
+	delete next[depName];
+	parsed["dependencies"] = next;
+	const trailingNewline = existing.endsWith("\n") ? "\n" : "";
+	return `${JSON.stringify(parsed, null, 2)}${trailingNewline}`;
+}
+
+//#endregion
+//#region src/commands/init/templates/render.ts
+function renderTemplate(templateFile, variableNames, vars) {
+	let result = readFileSync(join(import.meta.dirname, templateFile), "utf-8");
+	for (const key of variableNames) {
+		const value = vars[key];
+		if (value === void 0) throw new Error(`Template variable '${key}' is not defined`);
+		result = result.replaceAll(`{{${key}}}`, value);
+	}
+	return result;
+}
+
+//#endregion
+//#region src/commands/init/templates/agent-skill.ts
+const variables$1 = [
+	"schemaPath",
+	"schemaDir",
+	"dbImportPath",
+	"pkgRun",
+	"authoringLabel"
+];
+/**
+* Renders the per-project agent skill (FR5.2). The skill template is
+* target-specific (Postgres vs Mongo query syntax differs); the authoring
+* style enters via:
+*
+* - `schemaPath` — already routed through {@link agentSkillMd}'s caller
+*   (the AC says a TS-authoring scaffold must reference `prisma/contract.ts`).
+* - `authoringLabel` — a short human-readable note (`PSL` / `TypeScript`)
+*   the skill template uses when describing the contract file.
+*/
+function agentSkillMd(target, authoring, schemaPath, pkgRun) {
+	const schemaDir = dirname(schemaPath);
+	const vars = {
+		schemaPath,
+		schemaDir,
+		dbImportPath: `./${schemaDir}/db`,
+		pkgRun,
+		authoringLabel: authoring === "typescript" ? "TypeScript" : "PSL"
+	};
+	return renderTemplate(`agent-skill-${target}.md`, variables$1, vars);
+}
+
+//#endregion
+//#region src/commands/init/templates/env.ts
+/**
+* The minimum supported server version for each target (FR8.1). The
+* authoritative source of truth is each target package's
+* `package.json#prismaNext.minServerVersion` field — this module
+* mirrors those values and a workspace-level test asserts the two
+* never drift (`templates/tsconfig-env.test.ts`).
+*
+* Bumping a value here in isolation is **not** safe: edit the
+* corresponding target package's `package.json` first, then mirror
+* here. The scaffold's `.env.example` (FR3.1, FR8.2) and the
+* "Requirements" section of `prisma-next.md` both read from this
+* constant, so a stale value lies to every freshly initialised user.
+*/
+const MIN_SERVER_VERSION = {
+	postgres: "14",
+	mongo: "6.0"
+};
+const TARGET_LABEL = {
+	postgres: "PostgreSQL",
+	mongo: "MongoDB"
+};
+/**
+* Renders the placeholder body shared by `.env` and `.env.example`:
+* the target-specific connection-string requirement comments and the
+* commented-shape `DATABASE_URL` line. The output is identical for both
+* authoring styles — the env file is orthogonal to PSL vs TS schema
+* authoring.
+*/
+function envPlaceholderBody(target) {
+	const label = TARGET_LABEL[target];
+	const minVersion = MIN_SERVER_VERSION[target];
+	const lines = [];
+	lines.push(`# Connection string for ${label}.`);
+	lines.push(`# Requires ${label} >= ${minVersion}.`);
+	lines.push("");
+	if (target === "postgres") lines.push("DATABASE_URL=\"postgresql://user:password@localhost:5432/mydb\"");
+	else lines.push("DATABASE_URL=\"mongodb://localhost:27017/mydb\"");
+	lines.push("");
+	return lines.join("\n");
+}
+/**
+* Renders the `.env.example` content for a given target (FR3.1):
+*
+* - Carries a "Copy this file to `.env`…" intro that only makes sense
+*   for the example file (the real `.env` is the destination of that
+*   copy and so does not get the same intro).
+* - Documents the `DATABASE_URL` placeholder in the target's native URL
+*   shape (Postgres: standard `postgresql://`, Mongo: `mongodb://` plus
+*   a `mydb` database segment so the lazy facade has a `dbName`).
+* - Carries a `# Requires <db> >= <version>` comment so a fresh user
+*   knows the minimum supported server before they first try to
+*   connect (FR8.2).
+*/
+function envExampleContent(target) {
+	const lines = [];
+	lines.push("# Copy this file to `.env` and replace the placeholder with your real connection string.");
+	lines.push(envPlaceholderBody(target));
+	return lines.join("\n");
+}
+/**
+* Renders the initial `.env` content for `--write-env` / interactive
+* opt-in (FR3.2). Same placeholder body as `.env.example`, **without**
+* the example file's "Copy this file to `.env`…" intro: the real `.env`
+* is the destination of that copy, so the line would lie. Writing this
+* file is gitignored (FR3.3 ensures `.env` lands in `.gitignore`).
+*/
+function envFileContent(target) {
+	return envPlaceholderBody(target);
+}
+
+//#endregion
+//#region src/commands/init/templates/quick-reference.ts
+const variables = [
+	"schemaPath",
+	"schemaDir",
+	"dbImportPath",
+	"pkgRun",
+	"schemaSample",
+	"requirements"
+];
+function quickReferenceMd(target, authoring, schemaPath, pkgRun) {
+	const schemaDir = dirname(schemaPath);
+	const vars = {
+		schemaPath,
+		schemaDir,
+		dbImportPath: `./${schemaDir}/db`,
+		pkgRun,
+		schemaSample: schemaSample(target, authoring),
+		requirements: requirementsBlock(target)
+	};
+	return renderTemplate(`quick-reference-${target}.md`, variables, vars);
+}
+/**
+* Renders the FR8.2 "Requirements" block injected into `prisma-next.md`
+* (the user-facing quick reference). Sources the minimum server
+* version from `MIN_SERVER_VERSION` — itself mirrored from each
+* target package's `package.json#prismaNext.minServerVersion`
+* (FR8.1).
+*
+* The verification command is target-specific — Postgres scaffolds
+* shouldn't ship Mongo's `db.runCommand` (and vice versa) just because
+* we couldn't be bothered to branch.
+*/
+function requirementsBlock(target) {
+	return [
+		"## Requirements",
+		"",
+		`- **${TARGET_LABEL[target]} ${MIN_SERVER_VERSION[target]} or newer.** Older servers are not supported. Run ${target === "postgres" ? "`SELECT version()`" : "`db.runCommand({ buildInfo: 1 })`"} against your server to verify.`,
+		"- The CLI never connects to your database without explicit consent. Pass `--probe-db` to `prisma-next init` if you want `init` to verify the server version itself."
+	].join("\n");
+}
+
+//#endregion
+//#region src/commands/init/templates/tsconfig.ts
+/**
+* Compiler options the scaffolded `prisma-next.config.ts` and `db.ts` need
+* to typecheck:
+*
+* - `module: 'preserve'` + `moduleResolution: 'bundler'` align with how
+*   modern bundlers (and `tsdown`) consume our facade packages.
+* - `resolveJsonModule` lets `db.ts` import `contract.json with { type:
+*   'json' }` — the runtime path the facades document (FR4).
+*
+* `types: ['node']` is FR2.2 territory and lives in
+* `REQUIRED_COMPILER_OPTIONS_TYPES` because TS only honours an _array_
+* here, and a string-keyed merge would clobber any user-specified entries.
+* Merge handling preserves any extra `types` the user added.
+*/
+const REQUIRED_COMPILER_OPTIONS = {
+	module: "preserve",
+	moduleResolution: "bundler",
+	resolveJsonModule: true
+};
+/**
+* Types that must be present in `compilerOptions.types` for the scaffold
+* to typecheck. With `moduleResolution: 'bundler'`, TypeScript does not
+* implicitly include all `@types/*` packages — `process.env` only resolves
+* when `node` is in this array (or `types` is omitted, but then any other
+* type listed here would force the same behaviour). Listing `node`
+* explicitly is the documented escape hatch (FR2.2).
+*/
+const REQUIRED_COMPILER_OPTIONS_TYPES = ["node"];
+function defaultTsConfig() {
+	return JSON.stringify({
+		compilerOptions: {
+			target: "ES2022",
+			...REQUIRED_COMPILER_OPTIONS,
+			types: [...REQUIRED_COMPILER_OPTIONS_TYPES],
+			strict: true,
+			skipLibCheck: true,
+			esModuleInterop: true,
+			outDir: "dist"
+		},
+		include: ["**/*.ts"]
+	}, null, 2);
+}
+/**
+* Thrown by `mergeTsConfig` when the user's existing `tsconfig.json` is
+* not parseable as JSONC (TypeScript's actual configured dialect — see
+* FR6.1). Carries the raw parse errors so the caller can render an
+* actionable, location-aware message.
+*
+* `runInit` catches this exception during the precondition phase and
+* maps it to a `CliStructuredError(5011)` so the user's working tree
+* stays byte-identical when init bails (FR6.2 / NFR3).
+*/
+var TsConfigParseError = class extends Error {
+	errors;
+	constructor(errors) {
+		super(formatTsConfigParseErrors(errors));
+		this.errors = errors;
+		this.name = "TsConfigParseError";
+	}
+};
+function formatTsConfigParseErrors(errors) {
+	if (errors.length === 0) return "tsconfig.json is empty or not an object";
+	return errors.map((e) => `${printParseErrorCode(e.error)} at offset ${e.offset}`).join("; ");
+}
+/**
+* Merges the required compiler options into an existing `tsconfig.json`.
+*
+* Parsing is delegated to `jsonc-parser` so JSONC inputs (comments,
+* trailing commas) — TypeScript's real configuration dialect — survive
+* unchanged: edits are applied as text patches via `modify` /
+* `applyEdits`, preserving the user's formatting, key ordering, and
+* comments wherever the touched paths permit (FR6.1, AC "Hostile
+* inputs").
+*
+* Throws `TsConfigParseError` when the input is not parseable as JSONC.
+* The caller must catch this and surface a structured error before
+* writing any scaffold files (FR6.2 atomicity).
+*/
+function mergeTsConfig(existing) {
+	const { config } = parseTsConfigText(existing);
+	const formattingOptions = {
+		tabSize: detectIndent(existing),
+		insertSpaces: true,
+		eol: existing.includes("\r\n") ? "\r\n" : "\n"
+	};
+	let result = existing;
+	for (const [key, value] of Object.entries(REQUIRED_COMPILER_OPTIONS)) {
+		const edits = modify(result, ["compilerOptions", key], value, { formattingOptions });
+		result = applyEdits(result, edits);
+	}
+	const existingTypes = config["compilerOptions"]?.["types"];
+	const mergedTypes = mergeTypesArray(existingTypes);
+	const typesEdits = modify(result, ["compilerOptions", "types"], mergedTypes, { formattingOptions });
+	result = applyEdits(result, typesEdits);
+	return result;
+}
+/**
+* Parses an existing `tsconfig.json` (JSONC) and returns the structured
+* config alongside any non-fatal parse warnings. Throws
+* `TsConfigParseError` if the input cannot be parsed at all or does
+* not resolve to a JSON object — both cases mean we cannot safely
+* apply edits.
+*
+* Exposed independently so callers (notably `runInit`'s precondition
+* gate) can validate the file *before* any scaffold file is written.
+*/
+function parseTsConfigText(text) {
+	const errors = [];
+	const value = parse(text, errors, {
+		allowTrailingComma: true,
+		disallowComments: false,
+		allowEmptyContent: false
+	});
+	if (value === void 0 || value === null || typeof value !== "object" || Array.isArray(value)) throw new TsConfigParseError(errors);
+	if (errors.length > 0) throw new TsConfigParseError(errors);
+	return { config: value };
+}
+function detectIndent(text) {
+	const match = text.match(/^([ \t]+)\S/m);
+	if (match === null) return 2;
+	const indent = match[1] ?? "";
+	if (indent.startsWith("	")) return 1;
+	return indent.length || 2;
+}
+/**
+* Merges `REQUIRED_COMPILER_OPTIONS_TYPES` into the user's existing
+* `compilerOptions.types` array. Preserves order and dedupes. If the
+* user has no `types` array (or has set it to a non-array), we replace
+* with the required minimum — overwriting a non-array `types` is the
+* correct fix because anything other than a string array is invalid TS
+* config.
+*/
+function mergeTypesArray(existing) {
+	const result = [];
+	if (Array.isArray(existing)) {
+		for (const item of existing) if (typeof item === "string" && !result.includes(item)) result.push(item);
+	}
+	for (const required of REQUIRED_COMPILER_OPTIONS_TYPES) if (!result.includes(required)) result.push(required);
+	return result;
+}
+
+//#endregion
+//#region src/commands/init/init.ts
+/**
+* Runs the `init` command end-to-end and returns the exit code. Catches
+* structured CLI errors raised at every phase (input resolution, install,
+* emit) and renders them via the same UI surface as success output
+* (`--json` to stdout, human to stderr). Exit codes follow the documented
+* stable set in `./exit-codes.ts` (FR1.6) and the
+* [Style Guide § Exit Codes](../../../../../../../docs/CLI%20Style%20Guide.md#exit-codes).
+*
+* Layered for testability: the action handler in `./index.ts` is
+* responsible for parsing flags and constructing `runOptions`; this
+* function does no flag parsing of its own.
+*/
+async function runInit(baseDir, runOptions) {
+	const { options, flags, canPrompt, probeOverrides } = runOptions;
+	const ui = new TerminalUI({
+		color: flags.color,
+		interactive: flags.interactive
+	});
+	const warnings = [];
+	const filesWritten = [];
+	const filesDeleted = [];
+	if (!flags.json && !flags.quiet) clack.intro("prisma-next init", { output: process.stderr });
+	if (!hasProjectManifest(baseDir)) return emitError(ui, flags, errorInitMissingManifest());
+	let inputs;
+	try {
+		inputs = await resolveInitInputs({
+			baseDir,
+			options,
+			flags,
+			canPrompt
+		});
+	} catch (error) {
+		if (CliStructuredError.is(error)) return emitError(ui, flags, error);
+		throw error;
+	}
+	const pm = await detectPackageManager(baseDir);
+	const pkgRun = formatRunCommand(pm, "prisma-next", "").trimEnd();
+	const schemaDir = dirname(inputs.schemaPath);
+	const configContractPath = isAbsolute(inputs.schemaPath) ? inputs.schemaPath : `./${inputs.schemaPath}`;
+	const filesToWrite = [
+		{
+			path: inputs.schemaPath,
+			content: starterSchema(inputs.target, inputs.authoring)
+		},
+		{
+			path: "prisma-next.config.ts",
+			content: configFile(inputs.target, configContractPath)
+		},
+		{
+			path: join(schemaDir, "db.ts"),
+			content: dbFile(inputs.target)
+		},
+		{
+			path: "prisma-next.md",
+			content: quickReferenceMd(inputs.target, inputs.authoring, inputs.schemaPath, pkgRun)
+		},
+		{
+			path: ".agents/skills/prisma-next/SKILL.md",
+			content: agentSkillMd(inputs.target, inputs.authoring, inputs.schemaPath, pkgRun)
+		},
+		{
+			path: ".env.example",
+			content: envExampleContent(inputs.target)
+		}
+	];
+	const filesToDelete = inputs.reinit ? [...findStaleArtefacts(baseDir, schemaDir)] : [];
+	if (inputs.writeEnv) if (!existsSync(join(baseDir, ".env"))) filesToWrite.push({
+		path: ".env",
+		content: envFileContent(inputs.target)
+	});
+	else warnings.push(".env already exists; leaving it untouched. Compare with .env.example for any new keys.");
+	const tsconfigPath = join(baseDir, "tsconfig.json");
+	if (existsSync(tsconfigPath)) {
+		const existing = readFileSync(tsconfigPath, "utf-8");
+		let merged;
+		try {
+			merged = mergeTsConfig(existing);
+		} catch (err) {
+			if (err instanceof TsConfigParseError) return emitError(ui, flags, errorInitInvalidTsconfig({
+				path: "tsconfig.json",
+				cause: err.message
+			}));
+			throw err;
+		}
+		filesToWrite.push({
+			path: "tsconfig.json",
+			content: merged,
+			logMessage: "Updated tsconfig.json with required compiler options."
+		});
+	} else filesToWrite.push({
+		path: "tsconfig.json",
+		content: defaultTsConfig()
+	});
+	const gitignorePath = join(baseDir, ".gitignore");
+	const newGitignore = mergeGitignore(existsSync(gitignorePath) ? readFileSync(gitignorePath, "utf-8") : void 0);
+	if (newGitignore !== null) filesToWrite.push({
+		path: ".gitignore",
+		content: newGitignore
+	});
+	const gitattributesPath = join(baseDir, ".gitattributes");
+	const newGitattributes = mergeGitattributes(existsSync(gitattributesPath) ? readFileSync(gitattributesPath, "utf-8") : void 0, requiredGitattributesLines(schemaDir, inputs.target));
+	if (newGitattributes !== null) filesToWrite.push({
+		path: ".gitattributes",
+		content: newGitattributes
+	});
+	const packageJsonPath = join(baseDir, "package.json");
+	let parsedPackageJson = null;
+	if (existsSync(packageJsonPath)) {
+		const pkgRaw = readFileSync(packageJsonPath, "utf-8");
+		try {
+			parsedPackageJson = JSON.parse(pkgRaw);
+		} catch (err) {
+			if (err instanceof SyntaxError) return emitError(ui, flags, errorInitInvalidManifest({
+				path: "package.json",
+				cause: err.message
+			}));
+			throw err;
+		}
+		let workingPkg = pkgRaw;
+		let pkgChanged = false;
+		if (inputs.removePreviousFacade !== null) {
+			const next = removeDependency(workingPkg, inputs.removePreviousFacade);
+			if (next !== null) {
+				workingPkg = next;
+				pkgChanged = true;
+			}
+		}
+		const { content: nextPkg, warnings: scriptWarnings } = mergePackageScripts(workingPkg, REQUIRED_SCRIPTS);
+		if (nextPkg !== null) {
+			workingPkg = nextPkg;
+			pkgChanged = true;
+		}
+		if (pkgChanged) filesToWrite.push({
+			path: "package.json",
+			content: workingPkg
+		});
+		warnings.push(...scriptWarnings);
+	}
+	for (const file of filesToWrite) {
+		const fullPath = join(baseDir, file.path);
+		mkdirSync(dirname(fullPath), { recursive: true });
+		writeFileSync(fullPath, file.content, "utf-8");
+		filesWritten.push(file.path);
+		if (file.logMessage !== void 0 && !flags.json && !flags.quiet) ui.log(file.logMessage);
+	}
+	for (const rel of filesToDelete) {
+		const fullPath = join(baseDir, rel);
+		if (!existsSync(fullPath)) continue;
+		try {
+			unlinkSync(fullPath);
+			filesDeleted.push(rel);
+		} catch (err) {
+			if (!(err instanceof Error && "code" in err && err.code === "ENOENT")) throw err;
+		}
+	}
+	const emitCommand = formatRunCommand(pm, "prisma-next", "contract emit");
+	let install;
+	try {
+		install = await runInstall({
+			baseDir,
+			pm,
+			target: inputs.target,
+			install: inputs.install,
+			flags,
+			ui,
+			filesWritten,
+			hasTypesNode: parsedPackageJson !== null ? hasDirectDep(parsedPackageJson, "@types/node") : false
+		});
+	} catch (error) {
+		if (CliStructuredError.is(error)) return emitError(ui, flags, error);
+		throw error;
+	}
+	warnings.push(...install.warnings);
+	let contractEmitted = false;
+	if (!install.skipped) try {
+		await runEmit({
+			baseDir,
+			ui,
+			filesWritten,
+			emitCommand
+		});
+		contractEmitted = true;
+	} catch (error) {
+		if (CliStructuredError.is(error)) return emitError(ui, flags, error);
+		throw error;
+	}
+	if (inputs.probeDb) {
+		const escalated = applyProbeOutcome(await probeServerVersion({
+			baseDir,
+			target: inputs.target,
+			databaseUrl: process.env["DATABASE_URL"],
+			minVersion: MIN_SERVER_VERSION[inputs.target]
+		}, probeOverrides ?? {}), {
+			strictProbe: inputs.strictProbe,
+			warnings
+		});
+		if (escalated !== null) return emitError(ui, flags, errorInitProbeFailed({
+			cause: escalated,
+			filesWritten
+		}));
+	}
+	const output = {
+		ok: true,
+		target: inputs.target === "mongo" ? "mongodb" : "postgres",
+		authoring: inputs.authoring,
+		schemaPath: inputs.schemaPath,
+		filesWritten,
+		filesDeleted,
+		packagesInstalled: {
+			skipped: install.skipped,
+			deps: [...install.deps],
+			devDeps: [...install.devDeps]
+		},
+		contractEmitted,
+		nextSteps: buildNextSteps({
+			target: inputs.target === "mongo" ? "mongodb" : "postgres",
+			contractEmitted,
+			emitCommand,
+			schemaPath: inputs.schemaPath
+		}),
+		warnings
+	};
+	const validated = InitOutputSchema(output);
+	if (validated instanceof Error || validated.problems !== void 0) return emitError(ui, flags, new CliStructuredError("5009", "Init produced an invalid output document", {
+		domain: "CLI",
+		why: `The success document failed schema validation: ${String(validated)}`,
+		fix: "This is a bug in prisma-next. Please report it with the full `-v` output.",
+		docsUrl: "https://prisma-next.dev/docs/cli/init"
+	}));
+	if (flags.json) ui.output(formatInitJson(output));
+	else {
+		renderInitOutro(ui, output, flags);
+		if (!flags.quiet) clack.outro("Done. Open prisma-next.md to get started.", { output: process.stderr });
+	}
+	return INIT_EXIT_OK;
+}
+/**
+* Renders a structured CLI error to the right channel and returns the exit
+* code derived from the error's PN code. JSON-mode errors go to stdout
+* (so consumers always parse from one place); human-mode errors go to
+* stderr. Mirrors `handleResult` but returns init-specific exit codes
+* rather than the CLI/RUN binary.
+*/
+function emitError(ui, flags, error) {
+	const envelope = error.toEnvelope();
+	if (flags.json) ui.output(formatErrorJson(envelope));
+	else ui.error(formatErrorOutput(envelope, flags));
+	return exitCodeForError(error);
+}
+/**
+* Maps a structured init error to its documented exit code. Centralised so
+* the error → exit-code contract lives next to the codes themselves.
+*
+* `5009` (and the unknown-code default branch) routes to
+* `INIT_EXIT_INTERNAL_ERROR` because those represent prisma-next bugs the
+* user did not cause — surfacing them as `PRECONDITION` would mislead
+* automation into thinking the caller mis-invoked the CLI.
+*
+* See [exit-codes.ts](./exit-codes.ts) for the canonical list and
+* [Style Guide § Exit Codes](../../../../../../../docs/CLI%20Style%20Guide.md#exit-codes)
+* for the reservation policy.
+*
+* Exported for unit tests so the mapping can be asserted without
+* round-tripping a full `runInit` invocation.
+*/
+function exitCodeForError(error) {
+	switch (error.code) {
+		case "5001":
+		case "5002":
+		case "5003":
+		case "5004":
+		case "5005":
+		case "5010":
+		case "5011":
+		case "5012": return INIT_EXIT_PRECONDITION;
+		case "5006": return INIT_EXIT_USER_ABORTED;
+		case "5007": return INIT_EXIT_INSTALL_FAILED;
+		case "5008": return INIT_EXIT_EMIT_FAILED;
+		case "5009": return INIT_EXIT_INTERNAL_ERROR;
+		default: return INIT_EXIT_INTERNAL_ERROR;
+	}
+}
+/**
+* Folds a `ProbeOutcome` into init's warning channel and returns the
+* fatal cause string when `--strict-probe` should escalate. Mirrors
+* the FR8.3 contract:
+*
+* - `ok` — informational; nothing surfaced unless verbose. (We could
+*   plumb a `note` here, but the spec only requires the warning side
+*   of the contract; an "all good" line would just be noise on the
+*   common path.)
+* - `below-minimum` — warning regardless of `--strict-probe`. The
+*   probe ran successfully and found an old server; that is not a
+*   probe *failure* (which is what `--strict-probe` escalates), it
+*   is the probe doing its job.
+* - `no-database-url` / `connection-failed` / `driver-missing` —
+*   warning by default, fatal under `--strict-probe`.
+*
+* Exported for unit tests so the branching contract can be asserted
+* without spinning up a full `runInit` round trip.
+*/
+function applyProbeOutcome(outcome, ctx) {
+	switch (outcome.kind) {
+		case "ok": return null;
+		case "below-minimum":
+			ctx.warnings.push(outcome.message);
+			return null;
+		case "no-database-url":
+		case "connection-failed":
+		case "driver-missing":
+			if (ctx.strictProbe) return outcome.message;
+			ctx.warnings.push(outcome.message);
+			return null;
+	}
+}
+/**
+* Drives the `pnpm add` / `npm install` step. Failures are escalated to
+* a structured `errorInitInstallFailed` (exit code 4) — the spec treats
+* an unrecoverable install as a hard outcome rather than a warning so
+* CI/agents can branch on the exit code (FR1.6).
+*
+* For pnpm specifically, we additionally implement the FR7.2 fallback:
+* if pnpm fails with a recognised workspace/catalog resolution error
+* class (typically caused by a registry version that leaked
+* `workspace:*` or `catalog:` specifiers), we retry the install using
+* `npm` and surface a non-fatal warning explaining the swap.
+*/
+async function runInstall(ctx) {
+	const { baseDir, pm, target, install, flags, ui, filesWritten, hasTypesNode } = ctx;
+	const deps = [targetPackageName(target), "dotenv"];
+	const devDeps = hasTypesNode ? ["prisma-next"] : ["prisma-next", "@types/node"];
+	const addCommand = `${pm} ${formatAddArgs(pm, deps).join(" ")}`;
+	const addDevCommand = `${pm} ${formatAddDevArgs(pm, devDeps).join(" ")}`;
+	const emitCommand = formatRunCommand(pm, "prisma-next", "contract emit");
+	const catalogWarnings = pm === "pnpm" ? buildCatalogWarnings(baseDir, [...deps, ...devDeps]) : [];
+	if (!install) {
+		if (!flags.json && !flags.quiet) ui.note([
+			"Run the following commands to complete setup:",
+			"",
+			"  1. Install dependencies:",
+			`     ${addCommand}`,
+			`     ${addDevCommand}`,
+			"",
+			"  2. Emit the contract:",
+			`     ${emitCommand}`
+		].join("\n"), "Manual steps");
+		return {
+			skipped: true,
+			deps: [],
+			devDeps: [],
+			warnings: catalogWarnings
+		};
+	}
+	const exec = promisify(execFile);
+	const runPair = async (manager) => {
+		await exec(manager, formatAddArgs(manager, deps), { cwd: baseDir });
+		await exec(manager, formatAddDevArgs(manager, devDeps), { cwd: baseDir });
+	};
+	const allPackages = [...deps, ...devDeps].join(", ");
+	const spinner = ui.spinner();
+	spinner.start(`Installing ${allPackages}...`);
+	try {
+		await runPair(pm);
+		spinner.stop(`Installed ${allPackages}`);
+		return {
+			skipped: false,
+			deps,
+			devDeps,
+			warnings: catalogWarnings
+		};
+	} catch (err) {
+		const stderrText = redactSecrets(readChildStderr(err));
+		if (pm === "pnpm" && isRecognisedPnpmResolutionError(stderrText)) {
+			spinner.message("pnpm could not resolve a workspace/catalog dependency, retrying with npm...");
+			try {
+				await runPair("npm");
+				spinner.stop(`Installed ${allPackages} via npm (pnpm fallback)`);
+				return {
+					skipped: false,
+					deps,
+					devDeps,
+					warnings: [[
+						"pnpm could not install: a published Prisma Next dependency leaked a `workspace:*` or `catalog:` specifier.",
+						"Falling back to `npm install` so init can complete.",
+						stderrText ? `  pnpm error: ${stderrText.trim().split("\n")[0]}` : "",
+						"Once the offending package republishes a clean version, re-run `pnpm install` to switch back."
+					].filter(Boolean).join("\n")]
+				};
+			} catch (npmErr) {
+				spinner.stop("Installation failed");
+				throw errorInitInstallFailed({
+					addCommand,
+					addDevCommand,
+					emitCommand,
+					filesWritten,
+					stderrLines: [stderrText, redactSecrets(readChildStderr(npmErr))]
+				});
+			}
+		}
+		spinner.stop("Installation failed");
+		throw errorInitInstallFailed({
+			addCommand,
+			addDevCommand,
+			emitCommand,
+			filesWritten,
+			stderrLines: [stderrText]
+		});
+	}
+}
+/**
+* Builds the FR7.3 catalog-honoured warning(s) for the surrounding pnpm
+* workspace, if any. Returns an empty array when no `pnpm-workspace.yaml`
+* exists in any ancestor or when the workspace's catalog has no entry
+* for any of the packages `init` is about to install.
+*
+* Exported for unit tests.
+*/
+function buildCatalogWarnings(baseDir, packages) {
+	const result = detectPnpmCatalogOverrides(baseDir, packages);
+	if (result === null || result.entries.length === 0) return [];
+	return [formatCatalogWarning(result.workspaceFile, result.entries)];
+}
+function formatCatalogWarning(workspaceFile, entries) {
+	return [
+		"pnpm workspace catalog overrides detected — pnpm will install these versions instead of `latest`:",
+		entries.map((entry) => `  • ${entry.name}: ${entry.version}`).join("\n"),
+		`Catalog source: ${workspaceFile}`,
+		"To use the published `latest` instead, remove or update the catalog entry, then re-run `pnpm install`."
+	].join("\n");
+}
+/**
+* Recognised pnpm error signatures that justify a fallback to npm.
+*
+* These patterns indicate the published artefact itself is at fault
+* (a leaked `workspace:*` or `catalog:` specifier), not the user's
+* environment — pnpm is faithfully reporting "I cannot resolve this
+* registry version", and npm is willing to install it because npm
+* doesn't care about the protocol prefix when there's a fallback range.
+*
+* Exported for unit tests; do not depend on this from outside the init
+* command.
+*/
+function isRecognisedPnpmResolutionError(stderr) {
+	if (!stderr) return false;
+	return stderr.includes("ERR_PNPM_WORKSPACE_PKG_NOT_FOUND") || stderr.includes("ERR_PNPM_NO_MATCHING_VERSION") || /No matching version found for .* in the catalog/i.test(stderr) || /workspace:[^\s]+ is not a valid (version|spec)/i.test(stderr) || /catalog:[^\s]* is not a valid (version|spec)/i.test(stderr);
+}
+/**
+* FR2.1 — true when the parsed `package.json` declares `name` directly
+* in either `dependencies` or `devDependencies`. We deliberately don't
+* inspect `peerDependencies` (irrelevant for a leaf project) or the
+* lockfile (transitive presence is brittle to detect and not the
+* realistic clobber-risk path).
+*
+* Exported for unit tests.
+*/
+function hasDirectDep(parsed, name) {
+	for (const field of ["dependencies", "devDependencies"]) {
+		const value = parsed[field];
+		if (value !== null && typeof value === "object" && name in value) return true;
+	}
+	return false;
+}
+function readChildStderr(err) {
+	if (err instanceof Error && "stderr" in err) return String(err.stderr ?? "");
+	return "";
+}
+/**
+* Redacts userinfo (`user:password@`) from any URL-shaped substring inside
+* package-manager stderr before we surface it in a warning or error
+* meta. pnpm and npm both include the offending registry URL in resolve
+* errors, and that URL can carry an auth token (e.g. corporate registry
+* mirrors that bake `_authToken` into the URL). The Style Guide
+* (Testing & Accessibility — "Security: never print secrets") requires
+* we never surface those.
+*
+* Exported for unit tests.
+*/
+function redactSecrets(stderr) {
+	if (!stderr) return stderr;
+	return stderr.replace(/([a-zA-Z][a-zA-Z0-9+.-]*:\/\/)([^/@\s]+)@/g, "$1***@");
+}
+/**
+* Drives `prisma-next contract emit` against the freshly scaffolded
+* project. On failure, throws `errorInitEmitFailed` with the underlying
+* cause embedded in `meta.cause` so the user can re-run with `-v` to see
+* the full envelope and follow the fix steps. Maps to exit code
+* `5 = EMIT_FAILED` (FR1.6).
+*/
+async function runEmit(ctx) {
+	const spinner = ctx.ui.spinner();
+	spinner.start("Emitting contract...");
+	try {
+		const { executeContractEmit } = await import("./contract-emit-LjzCoicC.mjs");
+		await executeContractEmit({ configPath: join(ctx.baseDir, "prisma-next.config.ts") });
+		spinner.stop("Contract emitted");
+	} catch (err) {
+		spinner.stop("Contract emission failed");
+		throw errorInitEmitFailed({
+			emitCommand: ctx.emitCommand,
+			filesWritten: ctx.filesWritten,
+			cause: causeMessage(err)
+		});
+	}
+}
+function causeMessage(err) {
+	if (err instanceof Error) return err.message;
+	return String(err);
+}
+
+//#endregion
+export { runInit };
+//# sourceMappingURL=init-C7dE9KOJ.mjs.map