@prisma/orm-toolchain 8.0.0-rc.1-dev.38 → 8.0.0-rc.1-dev.39

package/dist/init-CcJxAIeS-CITTa8YU.mjs

@@ -0,0 +1,800 @@
+import { t as CliStructuredError$1 } from "./cli-errors-BG6bItjG-DwdKIeGz.mjs";
+import { a as formatErrorJson, o as formatErrorOutput, r as createTerminalUI } from "./terminal-ui-Cqz4LVL7-B0mcVdLy.mjs";
+import { c as targetLabel, i as scaffoldSpecifierResolverFor, l as targetPackageName, n as dbFile, o as starterSchema, r as defaultSchemaPath, t as configFile } from "./code-templates-CSLH8721-CWRA4Lru.mjs";
+import { A as isRecognisedPnpmResolutionError, B as removeDependency, C as findStaleArtifacts, D as formatSkillInstallCommand, E as formatRunCommand, F as mergeTsConfig, G as validateSchemaPath, H as resolveAuthoring, I as minimalProjectReadmeMd, L as probeServerVersion, M as mergeGitattributes, N as mergeGitignore, P as mergePackageScripts, R as quickReferenceMd, T as formatAddDevArgs, U as resolveProjectSkillInstallCommands, V as requiredGitattributesLines, W as resolveTarget, _ as errorInitProbeFailed, a as TsConfigParseError, b as errorInitStrictProbeWithoutProbe, c as detectPackageManager, d as envFileContent, f as errorInitEmitFailed, g as errorInitMissingFlags, h as errorInitInvalidTsconfig, i as REQUIRED_SCRIPTS, j as legacySkillDirs, k as hasProjectManifest, l as ensureEsmModuleType, m as errorInitInvalidManifest, n as DEFAULT_SKILL_SOURCES, o as buildCatalogWarnings, p as errorInitInstallFailed, r as MIN_SERVER_VERSION, s as defaultTsConfig, u as envExampleContent, v as errorInitReinitNeedsForce, w as formatAddArgs, x as errorInitUserAborted, y as errorInitSkillInstallFailed, z as redactSecrets } from "./redact-secrets-kQ0KKV1u-MnVSKe-u.mjs";
+import { i as renderInitOutro, n as buildNextSteps, r as formatInitJson, t as InitOutputSchema } from "./output-DP3woAjV-BxCr9nHA.mjs";
+import { basename, dirname, extname, isAbsolute, join } from "pathe";
+import { existsSync, mkdirSync, readFileSync, rmSync, unlinkSync, writeFileSync } from "node:fs";
+import { docsUrlFor } from "@prisma/orm-framework/utils/structured-error";
+import * as clack from "@clack/prompts";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+//#region ../../../1-framework/3-tooling/cli/dist/init-CcJxAIeS.mjs
+/**
+* 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;
+}
+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);
+}
+const exec = promisify(execFile);
+/**
+* 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-quoted tokens are preserved in the display form so
+* shell-sensitive characters stay copy-safe, 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(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 "";
+}
+/**
+* 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)] : [];
+	const legacyDirsToDelete = legacySkillDirs().filter((rel) => existsSync(join(baseDir, rel)));
+	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;
+		}
+	}
+	for (const rel of legacyDirsToDelete) {
+		rmSync(join(baseDir, rel), {
+			recursive: true,
+			force: true
+		});
+		filesDeleted.push(rel);
+	}
+	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 packagesInstalled = install.skipped ? "skipped" : "installed";
+	const output = {
+		ok: true,
+		target: inputs.target === "mongo" ? "mongodb" : "postgres",
+		authoring: inputs.authoring,
+		schemaPath: inputs.schemaPath,
+		filesWritten,
+		filesDeleted,
+		packagesInstalled: {
+			status: packagesInstalled,
+			deps: [...install.deps],
+			devDeps: [...install.devDeps]
+		},
+		contractEmitted,
+		nextSteps: buildNextSteps({
+			target: inputs.target === "mongo" ? "mongodb" : "postgres",
+			packagesInstalled,
+			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":
+		case "CLI.INIT_WRITE_FAILED": 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]
+		});
+	}
+}
+/**
+* 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 "";
+}
+/**
+* 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-Bzt11N4v-BQ2Pr8KG.mjs");
+		const { loadConfigForSections } = await import("./exports-BZLNbtkY.mjs").then((n) => n.t);
+		const configFilePath = join(ctx.baseDir, "prisma-next.config.ts");
+		const configResult = await loadConfigForSections(configFilePath, [
+			"contract",
+			"family",
+			"target",
+			"adapter",
+			"extensions"
+		]);
+		if (!configResult.ok) throw configResult.failure;
+		await executeContractEmit({
+			config: configResult.value,
+			cwd: process.cwd(),
+			configPath: configFilePath
+		});
+		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-CcJxAIeS-CITTa8YU.mjs.map