prisma-next 0.11.0-dev.9 → 0.12.0-dev.1

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

@@ -1,22 +1,21 @@
 import { t as loadConfig } from "./config-loader-B6sJjXTv.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 { $ as errorTargetMigrationNotSupported, A as CliStructuredError, G as errorPlanForgotTheFlag, P as errorContractValidationFailed, R as errorFileNotFound, T as formatStyledHeader, U as errorMigrationPlanningFailed, Z as errorSnapshotMissing, _ as createTerminalUI, g as parseGlobalFlagsOrExit, l as setCommandDescriptions, nt as mapMigrationToolsError, o as resolveContractPath, r as getTargetMigrations, rt as mapRefResolutionError, s as resolveMigrationPaths, t as addGlobalOptions, tt as errorUnexpected, u as setCommandExamples, y as handleResult } from "./command-helpers-Bbw1GbwL.mjs";
+import { t as assertFrameworkComponentsCompatible } from "./framework-components-fYXjz_in.mjs";
+import { n as toExtensionInputs } from "./extension-pack-inputs-IDvjRCi3.mjs";
+import { a as loadContractSpaceAggregateForCli, n as buildContractSpaceAggregate } from "./contract-space-aggregate-loader-DvZwdkrr.mjs";
+import { t as mapContractAtError } from "./contract-at-errors-BxP-TOMl.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 { 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 { 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 { assertHashIsGraphNode, findLatestMigration, isGraphNode } from "@prisma-next/migration-tools/migration-graph";
 import { parseContractRef } from "@prisma-next/migration-tools/ref-resolution";
 import { computeMigrationHash } from "@prisma-next/migration-tools/hash";
+import { copyFilesWithRename, formatMigrationDirName, materialiseExtensionMigrationPackageIfMissing, writeMigrationPackage } from "@prisma-next/migration-tools/io";
 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";
@@ -115,8 +114,8 @@ 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 graphIsEmpty(member) {
+	return member.packages.length === 0;
 }
 function getReachableRefs(refs, graph) {
 	return Object.entries(refs).flatMap(([name, entry]) => entry && isGraphNode(entry.hash, graph) ? [{
@@ -132,86 +131,70 @@ function assertFromIsGraphNode(fromHash, graph, refs, 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."
-	}));
+async function resolveContractRef(parsed, member, options) {
+	const { hash, provenance } = parsed;
+	const refName = provenance.kind === "ref" ? provenance.refName : void 0;
 	try {
+		const at = await member.contractAt(hash, refName !== void 0 ? { refName } : void 0);
+		if (at.provenance === "snapshot") return ok({
+			kind: "snapshot",
+			hash: at.hash,
+			contract: at.contract,
+			contractJson: at.contractJson,
+			contractDts: at.contractDts
+		});
 		return ok({
 			kind: "graph-node",
-			fromHash,
-			fromContract: await readBundleEndContract(matchingBundle.dirPath),
-			sourceDir: matchingBundle.dirPath
+			hash: at.hash,
+			contract: at.contract,
+			contractJson: at.contractJson,
+			contractDts: at.contractDts,
+			sourceDir: at.sourceDir
 		});
 	} catch (error) {
-		if (CliStructuredError.is(error)) return notOk(error);
-		throw error;
+		return mapContractAtError(error, options?.artifactRole !== void 0 ? { artifactRole: options.artifactRole } : void 0);
 	}
 }
-async function resolveFromRefName(refName, fromHash, input, refs) {
-	const { refsDir, bundles, graph, familyInstance, readBundleEndContract } = input;
-	const empty = graphIsEmpty(bundles);
+async function resolveFromPolicy(parsed, input, refs, explicitFromLabel) {
+	const resolution = await resolveContractRef(parsed, input.member, {
+		...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,
+		sourceDir: resolution.value.sourceDir
+	});
+	const { hash, contract, contractJson, contractDts } = resolution.value;
+	if (graphIsEmpty(input.member)) return ok({
+		kind: "auto-baseline",
+		fromHash: hash,
+		fromContract: contract,
+		contractDts,
+		contractJson
+	});
+	const graph = input.member.graph();
 	const graphTip = findLatestMigration(graph)?.to ?? null;
-	let snapshot;
 	try {
-		snapshot = await readRefSnapshot(refsDir, refName);
+		assertFromIsGraphNode(hash, graph, refs, graphTip);
 	} catch (error) {
-		if (MigrationToolsError.is(error)) return notOk(mapMigrationToolsError(error));
+		if (CliStructuredError.is(error)) return notOk(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`);
+	return ok({
+		kind: "snapshot",
+		fromHash: hash,
+		fromContract: contract,
+		contractDts,
+		contractJson
+	});
 }
 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;
-	}
+	const { optionsFrom, member } = input;
+	const graph = member.graph();
+	const refs = member.refs;
 	if (optionsFrom === void 0) {
 		const dbRef = refs["db"];
 		if (!dbRef) return ok({
@@ -219,7 +202,13 @@ async function resolveFromForPlan(input) {
 			fromHash: null,
 			fromContract: null
 		});
-		return resolveFromRefName("db", dbRef.hash, input, refs);
+		return resolveFromPolicy({
+			hash: dbRef.hash,
+			provenance: {
+				kind: "ref",
+				refName: "db"
+			}
+		}, input, refs);
 	}
 	const refResult = parseContractRef(optionsFrom, {
 		graph,
@@ -227,57 +216,39 @@ async function resolveFromForPlan(input) {
 	});
 	if (!refResult.ok) {
 		if (looksLikeFullHash(optionsFrom)) {
-			const empty = graphIsEmpty(input.bundles);
+			const empty = graphIsEmpty(member);
 			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);
+	return resolveFromPolicy(refResult.value, input, refs, optionsFrom);
+}
+async function resolveToForPlan(optionsTo, input) {
+	const { member } = input;
+	const graph = member.graph();
+	const refs = member.refs;
+	const refResult = parseContractRef(optionsTo, {
+		graph,
+		refs
+	});
+	if (!refResult.ok) return notOk(mapRefResolutionError(refResult.failure));
+	const resolution = await resolveContractRef(refResult.value, member, {
+		explicitLabel: optionsTo,
+		artifactRole: "to"
+	});
+	if (!resolution.ok) return resolution;
+	const { hash, contract, contractJson, contractDts } = resolution.value;
+	return ok({
+		hash,
+		contract,
+		contractJson,
+		contractDts
+	});
 }
 //#endregion
 //#region src/commands/migration-plan.ts
-/**
-* Load a predecessor migration's destination contract from its sibling
-* `end-contract.json` on disk and route it through the family's
-* `ContractSerializer` (via `deserializeContract`) so the in-memory shape
-* is the hydrated `Contract` every other caller sees. Bypassing this
-* seam was the root cause of TML-2536: a raw `JSON.parse(...) as Contract`
-* here let polymorphic `storage.types` entries reach the planner without
-* the `kind` discriminator the planner dispatches on.
-*
-* Throws `CliStructuredError` with:
-*   - `errorFileNotFound` when the sibling file is missing — the user
-*     has likely deleted or never authored the snapshot, and the
-*     message names the file and points them at re-emitting from the
-*     source.
-*   - `errorContractValidationFailed` when the JSON parses but the
-*     family deserializer rejects it (legacy untagged shape, structural
-*     mismatch, etc.) — the message names the predecessor's path so
-*     the operator can locate the bad snapshot.
-*/
-async function readPredecessorEndContract(migrationDir, familyInstance) {
-	const path = join(migrationDir, "end-contract.json");
-	let raw;
-	try {
-		raw = await readFile(path, "utf-8");
-	} catch (error) {
-		if (error instanceof Error && error.code === "ENOENT") throw errorFileNotFound(path, {
-			why: `Predecessor migration is missing its destination contract snapshot at ${path}`,
-			fix: "Re-emit the predecessor migration (`prisma-next migration plan` from its source) so its sibling `end-contract.json` is restored, then re-run this command."
-		});
-		throw error;
-	}
-	try {
-		return familyInstance.deserializeContract(JSON.parse(raw));
-	} catch (error) {
-		if (CliStructuredError.is(error)) throw error;
-		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`;
@@ -327,12 +298,6 @@ async function writePlannedMigrationPackage(packageDir, fromHash, toHash, create
 	const metadataWithInvariants = {
 		from: fromHash,
 		to: toHash,
-		hints: {
-			used: [],
-			applied: [],
-			plannerVersion: "2.0.0"
-		},
-		labels: [],
 		providedInvariants: deriveProvidedInvariants(opsForWrite),
 		createdAt: createdAt.toISOString()
 	};
@@ -366,6 +331,10 @@ async function executeMigrationPlanCommand(options, flags, ui, startTime) {
 			label: "from",
 			value: options.from
 		});
+		if (options.to) details.push({
+			label: "to",
+			value: options.to
+		});
 		if (options.name) details.push({
 			label: "name",
 			value: options.name
@@ -399,54 +368,61 @@ 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 toStorageHash = rawStorageHash;
+	let toArtifacts = null;
 	let fromContract = null;
 	let fromHash = null;
 	let fromContractSourceDir = null;
 	let snapshotStartContract = null;
 	let isAutoBaseline = false;
-	try {
-		const { bundles, graph } = await loadMigrationPackages(appMigrationsDir);
-		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));
-		if (CliStructuredError.is(error)) return notOk(error);
-		const message = error instanceof Error ? error.message : String(error);
-		return notOk(errorUnexpected(message, { why: `Unexpected error while loading migrations: ${message}` }));
+	const tolerantAggregateResult = await loadContractSpaceAggregateForCli({
+		targetId: config.target.targetId,
+		migrationsDir,
+		appContract: toContract,
+		extensionPacks: config.extensionPacks ?? [],
+		deserializeContract: (json) => familyInstance.deserializeContract(json)
+	});
+	if (!tolerantAggregateResult.ok) return notOk(tolerantAggregateResult.failure);
+	const resolutionMember = tolerantAggregateResult.value.app;
+	const resolutionResult = await resolveFromForPlan({
+		optionsFrom: options.from,
+		member: resolutionMember
+	});
+	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;
+	}
+	if (options.to !== void 0) {
+		const toResolution = await resolveToForPlan(options.to, { member: resolutionMember });
+		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 seedResult = await runContractSpaceSeedPhase({
 		migrationsDir,
@@ -488,6 +464,20 @@ async function executeMigrationPlanCommand(options, flags, ui, startTime) {
 		config.adapter,
 		...config.extensionPacks ?? []
 	]);
+	async function writeDestinationEndContract(packageDir) {
+		if (toArtifacts !== null) {
+			await writeSnapshotContractArtifacts(packageDir, toArtifacts.contractJson, toArtifacts.contractDts, "end-contract");
+			return;
+		}
+		const destinationArtifacts = getEmittedArtifactPaths(contractPathAbsolute);
+		await copyFilesWithRename(packageDir, [{
+			sourcePath: destinationArtifacts.jsonPath,
+			destName: "end-contract.json"
+		}, {
+			sourcePath: destinationArtifacts.dtsPath,
+			destName: "end-contract.d.ts"
+		}]);
+	}
 	try {
 		const planner = migrations.createPlanner(familyInstance);
 		if (isAutoBaseline && fromHash !== null && fromContract !== null && snapshotStartContract !== null) {
@@ -537,17 +527,10 @@ async function executeMigrationPlanCommand(options, flags, ui, startTime) {
 					timings: { total: Date.now() - startTime }
 				});
 			}
-			const deltaLeg = await runPlannerLeg(planner, migrations, frameworkComponents, aggregate.app.contract, fromContract, aggregate.app.spaceId);
+			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 writeDestinationEndContract(deltaPackageDir);
 			await writeSnapshotStartContract(deltaPackageDir, snapshotStartContract.contractJson, snapshotStartContract.contractDts);
 			const deltaOps = deltaLeg.value.hasPlaceholders ? [] : deltaLeg.value.plannedOps;
 			if (deltaLeg.value.hasPlaceholders) return ok({
@@ -584,17 +567,10 @@ async function executeMigrationPlanCommand(options, flags, ui, 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);
+		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,
-			destName: "end-contract.json"
-		}, {
-			sourcePath: destinationArtifacts.dtsPath,
-			destName: "end-contract.d.ts"
-		}]);
+		await writeDestinationEndContract(packageDir);
 		if (fromContractSourceDir !== null) {
 			const sourceArtifacts = getEmittedArtifactPaths(join(fromContractSourceDir, "end-contract.json"));
 			await copyFilesWithRename(packageDir, [{
@@ -645,8 +621,12 @@ async function executeMigrationPlanCommand(options, flags, ui, startTime) {
 function createMigrationPlanCommand() {
 	const command = new Command("plan");
 	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) => {
+	setCommandExamples(command, [
+		"prisma-next migration plan",
+		"prisma-next migration plan --name add-users-table",
+		"prisma-next migration plan --to <migration-dir>^ --name rollback"
+	]);
+	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)").option("--to <contract>", "Destination contract reference (hash, prefix, ref name, migration dir name, <dir>^, or ./path); defaults to the emitted contract").action(async (options) => {
 		const flags = parseGlobalFlagsOrExit(options);
 		const startTime = Date.now();
 		const ui = createTerminalUI(flags);
@@ -785,4 +765,4 @@ function resolveBundleByPrefix(bundles, needle) {
 //#endregion
 export { formatMigrationPlanOutput as n, resolveBundleByPrefix as r, createMigrationPlanCommand as t };
 
-//# sourceMappingURL=migration-plan-jdAHg_gK.mjs.map
+//# sourceMappingURL=migration-plan-9DJ7q7_z.mjs.map