prisma-next 0.10.0 → 0.11.0-dev.10

package/dist/{migration-plan-CHyUlBV0.mjs → migration-plan-jdAHg_gK.mjs}

@@ -1,24 +1,24 @@
 import { t as loadConfig } from "./config-loader-B6sJjXTv.mjs";
-import { _ as errorUnexpected, a as errorContractValidationFailed, f as errorMigrationPlanningFailed, h as errorTargetMigrationNotSupported, l as errorFileNotFound, t as CliStructuredError, v as mapMigrationToolsError, y as mapRefResolutionError } from "./cli-errors-CF60g2cG.mjs";
-import { t as assertFrameworkComponentsCompatible } from "./framework-components-xFLFpZUO.mjs";
-import { _ as parseGlobalFlags, a as loadMigrationPackages, b as formatStyledHeader, c as resolveContractPath, d as setCommandDescriptions, f as setCommandExamples, i as getTargetMigrations, l as resolveMigrationPaths, t as addGlobalOptions } from "./command-helpers-D3vL5yi8.mjs";
-import { t as handleResult } from "./result-handler-Bm_6dDYg.mjs";
-import { t as TerminalUI } from "./terminal-ui-XtOQsqe9.mjs";
-import { n as toExtensionInputs, t as buildContractSpaceAggregate } from "./contract-space-aggregate-loader-pAc8CDfY.mjs";
+import { C as errorSnapshotMissing, D as mapMigrationToolsError, E as errorUnexpected, O as mapRefResolutionError, _ as errorPlanForgotTheFlag, a as errorContractValidationFailed, l as errorFileNotFound, m as errorMigrationPlanningFailed, t as CliStructuredError, w as errorTargetMigrationNotSupported } from "./cli-errors-Bw2GlweY.mjs";
+import { t as assertFrameworkComponentsCompatible } from "./framework-components-Bexd0f4E.mjs";
+import { t as createTerminalUI } from "./terminal-ui-BiB_8KNo.mjs";
+import { S as formatStyledHeader, a as loadMigrationPackages, c as resolveContractPath, d as setCommandDescriptions, f as setCommandExamples, i as getTargetMigrations, l as resolveMigrationPaths, t as addGlobalOptions, v as parseGlobalFlagsOrExit, y as handleResult } from "./command-helpers-CRfjbZRz.mjs";
+import { n as toExtensionInputs, t as buildContractSpaceAggregate } from "./contract-space-aggregate-loader-CGakRlKM.mjs";
 import { Command } from "commander";
 import { getEmittedArtifactPaths } from "@prisma-next/emitter";
 import { notOk, ok } from "@prisma-next/utils/result";
 import { join, relative } from "pathe";
-import { readFile } from "node:fs/promises";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { createControlStack, hasOperationPreview } from "@prisma-next/framework-components/control";
 import { copyFilesWithRename, formatMigrationDirName, materialiseExtensionMigrationPackageIfMissing, writeMigrationPackage } from "@prisma-next/migration-tools/io";
-import { findLatestMigration } from "@prisma-next/migration-tools/migration-graph";
+import { assertHashIsGraphNode, findLatestMigration, isGraphNode } from "@prisma-next/migration-tools/migration-graph";
 import { emitContractSpaceArtefacts, planAllSpaces, readContractSpaceHeadRef, spaceMigrationDirectory } from "@prisma-next/migration-tools/spaces";
 import { MigrationToolsError } from "@prisma-next/migration-tools/errors";
+import { readRefSnapshot, readRefs } from "@prisma-next/migration-tools/refs";
 import { parseContractRef } from "@prisma-next/migration-tools/ref-resolution";
-import { readRefs } from "@prisma-next/migration-tools/refs";
 import { computeMigrationHash } from "@prisma-next/migration-tools/hash";
 import { writeMigrationTs } from "@prisma-next/migration-tools/migration-ts";
+import { canonicalizeJson } from "@prisma-next/framework-components/utils";
 import { deriveProvidedInvariants } from "@prisma-next/migration-tools/invariants";
 //#region src/utils/contract-space-seed-phase.ts
 /**
@@ -110,6 +110,135 @@ function buildPlaceholderContractDts(spaceId) {
 	].join("\n");
 }
 //#endregion
+//#region src/utils/plan-resolution.ts
+const FULL_HASH_PATTERN = /^sha256:([0-9a-f]{64}|empty)$/;
+function looksLikeFullHash(input) {
+	return FULL_HASH_PATTERN.test(input);
+}
+function graphIsEmpty(bundles) {
+	return bundles.length === 0;
+}
+function getReachableRefs(refs, graph) {
+	return Object.entries(refs).flatMap(([name, entry]) => entry && isGraphNode(entry.hash, graph) ? [{
+		name,
+		hash: entry.hash
+	}] : []).sort((a, b) => a.name.localeCompare(b.name));
+}
+function assertFromIsGraphNode(fromHash, graph, refs, graphTipHash) {
+	try {
+		assertHashIsGraphNode(fromHash, graph);
+	} catch (error) {
+		if (MigrationToolsError.is(error) && error.code === "MIGRATION.HASH_NOT_IN_GRAPH") throw errorPlanForgotTheFlag(fromHash, getReachableRefs(refs, graph), graphTipHash);
+		throw error;
+	}
+}
+async function deserializeSnapshotContract(familyInstance, contract) {
+	try {
+		return ok(familyInstance.deserializeContract(contract));
+	} catch (error) {
+		if (CliStructuredError.is(error)) return notOk(error);
+		return notOk(errorContractValidationFailed(`Ref snapshot contract failed to deserialize: ${error instanceof Error ? error.message : String(error)}`, { where: { path: "ref-snapshot" } }));
+	}
+}
+async function resolveGraphNodeFromBundle(fromHash, bundles, readBundleEndContract, explicitFromLabel) {
+	const matchingBundle = bundles.find((pkg) => pkg.metadata.to === fromHash);
+	if (!matchingBundle) return notOk(errorUnexpected(explicitFromLabel ? `No migration bundle found for --from "${explicitFromLabel}" (resolved hash: ${fromHash})` : `No migration bundle found for graph node ${fromHash}`, {
+		why: `The hash ${fromHash} is a graph node but no on-disk migration package has an end-contract hash matching it.`,
+		fix: "Provide a ref or hash that corresponds to an existing migration package, or run `migration list` to see available migrations."
+	}));
+	try {
+		return ok({
+			kind: "graph-node",
+			fromHash,
+			fromContract: await readBundleEndContract(matchingBundle.dirPath),
+			sourceDir: matchingBundle.dirPath
+		});
+	} catch (error) {
+		if (CliStructuredError.is(error)) return notOk(error);
+		throw error;
+	}
+}
+async function resolveFromRefName(refName, fromHash, input, refs) {
+	const { refsDir, bundles, graph, familyInstance, readBundleEndContract } = input;
+	const empty = graphIsEmpty(bundles);
+	const graphTip = findLatestMigration(graph)?.to ?? null;
+	let snapshot;
+	try {
+		snapshot = await readRefSnapshot(refsDir, refName);
+	} catch (error) {
+		if (MigrationToolsError.is(error)) return notOk(mapMigrationToolsError(error));
+		throw error;
+	}
+	if (snapshot) {
+		const contractResult = await deserializeSnapshotContract(familyInstance, snapshot.contract);
+		if (!contractResult.ok) return contractResult;
+		const fromContract = contractResult.value;
+		const { contractDts, contract: contractJson } = snapshot;
+		if (empty) return ok({
+			kind: "auto-baseline",
+			fromHash,
+			fromContract,
+			contractDts,
+			contractJson
+		});
+		try {
+			assertFromIsGraphNode(fromHash, graph, refs, graphTip);
+		} catch (error) {
+			if (CliStructuredError.is(error)) return notOk(error);
+			throw error;
+		}
+		return ok({
+			kind: "snapshot",
+			fromHash,
+			fromContract,
+			contractDts,
+			contractJson
+		});
+	}
+	if (isGraphNode(fromHash, graph)) return resolveGraphNodeFromBundle(fromHash, bundles, readBundleEndContract);
+	return notOk(errorSnapshotMissing(refName));
+}
+async function resolveFromHashProvenance(fromHash, input, _refs, explicitFromLabel) {
+	const { bundles, graph } = input;
+	if (isGraphNode(fromHash, graph)) return resolveGraphNodeFromBundle(fromHash, bundles, input.readBundleEndContract, explicitFromLabel);
+	throw new Error(`resolveFromHashProvenance: non-graph-node hash ${fromHash} should be refused via looksLikeFullHash before this helper is called`);
+}
+async function resolveFromForPlan(input) {
+	const { optionsFrom, refsDir, graph } = input;
+	let refs;
+	try {
+		refs = await readRefs(refsDir);
+	} catch (error) {
+		if (MigrationToolsError.is(error)) return notOk(mapMigrationToolsError(error));
+		throw error;
+	}
+	if (optionsFrom === void 0) {
+		const dbRef = refs["db"];
+		if (!dbRef) return ok({
+			kind: "greenfield",
+			fromHash: null,
+			fromContract: null
+		});
+		return resolveFromRefName("db", dbRef.hash, input, refs);
+	}
+	const refResult = parseContractRef(optionsFrom, {
+		graph,
+		refs
+	});
+	if (!refResult.ok) {
+		if (looksLikeFullHash(optionsFrom)) {
+			const empty = graphIsEmpty(input.bundles);
+			const graphTip = findLatestMigration(graph)?.to ?? null;
+			if (empty) return notOk(errorSnapshotMissing(optionsFrom, { viaRef: false }));
+			return notOk(errorPlanForgotTheFlag(optionsFrom, getReachableRefs(refs, graph), graphTip));
+		}
+		return notOk(mapRefResolutionError(refResult.failure));
+	}
+	const { hash: fromHash, provenance } = refResult.value;
+	if (provenance.kind === "ref") return resolveFromRefName(provenance.refName, fromHash, input, refs);
+	return resolveFromHashProvenance(fromHash, input, refs, optionsFrom);
+}
+//#endregion
 //#region src/commands/migration-plan.ts
 /**
 * Load a predecessor migration's destination contract from its sibling
@@ -149,6 +278,70 @@ async function readPredecessorEndContract(migrationDir, familyInstance) {
 		throw errorContractValidationFailed(`Predecessor contract at ${path} failed to deserialize: ${error instanceof Error ? error.message : String(error)}`, { where: { path } });
 	}
 }
+async function writeSnapshotContractArtifacts(packageDir, contractJson, contractDts, artifactBasename) {
+	await mkdir(packageDir, { recursive: true });
+	const jsonContent = `${canonicalizeJson(contractJson)}\n`;
+	const dtsContent = contractDts.endsWith("\n") ? contractDts : `${contractDts}\n`;
+	await writeFile(join(packageDir, `${artifactBasename}.json`), jsonContent);
+	await writeFile(join(packageDir, `${artifactBasename}.d.ts`), dtsContent);
+}
+async function writeSnapshotStartContract(packageDir, contractJson, contractDts) {
+	await writeSnapshotContractArtifacts(packageDir, contractJson, contractDts, "start-contract");
+}
+async function runPlannerLeg(planner, migrations, frameworkComponents, contract, fromContract, spaceId) {
+	const fromSchema = migrations.contractToSchema(fromContract, frameworkComponents);
+	const plannerResult = planner.plan({
+		contract,
+		schema: fromSchema,
+		policy: { allowedOperationClasses: [
+			"additive",
+			"widening",
+			"destructive",
+			"data"
+		] },
+		fromContract,
+		frameworkComponents,
+		spaceId
+	});
+	if (plannerResult.kind === "failure") return notOk(errorMigrationPlanningFailed({ conflicts: plannerResult.conflicts }));
+	let plannedOps = [];
+	let hasPlaceholders = false;
+	try {
+		plannedOps = plannerResult.plan.operations;
+		if (plannedOps.length === 0) return notOk(errorMigrationPlanningFailed({ conflicts: [{
+			kind: "unsupportedChange",
+			summary: "Contract changed but planner produced no operations. This indicates unsupported or ignored changes."
+		}] }));
+	} catch (e) {
+		if (CliStructuredError.is(e) && e.domain === "MIG" && e.code === "2001") hasPlaceholders = true;
+		else throw e;
+	}
+	return ok({
+		plannedOps,
+		migrationTsContent: plannerResult.plan.renderTypeScript(),
+		hasPlaceholders
+	});
+}
+async function writePlannedMigrationPackage(packageDir, fromHash, toHash, createdAt, leg) {
+	const opsForWrite = leg.hasPlaceholders ? [] : leg.plannedOps;
+	const metadataWithInvariants = {
+		from: fromHash,
+		to: toHash,
+		hints: {
+			used: [],
+			applied: [],
+			plannerVersion: "2.0.0"
+		},
+		labels: [],
+		providedInvariants: deriveProvidedInvariants(opsForWrite),
+		createdAt: createdAt.toISOString()
+	};
+	await writeMigrationPackage(packageDir, {
+		...metadataWithInvariants,
+		migrationHash: computeMigrationHash(metadataWithInvariants, opsForWrite)
+	}, opsForWrite);
+	await writeMigrationTs(packageDir, leg.migrationTsContent);
+}
 async function executeMigrationPlanCommand(options, flags, ui, startTime) {
 	const config = await loadConfig(options.config);
 	const { configPath, migrationsDir, appMigrationsDir, appMigrationsRelative } = resolveMigrationPaths(options.config, config);
@@ -207,36 +400,47 @@ async function executeMigrationPlanCommand(options, flags, ui, startTime) {
 	const rawStorageHash = toContract.storage?.storageHash;
 	if (typeof rawStorageHash !== "string") return notOk(errorContractValidationFailed("Contract is missing storageHash", { where: { path: contractPathAbsolute } }));
 	const toStorageHash = rawStorageHash;
+	const { refsDir } = resolveMigrationPaths(options.config, config);
 	let fromContract = null;
 	let fromHash = null;
 	let fromContractSourceDir = null;
+	let snapshotStartContract = null;
+	let isAutoBaseline = false;
 	try {
 		const { bundles, graph } = await loadMigrationPackages(appMigrationsDir);
-		if (options.from) {
-			const refs = await readRefs(resolveMigrationPaths(options.config, config).refsDir);
-			const refResult = parseContractRef(options.from, {
-				graph,
-				refs
-			});
-			if (!refResult.ok) return notOk(mapRefResolutionError(refResult.failure));
-			fromHash = refResult.value.hash;
-			const matchingBundle = bundles.find((p) => p.metadata.to === fromHash);
-			if (!matchingBundle) return notOk(errorUnexpected(`No migration bundle found for --from "${options.from}" (resolved hash: ${fromHash})`, {
-				why: `The ref resolved successfully but no on-disk migration package has an end-contract hash matching ${fromHash}.`,
-				fix: "Provide a ref or hash that corresponds to an existing migration package, or run `migration list` to see available migrations."
-			}));
-			fromContractSourceDir = matchingBundle.dirPath;
-			fromContract = await readPredecessorEndContract(fromContractSourceDir, familyInstance);
-		} else {
-			const latestMigration = findLatestMigration(graph);
-			if (latestMigration) {
-				fromHash = latestMigration.to;
-				const leafPkg = bundles.find((p) => p.metadata.migrationHash === latestMigration.migrationHash);
-				if (leafPkg) {
-					fromContractSourceDir = leafPkg.dirPath;
-					fromContract = await readPredecessorEndContract(fromContractSourceDir, familyInstance);
-				}
-			}
+		const resolutionResult = await resolveFromForPlan({
+			optionsFrom: options.from,
+			refsDir,
+			bundles,
+			graph,
+			familyInstance,
+			readBundleEndContract: (migrationDir) => readPredecessorEndContract(migrationDir, familyInstance)
+		});
+		if (!resolutionResult.ok) return notOk(resolutionResult.failure);
+		switch (resolutionResult.value.kind) {
+			case "greenfield": break;
+			case "graph-node":
+				fromHash = resolutionResult.value.fromHash;
+				fromContract = resolutionResult.value.fromContract;
+				fromContractSourceDir = resolutionResult.value.sourceDir;
+				break;
+			case "snapshot":
+				fromHash = resolutionResult.value.fromHash;
+				fromContract = resolutionResult.value.fromContract;
+				snapshotStartContract = {
+					contractJson: resolutionResult.value.contractJson,
+					contractDts: resolutionResult.value.contractDts
+				};
+				break;
+			case "auto-baseline":
+				fromHash = resolutionResult.value.fromHash;
+				fromContract = resolutionResult.value.fromContract;
+				snapshotStartContract = {
+					contractJson: resolutionResult.value.contractJson,
+					contractDts: resolutionResult.value.contractDts
+				};
+				isAutoBaseline = true;
+				break;
 		}
 	} catch (error) {
 		if (MigrationToolsError.is(error)) return notOk(mapMigrationToolsError(error));
@@ -258,7 +462,7 @@ async function executeMigrationPlanCommand(options, flags, ui, startTime) {
 		spaceId: r.spaceId,
 		dirName
 	})));
-	if (fromHash === toStorageHash) return ok({
+	if (fromHash === toStorageHash && !isAutoBaseline) return ok({
 		ok: true,
 		noOp: true,
 		from: fromHash,
@@ -284,58 +488,105 @@ async function executeMigrationPlanCommand(options, flags, ui, startTime) {
 		config.adapter,
 		...config.extensionPacks ?? []
 	]);
-	const timestamp = /* @__PURE__ */ new Date();
-	const packageDir = join(appMigrationsDir, formatMigrationDirName(timestamp, options.name ?? "migration"));
-	const baseMetadata = {
-		from: fromHash,
-		to: toStorageHash,
-		hints: {
-			used: [],
-			applied: [],
-			plannerVersion: "2.0.0"
-		},
-		labels: [],
-		createdAt: timestamp.toISOString()
-	};
 	try {
 		const planner = migrations.createPlanner(familyInstance);
-		const fromSchema = migrations.contractToSchema(fromContract, frameworkComponents);
-		const plannerResult = planner.plan({
-			contract: aggregate.app.contract,
-			schema: fromSchema,
-			policy: { allowedOperationClasses: [
-				"additive",
-				"widening",
-				"destructive",
-				"data"
-			] },
-			fromContract,
-			frameworkComponents,
-			spaceId: aggregate.app.spaceId
-		});
-		if (plannerResult.kind === "failure") return notOk(errorMigrationPlanningFailed({ conflicts: plannerResult.conflicts }));
-		let plannedOps = [];
-		let hasPlaceholders = false;
-		try {
-			plannedOps = plannerResult.plan.operations;
-			if (plannedOps.length === 0) return notOk(errorMigrationPlanningFailed({ conflicts: [{
-				kind: "unsupportedChange",
-				summary: "Contract changed but planner produced no operations. This indicates unsupported or ignored changes."
-			}] }));
-		} catch (e) {
-			if (CliStructuredError.is(e) && e.domain === "MIG" && e.code === "2001") hasPlaceholders = true;
-			else throw e;
+		if (isAutoBaseline && fromHash !== null && fromContract !== null && snapshotStartContract !== null) {
+			const baselineTimestamp = /* @__PURE__ */ new Date();
+			const deltaTimestamp = new Date(baselineTimestamp.getTime() + 6e4);
+			const baselineDirName = formatMigrationDirName(baselineTimestamp, "baseline");
+			const deltaDirName = formatMigrationDirName(deltaTimestamp, options.name ?? "migration");
+			const baselinePackageDir = join(appMigrationsDir, baselineDirName);
+			const deltaPackageDir = join(appMigrationsDir, deltaDirName);
+			const baselineLeg = await runPlannerLeg(planner, migrations, frameworkComponents, fromContract, null, aggregate.app.spaceId);
+			if (!baselineLeg.ok) return notOk(baselineLeg.failure);
+			await writePlannedMigrationPackage(baselinePackageDir, null, fromHash, baselineTimestamp, baselineLeg.value);
+			await writeSnapshotContractArtifacts(baselinePackageDir, snapshotStartContract.contractJson, snapshotStartContract.contractDts, "end-contract");
+			if (fromHash === toStorageHash) {
+				const baselineOps = baselineLeg.value.hasPlaceholders ? [] : baselineLeg.value.plannedOps;
+				if (baselineLeg.value.hasPlaceholders) {
+					const baselineDir = relative(process.cwd(), baselinePackageDir);
+					return ok({
+						ok: true,
+						noOp: false,
+						from: fromHash,
+						to: toStorageHash,
+						dir: baselineDir,
+						baselineDir,
+						operations: [],
+						emittedExtensionDirs,
+						pendingPlaceholders: true,
+						summary: "Planned baseline with placeholder(s) — edit migration.ts then run `node migration.ts` to self-emit",
+						timings: { total: Date.now() - startTime }
+					});
+				}
+				const preview = hasOperationPreview(familyInstance) ? familyInstance.toOperationPreview(baselineOps) : void 0;
+				return ok({
+					ok: true,
+					noOp: false,
+					from: fromHash,
+					to: toStorageHash,
+					baselineDir: relative(process.cwd(), baselinePackageDir),
+					operations: baselineOps.map((op) => ({
+						id: op.id,
+						label: op.label,
+						operationClass: op.operationClass
+					})),
+					emittedExtensionDirs,
+					...preview !== void 0 ? { preview } : {},
+					summary: buildAutoBaselinePlanSummary(0, emittedExtensionDirs.length),
+					timings: { total: Date.now() - startTime }
+				});
+			}
+			const deltaLeg = await runPlannerLeg(planner, migrations, frameworkComponents, aggregate.app.contract, fromContract, aggregate.app.spaceId);
+			if (!deltaLeg.ok) return notOk(deltaLeg.failure);
+			await writePlannedMigrationPackage(deltaPackageDir, fromHash, toStorageHash, deltaTimestamp, deltaLeg.value);
+			const destinationArtifacts = getEmittedArtifactPaths(contractPathAbsolute);
+			await copyFilesWithRename(deltaPackageDir, [{
+				sourcePath: destinationArtifacts.jsonPath,
+				destName: "end-contract.json"
+			}, {
+				sourcePath: destinationArtifacts.dtsPath,
+				destName: "end-contract.d.ts"
+			}]);
+			await writeSnapshotStartContract(deltaPackageDir, snapshotStartContract.contractJson, snapshotStartContract.contractDts);
+			const deltaOps = deltaLeg.value.hasPlaceholders ? [] : deltaLeg.value.plannedOps;
+			if (deltaLeg.value.hasPlaceholders) return ok({
+				ok: true,
+				noOp: false,
+				from: fromHash,
+				to: toStorageHash,
+				dir: relative(process.cwd(), deltaPackageDir),
+				baselineDir: relative(process.cwd(), baselinePackageDir),
+				operations: [],
+				emittedExtensionDirs,
+				pendingPlaceholders: true,
+				summary: "Planned baseline + migration with placeholder(s) — edit migration.ts then run `node migration.ts` to self-emit",
+				timings: { total: Date.now() - startTime }
+			});
+			const preview = hasOperationPreview(familyInstance) ? familyInstance.toOperationPreview(deltaOps) : void 0;
+			return ok({
+				ok: true,
+				noOp: false,
+				from: fromHash,
+				to: toStorageHash,
+				dir: relative(process.cwd(), deltaPackageDir),
+				baselineDir: relative(process.cwd(), baselinePackageDir),
+				operations: deltaOps.map((op) => ({
+					id: op.id,
+					label: op.label,
+					operationClass: op.operationClass
+				})),
+				emittedExtensionDirs,
+				...preview !== void 0 ? { preview } : {},
+				summary: buildAutoBaselinePlanSummary(deltaOps.length, emittedExtensionDirs.length),
+				timings: { total: Date.now() - startTime }
+			});
 		}
-		const migrationTsContent = plannerResult.plan.renderTypeScript();
-		const opsForWrite = hasPlaceholders ? [] : plannedOps;
-		const metadataWithInvariants = {
-			...baseMetadata,
-			providedInvariants: deriveProvidedInvariants(opsForWrite)
-		};
-		await writeMigrationPackage(packageDir, {
-			...metadataWithInvariants,
-			migrationHash: computeMigrationHash(metadataWithInvariants, opsForWrite)
-		}, opsForWrite);
+		const timestamp = /* @__PURE__ */ new Date();
+		const packageDir = join(appMigrationsDir, formatMigrationDirName(timestamp, options.name ?? "migration"));
+		const deltaLeg = await runPlannerLeg(planner, migrations, frameworkComponents, aggregate.app.contract, fromContract, aggregate.app.spaceId);
+		if (!deltaLeg.ok) return notOk(deltaLeg.failure);
+		await writePlannedMigrationPackage(packageDir, fromHash, toStorageHash, timestamp, deltaLeg.value);
 		const destinationArtifacts = getEmittedArtifactPaths(contractPathAbsolute);
 		await copyFilesWithRename(packageDir, [{
 			sourcePath: destinationArtifacts.jsonPath,
@@ -353,9 +604,8 @@ async function executeMigrationPlanCommand(options, flags, ui, startTime) {
 				sourcePath: sourceArtifacts.dtsPath,
 				destName: "start-contract.d.ts"
 			}]);
-		}
-		await writeMigrationTs(packageDir, migrationTsContent);
-		if (hasPlaceholders) return ok({
+		} else if (snapshotStartContract !== null) await writeSnapshotStartContract(packageDir, snapshotStartContract.contractJson, snapshotStartContract.contractDts);
+		if (deltaLeg.value.hasPlaceholders) return ok({
 			ok: true,
 			noOp: false,
 			from: fromHash,
@@ -367,6 +617,7 @@ async function executeMigrationPlanCommand(options, flags, ui, startTime) {
 			summary: "Planned migration with placeholder(s) — edit migration.ts then run `node migration.ts` to self-emit",
 			timings: { total: Date.now() - startTime }
 		});
+		const plannedOps = deltaLeg.value.plannedOps;
 		const preview = hasOperationPreview(familyInstance) ? familyInstance.toOperationPreview(plannedOps) : void 0;
 		return ok({
 			ok: true,
@@ -396,12 +647,9 @@ function createMigrationPlanCommand() {
 	setCommandDescriptions(command, "Plan a migration from contract changes", "Compares the emitted contract against the latest on-disk migration state and\nproduces a new migration package with the required operations. No database\nconnection is needed — this is a fully offline operation.");
 	setCommandExamples(command, ["prisma-next migration plan", "prisma-next migration plan --name add-users-table"]);
 	addGlobalOptions(command).option("--config <path>", "Path to prisma-next.config.ts").option("--name <slug>", "Name slug for the migration directory", "migration").option("--from <contract>", "Starting contract reference (hash, prefix, ref name, migration dir name, <dir>^, or ./path)").action(async (options) => {
-		const flags = parseGlobalFlags(options);
+		const flags = parseGlobalFlagsOrExit(options);
 		const startTime = Date.now();
-		const ui = new TerminalUI({
-			color: flags.color,
-			interactive: flags.interactive
-		});
+		const ui = createTerminalUI(flags);
 		const exitCode = handleResult(await executeMigrationPlanCommand(options, flags, ui, startTime), flags, ui, (planResult) => {
 			if (flags.json) ui.output(JSON.stringify(planResult, null, 2));
 			else if (!flags.quiet) ui.log(formatMigrationPlanOutput(planResult, flags));
@@ -429,6 +677,11 @@ function buildPlanSummary(plannedOpsCount, emittedExtensionDirsCount) {
 	if (emittedExtensionDirsCount === 0) return base;
 	return `${base}; materialised ${emittedExtensionDirsCount} ${emittedExtensionDirsCount === 1 ? "extension-space migration" : "extension-space migrations"}`;
 }
+function buildAutoBaselinePlanSummary(deltaOpsCount, emittedExtensionDirsCount) {
+	const base = `Planned baseline + ${deltaOpsCount} operation(s)`;
+	if (emittedExtensionDirsCount === 0) return base;
+	return `${base}; materialised ${emittedExtensionDirsCount} ${emittedExtensionDirsCount === 1 ? "extension-space migration" : "extension-space migrations"}`;
+}
 function formatMigrationPlanOutput(result, flags) {
 	const lines = [];
 	const useColor = flags.color !== false;
@@ -480,10 +733,12 @@ function formatMigrationPlanOutput(result, flags) {
 	}
 	lines.push(dim_(`from:   ${result.from}`));
 	lines.push(dim_(`to:     ${result.to}`));
+	if (result.baselineDir) lines.push(dim_(`Baseline → ${result.baselineDir}`));
 	if (result.dir) lines.push(dim_(`App space → ${result.dir}`));
 	for (const entry of result.emittedExtensionDirs) lines.push(dim_(`Extension space ${entry.spaceId} → migrations/${entry.spaceId}/${entry.dirName}`));
 	lines.push("");
-	lines.push(`Next: review ${green_(result.dir ?? "<dir>")} if needed, then run ${green_("prisma-next migrate")}.`);
+	const reviewTarget = result.baselineDir !== void 0 && result.dir !== void 0 ? `${result.baselineDir} and ${result.dir}` : result.baselineDir ?? result.dir ?? "<dir>";
+	lines.push(`Next: review ${green_(reviewTarget)} if needed, then run ${green_("prisma-next migrate")}.`);
 	if (result.preview && result.preview.statements.length > 0) {
 		const allSql = result.preview.statements.every((s) => s.language === "sql");
 		lines.push("");
@@ -530,4 +785,4 @@ function resolveBundleByPrefix(bundles, needle) {
 //#endregion
 export { formatMigrationPlanOutput as n, resolveBundleByPrefix as r, createMigrationPlanCommand as t };
 
-//# sourceMappingURL=migration-plan-CHyUlBV0.mjs.map
+//# sourceMappingURL=migration-plan-jdAHg_gK.mjs.map