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

package/dist/migration-plan-Cfz0efEL-DMNFq5b2.mjs

@@ -1,621 +0,0 @@
-import { F as errorUnexpected, I as mapRefResolutionError, N as errorTargetMigrationNotSupported, T as errorPlanForgotTheFlag, j as errorSnapshotMissing, l as errorContractValidationFailed, p as errorFileNotFound, t as CliStructuredError$1, x as errorMigrationPlanningFailed } from "./cli-errors-B4zTLaqQ-CXgjO9t4.mjs";
-import { t as assertFrameworkComponentsCompatible } from "./framework-components-Bau7o1-J-DTp6AUoq.mjs";
-import { t as createProjectSpecifierResolver } from "./project-import-root-B4nM-VWX-D__g0hTb.mjs";
-import { r as getEmittedArtifactPaths } from "./exports-BCLg4CiV-05kuwcb0.mjs";
-import { t as MigrationToolsError } from "./errors-CXbGUWGu-BQi6YS-H.mjs";
-import { a as snapshotsImportPathFrom, o as writeContractSnapshot } from "./contract-snapshot-store-B0G1Fw_F-C4JjmWEA.mjs";
-import { t as computeMigrationHash } from "./hash-DH8hl5Rq-BpM2t3Nu.mjs";
-import { t as deriveProvidedInvariants } from "./invariants-CTHy88OP-DJ-i5yTz.mjs";
-import { i as materialiseExtensionMigrationPackageIfMissing, r as formatMigrationDirName, u as writeMigrationPackage } from "./io-635GlNx1-D94PxRc-.mjs";
-import { r as findLatestMigration } from "./migration-graph-_SJImD5V-D5RCc651.mjs";
-import { c as spaceMigrationDirectory, s as readContractSpaceHeadRef } from "./verify-contract-spaces-DhJTb0zM-_oh6W6lp.mjs";
-import { i as emitContractSpaceArtifacts, o as planAllSpaces } from "./spaces-BG2w0P8d.mjs";
-import { _ as resolveMigrationPaths, g as resolveContractPath, l as getTargetMigrations } from "./command-helpers-BCgwcqTe-lNCtppzM.mjs";
-import { n as isGraphNode, t as assertHashIsGraphNode } from "./graph-membership-BViWUMpP-Cgu4Z2ox.mjs";
-import { a as loadContractSpaceAggregateForCli, d as toExtensionInputs, n as buildContractSpaceAggregate } from "./contract-space-aggregate-loader-fa04OIaL-B7LXHle3.mjs";
-import { n as parseContractRef } from "./ref-resolution-sGcINe7o.mjs";
-import { t as mapContractAtError } from "./contract-at-errors-BSoDI0Hw-BXeUNE3s.mjs";
-import { i as writeMigrationTs } from "./migration-ts-BoHxxGvi.mjs";
-import { join, relative } from "pathe";
-import { castAs } from "@prisma/orm-framework/utils/casts";
-import { readFile } from "node:fs/promises";
-import { createControlStack, hasOperationPreview } from "@prisma/orm-framework/components/control";
-import { notOk, ok } from "@prisma/orm-framework/utils/result";
-//#region ../../../1-framework/3-tooling/cli/dist/migration-plan-Cfz0efEL.mjs
-/**
-* Phase-1 of the two-phase `migration plan` pipeline (sub-spec § 4).
-*
-* For every extension that exposes a `contractSpace`:
-*
-* 1. Read the on-disk head ref (returns `null` on first emit).
-* 2. Write the head contract into the migrations-root snapshot store
-*    (write-if-absent, keyed by hash) and unconditionally re-emit
-*    `refs/head.json`, via {@link emitContractSpaceArtifacts}. The
-*    framework owns `refs/head.json`; re-emit is the contract for that
-*    file. The snapshot itself is only written once per distinct hash.
-* 3. Materialise any descriptor-shipped migration packages not yet on
-*    disk via {@link materialiseExtensionMigrationPackageIfMissing}.
-*    Existing packages are left untouched (by-existence skip).
-*
-* The return value lets the caller render a per-space status line and
-* lets the phase-2 aggregate loader run on a now-consistent disk state
-* (every loaded extension is guaranteed to have its head ref pinned
-* to the descriptor's hash and to ship every package the descriptor
-* declares).
-*
-* Output ordering is deterministic and alphabetical by spaceId (via
-* {@link planAllSpaces}, which also detects duplicate spaceIds). This
-* matches the canonical sort order used by every other aggregate
-* surface (`migrate`, `migration status`, the runner).
-*/
-async function runContractSpaceSeedPhase(inputs) {
-	const planned = planAllSpaces(inputs.extensions.filter((pack) => pack.contractSpace !== void 0).map((pack) => ({
-		spaceId: pack.id,
-		priorContract: null,
-		newContract: pack.contractSpace.contractJson,
-		__pack: pack.contractSpace
-	})), (input) => input.__pack.migrations);
-	const descriptorBySpace = /* @__PURE__ */ new Map();
-	for (const pack of inputs.extensions) if (pack.contractSpace !== void 0) descriptorBySpace.set(pack.id, pack.contractSpace);
-	const seeded = [];
-	for (const space of planned) {
-		const descriptor = descriptorBySpace.get(space.spaceId);
-		if (descriptor === void 0) continue;
-		const priorHash = (await readContractSpaceHeadRef(inputs.migrationsDir, space.spaceId))?.hash ?? null;
-		await emitContractSpaceArtifacts(inputs.migrationsDir, space.spaceId, {
-			contract: descriptor.contractJson,
-			contractDts: buildPlaceholderContractDts(space.spaceId),
-			headRef: {
-				hash: descriptor.headRef.hash,
-				invariants: descriptor.headRef.invariants
-			}
-		});
-		const spaceDir = spaceMigrationDirectory(inputs.migrationsDir, space.spaceId);
-		const newMigrationDirs = [];
-		for (const pkg of space.migrationPackages) {
-			const { written } = await materialiseExtensionMigrationPackageIfMissing(spaceDir, pkg);
-			if (written) newMigrationDirs.push(pkg.dirName);
-		}
-		const action = priorHash !== descriptor.headRef.hash || newMigrationDirs.length > 0 ? "updated" : "unchanged";
-		seeded.push({
-			spaceId: space.spaceId,
-			action,
-			priorHash,
-			newHash: descriptor.headRef.hash,
-			newMigrationDirs
-		});
-	}
-	return { seeded };
-}
-/**
-* Placeholder `.d.ts` content for an extension space's on-disk mirror.
-*
-* Rendering a fully-typed `.d.ts` for an extension contract requires
-* the SQL-family renderer with the codec / typemap registry threaded
-* through; until that integration ships, the on-disk `.d.ts` is a
-* stub `export {};` module that documents how consumers should
-* validate the sibling `contract.json`. The stub typechecks on its
-* own and does not need any TypeScript suppressions.
-*/
-function buildPlaceholderContractDts(spaceId) {
-	return [
-		"/**",
-		` * Placeholder \`.d.ts\` for extension space "${spaceId}".`,
-		" *",
-		" * The framework re-emits this file on every `migration plan` run",
-		" * alongside `contract.json` and `refs/head.json`. A typed `.d.ts`",
-		" * rendering pass for extension contracts is tracked separately;",
-		" * until that ships, consumers should import `contract.json`",
-		" * and pass it through the target descriptor’s `contractSerializer`.",
-		" */",
-		"export {};",
-		""
-	].join("\n");
-}
-const FULL_HASH_PATTERN = /^([0-9a-f]{64}|empty)$/;
-function looksLikeFullHash(input) {
-	return FULL_HASH_PATTERN.test(input);
-}
-function graphIsEmpty(space) {
-	return space.packages.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, { cause: error });
-		throw error;
-	}
-}
-async function resolveContractRef(parsed, space, options) {
-	const { hash, provenance } = parsed;
-	const refName = provenance.kind === "ref" ? provenance.refName : void 0;
-	try {
-		const at = await space.contractAt(hash, refName !== void 0 ? { refName } : void 0);
-		if (at.provenance === "ref") return ok({
-			kind: "ref",
-			hash: at.hash,
-			contract: at.contract,
-			contractJson: at.contractJson,
-			contractDts: at.contractDts
-		});
-		return ok({
-			kind: "graph-node",
-			hash: at.hash,
-			contract: at.contract,
-			contractJson: at.contractJson,
-			contractDts: at.contractDts
-		});
-	} catch (error) {
-		return mapContractAtError(error, options?.artifactRole !== void 0 ? { artifactRole: options.artifactRole } : void 0);
-	}
-}
-async function resolveFromPolicy(parsed, input, refs, explicitFromLabel) {
-	const resolution = await resolveContractRef(parsed, input.space, {
-		...explicitFromLabel !== void 0 ? { explicitLabel: explicitFromLabel } : {},
-		artifactRole: "from"
-	});
-	if (!resolution.ok) return resolution;
-	if (resolution.value.kind === "graph-node") return ok({
-		kind: "graph-node",
-		fromHash: resolution.value.hash,
-		fromContract: resolution.value.contract
-	});
-	const { hash, contract, contractJson, contractDts } = resolution.value;
-	if (graphIsEmpty(input.space)) return ok({
-		kind: "auto-baseline",
-		fromHash: hash,
-		fromContract: contract,
-		contractDts,
-		contractJson
-	});
-	const graph = input.space.graph();
-	const graphTip = findLatestMigration(graph)?.to ?? null;
-	try {
-		assertFromIsGraphNode(hash, graph, refs, graphTip);
-	} catch (error) {
-		if (CliStructuredError$1.is(error)) return notOk(error);
-		throw error;
-	}
-	return ok({
-		kind: "ref",
-		fromHash: hash,
-		fromContract: contract,
-		contractDts,
-		contractJson
-	});
-}
-async function resolveFromForPlan(input) {
-	const { optionsFrom, space } = input;
-	const graph = space.graph();
-	const refs = space.refs;
-	if (optionsFrom === void 0) {
-		const dbRef = refs["db"];
-		if (!dbRef) return ok({
-			kind: "greenfield",
-			fromHash: null,
-			fromContract: null
-		});
-		return resolveFromPolicy({
-			hash: dbRef.hash,
-			provenance: {
-				kind: "ref",
-				refName: "db"
-			}
-		}, input, refs);
-	}
-	const refResult = parseContractRef(optionsFrom, {
-		graph,
-		refs
-	});
-	if (!refResult.ok) {
-		if (looksLikeFullHash(optionsFrom)) {
-			const empty = graphIsEmpty(space);
-			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));
-	}
-	return resolveFromPolicy(refResult.value, input, refs, optionsFrom);
-}
-async function resolveToForPlan(optionsTo, input) {
-	const { space } = input;
-	const graph = space.graph();
-	const refs = space.refs;
-	const refResult = parseContractRef(optionsTo, {
-		graph,
-		refs
-	});
-	if (!refResult.ok) return notOk(mapRefResolutionError(refResult.failure));
-	const resolution = await resolveContractRef(refResult.value, space, {
-		explicitLabel: optionsTo,
-		artifactRole: "to"
-	});
-	if (!resolution.ok) return resolution;
-	const { hash, contract, contractJson, contractDts } = resolution.value;
-	return ok({
-		hash,
-		contract,
-		contractJson,
-		contractDts
-	});
-}
-/**
-* Policy core of `migration plan`: resolves from/to contracts, runs the planner legs, and writes the planned migration packages.
-*/
-function isEnoent(error) {
-	return error instanceof Error && "code" in error && error.code === "ENOENT";
-}
-async function runPlannerLeg(planner, migrations, frameworkComponents, contract, fromContract, spaceId, ownership, snapshotsImportPath, resolveImportSpecifier) {
-	const fromSchema = migrations.contractToSchema(fromContract, frameworkComponents);
-	const plannerResult = planner.plan({
-		contract,
-		schema: fromSchema,
-		policy: { allowedOperationClasses: [
-			"additive",
-			"widening",
-			"destructive",
-			"data"
-		] },
-		fromContract,
-		frameworkComponents,
-		spaceId,
-		ownership,
-		snapshotsImportPath
-	});
-	if (plannerResult.kind === "failure") return notOk(errorMigrationPlanningFailed({ conflicts: castAs(plannerResult.conflicts) }));
-	let plannedOps = [];
-	let hasPlaceholders = false;
-	try {
-		plannedOps = await Promise.all(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$1.is(e) && e.code === "MIGRATION.UNFILLED_PLACEHOLDER") hasPlaceholders = true;
-		else throw e;
-	}
-	return ok({
-		plannedOps,
-		migrationTsContent: plannerResult.plan.renderTypeScript(resolveImportSpecifier),
-		hasPlaceholders
-	});
-}
-async function writePlannedMigrationPackage(packageDir, fromHash, toHash, createdAt, leg) {
-	const opsForWrite = leg.hasPlaceholders ? [] : leg.plannedOps;
-	const metadataWithInvariants = {
-		from: fromHash,
-		to: toHash,
-		providedInvariants: deriveProvidedInvariants(opsForWrite),
-		createdAt: createdAt.toISOString()
-	};
-	await writeMigrationPackage(packageDir, {
-		...metadataWithInvariants,
-		migrationHash: computeMigrationHash(metadataWithInvariants, opsForWrite)
-	}, opsForWrite);
-	await writeMigrationTs(packageDir, leg.migrationTsContent);
-}
-async function executeMigrationPlanCommand(options, startTime, callbacks) {
-	try {
-		return await executeMigrationPlanCommandInner(options, startTime, callbacks);
-	} catch (error) {
-		if (CliStructuredError$1.is(error)) return notOk(error);
-		const message = error instanceof Error ? error.message : String(error);
-		return notOk(errorUnexpected(message, { why: `Unexpected error during migration plan: ${message}` }));
-	}
-}
-async function executeMigrationPlanCommandInner(options, startTime, callbacks) {
-	const config = options.config;
-	const cwd = options.cwd;
-	const { configPath, migrationsDir, appMigrationsDir, appMigrationsRelative } = resolveMigrationPaths(options.configPath, config, cwd);
-	const contractPathAbsolute = resolveContractPath(config);
-	const contractPath = relative(cwd, contractPathAbsolute);
-	callbacks?.onContextResolved?.({
-		configPath,
-		contractPath,
-		appMigrationsRelative
-	});
-	let contractJsonContent;
-	try {
-		contractJsonContent = await readFile(contractPathAbsolute, "utf-8");
-	} catch (error) {
-		if (isEnoent(error)) return notOk(errorFileNotFound(contractPathAbsolute, {
-			why: `Contract file not found at ${contractPathAbsolute}`,
-			fix: `Run \`prisma-next 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)}` }));
-	}
-	const stack = createControlStack(config);
-	const familyInstance = config.family.create(stack);
-	const controlAdapter = config.adapter.create(stack);
-	let toContract;
-	try {
-		toContract = familyInstance.deserializeContract(castAs(JSON.parse(contractJsonContent)));
-	} catch (error) {
-		return notOk(errorContractValidationFailed(`Contract at ${contractPathAbsolute} failed to deserialize: ${error instanceof Error ? error.message : String(error)}`, { where: { path: contractPathAbsolute } }));
-	}
-	const rawStorageHash = toContract.storage?.storageHash;
-	if (typeof rawStorageHash !== "string") return notOk(errorContractValidationFailed("Contract is missing storageHash", { where: { path: contractPathAbsolute } }));
-	let toStorageHash = rawStorageHash;
-	let toArtifacts = null;
-	let fromContract = null;
-	let fromHash = null;
-	let snapshotStartContract = null;
-	let isAutoBaseline = false;
-	const tolerantAggregateResult = await loadContractSpaceAggregateForCli({
-		targetId: config.target.targetId,
-		migrationsDir,
-		appContract: toContract,
-		extensions: config.extensions ?? [],
-		deserializeContract: (json) => familyInstance.deserializeContract(json)
-	});
-	if (!tolerantAggregateResult.ok) return notOk(tolerantAggregateResult.failure);
-	const resolutionSpace = tolerantAggregateResult.value.app;
-	const resolutionResult = await resolveFromForPlan({
-		optionsFrom: options.from,
-		space: resolutionSpace
-	});
-	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;
-			break;
-		case "ref":
-			fromHash = resolutionResult.value.fromHash;
-			fromContract = resolutionResult.value.fromContract;
-			snapshotStartContract = {
-				fromHash: resolutionResult.value.fromHash,
-				contractJson: resolutionResult.value.contractJson,
-				contractDts: resolutionResult.value.contractDts
-			};
-			break;
-		case "auto-baseline":
-			fromHash = resolutionResult.value.fromHash;
-			fromContract = resolutionResult.value.fromContract;
-			snapshotStartContract = {
-				fromHash: resolutionResult.value.fromHash,
-				contractJson: resolutionResult.value.contractJson,
-				contractDts: resolutionResult.value.contractDts
-			};
-			isAutoBaseline = true;
-			break;
-	}
-	if (options.to !== void 0) {
-		const toResolution = await resolveToForPlan(options.to, { space: resolutionSpace });
-		if (!toResolution.ok) return notOk(toResolution.failure);
-		toContract = toResolution.value.contract;
-		toStorageHash = toResolution.value.hash;
-		toArtifacts = {
-			contractJson: toResolution.value.contractJson,
-			contractDts: toResolution.value.contractDts
-		};
-	}
-	const resolveImportSpecifier = createProjectSpecifierResolver(options.configPath);
-	const seedResult = await runContractSpaceSeedPhase({
-		migrationsDir,
-		extensions: toExtensionInputs(config.extensions ?? [])
-	});
-	for (const record of seedResult.seeded) callbacks?.onSeeded?.(record);
-	const emittedExtensionDirs = seedResult.seeded.flatMap((r) => r.newMigrationDirs.map((dirName) => ({
-		spaceId: r.spaceId,
-		dirName
-	})));
-	if (fromHash === toStorageHash && !isAutoBaseline) return ok({
-		ok: true,
-		noOp: true,
-		from: fromHash,
-		to: toStorageHash,
-		operations: [],
-		emittedExtensionDirs,
-		summary: "No changes detected between contracts",
-		timings: { total: Date.now() - startTime }
-	});
-	const migrations = getTargetMigrations(config.target);
-	if (!migrations) return notOk(errorTargetMigrationNotSupported({ why: `Target "${config.target.id}" does not support migrations` }));
-	const aggregateResult = await buildContractSpaceAggregate({
-		targetId: config.target.targetId,
-		migrationsDir,
-		appContract: toContract,
-		extensions: config.extensions ?? [],
-		deserializeContract: (json) => familyInstance.deserializeContract(json)
-	});
-	if (!aggregateResult.ok) return notOk(aggregateResult.failure);
-	const aggregate = aggregateResult.value;
-	const frameworkComponents = assertFrameworkComponentsCompatible(config.family.familyId, config.target.targetId, [
-		config.target,
-		config.adapter,
-		...config.extensions ?? []
-	]);
-	async function writeDestinationSnapshot(destHash) {
-		if (toArtifacts !== null) {
-			await writeContractSnapshot(migrationsDir, destHash, {
-				contractJson: toArtifacts.contractJson,
-				contractDts: toArtifacts.contractDts
-			});
-			return;
-		}
-		const destinationArtifacts = getEmittedArtifactPaths(contractPathAbsolute);
-		const [contractJsonRaw, contractDts] = await Promise.all([readFile(destinationArtifacts.jsonPath, "utf-8"), readFile(destinationArtifacts.dtsPath, "utf-8")]);
-		await writeContractSnapshot(migrationsDir, destHash, {
-			contractJson: castAs(JSON.parse(contractJsonRaw)),
-			contractDts
-		});
-	}
-	try {
-		const planner = migrations.createPlanner(controlAdapter);
-		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, aggregate, snapshotsImportPathFrom(baselinePackageDir, migrationsDir), resolveImportSpecifier);
-			if (!baselineLeg.ok) return notOk(baselineLeg.failure);
-			await writePlannedMigrationPackage(baselinePackageDir, null, fromHash, baselineTimestamp, baselineLeg.value);
-			await writeContractSnapshot(migrationsDir, fromHash, {
-				contractJson: snapshotStartContract.contractJson,
-				contractDts: snapshotStartContract.contractDts
-			});
-			if (fromHash === toStorageHash) {
-				const baselineOps = baselineLeg.value.hasPlaceholders ? [] : baselineLeg.value.plannedOps;
-				if (baselineLeg.value.hasPlaceholders) {
-					const baselineDir = relative(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(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, aggregate, snapshotsImportPathFrom(deltaPackageDir, migrationsDir), resolveImportSpecifier);
-			if (!deltaLeg.ok) return notOk(deltaLeg.failure);
-			await writePlannedMigrationPackage(deltaPackageDir, fromHash, toStorageHash, deltaTimestamp, deltaLeg.value);
-			await writeDestinationSnapshot(toStorageHash);
-			await writeContractSnapshot(migrationsDir, fromHash, {
-				contractJson: snapshotStartContract.contractJson,
-				contractDts: 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(cwd, deltaPackageDir),
-				baselineDir: relative(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(cwd, deltaPackageDir),
-				baselineDir: relative(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 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, aggregate, snapshotsImportPathFrom(packageDir, migrationsDir), resolveImportSpecifier);
-		if (!deltaLeg.ok) return notOk(deltaLeg.failure);
-		await writePlannedMigrationPackage(packageDir, fromHash, toStorageHash, timestamp, deltaLeg.value);
-		await writeDestinationSnapshot(toStorageHash);
-		if (snapshotStartContract !== null) await writeContractSnapshot(migrationsDir, snapshotStartContract.fromHash, {
-			contractJson: snapshotStartContract.contractJson,
-			contractDts: snapshotStartContract.contractDts
-		});
-		if (deltaLeg.value.hasPlaceholders) return ok({
-			ok: true,
-			noOp: false,
-			from: fromHash,
-			to: toStorageHash,
-			dir: relative(cwd, packageDir),
-			operations: [],
-			emittedExtensionDirs,
-			pendingPlaceholders: true,
-			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,
-			noOp: false,
-			from: fromHash,
-			to: toStorageHash,
-			dir: relative(cwd, packageDir),
-			operations: plannedOps.map((op) => ({
-				id: op.id,
-				label: op.label,
-				operationClass: op.operationClass
-			})),
-			emittedExtensionDirs,
-			...preview !== void 0 ? { preview } : {},
-			summary: buildPlanSummary(plannedOps.length, emittedExtensionDirs.length),
-			timings: { total: Date.now() - startTime }
-		});
-	} catch (error) {
-		if (CliStructuredError$1.is(error)) return notOk(error);
-		if (MigrationToolsError.is(error)) return notOk(error);
-		const message = error instanceof Error ? error.message : String(error);
-		return notOk(errorUnexpected(message, { why: `Unexpected error during migration plan: ${message}` }));
-	}
-}
-/**
-* Compose the success-line summary so the cross-space side effect
-* (extension-space migration packages materialised on disk during
-* this `plan` run) is visible in the top line — not just in the
-* step log above it.
-*
-* Example outputs:
-*   - `Planned 3 operation(s)` (app-space-only project)
-*   - `Planned 3 operation(s); materialised 1 extension-space migration` (one extension)
-*   - `Planned 3 operation(s); materialised 2 extension-space migrations` (two extensions)
-*
-* Locks AC3 at the summary-line level: a reader of the success line
-* can tell that something happened beyond the app space.
-*/
-function buildPlanSummary(plannedOpsCount, emittedExtensionDirsCount) {
-	const base = `Planned ${plannedOpsCount} operation(s)`;
-	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"}`;
-}
-//#endregion
-export { runContractSpaceSeedPhase as i, resolveFromForPlan as n, resolveToForPlan as r, executeMigrationPlanCommand as t };
-
-//# sourceMappingURL=migration-plan-Cfz0efEL-DMNFq5b2.mjs.map