@prisma/orm-toolchain 0.16.0-dev.36

package/dist/init-DHctXAI9-DSlaaYXN.mjs

@@ -0,0 +1,2186 @@
+import { I as formatErrorJson, L as formatErrorOutput, o as createTerminalUI, t as CliStructuredError$1 } from "./command-helpers-CAoXqAY9-DWUBcTXM.mjs";
+import { i as renderInitOutro, n as buildNextSteps, r as formatInitJson, t as InitOutputSchema } from "./output-DWNYqZGc-D2sRgLAm.mjs";
+import { a as schemaSample, c as targetLabel, i as scaffoldSpecifierResolverFor, l as targetPackageName, n as dbFile, o as starterSchema, r as defaultSchemaPath, s as targetEntrypoint, t as configFile, u as version } from "./bin__prisma-next.mjs";
+import { createRequire } from "node:module";
+import { CliStructuredError } from "@prisma/orm-framework/errors/control";
+import { basename, dirname, extname, isAbsolute, join, normalize } from "pathe";
+import { blindCast } from "@prisma/orm-framework/utils/casts";
+import { InternalError } from "@prisma/orm-framework/utils/internal-error";
+import * as clack from "@clack/prompts";
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { docsUrlFor } from "@prisma/orm-framework/utils/structured-error";
+import { keepInternalSpecifiers } from "@prisma/orm-framework/components/emission";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { detect, getUserAgent } from "package-manager-detector/detect";
+import { applyEdits, modify, parse, printParseErrorCode } from "jsonc-parser";
+//#region ../../../1-framework/3-tooling/cli/dist/init-DHctXAI9.mjs
+const KNOWN = /* @__PURE__ */ new Set([
+	"pnpm",
+	"npm",
+	"yarn",
+	"bun",
+	"deno"
+]);
+function isPackageManager(name) {
+	return KNOWN.has(name);
+}
+/**
+* Resolves the package manager `init` should drive for `add` / `install`
+* commands. Tries, in order:
+*
+*  1. **`detect()`** — walks up from `cwd` looking for a lockfile, the
+*     `packageManager` field, the `devEngines.packageManager` field, or
+*     install metadata. This is the right answer whenever the user is
+*     anywhere inside an existing project, including a deep workspace
+*     subdirectory.
+*
+*  2. **`getUserAgent()`** — parses `npm_config_user_agent`, the env var
+*     every PM sets when it spawns a script. This catches the
+*     bare-directory case where there's no project to walk up to but the
+*     user invoked us via `pnpm dlx prisma-next init` / `bunx
+*     prisma-next init` / `yarn dlx …`. Same signal used by every
+*     `create-*` tool in the ecosystem (`create-vite`, `create-next-app`,
+*     `create-astro`, `@antfu/ni`, …).
+*
+*  3. **`npm`** — final fallback. Always present alongside Node.
+*/
+async function detectPackageManager(cwd) {
+	const detected = await detect({ cwd });
+	if (detected && isPackageManager(detected.name)) return detected.name;
+	const userAgent = getUserAgent();
+	if (userAgent !== null && isPackageManager(userAgent)) return userAgent;
+	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 formatRunScriptCommand(pm, scriptName) {
+	switch (pm) {
+		case "deno": return `deno task ${scriptName}`;
+		case "bun": return `bun run ${scriptName}`;
+		case "pnpm": return `pnpm run ${scriptName}`;
+		case "yarn": return `yarn run ${scriptName}`;
+		default: return `npm run ${scriptName}`;
+	}
+}
+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
+	];
+}
+/**
+* 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;
+}
+/**
+* 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$1("CLI.INIT_REINIT_NEEDS_FORCE", "Project is already initialized", {
+		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: docsUrlFor("CLI.INIT_REINIT_NEEDS_FORCE")
+	});
+}
+/**
+* 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$1("CLI.INIT_MISSING_FLAGS", "Missing required flags", {
+		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: docsUrlFor("CLI.INIT_MISSING_FLAGS"),
+		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$1("CLI.INIT_INVALID_FLAG_VALUE", `Invalid value for --${options.flag}`, {
+		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: docsUrlFor("CLI.INIT_INVALID_FLAG_VALUE"),
+		meta: {
+			flag: options.flag,
+			value: options.value,
+			allowed: options.allowed
+		}
+	});
+}
+/**
+* `--authoring` and `--schema-path` disagree on file extension (e.g. PSL
+* authoring with a `.ts` path). Surfaces before any scaffold files are
+* written so the project tree stays untouched.
+*/
+function errorInitAuthoringSchemaPathMismatch(options) {
+	const expectedAuthoring = options.expectedExtension === ".ts" ? "typescript" : "psl";
+	return new CliStructuredError$1("CLI.INIT_AUTHORING_SCHEMA_PATH_MISMATCH", "Authoring and schema path do not match", {
+		why: `\`--authoring ${options.authoring}\` requires a schema file ending in ${options.expectedExtension}, but \`--schema-path ${options.schemaPath}\` ends in ${options.actualExtension}.`,
+		fix: `Use a matching pair, for example \`--authoring ${expectedAuthoring} --schema-path <path>${options.expectedExtension}\`, or change \`--authoring\` to match the path you supplied. You can also omit \`--schema-path\` to use the default for the chosen authoring.`,
+		docsUrl: docsUrlFor("CLI.INIT_AUTHORING_SCHEMA_PATH_MISMATCH"),
+		meta: {
+			authoring: options.authoring,
+			schemaPath: options.schemaPath,
+			actualExtension: options.actualExtension,
+			expectedExtension: options.expectedExtension
+		}
+	});
+}
+/**
+* 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$1("CLI.INIT_USER_ABORTED", "Init cancelled", {
+		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$1("CLI.INIT_STRICT_PROBE_WITHOUT_PROBE", "`--strict-probe` requires `--probe-db`", {
+		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: docsUrlFor("CLI.INIT_STRICT_PROBE_WITHOUT_PROBE")
+	});
+}
+/**
+* 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$1("CLI.INIT_INSTALL_FAILED", "Failed to install dependencies", {
+		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: docsUrlFor("CLI.INIT_INSTALL_FAILED"),
+		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$1("CLI.INIT_INVALID_MANIFEST", `Failed to parse ${options.path}`, {
+		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: docsUrlFor("CLI.INIT_INVALID_MANIFEST"),
+		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$1("CLI.INIT_INVALID_TSCONFIG", `Failed to parse ${options.path}`, {
+		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: docsUrlFor("CLI.INIT_INVALID_TSCONFIG"),
+		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$1("CLI.INIT_PROBE_FAILED", "Database probe failed", {
+		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: docsUrlFor("CLI.INIT_PROBE_FAILED"),
+		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$1("CLI.INIT_EMIT_FAILED", "Failed to emit contract", {
+		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: docsUrlFor("CLI.INIT_EMIT_FAILED"),
+		meta: {
+			filesWritten: options.filesWritten,
+			cause: options.cause
+		}
+	});
+}
+/**
+* The project-level skills install (`npx skills add
+* prisma/prisma#v<version>`) failed after a successful dependency
+* install + emit. The project's scaffold remains on disk; the user
+* can either fix the underlying issue (network, registry, PATH) and
+* run the install command manually, or re-run `init --no-skill` to
+* proceed without the skill.
+*
+* Non-rolling-back, matching the existing install/emit failure
+* semantics. Maps to exit code `6 = SKILL_INSTALL_FAILED`.
+*/
+function errorInitSkillInstallFailed(options) {
+	return new CliStructuredError$1("CLI.INIT_SKILL_INSTALL_FAILED", "Failed to install Prisma Next skills", {
+		why: `\`${options.skillInstallCommand}\` exited with an error: ${options.cause}`,
+		fix: `Either:
+  - Re-run \`prisma-next init --no-skill${options.filesWritten.length > 0 ? " --force" : ""}\` to skip the skill install for this run, or\n  - Fix the underlying issue (network, npm registry, \`npx skills\` on PATH) and install manually:\n      ${options.skillInstallCommand}`,
+		docsUrl: docsUrlFor("CLI.INIT_SKILL_INSTALL_FAILED"),
+		meta: {
+			filesWritten: options.filesWritten,
+			skillInstallCommand: options.skillInstallCommand,
+			cause: options.cause
+		}
+	});
+}
+/**
+* The `.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**: `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 artifact lands.
+*
+* `ARTIFACT_FILENAMES` entries 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
+* `DEFAULT_CONTRACT_SOURCE_DIR/contract.json` (which would silently
+* break for a non-default schema path).
+*
+* The migration contract snapshot store (`migrations/snapshots/<hex>/`)
+* is anchored to the migrations root instead, not the schema directory:
+* migration package depth under `migrations/` varies (`app/<pkg>`,
+* `<space>/<pkg>`, or a bare `<pkg>` in extension source repos), so no
+* single schema-dir-relative pattern can reach every snapshot. See
+* `STORE_GITATTRIBUTES_LINES` below.
+*/
+const ARTIFACT_FILENAMES$1 = [
+	"contract.json",
+	"contract.d.ts",
+	"ops.json",
+	"migration.json"
+];
+const ATTRIBUTE = "linguist-generated";
+/**
+* Full `.gitattributes` lines for the migration contract snapshot store,
+* already anchored to the migrations root — unlike `ARTIFACT_FILENAMES`,
+* these are not combined with the schema-relative prefix.
+*/
+const STORE_GITATTRIBUTES_LINES = [`migrations/snapshots/**/contract.json ${ATTRIBUTE}`, `migrations/snapshots/**/contract.d.ts ${ATTRIBUTE}`];
+/**
+* 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
+* family-specific artifact) without a signature break.
+*/
+function requiredGitattributesLines(schemaDir, _target) {
+	const dir = schemaDir === "." ? "" : schemaDir.replace(/\/+$/, "");
+	const prefix = dir === "" ? "" : `${dir}/`;
+	return [...ARTIFACT_FILENAMES$1.map((file) => `${prefix}${file} ${ATTRIBUTE}`), ...STORE_GITATTRIBUTES_LINES];
+}
+/**
+* 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
+* `DEFAULT_CONTRACT_SOURCE_DIR/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`;
+}
+/**
+* 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`;
+}
+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 = blindCast(JSON.parse(existing));
+	const scripts = typeof parsed["scripts"] === "object" && parsed["scripts"] !== null ? { ...blindCast(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
+	};
+}
+/**
+* Idempotently sets `"type": "module"` on a `package.json` so the
+* scaffolded `prisma/db.ts` — which uses the ESM-only `with { type: 'json' }`
+* import attribute — loads as ES module under Node's loader (TML-2494).
+*
+* Without this field Node either:
+*
+* - emits `MODULE_TYPELESS_PACKAGE_JSON` and reparses the file as ESM
+*   with a perf penalty (Node 22+ with `--experimental-strip-types`), or
+* - hard-fails with `ERR_*` because the CJS loader cannot parse the
+*   import-attribute syntax (older Node, or any tool that doesn't
+*   reparse).
+*
+* Behaviour:
+*
+* - **Field missing** → set to `"module"`. New entry is inserted right
+*   after `"name"` (when present) so the diff lands in a conventional
+*   spot for human review; falls through to the natural append position
+*   otherwise.
+* - **Field already `"module"`** → no-op (idempotent).
+* - **Field set to anything else** (e.g. `"commonjs"`) → leave it alone
+*   and surface a structured warning. The user explicitly opted out of
+*   ESM and we don't silently overwrite that.
+*/
+function ensureEsmModuleType(existing) {
+	const parsed = blindCast(JSON.parse(existing));
+	const currentType = parsed["type"];
+	if (currentType === "module") return {
+		content: null,
+		warning: null
+	};
+	if (typeof currentType === "string" && currentType !== "module") return {
+		content: null,
+		warning: `package.json declares "type": "${currentType}" — keeping yours, but the scaffolded prisma/db.ts uses an ESM-only import attribute (\`with { type: 'json' }\`) and will not load under that module type.\nIf you want the default, set "type": "module" in package.json.`
+	};
+	const next = {};
+	let inserted = false;
+	for (const [key, value] of Object.entries(parsed)) {
+		if (key === "type") continue;
+		next[key] = value;
+		if (!inserted && key === "name") {
+			next["type"] = "module";
+			inserted = true;
+		}
+	}
+	if (!inserted) next["type"] = "module";
+	const trailingNewline = existing.endsWith("\n") ? "\n" : "";
+	return {
+		content: `${JSON.stringify(next, null, 2)}${trailingNewline}`,
+		warning: null
+	};
+}
+const TARGET_ALIASES = /* @__PURE__ */ new Map([
+	["postgres", "postgres"],
+	["postgresql", "postgres"],
+	["mongo", "mongo"],
+	["mongodb", "mongo"]
+]);
+const AUTHORING_VALUES = /* @__PURE__ */ 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
+	});
+	const installProjectSkill = options.skill !== false;
+	return {
+		target: finalTarget,
+		authoring: finalAuthoring,
+		schemaPath: finalSchemaPath,
+		install: options.install !== false,
+		writeEnv,
+		probeDb: Boolean(options.probeDb),
+		strictProbe: Boolean(options.strictProbe),
+		reinit,
+		removePreviousFacade,
+		installProjectSkill
+	};
+}
+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 otherFacadeNames = [targetPackageName(otherTarget, scaffoldSpecifierResolverFor(otherTarget)), 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;
+	const otherFacade = otherFacadeNames.find((name) => Object.hasOwn(deps, name));
+	if (otherFacade === void 0) 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 errorInitAuthoringSchemaPathMismatch({
+		authoring,
+		schemaPath: trimmed,
+		actualExtension: ext.length > 0 ? ext : "(none)",
+		expectedExtension: expected
+	});
+	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);
+}
+/**
+* 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 CliStructuredError("CLI.INIT_PROBE_FAILED", `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 CliStructuredError("CLI.INIT_PROBE_FAILED", "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)})`);
+	}
+}
+/**
+* Filenames the contract pipeline emits next to the user's schema source
+* (`<schemaDir>/contract.json`, `<schemaDir>/contract.d.ts`, …). Mirrors
+* the schema-dir-relative `ARTIFACT_FILENAMES` in `hygiene-gitattributes.ts`
+* (not that file's migrations-root-anchored store lines, which are outside
+* this command's scope — reinit only ever touches `schemaDir`); kept as a
+* separate constant here because the cleanup contract is target-agnostic
+* and we deliberately do not want a stale artifact from a previous target
+* lingering after a re-init.
+*
+* If a future emit pipeline produces an additional schema-dir artifact,
+* add it here **and** to `ARTIFACT_FILENAMES` in `hygiene-gitattributes.ts`
+* — 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 ARTIFACT_FILENAMES = [
+	"contract.json",
+	"contract.d.ts",
+	"ops.json",
+	"migration.json"
+];
+/**
+* Returns the schema-relative paths of stale contract artifacts 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 artifacts on disk and the project byte-identical to its pre-init
+* state.
+*/
+function findStaleArtifacts(baseDir, schemaDir) {
+	const result = [];
+	for (const filename of ARTIFACT_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}`;
+}
+const exec = promisify(execFile);
+/**
+* Default base for the GitHub-URL form `<owner>/<repo>` consumed by
+* upstream `skills add`. Each `SkillSource` joins this base with its
+* own subpath (and optional `#ref` for version-pinned clusters).
+*/
+const DEFAULT_SKILL_BASE = "prisma/prisma";
+const DEFAULT_SKILL_SOURCES = [
+	{
+		subpath: "skills",
+		ref: "cli",
+		description: "usage skills (version-locked to installed Prisma Next)"
+	},
+	{
+		subpath: "skills/upgrade",
+		ref: null,
+		description: "upgrade skill (always tracks `main`)"
+	},
+	{
+		subpath: "skills/extension-author",
+		ref: null,
+		description: "extension-author skill (always tracks `main`)"
+	}
+];
+/**
+* Test-only escape hatch for pinning the install base to a local
+* checkout. Production runs leave this unset, so installs always use
+* `DEFAULT_SKILL_BASE`.
+*
+* When set to an absolute filesystem path (typical for tests), the
+* `#ref` fragment is dropped — local-path mode in upstream's CLI does
+* not accept refs, and the local clone has whatever content the test
+* checked into it anyway. When set to anything else (e.g. a fork name
+* `myuser/prisma-next`), the ref policy is preserved.
+*/
+function resolveAgentSkillBase() {
+	const override = process.env["PRISMA_NEXT_SKILLS_BASE"]?.trim();
+	return override && override.length > 0 ? override : DEFAULT_SKILL_BASE;
+}
+function isLocalPath(base) {
+	return base.startsWith("/") || /^[a-zA-Z]:[\\/]/.test(base);
+}
+/**
+* Agents passed to every project-level init install. Upstream `skills add`
+* is the source of truth for per-agent install behaviour; the CLI lists
+* every supported runtime on one invocation and delegates the rest.
+*/
+const DEFAULT_SKILL_AGENTS = [
+	"cursor",
+	"claude-code",
+	"codex",
+	"windsurf"
+];
+/**
+* Build the `<base>/<subpath>[#ref]` URL the `skills` CLI will
+* resolve. Exported for unit tests so the per-source format can be
+* asserted without going through the full install loop.
+*/
+function formatSkillSourceUrl(source) {
+	const base = resolveAgentSkillBase();
+	const url = `${base}/${source.subpath}`;
+	if (source.ref === null) return url;
+	if (isLocalPath(base)) return url;
+	if (source.ref === "cli") return `${url}#v${version}`;
+	return url;
+}
+/**
+* The skill-install command for one source, formatted for the
+* project's detected package manager. `npx`/`pnpm dlx`/`bunx` are
+* interchangeable to the user; we pick the variant that matches the
+* rest of the install step so a single project consistently uses one
+* runner.
+*
+* `--agent` takes space-separated slugs on one flag; `--skill '*'` and `-y`
+* skip the multi-select prompts a non-interactive scaffold step cannot show.
+*
+* Exported for unit tests so the per-PM dispatch can be asserted
+* without a live subprocess.
+*/
+function formatSkillInstallCommand(args) {
+	const agents = args.agents ?? DEFAULT_SKILL_AGENTS;
+	const cliArgs = [
+		"skills@latest",
+		"add",
+		formatSkillSourceUrl(args.source),
+		"--agent",
+		...agents,
+		"--skill",
+		"'*'",
+		"-y"
+	];
+	return formatPackageManagerCommand(args.pm, cliArgs);
+}
+/**
+* Ordered skill-install commands for one init run. Exported for unit tests.
+*/
+function resolveProjectSkillInstallCommands(pm) {
+	return DEFAULT_SKILL_SOURCES.map((source) => formatSkillInstallCommand({
+		pm,
+		source
+	}));
+}
+function formatPackageManagerCommand(pm, args) {
+	switch (pm) {
+		case "pnpm": return `pnpm dlx ${args.join(" ")}`;
+		case "yarn": return `yarn dlx ${args.join(" ")}`;
+		case "bun": return `bunx ${args.join(" ")}`;
+		case "deno": return `deno run -A npm:${args.join(" ")}`;
+		case "npm": return `npx ${args.join(" ")}`;
+	}
+}
+/**
+* Parse the project-pm-formatted command into an exec call. The
+* format-then-parse split keeps the user-facing command string the same
+* as the surface the structured error advertises, so a user who copies
+* the error's `fix` line gets the same invocation that init just
+* attempted. Single quotes are preserved in the display form so `*` is
+* safe to copy into a shell, then stripped before `execFile`.
+*/
+function commandToExec(command) {
+	const tokens = (command.match(/'[^']*'|\S+/g) ?? []).map((token) => token.startsWith("'") && token.endsWith("'") ? token.slice(1, -1) : token);
+	return {
+		file: tokens[0] ?? "npx",
+		args: tokens.slice(1)
+	};
+}
+/**
+* Runs the project-level skill install for every source in
+* `DEFAULT_SKILL_SOURCES`, in order. Returns
+* `{ ok: true, commands }` on success; throws a structured
+* `errorInitSkillInstallFailed` on the first failure (subsequent
+* sources are not attempted — the user opted into Prisma Next by
+* running `init` and a partial install would leave the project in an
+* ambiguous state). The throw is intentionally fatal — project-level
+* skill install is unconditional (modulo `--no-skill`).
+*/
+async function runProjectLevelSkillInstall(ctx) {
+	const commands = [];
+	const installCommands = resolveProjectSkillInstallCommands(ctx.pm);
+	for (const command of installCommands) {
+		const { file, args } = commandToExec(command);
+		try {
+			await exec(file, args, { cwd: ctx.baseDir });
+			commands.push(command);
+		} catch (err) {
+			throw errorInitSkillInstallFailed({
+				skillInstallCommand: command,
+				filesWritten: ctx.filesWritten,
+				cause: redactSecrets$1(readChildStderr$1(err)) || (err instanceof Error ? err.message : String(err))
+			});
+		}
+	}
+	return {
+		ok: true,
+		commands
+	};
+}
+function readChildStderr$1(err) {
+	if (err instanceof Error && "stderr" in err) return String(err.stderr ?? "");
+	return "";
+}
+/**
+* Strips credentials from a `scheme://user:pass@host/...` URL anywhere
+* in `stderr`. Package-manager stderr regularly contains credentialed
+* registry URLs (private npm registries, GitHub Packages tokens), and
+* those bubble into the structured `errorInitSkillInstallFailed`
+* envelope, which ends up in logs and CI output. Redact at the
+* boundary so we never re-emit a secret.
+*
+* Exported for unit tests.
+*/
+function redactSecrets$1(stderr) {
+	if (!stderr) return stderr;
+	return stderr.replace(/([a-zA-Z][a-zA-Z0-9+.-]*:\/\/)([^/@\s]+)@/g, "$1***@");
+}
+/**
+* Hand-rolled skill stub path that init must not leave behind. Removed
+* on every init run so a project's `.agents/skills/prisma-next/` does
+* not shadow the installed Prisma Next skill cluster.
+*/
+const LEGACY_SKILL_FILE = ".agents/skills/prisma-next/SKILL.md";
+/**
+* The minimum supported server version for each target. 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` 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: "17",
+	mongo: "8.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("# Standalone local mongod / `docker run mongo:8` — no replica set required for first-run queries.");
+		lines.push("# Transactions and change streams need a replica set; add ?replicaSet=... only after initiating one.");
+		lines.push("");
+		lines.push("DATABASE_URL=\"mongodb://user:password@localhost:27017/mydb\"");
+	}
+	lines.push("");
+	return lines.join("\n");
+}
+/**
+* Renders the `.env.example` content for a given target:
+*
+* - 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.
+*/
+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. 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 (`.env` lands in `.gitignore` during init).
+*/
+function envFileContent(target) {
+	return envPlaceholderBody(target);
+}
+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 InternalError(`Template variable '${key}' is not defined`);
+		result = result.replaceAll(`{{${key}}}`, value);
+	}
+	return result;
+}
+const variables = [
+	"schemaPath",
+	"schemaDir",
+	"dbImportPath",
+	"pkgRun",
+	"pkg",
+	"configEntrypoint",
+	"schemaSample",
+	"requirements"
+];
+function quickReferenceMd(target, authoring, schemaPath, pkgRun, resolveImportSpecifier = keepInternalSpecifiers) {
+	const schemaDir = dirname(schemaPath);
+	const pkg = targetPackageName(target, resolveImportSpecifier);
+	const vars = {
+		schemaPath,
+		schemaDir,
+		dbImportPath: `./${schemaDir}/db`,
+		pkgRun,
+		pkg,
+		configEntrypoint: targetEntrypoint(target, "config", resolveImportSpecifier),
+		schemaSample: schemaSample(target, authoring, resolveImportSpecifier),
+		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");
+}
+const sharedVariables = [
+	"projectName",
+	"contractPath",
+	"runDev",
+	"runContractEmit"
+];
+const postgresVariables = [
+	...sharedVariables,
+	"runDbInit",
+	"runDbUpdate",
+	"runMigrationPlan",
+	"runMigrate",
+	"runDbSeed"
+];
+const mongoVariables = [
+	...sharedVariables,
+	"runDbUp",
+	"runDbDown",
+	"runDbReset",
+	"runMigrationPlan",
+	"runMigrate",
+	"runDbSeed"
+];
+function minimalProjectReadmeMd(target, schemaPath, projectName, pm) {
+	const run = (script) => formatRunScriptCommand(pm, script);
+	const shared = {
+		projectName,
+		contractPath: schemaPath,
+		runDev: run("dev"),
+		runContractEmit: run("contract:emit"),
+		runMigrationPlan: run("migration:plan"),
+		runMigrate: run("migrate"),
+		runDbSeed: run("db:seed")
+	};
+	if (target === "mongo") {
+		const vars = {
+			...shared,
+			runDbUp: run("db:up"),
+			runDbDown: run("db:down"),
+			runDbReset: run("db:reset")
+		};
+		return renderTemplate("readme-mongo.md", mongoVariables, vars);
+	}
+	const vars = {
+		...shared,
+		runDbInit: run("db:init"),
+		runDbUpdate: run("db:update")
+	};
+	return renderTemplate("readme-postgres.md", postgresVariables, vars);
+}
+/**
+* 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;
+}
+/**
+* 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` 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 = createTerminalUI(flags);
+	const warnings = [];
+	const filesWritten = [];
+	const filesDeleted = [];
+	if (!flags.json && !flags.quiet) clack.intro("prisma-next init", { output: process.stderr });
+	let inputs;
+	try {
+		inputs = await resolveInitInputs({
+			baseDir,
+			options,
+			flags,
+			canPrompt
+		});
+	} catch (error) {
+		if (CliStructuredError$1.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 resolveImportSpecifier = scaffoldSpecifierResolverFor(inputs.target);
+	const filesToWrite = [
+		{
+			path: inputs.schemaPath,
+			content: starterSchema(inputs.target, inputs.authoring, resolveImportSpecifier)
+		},
+		{
+			path: "prisma-next.config.ts",
+			content: configFile(inputs.target, configContractPath, resolveImportSpecifier)
+		},
+		{
+			path: join(schemaDir, "db.ts"),
+			content: dbFile(inputs.target, resolveImportSpecifier)
+		},
+		{
+			path: "prisma-next.md",
+			content: quickReferenceMd(inputs.target, inputs.authoring, inputs.schemaPath, pkgRun, resolveImportSpecifier)
+		},
+		{
+			path: ".env.example",
+			content: envExampleContent(inputs.target)
+		}
+	];
+	const filesToDelete = inputs.reinit ? [...findStaleArtifacts(baseDir, schemaDir)] : [];
+	if (existsSync(join(baseDir, ".agents/skills/prisma-next/SKILL.md"))) filesToDelete.push(LEGACY_SKILL_FILE);
+	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");
+	const packageJsonExisted = existsSync(packageJsonPath);
+	const synthesisePackageJson = !packageJsonExisted && !hasProjectManifest(baseDir);
+	let parsedPackageJson = null;
+	if (packageJsonExisted || synthesisePackageJson) {
+		const pkgRaw = packageJsonExisted ? readFileSync(packageJsonPath, "utf-8") : defaultPackageJsonContent(basename(baseDir));
+		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 = synthesisePackageJson;
+		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;
+		}
+		const { content: typedPkg, warning: typeWarning } = ensureEsmModuleType(workingPkg);
+		if (typedPkg !== null) {
+			workingPkg = typedPkg;
+			pkgChanged = true;
+		}
+		if (pkgChanged) filesToWrite.push({
+			path: "package.json",
+			content: workingPkg
+		});
+		warnings.push(...scriptWarnings);
+		if (typeWarning !== null) warnings.push(typeWarning);
+		if (synthesisePackageJson) warnings.push("No package.json found in the target directory; created a minimal one. Edit `name` / `version` to taste.");
+	}
+	if (existsSync(join(baseDir, "src/index.ts"))) if (!existsSync(join(baseDir, "README.md"))) {
+		const rawName = parsedPackageJson !== null && typeof parsedPackageJson["name"] === "string" ? parsedPackageJson["name"] : basename(baseDir);
+		filesToWrite.push({
+			path: "README.md",
+			content: minimalProjectReadmeMd(inputs.target, inputs.schemaPath, sanitisePackageName(rawName), pm)
+		});
+	} else warnings.push("README.md already exists; leaving it untouched.");
+	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,
+			resolveImportSpecifier,
+			hasTypesNode: parsedPackageJson !== null ? hasDirectDep(parsedPackageJson, "@types/node") : false
+		});
+	} catch (error) {
+		if (CliStructuredError$1.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$1.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 manualProjectSkillSummary = DEFAULT_SKILL_SOURCES.map((source) => formatSkillInstallCommand({
+		pm: install.effectivePm,
+		source
+	})).map((c) => `\`${c}\``).join(" && ");
+	let skillRegistered = false;
+	if (!inputs.installProjectSkill) warnings.push(`Skipped Prisma Next skills install (--no-skill). To install the skills later, run: ${manualProjectSkillSummary}`);
+	else {
+		const spinner = ui.spinner();
+		spinner.start("Registering Prisma Next skills with the agent runtime...");
+		try {
+			const project = await runProjectLevelSkillInstall({
+				baseDir,
+				pm: install.effectivePm,
+				filesWritten
+			});
+			spinner.stop(`Registered Prisma Next skills (project level) — ran ${project.commands.map((c) => `\`${c}\``).join(", ")}`);
+			skillRegistered = true;
+		} catch (error) {
+			spinner.stop("Agent-skill install failed");
+			if (CliStructuredError$1.is(error)) return emitError(ui, flags, error);
+			throw error;
+		}
+	}
+	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,
+			skillRegistered
+		}),
+		warnings
+	};
+	const validated = InitOutputSchema(output);
+	if (validated instanceof Error || validated.problems !== void 0) return emitError(ui, flags, new CliStructuredError$1("CLI.INIT_INVALID_OUTPUT_DOCUMENT", "Init produced an invalid output document", {
+		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: docsUrlFor("CLI.INIT_INVALID_OUTPUT_DOCUMENT")
+	}));
+	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 0;
+}
+/**
+* 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.
+*
+* `CLI.INIT_INVALID_OUTPUT_DOCUMENT` (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 "CLI.INIT_REINIT_NEEDS_FORCE":
+		case "CLI.INIT_MISSING_FLAGS":
+		case "CLI.INIT_INVALID_FLAG_VALUE":
+		case "CLI.INIT_STRICT_PROBE_WITHOUT_PROBE":
+		case "CLI.INIT_INVALID_MANIFEST":
+		case "CLI.INIT_INVALID_TSCONFIG":
+		case "CLI.INIT_PROBE_FAILED":
+		case "CLI.INIT_AUTHORING_SCHEMA_PATH_MISMATCH": return 2;
+		case "CLI.INIT_USER_ABORTED": return 3;
+		case "CLI.INIT_INSTALL_FAILED": return 4;
+		case "CLI.INIT_EMIT_FAILED": return 5;
+		case "CLI.INIT_INVALID_OUTPUT_DOCUMENT": return 1;
+		case "CLI.INIT_SKILL_INSTALL_FAILED": return 6;
+		default: return 1;
+	}
+}
+/**
+* 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, ctx.resolveImportSpecifier), "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,
+			effectivePm: pm
+		};
+	}
+	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,
+			effectivePm: pm
+		};
+	} 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")],
+					effectivePm: "npm"
+				};
+			} 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 artifact 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-B6odMoem-CK3diBPk.mjs").then((n) => n.t).then((n) => n.t);
+		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);
+}
+/**
+* Minimal `package.json` content used when init runs in a directory
+* that has no project manifest (TML-2496). Mirrors the npm 11 `init -y`
+* defaults, with two deliberate deviations:
+*
+* - `"private": true` so a stray `npm publish` cannot leak the
+*   placeholder. Users who want to publish have to opt in by removing
+*   the field.
+* - `"type": "module"` so the scaffolded ESM imports in
+*   `prisma-next.config.ts` and `db.ts` typecheck and run without
+*   additional tsconfig coercion.
+*
+* Exported for unit tests so the canonical shape is asserted in one
+* place rather than re-derived at every call site.
+*/
+function defaultPackageJsonContent(rawName) {
+	return `${JSON.stringify({
+		name: sanitisePackageName(rawName),
+		version: "0.0.0",
+		private: true,
+		type: "module"
+	}, null, 2)}\n`;
+}
+/**
+* npm package names are restricted to lowercase, no leading dot/underscore,
+* and a small URL-safe character set. `basename(cwd)` happily returns
+* "My Project" or ".hidden" — both rejected by `npm install` validation.
+* Coerce to a safe fallback rather than emit a manifest npm refuses to
+* read.
+*/
+function sanitisePackageName(raw) {
+	const trimmed = raw.toLowerCase().replace(/[^a-z0-9._~-]/g, "-").replace(/^[._-]+/, "").replace(/-+/g, "-");
+	return trimmed.length > 0 ? trimmed : "my-app";
+}
+//#endregion
+export { runInit };
+
+//# sourceMappingURL=init-DHctXAI9-DSlaaYXN.mjs.map