@prisma/orm-toolchain 0.16.0-dev.36

package/dist/format-ByDm2goZ-DKLyhNHo.mjs

@@ -0,0 +1,101 @@
+import { N as errorUnexpected, O as errorRuntime$1, W as formatStyledHeader, ct as setCommandExamples, o as createTerminalUI, q as handleResult, r as addGlobalOptions, st as setCommandDescriptions, t as CliStructuredError$1, tt as parseGlobalFlagsOrExit } from "./command-helpers-CAoXqAY9-DWUBcTXM.mjs";
+import { r as loadConfig } from "./exports-Dl2aGAk7.mjs";
+import { ifDefined } from "@prisma/orm-framework/utils/defined";
+import { notOk, ok } from "@prisma/orm-framework/utils/result";
+import { relative, resolve } from "pathe";
+import { readFile, writeFile } from "node:fs/promises";
+import { isStructuredError } from "@prisma/orm-framework/utils/structured-error";
+import { Command } from "commander";
+import { EOL } from "node:os";
+import { format } from "@prisma/orm-framework/psl-parser/format";
+//#region ../../../1-framework/3-tooling/cli/dist/format-ByDm2goZ.mjs
+function resolveNewline(formatterNewline, eol) {
+	if (formatterNewline !== void 0) return formatterNewline;
+	return eol === "\r\n" ? "CRLF" : "LF";
+}
+async function executeFormat(options) {
+	const eol = options.eol ?? EOL;
+	let config;
+	try {
+		config = await loadConfig(options.configPath);
+	} catch (error) {
+		if (CliStructuredError$1.is(error)) return notOk(error);
+		return notOk(errorUnexpected(error instanceof Error ? error.message : String(error)));
+	}
+	const source = config.contract?.source;
+	if (source?.format !== "psl") return ok({ formatted: false });
+	const inputPath = source.inputs?.[0];
+	if (inputPath === void 0) return ok({ formatted: false });
+	let contents;
+	try {
+		contents = await readFile(inputPath, "utf-8");
+	} catch (error) {
+		return notOk(errorRuntime$1("Failed to read contract source file", {
+			why: error instanceof Error ? error.message : String(error),
+			fix: `Check that ${inputPath} exists and is readable.`
+		}));
+	}
+	const formatOptions = {
+		indent: config.formatter?.indent ?? 2,
+		newline: resolveNewline(config.formatter?.newline, eol)
+	};
+	let formatted;
+	try {
+		formatted = format(contents, formatOptions);
+	} catch (error) {
+		if (isStructuredError(error) && error.code === "PSL.PARSE_FAILED") return notOk(errorRuntime$1("Cannot format PSL with parse errors", {
+			why: error.message,
+			fix: "Fix the parse errors in your schema and try again.",
+			meta: { diagnostics: error.meta?.["diagnostics"] }
+		}));
+		return notOk(errorUnexpected(error instanceof Error ? error.message : String(error)));
+	}
+	try {
+		await writeFile(inputPath, formatted, "utf-8");
+	} catch (error) {
+		return notOk(errorRuntime$1("Failed to write formatted contract source file", {
+			why: error instanceof Error ? error.message : String(error),
+			fix: `Check that ${inputPath} is writable.`
+		}));
+	}
+	return ok({
+		formatted: true,
+		path: inputPath
+	});
+}
+function createFormatCommand() {
+	const command = new Command("format");
+	setCommandDescriptions(command, "Format your PSL contract source", "Formats the Prisma schema (PSL) contract source declared in your config\n(contract.source.inputs[0]) in place. Only runs when contract.source.format\nis 'psl'; a TypeScript or unset source is left untouched. Indent and newline are\nread from the optional formatter config section, defaulting to two spaces and the\nsystem newline.");
+	setCommandExamples(command, ["prisma-next format", "prisma-next format --config ./custom-config.ts"]);
+	addGlobalOptions(command).option("--config <path>", "Path to prisma-next.config.ts").action(async (options) => {
+		const flags = parseGlobalFlagsOrExit(options);
+		const ui = createTerminalUI(flags);
+		if (!flags.json && !flags.quiet) {
+			const displayConfigPath = options.config ? relative(process.cwd(), resolve(options.config)) : "prisma-next.config.ts";
+			ui.stderr(formatStyledHeader({
+				command: "format",
+				description: "Format your PSL contract source",
+				details: [{
+					label: "config",
+					value: displayConfigPath
+				}],
+				flags
+			}));
+		}
+		const exitCode = handleResult(await executeFormat({ ...ifDefined("configPath", options.config) }), flags, ui, (value) => {
+			if (flags.json) {
+				ui.output(JSON.stringify(value));
+				return;
+			}
+			if (flags.quiet) return;
+			if (value.formatted) ui.success(`Formatted ${relative(process.cwd(), value.path ?? "")}`);
+			else ui.info("Nothing to format (contract source is not PSL).");
+		});
+		process.exit(exitCode);
+	});
+	return command;
+}
+//#endregion
+export { createFormatCommand as t };
+
+//# sourceMappingURL=format-ByDm2goZ-DKLyhNHo.mjs.map

package/dist/format-ByDm2goZ-DKLyhNHo.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"format-ByDm2goZ-DKLyhNHo.mjs","names":["CliStructuredError","errorRuntime"],"sources":["../../../../1-framework/3-tooling/cli/dist/format-ByDm2goZ.mjs"],"sourcesContent":["import { A as formatStyledHeader, F as CliStructuredError, _ as createTerminalUI, ct as errorUnexpected, g as parseGlobalFlagsOrExit, l as setCommandDescriptions, rt as errorRuntime, t as addGlobalOptions, u as setCommandExamples, y as handleResult } from \"./command-helpers-CAoXqAY9.mjs\";\nimport { Command } from \"commander\";\nimport { loadConfig } from \"@internal/config-loader\";\nimport { ifDefined } from \"@internal/utils/defined\";\nimport { notOk, ok } from \"@internal/utils/result\";\nimport { relative, resolve } from \"pathe\";\nimport { readFile, writeFile } from \"node:fs/promises\";\nimport { isStructuredError } from \"@internal/utils/structured-error\";\nimport { EOL } from \"node:os\";\nimport { format } from \"@internal/psl-parser/format\";\n//#region src/control-api/operations/format.ts\nfunction resolveNewline(formatterNewline, eol) {\n\tif (formatterNewline !== void 0) return formatterNewline;\n\treturn eol === \"\\r\\n\" ? \"CRLF\" : \"LF\";\n}\nasync function executeFormat(options) {\n\tconst eol = options.eol ?? EOL;\n\tlet config;\n\ttry {\n\t\tconfig = await loadConfig(options.configPath);\n\t} catch (error) {\n\t\tif (CliStructuredError.is(error)) return notOk(error);\n\t\treturn notOk(errorUnexpected(error instanceof Error ? error.message : String(error)));\n\t}\n\tconst source = config.contract?.source;\n\tif (source?.format !== \"psl\") return ok({ formatted: false });\n\tconst inputPath = source.inputs?.[0];\n\tif (inputPath === void 0) return ok({ formatted: false });\n\tlet contents;\n\ttry {\n\t\tcontents = await readFile(inputPath, \"utf-8\");\n\t} catch (error) {\n\t\treturn notOk(errorRuntime(\"Failed to read contract source file\", {\n\t\t\twhy: error instanceof Error ? error.message : String(error),\n\t\t\tfix: `Check that ${inputPath} exists and is readable.`\n\t\t}));\n\t}\n\tconst formatOptions = {\n\t\tindent: config.formatter?.indent ?? 2,\n\t\tnewline: resolveNewline(config.formatter?.newline, eol)\n\t};\n\tlet formatted;\n\ttry {\n\t\tformatted = format(contents, formatOptions);\n\t} catch (error) {\n\t\tif (isStructuredError(error) && error.code === \"PSL.PARSE_FAILED\") return notOk(errorRuntime(\"Cannot format PSL with parse errors\", {\n\t\t\twhy: error.message,\n\t\t\tfix: \"Fix the parse errors in your schema and try again.\",\n\t\t\tmeta: { diagnostics: error.meta?.[\"diagnostics\"] }\n\t\t}));\n\t\treturn notOk(errorUnexpected(error instanceof Error ? error.message : String(error)));\n\t}\n\ttry {\n\t\tawait writeFile(inputPath, formatted, \"utf-8\");\n\t} catch (error) {\n\t\treturn notOk(errorRuntime(\"Failed to write formatted contract source file\", {\n\t\t\twhy: error instanceof Error ? error.message : String(error),\n\t\t\tfix: `Check that ${inputPath} is writable.`\n\t\t}));\n\t}\n\treturn ok({\n\t\tformatted: true,\n\t\tpath: inputPath\n\t});\n}\n//#endregion\n//#region src/commands/format.ts\nfunction createFormatCommand() {\n\tconst command = new Command(\"format\");\n\tsetCommandDescriptions(command, \"Format your PSL contract source\", \"Formats the Prisma schema (PSL) contract source declared in your config\\n(contract.source.inputs[0]) in place. Only runs when contract.source.format\\nis 'psl'; a TypeScript or unset source is left untouched. Indent and newline are\\nread from the optional formatter config section, defaulting to two spaces and the\\nsystem newline.\");\n\tsetCommandExamples(command, [\"prisma-next format\", \"prisma-next format --config ./custom-config.ts\"]);\n\taddGlobalOptions(command).option(\"--config <path>\", \"Path to prisma-next.config.ts\").action(async (options) => {\n\t\tconst flags = parseGlobalFlagsOrExit(options);\n\t\tconst ui = createTerminalUI(flags);\n\t\tif (!flags.json && !flags.quiet) {\n\t\t\tconst displayConfigPath = options.config ? relative(process.cwd(), resolve(options.config)) : \"prisma-next.config.ts\";\n\t\t\tui.stderr(formatStyledHeader({\n\t\t\t\tcommand: \"format\",\n\t\t\t\tdescription: \"Format your PSL contract source\",\n\t\t\t\tdetails: [{\n\t\t\t\t\tlabel: \"config\",\n\t\t\t\t\tvalue: displayConfigPath\n\t\t\t\t}],\n\t\t\t\tflags\n\t\t\t}));\n\t\t}\n\t\tconst exitCode = handleResult(await executeFormat({ ...ifDefined(\"configPath\", options.config) }), flags, ui, (value) => {\n\t\t\tif (flags.json) {\n\t\t\t\tui.output(JSON.stringify(value));\n\t\t\t\treturn;\n\t\t\t}\n\t\t\tif (flags.quiet) return;\n\t\t\tif (value.formatted) ui.success(`Formatted ${relative(process.cwd(), value.path ?? \"\")}`);\n\t\t\telse ui.info(\"Nothing to format (contract source is not PSL).\");\n\t\t});\n\t\tprocess.exit(exitCode);\n\t});\n\treturn command;\n}\n//#endregion\nexport { createFormatCommand as t };\n\n//# sourceMappingURL=format-ByDm2goZ.mjs.map"],"mappings":"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"}

package/dist/framework-components-CjshQKHA-Dlp6Leo5.mjs

@@ -0,0 +1,58 @@
+import { l as errorConfigValidation } from "./command-helpers-CAoXqAY9-DWUBcTXM.mjs";
+import "@prisma/orm-framework/components/components";
+//#region ../../../1-framework/3-tooling/cli/dist/framework-components-CjshQKHA.mjs
+/**
+* Asserts that all framework components are compatible with the expected family and target.
+*
+* This function validates that each component in the framework components array:
+* - Has kind 'target', 'adapter', 'extension', or 'driver'
+* - Has familyId matching expectedFamilyId
+* - Has targetId matching expectedTargetId
+*
+* This validation happens at the CLI composition boundary, before passing components
+* to typed planner/runner instances. It fills the gap between runtime validation
+* (via `validateConfig()`) and compile-time type enforcement.
+*
+* @param expectedFamilyId - The expected family ID (e.g., 'sql')
+* @param expectedTargetId - The expected target ID (e.g., 'postgres')
+* @param frameworkComponents - Array of framework components to validate
+* @returns The same array typed as TargetBoundComponentDescriptor
+* @throws CliStructuredError if any component is incompatible
+*
+* @example
+* ```ts
+* const config = await loadConfig();
+* const frameworkComponents = [config.target, config.adapter, ...(config.extensions ?? [])];
+*
+* // Validate and type-narrow components before passing to planner
+* const typedComponents = assertFrameworkComponentsCompatible(
+*   config.family.familyId,
+*   config.target.targetId,
+*   frameworkComponents
+* );
+*
+* const planner = target.migrations.createPlanner(familyInstance);
+* planner.plan({ contract, schema, policy, frameworkComponents: typedComponents });
+* ```
+*/
+function assertFrameworkComponentsCompatible(expectedFamilyId, expectedTargetId, frameworkComponents) {
+	for (let i = 0; i < frameworkComponents.length; i++) {
+		const component = frameworkComponents[i];
+		if (typeof component !== "object" || component === null) throw errorConfigValidation("frameworkComponents[]", { why: `Framework component at index ${i} must be an object` });
+		const record = component;
+		if (!Object.hasOwn(record, "kind")) throw errorConfigValidation("frameworkComponents[].kind", { why: `Framework component at index ${i} must have 'kind' property` });
+		const kind = record["kind"];
+		if (kind !== "target" && kind !== "adapter" && kind !== "extension" && kind !== "driver") throw errorConfigValidation("frameworkComponents[].kind", { why: `Framework component at index ${i} has invalid kind '${String(kind)}' (must be 'target', 'adapter', 'extension', or 'driver')` });
+		if (!Object.hasOwn(record, "familyId")) throw errorConfigValidation("frameworkComponents[].familyId", { why: `Framework component at index ${i} (kind: ${String(kind)}) must have 'familyId' property` });
+		const familyId = record["familyId"];
+		if (familyId !== expectedFamilyId) throw errorConfigValidation("frameworkComponents[].familyId", { why: `Framework component at index ${i} (kind: ${String(kind)}) has familyId '${String(familyId)}' but expected '${expectedFamilyId}'` });
+		if (!Object.hasOwn(record, "targetId")) throw errorConfigValidation("frameworkComponents[].targetId", { why: `Framework component at index ${i} (kind: ${String(kind)}) must have 'targetId' property` });
+		const targetId = record["targetId"];
+		if (targetId !== expectedTargetId) throw errorConfigValidation("frameworkComponents[].targetId", { why: `Framework component at index ${i} (kind: ${String(kind)}) has targetId '${String(targetId)}' but expected '${expectedTargetId}'` });
+	}
+	return frameworkComponents;
+}
+//#endregion
+export { assertFrameworkComponentsCompatible as t };
+
+//# sourceMappingURL=framework-components-CjshQKHA-Dlp6Leo5.mjs.map

package/dist/framework-components-CjshQKHA-Dlp6Leo5.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"framework-components-CjshQKHA-Dlp6Leo5.mjs","names":[],"sources":["../../../../1-framework/3-tooling/cli/dist/framework-components-CjshQKHA.mjs"],"sourcesContent":["import { R as errorConfigValidation } from \"./command-helpers-CAoXqAY9.mjs\";\nimport \"@internal/framework-components/components\";\n//#region src/utils/framework-components.ts\n/**\n* Asserts that all framework components are compatible with the expected family and target.\n*\n* This function validates that each component in the framework components array:\n* - Has kind 'target', 'adapter', 'extension', or 'driver'\n* - Has familyId matching expectedFamilyId\n* - Has targetId matching expectedTargetId\n*\n* This validation happens at the CLI composition boundary, before passing components\n* to typed planner/runner instances. It fills the gap between runtime validation\n* (via `validateConfig()`) and compile-time type enforcement.\n*\n* @param expectedFamilyId - The expected family ID (e.g., 'sql')\n* @param expectedTargetId - The expected target ID (e.g., 'postgres')\n* @param frameworkComponents - Array of framework components to validate\n* @returns The same array typed as TargetBoundComponentDescriptor\n* @throws CliStructuredError if any component is incompatible\n*\n* @example\n* ```ts\n* const config = await loadConfig();\n* const frameworkComponents = [config.target, config.adapter, ...(config.extensions ?? [])];\n*\n* // Validate and type-narrow components before passing to planner\n* const typedComponents = assertFrameworkComponentsCompatible(\n*   config.family.familyId,\n*   config.target.targetId,\n*   frameworkComponents\n* );\n*\n* const planner = target.migrations.createPlanner(familyInstance);\n* planner.plan({ contract, schema, policy, frameworkComponents: typedComponents });\n* ```\n*/\nfunction assertFrameworkComponentsCompatible(expectedFamilyId, expectedTargetId, frameworkComponents) {\n\tfor (let i = 0; i < frameworkComponents.length; i++) {\n\t\tconst component = frameworkComponents[i];\n\t\tif (typeof component !== \"object\" || component === null) throw errorConfigValidation(\"frameworkComponents[]\", { why: `Framework component at index ${i} must be an object` });\n\t\tconst record = component;\n\t\tif (!Object.hasOwn(record, \"kind\")) throw errorConfigValidation(\"frameworkComponents[].kind\", { why: `Framework component at index ${i} must have 'kind' property` });\n\t\tconst kind = record[\"kind\"];\n\t\tif (kind !== \"target\" && kind !== \"adapter\" && kind !== \"extension\" && kind !== \"driver\") throw errorConfigValidation(\"frameworkComponents[].kind\", { why: `Framework component at index ${i} has invalid kind '${String(kind)}' (must be 'target', 'adapter', 'extension', or 'driver')` });\n\t\tif (!Object.hasOwn(record, \"familyId\")) throw errorConfigValidation(\"frameworkComponents[].familyId\", { why: `Framework component at index ${i} (kind: ${String(kind)}) must have 'familyId' property` });\n\t\tconst familyId = record[\"familyId\"];\n\t\tif (familyId !== expectedFamilyId) throw errorConfigValidation(\"frameworkComponents[].familyId\", { why: `Framework component at index ${i} (kind: ${String(kind)}) has familyId '${String(familyId)}' but expected '${expectedFamilyId}'` });\n\t\tif (!Object.hasOwn(record, \"targetId\")) throw errorConfigValidation(\"frameworkComponents[].targetId\", { why: `Framework component at index ${i} (kind: ${String(kind)}) must have 'targetId' property` });\n\t\tconst targetId = record[\"targetId\"];\n\t\tif (targetId !== expectedTargetId) throw errorConfigValidation(\"frameworkComponents[].targetId\", { why: `Framework component at index ${i} (kind: ${String(kind)}) has targetId '${String(targetId)}' but expected '${expectedTargetId}'` });\n\t}\n\treturn frameworkComponents;\n}\n//#endregion\nexport { assertFrameworkComponentsCompatible as t };\n\n//# sourceMappingURL=framework-components-CjshQKHA.mjs.map"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCA,SAAS,oCAAoC,kBAAkB,kBAAkB,qBAAqB;CACrG,KAAK,IAAI,IAAI,GAAG,IAAI,oBAAoB,QAAQ,KAAK;EACpD,MAAM,YAAY,oBAAoB;EACtC,IAAI,OAAO,cAAc,YAAY,cAAc,MAAM,MAAM,sBAAsB,yBAAyB,EAAE,KAAK,gCAAgC,EAAE,oBAAoB,CAAC;EAC5K,MAAM,SAAS;EACf,IAAI,CAAC,OAAO,OAAO,QAAQ,MAAM,GAAG,MAAM,sBAAsB,8BAA8B,EAAE,KAAK,gCAAgC,EAAE,4BAA4B,CAAC;EACpK,MAAM,OAAO,OAAO;EACpB,IAAI,SAAS,YAAY,SAAS,aAAa,SAAS,eAAe,SAAS,UAAU,MAAM,sBAAsB,8BAA8B,EAAE,KAAK,gCAAgC,EAAE,qBAAqB,OAAO,IAAI,EAAE,2DAA2D,CAAC;EAC3R,IAAI,CAAC,OAAO,OAAO,QAAQ,UAAU,GAAG,MAAM,sBAAsB,kCAAkC,EAAE,KAAK,gCAAgC,EAAE,UAAU,OAAO,IAAI,EAAE,iCAAiC,CAAC;EACxM,MAAM,WAAW,OAAO;EACxB,IAAI,aAAa,kBAAkB,MAAM,sBAAsB,kCAAkC,EAAE,KAAK,gCAAgC,EAAE,UAAU,OAAO,IAAI,EAAE,kBAAkB,OAAO,QAAQ,EAAE,kBAAkB,iBAAiB,GAAG,CAAC;EAC3O,IAAI,CAAC,OAAO,OAAO,QAAQ,UAAU,GAAG,MAAM,sBAAsB,kCAAkC,EAAE,KAAK,gCAAgC,EAAE,UAAU,OAAO,IAAI,EAAE,iCAAiC,CAAC;EACxM,MAAM,WAAW,OAAO;EACxB,IAAI,aAAa,kBAAkB,MAAM,sBAAsB,kCAAkC,EAAE,KAAK,gCAAgC,EAAE,UAAU,OAAO,IAAI,EAAE,kBAAkB,OAAO,QAAQ,EAAE,kBAAkB,iBAAiB,GAAG,CAAC;CAC5O;CACA,OAAO;AACR"}

package/dist/global-flags-BpoOYtNZ-CHZD3fud.d.mts

@@ -0,0 +1,35 @@
+//#region ../../../1-framework/3-tooling/cli/dist/global-flags-BpoOYtNZ.d.mts
+//#region src/utils/global-flags.d.ts
+type OutputFormat = 'pretty' | 'json';
+interface GlobalFlags {
+  readonly format: OutputFormat;
+  readonly explicitFormat: boolean;
+  readonly json?: boolean;
+  readonly quiet?: boolean;
+  readonly verbose?: number;
+  readonly color?: boolean;
+  readonly interactive?: boolean;
+  readonly yes?: boolean;
+}
+/**
+ * Common options parsed by Commander.js for every command.
+ * Extend this for command-specific options instead of duplicating these fields.
+ */
+interface CommonCommandOptions {
+  readonly format?: string;
+  readonly json?: string | boolean;
+  readonly quiet?: boolean;
+  readonly q?: boolean;
+  readonly verbose?: boolean;
+  readonly v?: boolean;
+  readonly trace?: boolean;
+  readonly color?: boolean;
+  readonly 'no-color'?: boolean;
+  readonly interactive?: boolean;
+  readonly 'no-interactive'?: boolean;
+  readonly yes?: boolean;
+  readonly y?: boolean;
+}
+//#endregion
+export { GlobalFlags as n, CommonCommandOptions as t };
+//# sourceMappingURL=global-flags-BpoOYtNZ-CHZD3fud.d.mts.map

package/dist/global-flags-BpoOYtNZ-CHZD3fud.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"global-flags-BpoOYtNZ-CHZD3fud.d.mts","names":[],"sources":["../../../../1-framework/3-tooling/cli/dist/global-flags-BpoOYtNZ.d.mts"],"mappings":";;KACK;UACK;WACC,QAAQ;WACR;WACA;WACA;WACA;WACA;WACA;WACA;;;;;;UAMD;WACC;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA"}

package/dist/graph-bDjJ4GL9-BhFevsJS.d.mts

@@ -0,0 +1,28 @@
+//#region ../../../1-framework/3-tooling/migration/dist/graph-bDjJ4GL9.d.mts
+//#region src/graph.d.ts
+/**
+ * An entry in the migration graph. All on-disk migrations are attested,
+ * so `migrationHash` is always a string.
+ */
+interface MigrationEdge {
+  readonly from: string;
+  readonly to: string;
+  readonly migrationHash: string;
+  readonly dirName: string;
+  readonly createdAt: string;
+  /**
+   * Sorted, deduplicated list of `invariantId`s this edge provides.
+   * An empty array means the migration declares no routing-visible
+   * data transforms.
+   */
+  readonly invariants: readonly string[];
+}
+interface MigrationGraph {
+  readonly nodes: ReadonlySet<string>;
+  readonly forwardChain: ReadonlyMap<string, readonly MigrationEdge[]>;
+  readonly reverseChain: ReadonlyMap<string, readonly MigrationEdge[]>;
+  readonly migrationByHash: ReadonlyMap<string, MigrationEdge>;
+}
+//#endregion
+export { MigrationGraph as n, MigrationEdge as t };
+//# sourceMappingURL=graph-bDjJ4GL9-BhFevsJS.d.mts.map

package/dist/graph-bDjJ4GL9-BhFevsJS.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph-bDjJ4GL9-BhFevsJS.d.mts","names":[],"sources":["../../../../1-framework/3-tooling/migration/dist/graph-bDjJ4GL9.d.mts"],"mappings":";;;;;;UAKU;WACC;WACA;WACA;WACA;WACA;;;;;;WAMA;;UAED;WACC,OAAO;WACP,cAAc,6BAA6B;WAC3C,cAAc,6BAA6B;WAC3C,iBAAiB,oBAAoB"}

package/dist/graph-membership-DW6nnbyQ-Bp2KcVwR.mjs

@@ -0,0 +1,14 @@
+import { p as errorHashNotInGraph } from "./errors-IpZm1Skp-BH495dRd.mjs";
+//#region ../../../1-framework/3-tooling/migration/dist/graph-membership-DW6nnbyQ.mjs
+function isGraphNode(hash, graph) {
+	if (hash === "empty") return true;
+	return graph.nodes.has(hash);
+}
+function assertHashIsGraphNode(hash, graph) {
+	if (isGraphNode(hash, graph)) return;
+	throw errorHashNotInGraph(hash, graph);
+}
+//#endregion
+export { isGraphNode as n, assertHashIsGraphNode as t };
+
+//# sourceMappingURL=graph-membership-DW6nnbyQ-Bp2KcVwR.mjs.map

package/dist/graph-membership-DW6nnbyQ-Bp2KcVwR.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"graph-membership-DW6nnbyQ-Bp2KcVwR.mjs","names":[],"sources":["../../../../1-framework/3-tooling/migration/dist/graph-membership-DW6nnbyQ.mjs"],"sourcesContent":["import { p as errorHashNotInGraph } from \"./errors-IpZm1Skp.mjs\";\nimport \"./constants-CM-w38DQ.mjs\";\n//#region src/graph-membership.ts\nfunction isGraphNode(hash, graph) {\n\tif (hash === \"empty\") return true;\n\treturn graph.nodes.has(hash);\n}\nfunction assertHashIsGraphNode(hash, graph) {\n\tif (isGraphNode(hash, graph)) return;\n\tthrow errorHashNotInGraph(hash, graph);\n}\n//#endregion\nexport { isGraphNode as n, assertHashIsGraphNode as t };\n\n//# sourceMappingURL=graph-membership-DW6nnbyQ.mjs.map"],"mappings":";;AAGA,SAAS,YAAY,MAAM,OAAO;CACjC,IAAI,SAAS,SAAS,OAAO;CAC7B,OAAO,MAAM,MAAM,IAAI,IAAI;AAC5B;AACA,SAAS,sBAAsB,MAAM,OAAO;CAC3C,IAAI,YAAY,MAAM,KAAK,GAAG;CAC9B,MAAM,oBAAoB,MAAM,KAAK;AACtC"}

package/dist/hash-DH8hl5Rq-BpM2t3Nu.mjs

@@ -0,0 +1,64 @@
+import { createHash } from "node:crypto";
+import { canonicalizeJson } from "@prisma/orm-framework/components/utils";
+//#region ../../../1-framework/3-tooling/migration/dist/hash-DH8hl5Rq.mjs
+function sha256Hex(input) {
+	return createHash("sha256").update(input).digest("hex");
+}
+/**
+* Content-addressed migration hash over (metadata envelope, ops). See
+* ADR 199 — Storage-only migration identity for the rationale: the
+* storage-hash bookends (`from`, `to`) inside the envelope anchor the
+* contract identity by hash. The full contract IRs are not part of the
+* manifest — they live in sibling `*-contract.json` files authored
+* alongside the migration, never inlined here.
+*
+* The integrity check is purely structural, not semantic. The function
+* canonicalizes its inputs via `sortKeys` (recursive) + `JSON.stringify`
+* and hashes the result. Target-specific operation payloads (`step.sql`,
+* Mongo's pipeline AST, …) are hashed verbatim — no per-target
+* normalization is required, because what's being verified is "do the
+* on-disk bytes still produce their recorded hash", not "do two
+* semantically-equivalent migrations hash the same". The latter is an
+* emit-drift concern (ADR 192 step 2).
+*
+* The symmetry across write and read holds because `JSON.parse(
+* JSON.stringify(x))` round-trips JSON-safe values losslessly and
+* `sortKeys` is idempotent and deterministic — write-time and read-time
+* canonicalization produce the same canonical bytes regardless of
+* source-side key ordering or whitespace.
+*
+* The `migrationHash` field on the metadata is stripped before hashing
+* so the function can be used both at write time (when no hash exists
+* yet) and at verify time (rehashing an already-attested record).
+*/
+function computeMigrationHash(metadata, ops) {
+	const { migrationHash: _migrationHash, ...strippedMeta } = metadata;
+	return sha256Hex(canonicalizeJson([canonicalizeJson(strippedMeta), canonicalizeJson(ops)].map(sha256Hex)));
+}
+/**
+* Re-hash an in-memory migration package and compare against the stored
+* `migrationHash`. See `computeMigrationHash` for the canonicalization rules.
+*
+* Returns `{ ok: true }` when the package is internally consistent, or
+* `{ ok: false, reason: 'mismatch', storedHash, computedHash }` when it is
+* not — typically a sign of FS corruption, partial writes, or a post-emit
+* hand edit.
+*/
+function verifyMigrationHash(pkg) {
+	const computed = computeMigrationHash(pkg.metadata, pkg.ops);
+	if (pkg.metadata.migrationHash === computed) return {
+		ok: true,
+		storedHash: pkg.metadata.migrationHash,
+		computedHash: computed
+	};
+	return {
+		ok: false,
+		reason: "mismatch",
+		storedHash: pkg.metadata.migrationHash,
+		computedHash: computed
+	};
+}
+//#endregion
+export { verifyMigrationHash as n, computeMigrationHash as t };
+
+//# sourceMappingURL=hash-DH8hl5Rq-BpM2t3Nu.mjs.map

package/dist/hash-DH8hl5Rq-BpM2t3Nu.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash-DH8hl5Rq-BpM2t3Nu.mjs","names":[],"sources":["../../../../1-framework/3-tooling/migration/dist/hash-DH8hl5Rq.mjs"],"sourcesContent":["import { createHash } from \"node:crypto\";\nimport { canonicalizeJson } from \"@internal/framework-components/utils\";\n//#region src/hash.ts\nfunction sha256Hex(input) {\n\treturn createHash(\"sha256\").update(input).digest(\"hex\");\n}\n/**\n* Content-addressed migration hash over (metadata envelope, ops). See\n* ADR 199 — Storage-only migration identity for the rationale: the\n* storage-hash bookends (`from`, `to`) inside the envelope anchor the\n* contract identity by hash. The full contract IRs are not part of the\n* manifest — they live in sibling `*-contract.json` files authored\n* alongside the migration, never inlined here.\n*\n* The integrity check is purely structural, not semantic. The function\n* canonicalizes its inputs via `sortKeys` (recursive) + `JSON.stringify`\n* and hashes the result. Target-specific operation payloads (`step.sql`,\n* Mongo's pipeline AST, …) are hashed verbatim — no per-target\n* normalization is required, because what's being verified is \"do the\n* on-disk bytes still produce their recorded hash\", not \"do two\n* semantically-equivalent migrations hash the same\". The latter is an\n* emit-drift concern (ADR 192 step 2).\n*\n* The symmetry across write and read holds because `JSON.parse(\n* JSON.stringify(x))` round-trips JSON-safe values losslessly and\n* `sortKeys` is idempotent and deterministic — write-time and read-time\n* canonicalization produce the same canonical bytes regardless of\n* source-side key ordering or whitespace.\n*\n* The `migrationHash` field on the metadata is stripped before hashing\n* so the function can be used both at write time (when no hash exists\n* yet) and at verify time (rehashing an already-attested record).\n*/\nfunction computeMigrationHash(metadata, ops) {\n\tconst { migrationHash: _migrationHash, ...strippedMeta } = metadata;\n\treturn sha256Hex(canonicalizeJson([canonicalizeJson(strippedMeta), canonicalizeJson(ops)].map(sha256Hex)));\n}\n/**\n* Re-hash an in-memory migration package and compare against the stored\n* `migrationHash`. See `computeMigrationHash` for the canonicalization rules.\n*\n* Returns `{ ok: true }` when the package is internally consistent, or\n* `{ ok: false, reason: 'mismatch', storedHash, computedHash }` when it is\n* not — typically a sign of FS corruption, partial writes, or a post-emit\n* hand edit.\n*/\nfunction verifyMigrationHash(pkg) {\n\tconst computed = computeMigrationHash(pkg.metadata, pkg.ops);\n\tif (pkg.metadata.migrationHash === computed) return {\n\t\tok: true,\n\t\tstoredHash: pkg.metadata.migrationHash,\n\t\tcomputedHash: computed\n\t};\n\treturn {\n\t\tok: false,\n\t\treason: \"mismatch\",\n\t\tstoredHash: pkg.metadata.migrationHash,\n\t\tcomputedHash: computed\n\t};\n}\n//#endregion\nexport { verifyMigrationHash as n, computeMigrationHash as t };\n\n//# sourceMappingURL=hash-DH8hl5Rq.mjs.map"],"mappings":";;;AAGA,SAAS,UAAU,OAAO;CACzB,OAAO,WAAW,QAAQ,CAAC,CAAC,OAAO,KAAK,CAAC,CAAC,OAAO,KAAK;AACvD;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA4BA,SAAS,qBAAqB,UAAU,KAAK;CAC5C,MAAM,EAAE,eAAe,gBAAgB,GAAG,iBAAiB;CAC3D,OAAO,UAAU,iBAAiB,CAAC,iBAAiB,YAAY,GAAG,iBAAiB,GAAG,CAAC,CAAC,CAAC,IAAI,SAAS,CAAC,CAAC;AAC1G;;;;;;;;;;AAUA,SAAS,oBAAoB,KAAK;CACjC,MAAM,WAAW,qBAAqB,IAAI,UAAU,IAAI,GAAG;CAC3D,IAAI,IAAI,SAAS,kBAAkB,UAAU,OAAO;EACnD,IAAI;EACJ,YAAY,IAAI,SAAS;EACzB,cAAc;CACf;CACA,OAAO;EACN,IAAI;EACJ,QAAQ;EACR,YAAY,IAAI,SAAS;EACzB,cAAc;CACf;AACD"}

package/dist/hash-XZYYKJ-i.d.mts

@@ -0,0 +1,53 @@
+import { n as OnDiskMigrationPackage, t as MigrationOps } from "./package-CfWiDNrr-ZR4HM_Iz.mjs";
+import { t as MigrationMetadata$1 } from "./metadata-2nbOAGsV-uYNeq2Cp.mjs";
+//#region ../../../1-framework/3-tooling/migration/dist/exports/hash.d.mts
+//#region src/hash.d.ts
+interface VerifyResult {
+  readonly ok: boolean;
+  readonly reason?: 'mismatch';
+  readonly storedHash: string;
+  readonly computedHash: string;
+}
+/**
+ * Content-addressed migration hash over (metadata envelope, ops). See
+ * ADR 199 — Storage-only migration identity for the rationale: the
+ * storage-hash bookends (`from`, `to`) inside the envelope anchor the
+ * contract identity by hash. The full contract IRs are not part of the
+ * manifest — they live in sibling `*-contract.json` files authored
+ * alongside the migration, never inlined here.
+ *
+ * The integrity check is purely structural, not semantic. The function
+ * canonicalizes its inputs via `sortKeys` (recursive) + `JSON.stringify`
+ * and hashes the result. Target-specific operation payloads (`step.sql`,
+ * Mongo's pipeline AST, …) are hashed verbatim — no per-target
+ * normalization is required, because what's being verified is "do the
+ * on-disk bytes still produce their recorded hash", not "do two
+ * semantically-equivalent migrations hash the same". The latter is an
+ * emit-drift concern (ADR 192 step 2).
+ *
+ * The symmetry across write and read holds because `JSON.parse(
+ * JSON.stringify(x))` round-trips JSON-safe values losslessly and
+ * `sortKeys` is idempotent and deterministic — write-time and read-time
+ * canonicalization produce the same canonical bytes regardless of
+ * source-side key ordering or whitespace.
+ *
+ * The `migrationHash` field on the metadata is stripped before hashing
+ * so the function can be used both at write time (when no hash exists
+ * yet) and at verify time (rehashing an already-attested record).
+ */
+declare function computeMigrationHash(metadata: Omit<MigrationMetadata$1, 'migrationHash'> & {
+  readonly migrationHash?: string;
+}, ops: MigrationOps): string;
+/**
+ * Re-hash an in-memory migration package and compare against the stored
+ * `migrationHash`. See `computeMigrationHash` for the canonicalization rules.
+ *
+ * Returns `{ ok: true }` when the package is internally consistent, or
+ * `{ ok: false, reason: 'mismatch', storedHash, computedHash }` when it is
+ * not — typically a sign of FS corruption, partial writes, or a post-emit
+ * hand edit.
+ */
+declare function verifyMigrationHash(pkg: OnDiskMigrationPackage): VerifyResult;
+//#endregion
+export { computeMigrationHash as n, verifyMigrationHash as r, VerifyResult as t };
+//# sourceMappingURL=hash-XZYYKJ-i.d.mts.map

package/dist/hash-XZYYKJ-i.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash-XZYYKJ-i.d.mts","names":[],"sources":["../../../../1-framework/3-tooling/migration/dist/exports/hash.d.mts"],"mappings":";;;;UAGU;WACC;WACA;WACA;WACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6BM,qBAAqB,UAAU,KAAK;WAC1C;GACR,KAAK;;;;;;;;;;iBAUS,oBAAoB,KAAK,yBAAyB"}

package/dist/import-roots-B6CtsWXb.d.mts

@@ -0,0 +1,119 @@
+import { r as ShellName, t as ShellDefinition } from "./shells-COHV_Ozf.mjs";
+//#region ../../../0-shared/publish-surface/dist/import-roots.d.mts
+//#region src/import-roots.d.ts
+/** An import root that emitted code cannot express. */
+declare class ImportRootError extends Error {}
+type ImportRootMode = 'internal' | 'facade' | 'platform';
+/**
+ * The published packages an application depends on directly, from emission's
+ * point of view.
+ *
+ * - `internal` — the repo's own workspace names. Emitted output is unchanged
+ *   from before ADR 242; this is the default and stays so until every in-repo
+ *   consumer imports published names.
+ * - `facade` — the application installed one `@prisma/orm-<database>` package.
+ * - `platform` — a decomposed install that wires the platform packages itself.
+ */
+type ImportRoot = {
+  readonly mode: 'internal';
+} | {
+  readonly mode: 'facade';
+  readonly facade: ShellName;
+} | {
+  readonly mode: 'platform';
+};
+declare const internalImportRoot: Extract<ImportRoot, {
+  mode: 'internal';
+}>;
+/**
+ * Rewrites one module specifier for an import root. Specifiers outside the
+ * internal scope — relative paths, `node:` builtins, third-party packages —
+ * come back unchanged.
+ */
+type ImportSpecifierResolver = (specifier: string) => string;
+/**
+ * The import root an application's own dependency list expresses.
+ *
+ * Emission has to name packages the application can actually resolve, and the
+ * application already states which those are. Reading its manifest keeps the
+ * two from drifting and lets consumers move to published names one project at
+ * a time instead of behind a repository-wide switch.
+ *
+ * A project that names exactly one facade is on the facade root; one that
+ * names platform shells without a facade is a decomposed install; anything
+ * else — including a project with no `@prisma/orm-*` dependency at all — is on
+ * the internal root, which emits workspace names unchanged.
+ *
+ * @throws {ImportRootError} when the project depends on two facades, which no
+ * single generated file can be emitted for.
+ */
+declare function importRootForDependencies(dependencies: Iterable<string>): ImportRoot;
+interface OwningShell {
+  readonly shell: ShellName;
+  readonly entry: string;
+}
+/**
+ * Takes the shell map as an argument rather than closing over `publicShells`
+ * so the duplicate-owner guard is reachable from a test: the real map is
+ * valid by construction, and a guard nothing can exercise is a guard nobody
+ * knows still works.
+ */
+declare function buildOwnerIndex(shells: ReadonlyMap<ShellName, ShellDefinition>): Map<string, OwningShell>;
+/**
+ * The shells an application installs directly under this root. Emitted code
+ * may name only these: a package manager puts a package's own dependencies in
+ * its own `node_modules`, so importing a transitively installed package fails
+ * to resolve at run time even though the files are on disk.
+ */
+declare function directDependencyShells(root: ImportRoot): ReadonlySet<ShellName>;
+/**
+ * The platform-install name for an internal specifier, with the shell that
+ * owns it. The shell build needs both: an import that stays inside the shell
+ * being built is bundled rather than externalized.
+ */
+declare function platformEntrypointOf(specifier: string): {
+  shell: ShellName;
+  id: string;
+};
+declare function resolveImportSpecifier(specifier: string, root: ImportRoot): string;
+declare function createImportSpecifierResolver(root: ImportRoot): ImportSpecifierResolver;
+/**
+ * The import roots a scaffolded application can be generated against.
+ *
+ * `platform` is absent deliberately, and this is a modelling statement rather
+ * than a limitation to be lifted: `prisma-next init` writes an application
+ * around a per-database facade, and that facade's `runtime` entrypoint is its
+ * own wiring code, not a re-export of anything. A decomposed install has no
+ * name for it because it has no such module — it wires the platform packages
+ * itself. Scaffolding a decomposed project is a different template, not a
+ * different import root.
+ */
+type ScaffoldImportRoot = Extract<ImportRoot, {
+  mode: 'internal' | 'facade';
+}>;
+/**
+ * Builds the resolver `prisma-next init` scaffolds with. Identical to
+ * {@link createImportSpecifierResolver} except that it will not accept a root
+ * a scaffold cannot express, so the impossible case is rejected where the
+ * resolver is made rather than when a template happens to hit a name.
+ */
+declare function createScaffoldSpecifierResolver(root: ScaffoldImportRoot): ImportSpecifierResolver;
+/** The module specifiers a generated source file names. */
+declare function importedSpecifiers(source: string): string[];
+/**
+ * The specifiers in a generated file that the application would not have as a
+ * direct dependency under `root` — the thing no emitted file may contain.
+ *
+ * Under the `internal` root nothing is reported: those names are the
+ * repository's own, and every in-repo consumer resolves them through the
+ * workspace.
+ *
+ * Throws rather than returning `[]` when the source plainly has imports but
+ * the scan found none. An audit whose scanner has stopped matching would
+ * otherwise report every file as clean, which is the one failure mode that
+ * makes the audit worse than not having it.
+ */
+declare function transitiveImports(source: string, root: ImportRoot): string[];
+//#endregion
+export { ScaffoldImportRoot as a, createScaffoldSpecifierResolver as c, importedSpecifiers as d, internalImportRoot as f, transitiveImports as h, ImportSpecifierResolver as i, directDependencyShells as l, resolveImportSpecifier as m, ImportRootError as n, buildOwnerIndex as o, platformEntrypointOf as p, ImportRootMode as r, createImportSpecifierResolver as s, ImportRoot as t, importRootForDependencies as u };
+//# sourceMappingURL=import-roots-B6CtsWXb.d.mts.map

package/dist/import-roots-B6CtsWXb.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"import-roots-B6CtsWXb.d.mts","names":[],"sources":["../../../../0-shared/publish-surface/dist/import-roots.d.mts"],"mappings":";;;;cAGc,wBAAwB;KACjC;;;;;;;;;;;KAWA;WACM;;WAEA;WACA,QAAQ;;WAER;;cAEG,oBAAoB,QAAQ;EACxC;;;;;;;KAOG,2BAA2B;;;;;;;;;;;;;;;;;iBAiBf,0BAA0B,cAAc,mBAAmB;UAClE;WACC,OAAO;WACP;;;;;;;;iBAQM,gBAAgB,QAAQ,YAAY,WAAW,mBAAmB,YAAY;;;;;;;iBAO9E,uBAAuB,MAAM,aAAa,YAAY;;;;;;iBAMtD,qBAAqB;EACpC,OAAO;EACP;;iBAEe,uBAAuB,mBAAmB,MAAM;iBAChD,8BAA8B,MAAM,aAAa;;;;;;;;;;;;KAY7D,qBAAqB,QAAQ;EAChC;;;;;;;;iBAQe,gCAAgC,MAAM,qBAAqB;;iBAE3D,mBAAmB;;;;;;;;;;;;;;iBAcnB,kBAAkB,gBAAgB,MAAM"}