@prisma/orm-toolchain 8.0.0-rc.1-dev.46 → 8.0.0-rc.10-dev.1

package/dist/{ref-h6InR6dO-rGfl18Jv.mjs → ref-DcqFmceq-QaUjgZeM.mjs}

@@ -1,20 +1,21 @@
-import { r as getEmittedArtifactPaths, t as emit } from "./exports-BCLg4CiV-05kuwcb0.mjs";
-import { O as errorNoInvariantPath, P as errorUnknownInvariant, b as errorInvalidRefName, i as errorContractDeserializationFailed, t as MigrationToolsError } from "./errors-CXbGUWGu-CstQHPh6.mjs";
-import { a as snapshotsImportPathFrom, o as writeContractSnapshot, r as readContractSnapshotJson, t as contractSnapshotDir } from "./contract-snapshot-store-B0G1Fw_F-CHc4QfKb.mjs";
+import { r as getEmittedArtifactPaths, t as emit } from "./exports-CE6OD63o-4Qpqr2W7.mjs";
+import { O as errorNoInvariantPath, P as errorUnknownInvariant, b as errorInvalidRefName, i as errorContractDeserializationFailed, t as MigrationToolsError } from "./errors-SoLLYLtw-DMxVbVs9.mjs";
+import { a as snapshotsImportPathFrom, o as writeContractSnapshot, r as readContractSnapshotJson, t as contractSnapshotDir } from "./contract-snapshot-store-qGrwlGmt-Cf2NFzRL.mjs";
 import { n as verifyMigrationHash, t as computeMigrationHash } from "./hash-DH8hl5Rq-BpM2t3Nu.mjs";
-import { t as deriveProvidedInvariants } from "./invariants-CTHy88OP-CYI2a8IO.mjs";
-import { i as materialiseExtensionMigrationPackageIfMissing, r as formatMigrationDirName, u as writeMigrationPackage } from "./io-635GlNx1-D3zrw2qu.mjs";
+import { t as deriveProvidedInvariants } from "./invariants-Cww4bv0v-BEiFxmbX.mjs";
+import { i as materialiseExtensionMigrationPackageIfMissing, r as formatMigrationDirName, u as writeMigrationPackage } from "./io-BmWQNxRP-DQqbcPsS.mjs";
 import { t as EMPTY_CONTRACT_HASH } from "./constants-CM-w38DQ-Cz_EXbOc.mjs";
-import { n as isGraphNode, t as assertHashIsGraphNode } from "./graph-membership-BViWUMpP-C4lYYJdU.mjs";
-import { a as findPath, o as findPathWithDecision, r as findLatestMigration } from "./migration-graph-_SJImD5V-BURyY1KM.mjs";
-import { d as writeRef, i as readRefs, l as validateRefName, n as deleteRef, o as refsByContractHash, t as HEAD_REF_NAME, u as validateRefValue } from "./refs-WK86uYYp-gM8tvWQP.mjs";
-import { a as isValidSpaceId, c as spaceMigrationDirectory, l as spaceRefsDirectory, o as listContractSpaceDirectories, s as readContractSpaceHeadRef, t as APP_SPACE_ID$1 } from "./verify-contract-spaces-DhJTb0zM-B62maCfE.mjs";
-import { d as resolveRecordedPath, f as verifyMigration, l as planMigration, n as buildFabricatedMigrationEdge, r as collectAggregateNamespaces, s as loadContractSpaceAggregate, t as allStorageElementsExternal, u as requireHeadRef } from "./aggregate-CPZB020V.mjs";
-import { i as emitContractSpaceArtifacts, o as planAllSpaces } from "./spaces-4qMOAYE9.mjs";
-import { c as internalImportRoot, o as importRootForDependencies, r as createImportSpecifierResolver } from "./import-roots-CNFBPAT1.mjs";
-import { n as parseContractRef, r as parseMigrationRef } from "./ref-resolution-HeNBXW53.mjs";
+import { n as isGraphNode, t as assertHashIsGraphNode } from "./graph-membership-DY1Onbc3-CwBd6wuB.mjs";
+import { a as findPath, o as findPathWithDecision, r as findLatestMigration } from "./migration-graph-CW4bMmTz-B5xFtFVB.mjs";
+import { d as writeRef, i as readRefs, l as validateRefName, n as deleteRef, o as refsByContractHash, t as HEAD_REF_NAME, u as validateRefValue } from "./refs-BpSpzdYB-BcDelHGt.mjs";
+import { a as isValidSpaceId, c as spaceMigrationDirectory, l as spaceRefsDirectory, o as listContractSpaceDirectories, s as readContractSpaceHeadRef, t as APP_SPACE_ID$1 } from "./verify-contract-spaces-CrxvgpwD-D5LLXGci.mjs";
+import { d as resolveRecordedPath, f as verifyMigration, l as planMigration, n as buildFabricatedMigrationEdge, r as collectAggregateNamespaces, s as loadContractSpaceAggregate, t as allStorageElementsExternal, u as requireHeadRef } from "./aggregate-B4HKshLQ.mjs";
+import { i as emitContractSpaceArtifacts, o as planAllSpaces } from "./spaces-BCZiAZQn.mjs";
+import { c as internalImportRoot, o as importRootForDependencies, r as createImportSpecifierResolver } from "./import-roots-BHOrDJbI.mjs";
+import { n as parseContractRef, r as parseMigrationRef } from "./ref-resolution-BWpwb8_b.mjs";
 import { i as writeMigrationTs } from "./migration-ts-DdVm0rws.mjs";
 import { createRequire } from "node:module";
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
 import { ifDefined } from "@prisma/orm-framework/utils/defined";
 import { structuredError } from "@prisma/orm-framework/utils/structured-error";
 import { blindCast, castAs } from "@prisma/orm-framework/utils/casts";
@@ -30,8 +31,8 @@ import { mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
 import { createHash } from "node:crypto";
 import { canonicalizeJson } from "@prisma/orm-framework/components/utils";
 import { abortable } from "@prisma/orm-framework/utils/abortable";
-import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
-//#region ../../../1-framework/3-tooling/cli/dist/ref-h6InR6dO.mjs
+import { resolve as resolve$1 } from "node:path";
+//#region ../../../1-framework/3-tooling/cli/dist/ref-DcqFmceq.mjs
 /**
 * The typed remediation the CLI attaches to its own errors and findings.
 * Constructors live here rather than in any library the CLI calls: naming a
@@ -85,10 +86,24 @@ function errorContractArgConflict(options) {
 		}
 	});
 }
+/**
+* A command was told both which ref to advance and not to advance any ref.
+* Same envelope as the positional/flag contract conflict, so a script sees
+* every invocation conflict in one shape.
+*/
+function errorAdvanceRefArgConflict(options) {
+	const fix = "Pass either --advance-ref <name> or --no-advance-ref, not both.";
+	return new ActionableCliError("CLI.ADVANCE_REF_ARG_CONFLICT", "Cannot specify both --advance-ref and --no-advance-ref", {
+		why: `--advance-ref names "${options.advanceRef}" while --no-advance-ref asks for no ref to be written; there is no rule for which wins.`,
+		fix,
+		nextActions: [chooseAction(fix)],
+		meta: { advanceRef: options.advanceRef }
+	});
+}
 function errorRefSetHashNotInGraph(resolvedHash, reachableHashes, graphTipHash) {
 	const reachableList = reachableHashes.length > 0 ? reachableHashes.join(", ") : "(none — migration graph is empty)";
-	const fix = reachableHashes.length > 0 ? graphTipHash !== null ? `Set the ref to a graph-node hash such as ${graphTipHash}, or run \`prisma-cli migration plan\` to extend the graph.` : "Set the ref to a hash that appears in the migration graph." : "Run `prisma-cli migration plan` first.";
-	const nextActions = reachableHashes.length > 0 ? graphTipHash !== null ? [chooseAction(`Set the ref to a graph-node hash such as ${graphTipHash}`), runCommandAction("Extend the migration graph", "prisma-cli migration plan")] : [chooseAction("Set the ref to a hash that appears in the migration graph")] : [runCommandAction("Plan the first migration", "prisma-cli migration plan")];
+	const fix = reachableHashes.length > 0 ? graphTipHash !== null ? `Set the ref to a graph-node hash such as ${graphTipHash}, or run \`{bin} migration plan\` to extend the graph.` : "Set the ref to a hash that appears in the migration graph." : "Run `{bin} migration plan` first.";
+	const nextActions = reachableHashes.length > 0 ? graphTipHash !== null ? [chooseAction(`Set the ref to a graph-node hash such as ${graphTipHash}`), runCommandAction("Extend the migration graph", "{bin} migration plan")] : [chooseAction("Set the ref to a hash that appears in the migration graph")] : [runCommandAction("Plan the first migration", "{bin} migration plan")];
 	return new ActionableCliError("MIGRATION.HASH_NOT_IN_GRAPH", `Resolved contract hash is not in the migration graph: ${resolvedHash}`, {
 		why: reachableHashes.length > 0 ? `The migration graph reaches ${reachableList}; resolved ${resolvedHash} isn't a graph node.` : "The migration graph is empty — no hashes reachable.",
 		fix,
@@ -130,7 +145,7 @@ function errorInvalidSpaceId(spaceId) {
 	return new ActionableCliError("MIGRATION.INVALID_SPACE_ID", `Invalid contract space id: ${spaceId}`, {
 		why: "Contract space ids must match [a-z][a-z0-9_-]{0,63} (lowercase, starts with a letter, max 64 characters — the rule applied to every on-disk space directory).",
 		fix: "Pass a space id that matches the directory naming rule, or omit --space to list every space.",
-		nextActions: [chooseAction("Pass a space id matching [a-z][a-z0-9_-]{0,63}"), runCommandAction("Or list every space", "prisma-cli migration list")],
+		nextActions: [chooseAction("Pass a space id matching [a-z][a-z0-9_-]{0,63}"), runCommandAction("Or list every space", "{bin} migration list")],
 		meta: { spaceId }
 	});
 }
@@ -147,8 +162,8 @@ function errorInvalidSpaceId(spaceId) {
 */
 function errorSpaceNotFound(spaceId, availableSpaces) {
 	const availableList = availableSpaces.length > 0 ? availableSpaces.join(", ") : "(none — no contract spaces on disk yet)";
-	const fix = availableSpaces.length > 0 ? `Pick one of: ${availableList}. Run \`prisma-cli migration list\` (no --space) to see every space's migrations.` : "Author a migration with `prisma-cli migration new` to create the first contract-space directory.";
-	const nextActions = availableSpaces.length > 0 ? [chooseAction(`Pick one of: ${availableList}`), runCommandAction("See every space's migrations", "prisma-cli migration list")] : [runCommandAction("Author the first migration, which creates the contract-space directory", "prisma-cli migration new")];
+	const fix = availableSpaces.length > 0 ? `Pick one of: ${availableList}. Run \`{bin} migration list\` (no --space) to see every space's migrations.` : "Author a migration with `{bin} migration new` to create the first contract-space directory.";
+	const nextActions = availableSpaces.length > 0 ? [chooseAction(`Pick one of: ${availableList}`), runCommandAction("See every space's migrations", "{bin} migration list")] : [runCommandAction("Author the first migration, which creates the contract-space directory", "{bin} migration new")];
 	return new ActionableCliError("MIGRATION.SPACE_NOT_FOUND", `Unknown contract space: ${spaceId}`, {
 		why: `No directory named "${spaceId}" exists under the migrations root.`,
 		fix,
@@ -167,15 +182,15 @@ function errorMigrationPackageNotFound(why) {
 	return new ActionableCliError("MIGRATION.PACKAGE_NOT_FOUND", "Migration package not found", {
 		why,
 		fix: "Pass a directory name, hash prefix, or path to an on-disk app-space migration package.",
-		nextActions: [chooseAction("Pass a directory name, hash prefix, or path to an on-disk app-space migration package"), runCommandAction("List what is on disk", "prisma-cli migration list")]
+		nextActions: [chooseAction("Pass a directory name, hash prefix, or path to an on-disk app-space migration package"), runCommandAction("List what is on disk", "{bin} migration list")]
 	});
 }
 /** The app space has no migration packages at all, so no target can resolve. */
 function errorNoMigrations(appMigrationsRelative) {
 	return new ActionableCliError("MIGRATION.NO_MIGRATIONS", "No migrations found", {
 		why: `No migration packages found in ${appMigrationsRelative}`,
-		fix: "Run `prisma-cli migration plan` to create a migration first.",
-		nextActions: [runCommandAction("Create the first migration", "prisma-cli migration plan")]
+		fix: "Run `{bin} migration plan` to create a migration first.",
+		nextActions: [runCommandAction("Create the first migration", "{bin} migration plan")]
 	});
 }
 function errorRefSetBundleNotFound(hash) {
@@ -189,7 +204,7 @@ function errorRefSetBundleNotFound(hash) {
 function errorPlanForgotTheFlag(resolvedHash, reachableRefs, graphTipHash, options) {
 	const reachableList = reachableRefs.length > 0 ? reachableRefs.map((r) => `${r.name} (${r.hash})`).join(", ") : "(none)";
 	const refFix = reachableRefs.length > 0 ? `Run migration plan with ${reachableRefs.map((r) => `--from ${r.name}`).join(" or ")}.` : graphTipHash !== null ? `Run migration plan --from ${graphTipHash}.` : "Commit pending migrations first, then run migration plan.";
-	const nextActions = reachableRefs.length > 0 ? reachableRefs.map((ref) => runCommandAction(`Plan from ${ref.name}`, `prisma-cli migration plan --from ${ref.name}`)) : graphTipHash !== null ? [runCommandAction("Plan from the graph tip", `prisma-cli migration plan --from ${graphTipHash}`)] : [chooseAction("Commit pending migrations first, then run migration plan")];
+	const nextActions = reachableRefs.length > 0 ? reachableRefs.map((ref) => runCommandAction(`Plan from ${ref.name}`, `{bin} migration plan --from ${ref.name}`)) : graphTipHash !== null ? [runCommandAction("Plan from the graph tip", `{bin} migration plan --from ${graphTipHash}`)] : [chooseAction("Commit pending migrations first, then run migration plan")];
 	return new ActionableCliError("MIGRATION.HASH_NOT_IN_GRAPH", `Resolved from-hash is not in the migration graph: ${resolvedHash}`, {
 		why: `The migration graph reaches ${reachableList}; resolved ${resolvedHash} isn't a graph node.`,
 		fix: refFix,
@@ -212,12 +227,12 @@ function errorPlanForgotTheFlag(resolvedHash, reachableRefs, graphTipHash, optio
 */
 function errorSnapshotMissing(identifier, options) {
 	const viaRef = options?.viaRef !== false;
-	const fix = viaRef ? `Create the ref with "prisma-cli ref set ${identifier} <hash>" (or advance it via "prisma-cli db update --advance-ref ${identifier}"), or pass a hash that is a node in the migration graph.` : `No contract source exists for hash "${identifier}" on an empty migration graph. Use --from with a ref name (its contract resolves through the snapshot store), or run db update first.`;
+	const fix = viaRef ? `Create the ref with "{bin} migration ref set ${identifier} <hash>" (or advance it via "{bin} db update --advance-ref ${identifier}"), or pass a hash that is a node in the migration graph.` : `No contract source exists for hash "${identifier}" on an empty migration graph. Use --from with a ref name (its contract resolves through the snapshot store), or run db update first.`;
 	const nextActions = viaRef ? [
-		runCommandAction(`Create the ref "${identifier}"`, `prisma-cli ref set ${identifier} <hash>`),
-		runCommandAction("Or advance it from the database", `prisma-cli db update --advance-ref ${identifier}`),
+		runCommandAction(`Create the ref "${identifier}"`, `{bin} migration ref set ${identifier} <hash>`),
+		runCommandAction("Or advance it from the database", `{bin} db update --advance-ref ${identifier}`),
 		chooseAction("Or pass a hash that is a node in the migration graph")
-	] : [chooseAction("Pass --from a ref name, whose contract resolves through the snapshot store"), runCommandAction("Or populate the graph first", "prisma-cli db update")];
+	] : [chooseAction("Pass --from a ref name, whose contract resolves through the snapshot store"), runCommandAction("Or populate the graph first", "{bin} db update")];
 	return new ActionableCliError("MIGRATION.SNAPSHOT_MISSING", viaRef ? `Ref "${identifier}" is not resolvable` : `No contract source for from-hash "${identifier}"`, {
 		why: viaRef ? `Ref "${identifier}" has no pointer file, and the hash being resolved is not a node in the migration graph either.` : `Hash "${identifier}" is not a node in the migration graph (the graph is empty), and it does not name a ref either.`,
 		fix,
@@ -229,20 +244,47 @@ function errorSnapshotMissing(identifier, options) {
 		...ifDefined("cause", options?.cause)
 	});
 }
+/**
+* Default origin resolution for `migration plan` found nothing (no `--from`,
+* no `db` ref) while migrations already exist on disk. Planning would silently
+* produce an empty-origin migration that ignores the existing history — almost
+* always a mistake — so the command refuses and names the three exits.
+*/
+function errorPlanOriginUnknown(reachableRefs, graphTipHash) {
+	const fromSuggestion = reachableRefs.length > 0 ? reachableRefs.map((r) => `--from ${r.name}`).join(" or ") : graphTipHash !== null ? `--from ${graphTipHash}` : "--from <contract>";
+	const refSetCommand = graphTipHash !== null ? `{bin} migration ref set db ${graphTipHash}` : "{bin} migration ref set db <contract>";
+	return new ActionableCliError("MIGRATION.PLAN_ORIGIN_UNKNOWN", "Cannot determine the plan origin: migrations exist but no origin is named", {
+		why: "Migrations exist on disk, but there is no `db` ref and no --from was given, so the plan origin would silently fall back to an empty database and the resulting migration would recreate everything the existing migrations already create.",
+		fix: [
+			`Set the \`db\` ref to the contract your dev database is at (\`${refSetCommand}\`), or advance it via \`{bin} db update\`.`,
+			`Or pass the origin explicitly: \`{bin} migration plan ${fromSuggestion}\`.`,
+			"Or pass --from @empty to deliberately plan from an empty database."
+		].join("\n"),
+		nextActions: [
+			runCommandAction("Point the db ref at the origin contract", refSetCommand),
+			...reachableRefs.length > 0 ? reachableRefs.map((ref) => runCommandAction(`Plan from ${ref.name}`, `{bin} migration plan --from ${ref.name}`)) : [runCommandAction("Plan from an explicit origin", `{bin} migration plan ${fromSuggestion}`)],
+			runCommandAction("Plan from an empty database deliberately", "{bin} migration plan --from @empty")
+		],
+		meta: {
+			reachableRefs: reachableRefs.map((r) => r.name),
+			...graphTipHash !== null ? { graphTipHash } : {}
+		}
+	});
+}
 function errorMarkerMismatch(markerHash, reachableHashes, graphTip) {
 	const reachableList = reachableHashes.length > 0 ? reachableHashes.join(", ") : "(none — migration graph is empty)";
-	const planFromFix = graphTip !== null ? `Run \`prisma-cli migration plan --from ${graphTip}\` if the live marker is canonical and the on-disk graph needs catching up.` : "Run `prisma-cli migration plan` if the live marker is canonical and the on-disk graph needs catching up.";
-	const planCommand = graphTip !== null ? `prisma-cli migration plan --from ${graphTip}` : "prisma-cli migration plan";
+	const planFromFix = graphTip !== null ? `Run \`{bin} migration plan --from ${graphTip}\` if the live marker is canonical and the on-disk graph needs catching up.` : "Run `{bin} migration plan` if the live marker is canonical and the on-disk graph needs catching up.";
+	const planCommand = graphTip !== null ? `{bin} migration plan --from ${graphTip}` : "{bin} migration plan";
 	return new ActionableCliError("MIGRATION.MARKER_MISMATCH", "Database marker is not reachable in the on-disk migration graph", {
 		why: `DB marker is ${markerHash}, but the on-disk migration graph reaches: ${reachableList}.`,
 		fix: [
 			planFromFix,
-			`Run \`prisma-cli ref set db ${markerHash}\` if the on-disk graph is canonical and the local \`db\` ref drifted.`,
+			`Run \`{bin} migration ref set db ${markerHash}\` if the on-disk graph is canonical and the local \`db\` ref drifted.`,
 			"Investigate whether the database was migrated by an out-of-band process."
 		].join("\n"),
 		nextActions: [
 			runCommandAction("Catch the on-disk graph up to the live marker", planCommand),
-			runCommandAction("Point the local db ref at the live marker", `prisma-cli ref set db ${markerHash}`),
+			runCommandAction("Point the local db ref at the live marker", `{bin} migration ref set db ${markerHash}`),
 			chooseAction("Investigate whether the database was migrated by an out-of-band process")
 		],
 		meta: {
@@ -263,13 +305,13 @@ function errorPathUnreachable(failure) {
 	const deadEndsSuffix = Array.isArray(deadEnds) && deadEnds.length > 0 ? ` Dead-ends: ${deadEnds.map(String).join(", ")}.` : "";
 	const neverPlanned = meta["kind"] === "neverPlanned";
 	const planCommand = (() => {
-		if (neverPlanned) return "prisma-cli migration plan --name <slug>";
-		if (planFromHash !== null && targetHash !== null) return `prisma-cli migration plan --from ${planFromHash} --to ${targetHash} --name <slug>`;
-		if (targetHash !== null) return `prisma-cli migration plan --to ${targetHash} --name <slug>`;
-		if (planFromHash !== null) return `prisma-cli migration plan --from ${planFromHash} --name <slug>`;
-		return "prisma-cli migration plan";
+		if (neverPlanned) return "{bin} migration plan --name <slug>";
+		if (planFromHash !== null && targetHash !== null) return `{bin} migration plan --from ${planFromHash} --to ${targetHash} --name <slug>`;
+		if (targetHash !== null) return `{bin} migration plan --to ${targetHash} --name <slug>`;
+		if (planFromHash !== null) return `{bin} migration plan --from ${planFromHash} --name <slug>`;
+		return "{bin} migration plan";
 	})();
-	const applyCommand = targetHash !== null && !neverPlanned ? `prisma-cli migrate --to ${targetHash}` : "prisma-cli migrate";
+	const applyCommand = targetHash !== null && !neverPlanned ? `{bin} db migrate --to ${targetHash}` : "{bin} db migrate";
 	return new ActionableCliError("MIGRATION.PATH_UNREACHABLE", failure.summary, {
 		why: failure.why ?? `Cannot reach target "${targetHash ?? "<unknown>"}" from current marker "${fromHashMeta ?? "<unknown>"}".${deadEndsSuffix}`,
 		fix: [
@@ -278,15 +320,15 @@ function errorPathUnreachable(failure) {
 			`  2. ${applyCommand}`,
 			`${ROLLBACK_IS_DESTRUCTIVE}.`,
 			`${NARROWER_CASES_NEED_A_HINT}.`,
-			"Inspect the on-disk graph with `prisma-cli migration list`, or `prisma-cli migration show <bundle>` for any bundle in the path you expected."
+			"Inspect the on-disk graph with `{bin} migration list`, or `{bin} migration show <bundle>` for any bundle in the path you expected."
 		].join("\n"),
 		nextActions: [
 			runCommandAction("Plan the missing edge", planCommand),
 			runCommandAction("Apply it", applyCommand),
 			chooseAction(ROLLBACK_IS_DESTRUCTIVE),
 			chooseAction(NARROWER_CASES_NEED_A_HINT),
-			runCommandAction("Inspect the on-disk graph", "prisma-cli migration list"),
-			runCommandAction("Inspect a bundle in the path you expected", "prisma-cli migration show <bundle>")
+			runCommandAction("Inspect the on-disk graph", "{bin} migration list"),
+			runCommandAction("Inspect a bundle in the path you expected", "{bin} migration show <bundle>")
 		],
 		meta: { ...meta }
 	});
@@ -565,7 +607,7 @@ async function readContractEnvelope(config) {
 	const json = JSON.parse(content);
 	const { schemaVersion, target, targetFamily, profileHash } = json;
 	const storageHash = json["storage"]?.["storageHash"];
-	if (typeof storageHash !== "string") throw new CliStructuredError$1("CONTRACT.VALIDATION_FAILED", `Contract at ${relative(process.cwd(), contractPath)} is missing a valid storage.storageHash. Run \`prisma-cli contract emit\` to regenerate.`, { where: { path: contractPath } });
+	if (typeof storageHash !== "string") throw new CliStructuredError$1("CONTRACT.VALIDATION_FAILED", `Contract at ${relative(process.cwd(), contractPath)} is missing a valid storage.storageHash. Run \`{bin} contract emit\` to regenerate.`, { where: { path: contractPath } });
 	if (typeof schemaVersion !== "string") throw new CliStructuredError$1("CONTRACT.VALIDATION_FAILED", `Contract at ${relative(process.cwd(), contractPath)} is missing schemaVersion.`, { where: { path: contractPath } });
 	if (typeof target !== "string") throw new CliStructuredError$1("CONTRACT.VALIDATION_FAILED", `Contract at ${relative(process.cwd(), contractPath)} is missing target.`, { where: { path: contractPath } });
 	if (typeof targetFamily !== "string") throw new CliStructuredError$1("CONTRACT.VALIDATION_FAILED", `Contract at ${relative(process.cwd(), contractPath)} is missing targetFamily.`, { where: { path: contractPath } });
@@ -729,14 +771,14 @@ function describeIntegrityViolation(violation) {
 * target mismatch, then disjointness, then a contract-validation
 * failure, then any remaining structural integrity violation.
 */
-function mapIntegrityViolations(violations) {
+function mapIntegrityViolations(violations, migrationsDir) {
 	if (violations.length === 0) return null;
 	const layout = violations.filter((v) => v.kind === "orphanSpaceDir" || v.kind === "declaredButUnmigrated");
 	if (layout.length > 0) {
 		const lines = layout.map((v) => `- [${v.kind}] ${v.spaceId}`);
 		return new CliStructuredError$1("MIGRATION.CONTRACT_SPACE_LAYOUT_VIOLATION", layout.length === 1 ? "Contract-space layout violation detected" : `Contract-space layout violations detected (${layout.length})`, {
-			why: `The on-disk \`migrations/\` directory and your \`extensions\` declaration are not in agreement.\n${lines.join("\n")}`,
-			fix: "Declare the extension in `extensions` and re-emit its contract-space artefacts, or remove the orphan `migrations/<space>` directory.",
+			why: `The on-disk \`${migrationsDir}/\` directory and your \`extensions\` declaration are not in agreement.\n${lines.join("\n")}`,
+			fix: `Declare the extension in \`extensions\` and re-emit its contract-space artefacts, or remove the orphan \`${migrationsDir}/<space>\` directory.`,
 			docsUrl: CONTRACT_SPACES_DOCS_URL,
 			meta: { violations: layout }
 		});
@@ -752,13 +794,13 @@ function mapIntegrityViolations(violations) {
 	const contractUnreadable = violations.find((v) => v.kind === "contractUnreadable");
 	if (contractUnreadable && contractUnreadable.kind === "contractUnreadable") return contractSpaceViolationError(`Contract-space contract validation failed for "${contractUnreadable.spaceId}"`, {
 		why: contractUnreadable.detail,
-		fix: "Re-emit the extension contract with `prisma-cli contract emit`, or fix the extension pack descriptor producing the invalid contract.",
+		fix: "Re-emit the extension contract with `{bin} contract emit`, or fix the extension pack descriptor producing the invalid contract.",
 		violations: [contractUnreadable]
 	});
 	const structural = violations[0];
 	return contractSpaceViolationError(`Contract-space integrity failure for "${"spaceId" in structural ? structural.spaceId : "*"}"`, {
 		why: describeIntegrityViolation(structural),
-		fix: "Re-emit the affected migration package(s) or restore the on-disk `migrations/` directory from version control.",
+		fix: `Re-emit the affected migration package(s) or restore the on-disk \`${migrationsDir}\` directory from version control.`,
 		violations: [structural]
 	});
 }
@@ -793,8 +835,8 @@ async function loadContractSpaceAggregateForCli(inputs) {
 * the contract-space refusal envelope, or return `null` when the model
 * is acceptable for the requested check scope.
 */
-function refuseContractSpaceIntegrity(aggregate, options) {
-	return mapIntegrityViolations(aggregate.checkIntegrity(options));
+function refuseContractSpaceIntegrity(aggregate, options, migrationsDir) {
+	return mapIntegrityViolations(aggregate.checkIntegrity(options), migrationsDir);
 }
 const PACKAGE_CORRUPTION_KINDS = /* @__PURE__ */ new Set([
 	"hashMismatch",
@@ -806,8 +848,8 @@ const PACKAGE_CORRUPTION_KINDS = /* @__PURE__ */ new Set([
 * corruptions only (`hashMismatch`, `providedInvariantsMismatch`,
 * `packageUnloadable`).
 */
-function refusePackageCorruptionOnAggregate(aggregate) {
-	return mapIntegrityViolations(aggregate.checkIntegrity().filter((v) => PACKAGE_CORRUPTION_KINDS.has(v.kind)));
+function refusePackageCorruptionOnAggregate(aggregate, migrationsDir) {
+	return mapIntegrityViolations(aggregate.checkIntegrity().filter((v) => PACKAGE_CORRUPTION_KINDS.has(v.kind)), migrationsDir);
 }
 /**
 * Construct the tolerant {@link ContractSpaceAggregate} at the CLI
@@ -823,7 +865,7 @@ async function buildContractSpaceAggregate(inputs) {
 	const failure = refuseContractSpaceIntegrity(loaded.value, {
 		declaredExtensions,
 		checkContracts: true
-	});
+	}, inputs.migrationsDir);
 	if (failure) return notOk(failure);
 	return ok(loaded.value);
 }
@@ -1490,7 +1532,8 @@ async function executeDbVerify(options) {
 		}),
 		aggregate,
 		skipMarker,
-		onProgress
+		onProgress,
+		migrationsDir: options.migrationsDir
 	});
 }
 function buildLoadInputs(options) {
@@ -1573,7 +1616,7 @@ function emitVerifySpan(onProgress, kind) {
 * by the CLI's `--schema-only` mode.
 */
 function finaliseVerifyResult(args) {
-	const { verifyResult, aggregate, skipMarker, onProgress } = args;
+	const { verifyResult, aggregate, skipMarker, onProgress, migrationsDir } = args;
 	if (!verifyResult.ok) {
 		emitVerifySpan(onProgress, "spanEndError");
 		return notOk(new CliStructuredError$1("MIGRATION.CONTRACT_SPACE_VIOLATION", "Aggregate verifier introspection failed", {
@@ -1582,7 +1625,7 @@ function finaliseVerifyResult(args) {
 			docsUrl: "https://pris.ly/contract-spaces"
 		}));
 	}
-	const markerDrift = skipMarker ? null : mapMarkerCheckFailures(aggregate.app.spaceId, verifyResult.value.markerCheck);
+	const markerDrift = skipMarker ? null : mapMarkerCheckFailures(aggregate.app.spaceId, verifyResult.value.markerCheck, migrationsDir);
 	emitVerifySpan(onProgress, markerDrift === null ? "spanEndOk" : "spanEndError");
 	return ok({
 		schemaResults: verifyResult.value.schemaCheck.perSpace,
@@ -1614,7 +1657,7 @@ function buildSkippedSchemaResult(space) {
 * `MIGRATION.CONTRACT_SPACE_VIOLATION` (was emitted by
 * `runContractSpaceVerifierMarkerCheck`).
 */
-function mapMarkerCheckFailures(appSpaceId, section) {
+function mapMarkerCheckFailures(appSpaceId, section, migrationsDir) {
 	const violations = [];
 	for (const [spaceId, result] of section.perSpace) {
 		if (result.kind === "ok" || result.kind === "absent") continue;
@@ -1622,14 +1665,14 @@ function mapMarkerCheckFailures(appSpaceId, section) {
 			violations.push({
 				kind: "hashMismatch",
 				spaceId,
-				remediation: spaceId === appSpaceId ? "Run `prisma-cli db update` to advance the marker, or roll the database back to the recorded hash." : `Apply on-disk migrations under \`migrations/${spaceId}/\` to advance the marker, or remove the conflicting marker row.`
+				remediation: spaceId === appSpaceId ? "Run `{bin} db update` to advance the marker, or roll the database back to the recorded hash." : `Apply on-disk migrations under \`${migrationsDir}/${spaceId}/\` to advance the marker, or remove the conflicting marker row.`
 			});
 			continue;
 		}
 		if (result.kind === "missingInvariants") violations.push({
 			kind: "invariantsMismatch",
 			spaceId,
-			remediation: `Re-apply the migrations under \`migrations/${spaceId}/\` so the marker carries invariants: ${result.missing.join(", ")}.`
+			remediation: `Re-apply the migrations under \`${migrationsDir}/${spaceId}/\` so the marker carries invariants: ${result.missing.join(", ")}.`
 		});
 	}
 	for (const orphan of section.orphanMarkers) violations.push({
@@ -1640,7 +1683,7 @@ function mapMarkerCheckFailures(appSpaceId, section) {
 	if (violations.length === 0) return null;
 	const lines = violations.map((v) => `- [${v.kind}] ${v.spaceId}: ${v.remediation}`);
 	return new CliStructuredError$1("MIGRATION.CONTRACT_SPACE_VIOLATION", violations.length === 1 ? "Contract-space verifier found a violation" : `Contract-space verifier found violations (${violations.length})`, {
-		why: `The on-disk \`migrations/\` directory, the \`extensions\` declaration, and the live database marker rows are not in agreement.\n${lines.join("\n")}`,
+		why: `The on-disk \`${migrationsDir}/\` directory, the \`extensions\` declaration, and the live database marker rows are not in agreement.\n${lines.join("\n")}`,
 		fix: violations[0]?.remediation ?? "Review and reconcile the violations listed above.",
 		docsUrl: "https://pris.ly/contract-spaces",
 		meta: { violations }
@@ -1702,7 +1745,7 @@ async function executeMigrate(options) {
 			atHeadResolutions.set(space.spaceId, outcome.plan);
 			continue;
 		}
-		if (outcome.kind === "never-planned") return notOk(buildNeverPlannedFailure(outcome.spaceId, outcome.targetHash));
+		if (outcome.kind === "never-planned") return notOk(buildNeverPlannedFailure(outcome.spaceId, outcome.targetHash, migrationsDir));
 		if (outcome.kind === "unreachable") return notOk(buildPathNotFoundFailure(outcome.spaceId, outcome.liveMarker, outcome.targetHash));
 		if (outcome.kind === "unsatisfiable") {
 			const structural = findPathWithDecision(outcome.targetSpace.graph(), outcome.liveHash, spaceTargetHash, { required: /* @__PURE__ */ new Set() });
@@ -1974,11 +2017,11 @@ function buildSuccess(args) {
 *
 * @internal Exported for testing only.
 */
-function buildNeverPlannedFailure(spaceId, targetHash) {
+function buildNeverPlannedFailure(spaceId, targetHash, migrationsDir) {
 	return {
 		code: "MIGRATION_PATH_NOT_FOUND",
 		summary: `No on-disk migrations for contract space "${spaceId}"`,
-		why: `migrate is replay-only: a contract space that declares managed storage elements must have an authored migration graph on disk. Space "${spaceId}" has no migrations under \`migrations/${spaceId}/\` but its head ref targets "${targetHash}".`,
+		why: `migrate is replay-only: a contract space that declares managed storage elements must have an authored migration graph on disk. Space "${spaceId}" has no migrations under \`${migrationsDir}/${spaceId}/\` but its head ref targets "${targetHash}".`,
 		meta: {
 			spaceId,
 			target: targetHash,
@@ -2011,7 +2054,7 @@ function buildPathNotFoundFailure(spaceId, marker, targetHash) {
 	};
 }
 /**
-* Creates a programmatic control client for Prisma Next operations.
+* Creates a programmatic control client for Prisma ORM operations.
 *
 * The client accepts framework component descriptors at creation time,
 * manages driver lifecycle via connect()/close(), and exposes domain
@@ -2499,7 +2542,10 @@ var ControlClientImpl = class {
 					meta: void 0
 				});
 			}
-			const result = await emit(deserializedContract, this.stack, this.options.family.emission, { serializeContract: (contract) => this.options.target.contractSerializer.serializeContract(contract) });
+			const result = await emit(deserializedContract, this.stack, this.options.family.emission, {
+				serializeContract: (contract) => this.options.target.contractSerializer.serializeContract(contract),
+				...ifDefined("supportsNamespaces", this.options.target.supportsNamespaces)
+			});
 			onProgress?.({
 				action: "emit",
 				kind: "spanEnd",
@@ -2727,7 +2773,7 @@ function extractPackageSpecifiers(dtsContent) {
 }
 function validateContractDeps(dtsContent, projectRoot) {
 	const packages = extractPackageSpecifiers(dtsContent);
-	const resolve = createRequire(`${projectRoot}/package.json`);
+	const resolve = createRequire(resolve$1(projectRoot, "package.json"));
 	const missing = [];
 	for (const pkg of packages) try {
 		resolve.resolve(`${pkg}/package.json`);
@@ -2831,7 +2877,7 @@ function validateProviderResult(providerResult) {
 * Canonical contract emit operation.
 *
 * This is the SINGLE publication path used by both the CLI command
-* (`prisma-next contract emit`) and the Vite plugin
+* (`prisma contract emit`) and the Vite plugin
 * (`@internal/vite-plugin-contract-emit`). New callers must go through this
 * function rather than re-implementing load → emit → publish.
 *
@@ -2908,7 +2954,8 @@ async function executeContractEmit(options, dependencies = defaultContractEmitDe
 				serializeContract,
 				resolveImportSpecifier: createProjectSpecifierResolver(configPath ?? outputJsonPath),
 				...ifDefined("shouldPreserveEmpty", contractSerializer.shouldPreserveEmpty),
-				...ifDefined("sortStorage", contractSerializer.sortStorage)
+				...ifDefined("sortStorage", contractSerializer.sortStorage),
+				...ifDefined("supportsNamespaces", config.target.supportsNamespaces)
 			}));
 		} catch (error) {
 			endSpan(onProgress, "emit", "error");
@@ -2941,12 +2988,43 @@ function computeRefAdvancementName(options) {
 	if (options.db === void 0) return "db";
 	return null;
 }
+function contractDtsPathOf(contractJsonPath) {
+	return contractJsonPath.replace(/\.json$/i, ".d.ts");
+}
 async function readContractIR(contractJson, contractJsonPath) {
 	return {
 		contract: contractJson,
-		contractDts: await readFile(contractJsonPath.replace(/\.json$/i, ".d.ts"), "utf-8")
+		contractDts: await readFile(contractDtsPathOf(contractJsonPath), "utf-8")
 	};
 }
+function fsErrorCodeOf(error) {
+	const code = error instanceof Error ? Reflect.get(error, "code") : void 0;
+	return typeof code === "string" ? code : void 0;
+}
+function errorUnreadableContractDts(contractJsonPath, cause) {
+	const contractDtsPath = contractDtsPathOf(contractJsonPath);
+	const code = fsErrorCodeOf(cause);
+	return errorFileNotFound(contractDtsPath, {
+		why: code === "ENOENT" ? `The contract types next to ${contractJsonPath} are missing: ${contractDtsPath}` : `The contract types next to ${contractJsonPath} could not be read${code === void 0 ? "" : ` (${code})`}: ${contractDtsPath}`,
+		fix: "Run {bin} contract emit to regenerate the contract artifacts, then advance the ref again.",
+		cause
+	});
+}
+/**
+* Everything `advanceRefSafely` needs from disk, loaded before a command does
+* the work that precedes the ref write: the ref name is validated and the
+* sibling `.d.ts` of the contract to snapshot is read. The returned
+* `ContractIR` is what the command then hands to `advanceRefSafely`, so no
+* file is read after the database is signed.
+*/
+async function preflightRefAdvancement(args) {
+	if (!validateRefName(args.name)) return notOk(errorInvalidRefName(args.name));
+	try {
+		return ok(await readContractIR(args.contractJson, args.contractJsonPath));
+	} catch (error) {
+		return notOk(errorUnreadableContractDts(args.contractJsonPath, error));
+	}
+}
 async function executeRefAdvancement(refsDir, migrationsDir, name, hash, contractIR) {
 	if (!validateRefName(name)) throw errorInvalidRefName(name);
 	await writeContractSnapshot(migrationsDir, hash, {
@@ -3012,7 +3090,10 @@ async function resolveRefAdvancementFields(options) {
 		throw error;
 	}
 }
-/** migrate's --advance-ref tail: executeRefAdvancement with MigrationToolsError passed through, others rethrown. */
+/**
+* The --advance-ref tail of migrate and db sign: executeRefAdvancement with
+* MigrationToolsError failures passed through as notOk, others rethrown.
+*/
 async function advanceRefSafely(args) {
 	try {
 		return ok(await executeRefAdvancement(args.refsDir, args.migrationsDir, args.name, args.hash, args.contractIR));
@@ -3056,7 +3137,7 @@ async function resolveContractRefToSnapshot(options) {
 		} catch (error) {
 			if (isEnoent$1(error)) return notOk(errorFileNotFound(options.contractPathAbsolute, {
 				why: `Contract file not found at ${options.contractPathAbsolute}`,
-				fix: "Run `prisma-cli contract emit` first to generate the contract",
+				fix: "Run `{bin} contract emit` first to generate the contract",
 				cause: error
 			}));
 			return notOk(errorUnexpected(error instanceof Error ? error.message : String(error), {
@@ -3197,7 +3278,7 @@ async function executeMigrateShowPlan(options) {
 			dbConnection,
 			hasDriver,
 			why: "migrate --show needs a database connection to read the live marker (or pass --from <contract> for an offline preview)",
-			retryCommand: "prisma-cli migrate --show --from <contract>"
+			retryCommand: "{bin} db migrate --show --from <contract>"
 		});
 		if (missingDb) return notOk(missingDb);
 	}
@@ -3244,7 +3325,7 @@ async function executeMigrateShowPlan(options) {
 			dbConnection,
 			hasDriver,
 			why: "@db resolves to the live database marker and requires a --db connection",
-			retryCommand: "prisma-cli migrate --show --from @db --db $DATABASE_URL"
+			retryCommand: "{bin} db migrate --show --from @db --db $DATABASE_URL"
 		});
 		if (missingDb) return notOk(missingDb);
 	} else {
@@ -3628,7 +3709,7 @@ function checkDanglingRefs(space) {
 		code: "MIGRATION.CHECK_DANGLING_REF",
 		where: relative(space.cwd, join(space.refsDir, `${name}.json`)),
 		why: `Ref "${name}" points at ${entry.hash} which does not exist in the migration graph`,
-		nextActions: [runCommandAction("Point the ref at a graph node", `prisma-cli ref set ${name} <valid-hash>`), chooseAction("Or delete the ref")]
+		nextActions: [runCommandAction("Point the ref at a graph node", `{bin} migration ref set ${name} <valid-hash>`), chooseAction("Or delete the ref")]
 	});
 	return failures;
 }
@@ -3871,7 +3952,7 @@ async function executeMigrationNewCommand(options) {
 	} catch (error) {
 		if (error instanceof Error && error.code === "ENOENT") return notOk(errorRuntime("CLI.FILE_NOT_FOUND", `Contract file not found at ${contractPathAbsolute}`, {
 			why: `Contract file not found at ${contractPathAbsolute}`,
-			fix: "Run `prisma-cli contract emit` first to generate the contract"
+			fix: "Run `{bin} contract emit` first to generate the contract"
 		}));
 		throw error;
 	}
@@ -3882,21 +3963,21 @@ async function executeMigrationNewCommand(options) {
 	} catch (error) {
 		return notOk(errorRuntime("MIGRATION.CONTRACT_DESERIALIZATION_FAILED", "Contract JSON is invalid", {
 			why: `Failed to deserialize ${contractPathAbsolute}: ${error instanceof Error ? error.message : String(error)}`,
-			fix: "Run `prisma-cli contract emit` to regenerate the contract",
+			fix: "Run `{bin} contract emit` to regenerate the contract",
 			cause: error
 		}));
 	}
 	const toStorageHash = toContract.storage?.storageHash;
 	if (typeof toStorageHash !== "string") return notOk(errorRuntime("CONTRACT.VALIDATION_FAILED", "Contract is missing storageHash", {
 		why: `Contract at ${contractPathAbsolute} has no storageHash`,
-		fix: "Run `prisma-cli contract emit` to regenerate the contract"
+		fix: "Run `{bin} contract emit` to regenerate the contract"
 	}));
 	const aggregate = await loadContractSpaceAggregate({
 		migrationsDir,
 		deserializeContract: (json) => familyInstance.deserializeContract(json),
 		appContract: toContract
 	});
-	const packageCorruptionFailure = refusePackageCorruptionOnAggregate(aggregate);
+	const packageCorruptionFailure = refusePackageCorruptionOnAggregate(aggregate, migrationsDir);
 	if (packageCorruptionFailure) return notOk(packageCorruptionFailure);
 	const packages = aggregate.app.packages;
 	const graph = aggregate.app.graph();
@@ -3914,7 +3995,7 @@ async function executeMigrationNewCommand(options) {
 	}
 	if (fromHash === toStorageHash && !options.from) return notOk(errorRuntime("MIGRATION.NO_CHANGES", "No changes detected", {
 		why: "The from and to contract hashes are identical — there is nothing to migrate.",
-		fix: "Change the contract and run `prisma-cli contract emit` before creating a new migration. To author a data-only migration on the current contract hash, pass `--from <hash>` explicitly."
+		fix: "Change the contract and run `{bin} contract emit` before creating a new migration. To author a data-only migration on the current contract hash, pass `--from <hash>` explicitly."
 	}));
 	const timestamp = /* @__PURE__ */ new Date();
 	const packageDir = join(appMigrationsDir, formatMigrationDirName(timestamp, options.name ?? "migration"));
@@ -4138,11 +4219,15 @@ async function resolveFromForPlan(input) {
 	const refs = space.refs;
 	if (optionsFrom === void 0) {
 		const dbRef = refs["db"];
-		if (!dbRef) return ok({
-			kind: "greenfield",
-			fromHash: null,
-			fromContract: null
-		});
+		if (!dbRef) {
+			if (graphIsEmpty(space)) return ok({
+				kind: "greenfield",
+				fromHash: null,
+				fromContract: null,
+				defaulted: true
+			});
+			return notOk(errorPlanOriginUnknown(getReachableRefs(refs, graph), findLatestMigration(graph)?.to ?? null));
+		}
 		return resolveFromPolicy({
 			hash: dbRef.hash,
 			provenance: {
@@ -4164,6 +4249,12 @@ async function resolveFromForPlan(input) {
 		}
 		return notOk(mapRefResolutionError(refResult.failure));
 	}
+	if (refResult.value.provenance.kind === "reserved-empty") return ok({
+		kind: "greenfield",
+		fromHash: null,
+		fromContract: null,
+		defaulted: false
+	});
 	return resolveFromPolicy(refResult.value, input, refs, optionsFrom);
 }
 async function resolveToForPlan(optionsTo, input) {
@@ -4175,6 +4266,13 @@ async function resolveToForPlan(optionsTo, input) {
 		refs
 	});
 	if (!refResult.ok) return notOk(mapRefResolutionError(refResult.failure));
+	if (refResult.value.provenance.kind === "reserved-empty") return notOk(mapRefResolutionError({
+		kind: "wrong-grammar",
+		input: optionsTo,
+		expectedGrammar: "contract",
+		message: "`@empty` is only valid as an origin (`--from`); planning a migration to the empty contract is not supported through this shortcut",
+		fix: "Pass `--to` a contract hash, ref name, or migration directory name. To plan starting from an empty database, use `--from @empty`."
+	}));
 	const resolution = await resolveContractRef(refResult.value, space, {
 		explicitLabel: optionsTo,
 		artifactRole: "to"
@@ -4270,7 +4368,7 @@ async function executeMigrationPlanCommandInner(options, startTime, callbacks) {
 	} catch (error) {
 		if (isEnoent(error)) return notOk(errorFileNotFound(contractPathAbsolute, {
 			why: `Contract file not found at ${contractPathAbsolute}`,
-			fix: `Run \`prisma-cli contract emit\` to generate ${contractPath}, or update \`config.contract.output\` in ${configPath}`
+			fix: `Run \`{bin} contract emit\` to generate ${contractPath}, or update \`config.contract.output\` in ${configPath}`
 		}));
 		return notOk(errorUnexpected(error instanceof Error ? error.message : String(error), { why: `Failed to read contract file: ${error instanceof Error ? error.message : String(error)}` }));
 	}
@@ -4291,6 +4389,7 @@ async function executeMigrationPlanCommandInner(options, startTime, callbacks) {
 	let fromHash = null;
 	let snapshotStartContract = null;
 	let isAutoBaseline = false;
+	let fromDefaulted = false;
 	const tolerantAggregateResult = await loadContractSpaceAggregateForCli({
 		targetId: config.target.targetId,
 		migrationsDir,
@@ -4306,7 +4405,9 @@ async function executeMigrationPlanCommandInner(options, startTime, callbacks) {
 	});
 	if (!resolutionResult.ok) return notOk(resolutionResult.failure);
 	switch (resolutionResult.value.kind) {
-		case "greenfield": break;
+		case "greenfield":
+			fromDefaulted = resolutionResult.value.defaulted;
+			break;
 		case "graph-node":
 			fromHash = resolutionResult.value.fromHash;
 			fromContract = resolutionResult.value.fromContract;
@@ -4504,6 +4605,7 @@ async function executeMigrationPlanCommandInner(options, startTime, callbacks) {
 			operations: [],
 			emittedExtensionDirs,
 			pendingPlaceholders: true,
+			...fromDefaulted ? { fromDefaulted } : {},
 			summary: "Planned migration with placeholder(s) — edit migration.ts then run `node migration.ts` to self-emit",
 			timings: { total: Date.now() - startTime }
 		});
@@ -4522,6 +4624,7 @@ async function executeMigrationPlanCommandInner(options, startTime, callbacks) {
 			})),
 			emittedExtensionDirs,
 			...preview !== void 0 ? { preview } : {},
+			...fromDefaulted ? { fromDefaulted } : {},
 			summary: buildPlanSummary(plannedOps.length, emittedExtensionDirs.length),
 			timings: { total: Date.now() - startTime }
 		});
@@ -4681,6 +4784,6 @@ async function executeRefListCommand(options) {
 	}
 }
 //#endregion
-export { loadContractRawSafely as $, errorMigrationPlanningFailed as A, statusForMigrationHash as At, executeDbUpdate as B, errorDestructiveChanges as C, resolveRefAdvancementFields as Ct, errorLegendHumanOnly as D, runMigrationCheck as Dt, errorHashMismatch as E, runContractSpaceSeedPhase as Et, errorTargetMigrationNotSupported as F, executeRefAdvancement as G, executeMigrateShowPlan as H, errorTargetMismatch as I, executeRefSetCommand as J, executeRefDeleteCommand as K, errorUnexpected as L, errorPathUnreachable as M, toDeclaredExtensionsFromRaw as Mt, errorRunnerFailed as N, errorMarkerMissing as O, runMigrationList as Ot, errorRuntime as P, loadAggregateIntegrityViolations as Q, executeContractEmit as R, errorDatabaseConnectionRequired as S, resolveMigrationRef as St, errorFileNotFound as T, runCommandAction as Tt, executeMigrationNewCommand as U, executeDbVerify as V, executeMigrationPlanCommand as W, hasMigrationPath as X, findPackageByDirPath as Y, listRefsByContractHash as Z, enumerateCheckSpaces as _, requireLiveDatabase as _t, buildContractSpaceAggregate as a, maskConnectionUrl as at, errorContractArgConflict as b, resolveContractRefToSnapshot as bt, buildRefAdvancementFields as c, readContractEnvelope as ct, closeQuietly as d, refuseContractSpaceIntegrity as dt, loadContractSpaceAggregateForCli as et, computeRefAdvancementName as f, refuseDeclaredExtensionTargetMismatch as ft, enrichContract as g, refuseUnknownInvariants as gt, disposeEmitQueue as h, refusePackageCorruptionOnAggregate as ht, appliedHashesFromLedger as i, mapIntegrityViolations as it, errorNoMigrations as j, targetSupportsMigrations as jt, errorMigrationPackageNotFound as k, sanitizeErrorMessage as kt, checkSingleTarget as l, readContractIR as lt, deriveStatusEdgeAnnotations as m, refuseMissingInvariantPath as mt, advanceRefSafely as n, mapCaughtMigrationError as nt, buildMigrationSpaceGraphEntries as o, migrationSpaceListEntriesFromAggregate as ot, createControlClient as p, refuseMarkerOutsideGraph as pt, executeRefListCommand as q, appContractStandInFromIdentity as r, mapContractAtError as rt, buildReadAggregate as s, originHashForStatus as st, CliStructuredError$1 as t, looksLikePath as tt, chooseAction as u, readMigrationRefs as ut, errorConfigValidation$1 as v, resolveAppTargetPath as vt, errorDriverRequired as w, resolveToForPlan as wt, errorContractValidationFailed as x, resolveFromForPlan as xt, errorConsentPlanMismatch as y, resolveContractRef$1 as yt, executeDbInit as z };
+export { loadAggregateIntegrityViolations as $, errorMigrationPackageNotFound as A, runMigrationList as At, executeDbInit as B, errorDatabaseConnectionRequired as C, resolveFromForPlan as Ct, errorHashMismatch as D, runCommandAction as Dt, errorFileNotFound as E, resolveToForPlan as Et, errorRuntime as F, executeMigrationPlanCommand as G, executeDbVerify as H, errorTargetMigrationNotSupported as I, executeRefListCommand as J, executeRefAdvancement as K, errorTargetMismatch as L, errorNoMigrations as M, statusForMigrationHash as Mt, errorPathUnreachable as N, targetSupportsMigrations as Nt, errorLegendHumanOnly as O, runContractSpaceSeedPhase as Ot, errorRunnerFailed as P, toDeclaredExtensionsFromRaw as Pt, listRefsByContractHash as Q, errorUnexpected as R, errorContractValidationFailed as S, resolveContractRefToSnapshot as St, errorDriverRequired as T, resolveRefAdvancementFields as Tt, executeMigrateShowPlan as U, executeDbUpdate as V, executeMigrationNewCommand as W, findPackageByDirPath as X, executeRefSetCommand as Y, hasMigrationPath as Z, enumerateCheckSpaces as _, refusePackageCorruptionOnAggregate as _t, buildContractSpaceAggregate as a, mapIntegrityViolations as at, errorConsentPlanMismatch as b, resolveAppTargetPath as bt, buildRefAdvancementFields as c, originHashForStatus as ct, closeQuietly as d, readContractIR as dt, loadContractRawSafely as et, computeRefAdvancementName as f, readMigrationRefs as ft, enrichContract as g, refuseMissingInvariantPath as gt, disposeEmitQueue as h, refuseMarkerOutsideGraph as ht, appliedHashesFromLedger as i, mapContractAtError as it, errorMigrationPlanningFailed as j, sanitizeErrorMessage as jt, errorMarkerMissing as k, runMigrationCheck as kt, checkSingleTarget as l, preflightRefAdvancement as lt, deriveStatusEdgeAnnotations as m, refuseDeclaredExtensionTargetMismatch as mt, advanceRefSafely as n, looksLikePath as nt, buildMigrationSpaceGraphEntries as o, maskConnectionUrl as ot, createControlClient as p, refuseContractSpaceIntegrity as pt, executeRefDeleteCommand as q, appContractStandInFromIdentity as r, mapCaughtMigrationError as rt, buildReadAggregate as s, migrationSpaceListEntriesFromAggregate as st, CliStructuredError$1 as t, loadContractSpaceAggregateForCli as tt, chooseAction as u, readContractEnvelope as ut, errorAdvanceRefArgConflict as v, refuseUnknownInvariants as vt, errorDestructiveChanges as w, resolveMigrationRef as wt, errorContractArgConflict as x, resolveContractRef$1 as xt, errorConfigValidation$1 as y, requireLiveDatabase as yt, executeContractEmit as z };
 
-//# sourceMappingURL=ref-h6InR6dO-rGfl18Jv.mjs.map
+//# sourceMappingURL=ref-DcqFmceq-QaUjgZeM.mjs.map