prisma-next 0.5.0-dev.9 → 0.5.0

package/dist/migration-plan-C6lVaHsO.mjs

@@ -0,0 +1,554 @@
+import { t as loadConfig } from "./config-loader-B6sJjXTv.mjs";
+import { _ as errorUnexpected, a as errorContractValidationFailed, f as errorMigrationPlanningFailed, h as errorTargetMigrationNotSupported, l as errorFileNotFound, m as errorRuntime, t as CliStructuredError, v as mapMigrationToolsError } from "./cli-errors-D3_sMh2K.mjs";
+import { t as assertFrameworkComponentsCompatible } from "./framework-components-ChqVUxR-.mjs";
+import { a as loadMigrationPackages, c as resolveContractPath, d as setCommandDescriptions, f as setCommandExamples, g as parseGlobalFlags, i as getTargetMigrations, l as resolveMigrationPaths, t as addGlobalOptions, y as formatStyledHeader } from "./command-helpers-BeZHkxV8.mjs";
+import { t as TerminalUI } from "./terminal-ui-C_hFNbAn.mjs";
+import { t as handleResult } from "./result-handler-rmPVKIP2.mjs";
+import { i as toMigratePassInputs, n as toExtensionInputs, r as toExtensionMigrationsInputs } from "./extension-pack-inputs-C7xgE-vv.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 { APP_SPACE_ID, 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 { detectSpaceContractDrift, emitContractSpaceArtefacts, planAllSpaces, readContractSpaceHeadRef, spaceMigrationDirectory } from "@prisma-next/migration-tools/spaces";
+import { MigrationToolsError } from "@prisma-next/migration-tools/errors";
+import { computeMigrationHash } from "@prisma-next/migration-tools/hash";
+import { writeMigrationTs } from "@prisma-next/migration-tools/migration-ts";
+import { deriveProvidedInvariants } from "@prisma-next/migration-tools/invariants";
+//#region src/utils/contract-space-extension-migrations-pass.ts
+/**
+* Materialise an extension's pre-built migration packages onto disk
+* under `migrations/<spaceId>/<dirName>/` for every package that does
+* not yet exist there.
+*
+* Helper-location pattern — the per-space "planner" for extension
+* spaces is a no-op that just returns the descriptor's `migrations`
+* verbatim; the value `planAllSpaces` brings to this consumer site is
+* **deterministic ordering** (alphabetical by spaceId) and
+* **duplicate-spaceId detection**. The actual write is performed via
+* `materialiseMigrationPackage` per package.
+*
+* Idempotent: an existing `migrations/<spaceId>/<dirName>/` is left
+* untouched and reported in `result.skipped` — the helper never
+* overwrites authored migration content, ensuring re-running
+* `migrate` does not corrupt or churn extension migration packages.
+*
+* Per-space artefacts (`contract.json`, `contract.d.ts`,
+* `refs/head.json`) are emitted by
+* {@link import('./contract-space-migrate-pass').runContractSpaceMigratePass}
+* separately — they cover the head-pointer side of the ledger. This
+* helper covers the migration-graph side.
+*/
+async function runContractSpaceExtensionMigrationsPass(inputs) {
+	const planned = planAllSpaces(inputs.extensionPacks.filter((pack) => pack.contractSpace !== void 0).map((pack) => ({
+		spaceId: pack.id,
+		priorContract: null,
+		newContract: pack.contractSpace.contractJson,
+		__migrations: pack.contractSpace.migrations
+	})), (input) => input.__migrations);
+	const emitted = [];
+	const skipped = [];
+	for (const space of planned) {
+		const spaceDir = spaceMigrationDirectory(inputs.migrationsDir, space.spaceId);
+		for (const pkg of space.migrationPackages) {
+			const { written } = await materialiseExtensionMigrationPackageIfMissing(spaceDir, pkg);
+			if (written) emitted.push({
+				spaceId: space.spaceId,
+				dirName: pkg.dirName
+			});
+			else skipped.push({
+				spaceId: space.spaceId,
+				dirName: pkg.dirName
+			});
+		}
+	}
+	return {
+		emitted,
+		skipped
+	};
+}
+//#endregion
+//#region src/utils/contract-space-migrate-pass.ts
+/**
+* Run drift detection + on-disk artefact emission for every loaded
+* extension space at `migrate` time.
+*
+* Per sub-spec § 3:
+*
+* - For each declared extension that exposes a `contractSpace`:
+*   - Read the on-disk head hash from `migrations/<spaceId>/refs/head.json`
+*     (returns `null` on first emit).
+*   - Compare against the descriptor's `headRef.hash` via
+*     `detectSpaceContractDrift`. The `kind` discriminant decides whether
+*     the user sees a warning (`drift`), a no-op silent emit (`firstEmit`,
+*     `noDrift`), or nothing at all.
+*   - Always re-emit the on-disk artefacts (`contract.json`, `contract.d.ts`,
+*     `refs/head.json`). The framework owns these files and the helper is
+*     idempotent.
+*
+* Drift warnings are returned to the caller for formatting (TerminalUI,
+* structured-output envelope, etc.) — the helper does not print directly,
+* keeping it framework-neutral and unit-testable.
+*
+* Extension migration packages (the descriptor's pre-canned `migrations`
+* array → `migrations/<spaceId>/<dirName>/`) are intentionally not
+* materialised here — that interaction will be wired in a follow-on round
+* once the runner-side single-tx slice (sub-spec § 6) is in place.
+* On-disk artefacts are sufficient to lock the drift-warning behaviour
+* and the always-on re-emit AC for R2.
+*
+* @see specs/framework-mechanism.spec.md § 3 — Drift detection (T1.9).
+*/
+async function runContractSpaceMigratePass(inputs) {
+	const drifts = [];
+	const emittedSpaceIds = [];
+	for (const pack of inputs.extensionPacks) {
+		if (pack.contractSpace === void 0) continue;
+		const { contractJson, headRef } = pack.contractSpace;
+		const onDiskHeadRef = await readContractSpaceHeadRef(inputs.migrationsDir, pack.id);
+		const drift = detectSpaceContractDrift(pack.id, {
+			descriptorHash: headRef.hash,
+			priorHeadHash: onDiskHeadRef?.hash ?? null
+		});
+		drifts.push(drift);
+		await emitContractSpaceArtefacts(inputs.migrationsDir, pack.id, {
+			contract: contractJson,
+			contractDts: buildPlaceholderContractDts(pack.id),
+			headRef: {
+				hash: headRef.hash,
+				invariants: headRef.invariants
+			}
+		});
+		emittedSpaceIds.push(pack.id);
+	}
+	return {
+		drifts,
+		emittedSpaceIds
+	};
+}
+/**
+* Format the user-facing drift warning for a single space. Callers
+* funnel this through their preferred output channel (TerminalUI line,
+* structured-output envelope `warnings[]`, etc.).
+*
+* Locks AM7 — drift warning surfaces the extension name and the diff
+* direction (descriptor → on-disk head).
+*/
+function formatContractSpaceDriftWarning(drift) {
+	if (drift.kind !== "drift") throw new Error(`formatContractSpaceDriftWarning called with non-drift result: ${drift.kind}`);
+	return `Contract-space drift detected for "${drift.spaceId}": descriptor hash ${drift.descriptorHash} differs from on-disk head hash ${drift.priorHeadHash ?? "<none>"}. The on-disk artefacts under migrations/${drift.spaceId}/ will be refreshed to match the descriptor.`;
+}
+/**
+* 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; that integration is tracked under sub-spec Open Question 3
+* (see `projects/extension-contract-spaces/specs/framework-mechanism.spec.md`).
+*
+* Until that ships, the on-disk `.d.ts` is a `@ts-nocheck` stub. The
+* spec gap closing alongside the typed renderer is **AC2 / AC14**
+* (byte-equivalence of per-space artefacts under `migrate`):
+* a placeholder cannot be byte-equal to a fully-rendered `.d.ts` from
+* the same descriptor, so AC2 / AC14 are PARTIAL today and become
+* fully-PASS once OQ3 closes.
+*
+* Scheduled to close in **M3** (cipherstash editor tooling) — that's
+* the milestone where the typed renderer gets its first real
+* extension-space consumer and the byte-equivalence guarantee is
+* practically required.
+*/
+function buildPlaceholderContractDts(spaceId) {
+	return [
+		"// @ts-nocheck",
+		"/**",
+		` * Placeholder \`.d.ts\` for extension space "${spaceId}".`,
+		" *",
+		" * The framework re-emits this file on every `migrate` run alongside",
+		" * `contract.json` and `refs/head.json`. A typed `.d.ts` rendering",
+		" * pass for extension contracts is tracked under the project's open",
+		" * questions; until that ships, consumers should import",
+		" * `contract.json` directly with `validateContract<…>(…)`.",
+		" */",
+		"export {};",
+		""
+	].join("\n");
+}
+//#endregion
+//#region src/commands/migration-plan.ts
+async function executeMigrationPlanCommand(options, flags, ui, startTime) {
+	const config = await loadConfig(options.config);
+	const { configPath, migrationsDir, appMigrationsDir, appMigrationsRelative } = resolveMigrationPaths(options.config, config);
+	const contractPathAbsolute = resolveContractPath(config);
+	const contractPath = relative(process.cwd(), contractPathAbsolute);
+	if (!flags.json && !flags.quiet) {
+		const details = [
+			{
+				label: "config",
+				value: configPath
+			},
+			{
+				label: "contract",
+				value: contractPath
+			},
+			{
+				label: "migrations",
+				value: appMigrationsRelative
+			}
+		];
+		if (options.from) details.push({
+			label: "from",
+			value: options.from
+		});
+		if (options.name) details.push({
+			label: "name",
+			value: options.name
+		});
+		const header = formatStyledHeader({
+			command: "migration plan",
+			description: "Plan a migration from contract changes",
+			url: "https://pris.ly/migration-plan",
+			details,
+			flags
+		});
+		ui.stderr(header);
+	}
+	let contractJsonContent;
+	try {
+		contractJsonContent = await readFile(contractPathAbsolute, "utf-8");
+	} catch (error) {
+		if (error instanceof Error && error.code === "ENOENT") 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)}` }));
+	}
+	let toContractJson;
+	try {
+		toContractJson = JSON.parse(contractJsonContent);
+	} catch (error) {
+		return notOk(errorContractValidationFailed(`Contract JSON is invalid: ${error instanceof Error ? error.message : String(error)}`, { where: { path: contractPathAbsolute } }));
+	}
+	const rawStorageHash = toContractJson.storage?.storageHash;
+	if (typeof rawStorageHash !== "string") return notOk(errorContractValidationFailed("Contract is missing storageHash", { where: { path: contractPathAbsolute } }));
+	const toStorageHash = rawStorageHash;
+	let fromContract = null;
+	let fromHash = null;
+	let fromContractSourceDir = null;
+	try {
+		const { bundles, graph } = await loadMigrationPackages(appMigrationsDir);
+		if (options.from) {
+			const resolved = resolveBundleByPrefix(bundles, options.from);
+			if (!resolved.ok) {
+				const f = resolved.failure;
+				return notOk(f.reason === "ambiguous" ? errorRuntime("Multiple matching migrations found", {
+					why: `Prefix "${options.from}" matches ${f.count} migrations in ${appMigrationsRelative}`,
+					fix: "Provide a longer prefix to disambiguate, or omit --from to use the latest migration target."
+				}) : errorRuntime("Starting contract not found", {
+					why: `No migration with to hash matching "${options.from}" exists in ${appMigrationsRelative}`,
+					fix: "Check that the --from hash matches a known migration target hash, or omit --from to use the latest migration target."
+				}));
+			}
+			fromHash = resolved.value.metadata.to;
+			fromContract = resolved.value.metadata.toContract;
+			fromContractSourceDir = resolved.value.dirPath;
+		} else {
+			const latestMigration = findLatestMigration(graph);
+			if (latestMigration) {
+				fromHash = latestMigration.to;
+				const leafPkg = bundles.find((p) => p.metadata.migrationHash === latestMigration.migrationHash);
+				if (leafPkg) {
+					fromContract = leafPkg.metadata.toContract;
+					fromContractSourceDir = leafPkg.dirPath;
+				}
+			}
+		}
+	} catch (error) {
+		if (MigrationToolsError.is(error)) return notOk(mapMigrationToolsError(error));
+		const message = error instanceof Error ? error.message : String(error);
+		return notOk(errorUnexpected(message, { why: `Unexpected error while loading migrations: ${message}` }));
+	}
+	const canonicalExtensionInputs = toExtensionInputs(config.extensionPacks ?? []);
+	const migratePass = await runContractSpaceMigratePass({
+		migrationsDir,
+		extensionPacks: toMigratePassInputs(canonicalExtensionInputs)
+	});
+	if (!flags.json && !flags.quiet) {
+		for (const drift of migratePass.drifts) if (drift.kind === "drift") ui.stderr(formatContractSpaceDriftWarning(drift));
+	}
+	const extensionMigrationsResult = await runContractSpaceExtensionMigrationsPass({
+		migrationsDir,
+		extensionPacks: toExtensionMigrationsInputs(canonicalExtensionInputs)
+	});
+	if (!flags.json && !flags.quiet) for (const entry of extensionMigrationsResult.emitted) ui.step(`Emitted ${entry.spaceId}/${entry.dirName}`);
+	if (fromHash === toStorageHash) return ok({
+		ok: true,
+		noOp: true,
+		from: fromHash,
+		to: toStorageHash,
+		operations: [],
+		emittedExtensionDirs: extensionMigrationsResult.emitted,
+		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 frameworkComponents = assertFrameworkComponentsCompatible(config.family.familyId, config.target.targetId, [
+		config.target,
+		config.adapter,
+		...config.extensionPacks ?? []
+	]);
+	const timestamp = /* @__PURE__ */ new Date();
+	const packageDir = join(appMigrationsDir, formatMigrationDirName(timestamp, options.name ?? "migration"));
+	const baseMetadata = {
+		from: fromHash,
+		to: toStorageHash,
+		fromContract,
+		toContract: toContractJson,
+		hints: {
+			used: [],
+			applied: [],
+			plannerVersion: "2.0.0"
+		},
+		labels: [],
+		createdAt: timestamp.toISOString()
+	};
+	try {
+		const stack = createControlStack(config);
+		const familyInstance = config.family.create(stack);
+		const planner = migrations.createPlanner(familyInstance);
+		const fromSchema = migrations.contractToSchema(fromContract, frameworkComponents);
+		const plannerResult = planner.plan({
+			contract: toContractJson,
+			schema: fromSchema,
+			policy: { allowedOperationClasses: [
+				"additive",
+				"widening",
+				"destructive",
+				"data"
+			] },
+			fromContract,
+			frameworkComponents,
+			spaceId: APP_SPACE_ID
+		});
+		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;
+		}
+		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 destinationArtifacts = getEmittedArtifactPaths(contractPathAbsolute);
+		await copyFilesWithRename(packageDir, [{
+			sourcePath: destinationArtifacts.jsonPath,
+			destName: "end-contract.json"
+		}, {
+			sourcePath: destinationArtifacts.dtsPath,
+			destName: "end-contract.d.ts"
+		}]);
+		if (fromContractSourceDir !== null) {
+			const sourceArtifacts = getEmittedArtifactPaths(join(fromContractSourceDir, "end-contract.json"));
+			await copyFilesWithRename(packageDir, [{
+				sourcePath: sourceArtifacts.jsonPath,
+				destName: "start-contract.json"
+			}, {
+				sourcePath: sourceArtifacts.dtsPath,
+				destName: "start-contract.d.ts"
+			}]);
+		}
+		await writeMigrationTs(packageDir, migrationTsContent);
+		if (hasPlaceholders) return ok({
+			ok: true,
+			noOp: false,
+			from: fromHash,
+			to: toStorageHash,
+			dir: relative(process.cwd(), packageDir),
+			operations: [],
+			emittedExtensionDirs: extensionMigrationsResult.emitted,
+			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 preview = hasOperationPreview(familyInstance) ? familyInstance.toOperationPreview(plannedOps) : void 0;
+		return ok({
+			ok: true,
+			noOp: false,
+			from: fromHash,
+			to: toStorageHash,
+			dir: relative(process.cwd(), packageDir),
+			operations: plannedOps.map((op) => ({
+				id: op.id,
+				label: op.label,
+				operationClass: op.operationClass
+			})),
+			emittedExtensionDirs: extensionMigrationsResult.emitted,
+			...preview !== void 0 ? { preview } : {},
+			summary: buildPlanSummary(plannedOps.length, extensionMigrationsResult.emitted.length),
+			timings: { total: Date.now() - startTime }
+		});
+	} catch (error) {
+		if (CliStructuredError.is(error)) return notOk(error);
+		if (MigrationToolsError.is(error)) return notOk(mapMigrationToolsError(error));
+		const message = error instanceof Error ? error.message : String(error);
+		return notOk(errorUnexpected(message, { why: `Unexpected error during migration plan: ${message}` }));
+	}
+}
+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 <hash>", "Explicit starting contract hash (overrides latest migration target)").action(async (options) => {
+		const flags = parseGlobalFlags(options);
+		const startTime = Date.now();
+		const ui = new TerminalUI({
+			color: flags.color,
+			interactive: flags.interactive
+		});
+		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));
+		});
+		process.exit(exitCode);
+	});
+	return command;
+}
+/**
+* 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 formatMigrationPlanOutput(result, flags) {
+	const lines = [];
+	const useColor = flags.color !== false;
+	const green_ = useColor ? (s) => `\x1b[32m${s}\x1b[0m` : (s) => s;
+	const yellow_ = useColor ? (s) => `\x1b[33m${s}\x1b[0m` : (s) => s;
+	const dim_ = useColor ? (s) => `\x1b[2m${s}\x1b[0m` : (s) => s;
+	function appendEmittedExtensions() {
+		if (result.emittedExtensionDirs.length === 0) return;
+		lines.push("");
+		lines.push(dim_("Emitted extension migrations:"));
+		for (const entry of result.emittedExtensionDirs) lines.push(dim_(`  ${entry.spaceId} → migrations/${entry.spaceId}/${entry.dirName}`));
+		lines.push("");
+		lines.push(`Next: review the extension migrations above, then run ${green_("prisma-next migration apply")}.`);
+	}
+	if (result.noOp) {
+		lines.push(`${green_("✔")} No changes detected`);
+		lines.push(dim_(`  from: ${result.from}`));
+		lines.push(dim_(`  to:   ${result.to}`));
+		appendEmittedExtensions();
+		return lines.join("\n");
+	}
+	if (result.pendingPlaceholders) {
+		lines.push(`${yellow_("⚠")} ${result.summary}`);
+		lines.push("");
+		lines.push(dim_(`from: ${result.from}`));
+		lines.push(dim_(`to:   ${result.to}`));
+		if (result.dir) lines.push(dim_(`dir:  ${result.dir}`));
+		lines.push("");
+		lines.push("Open migration.ts and replace each `placeholder(...)` call with your actual query.");
+		lines.push(`Then run: ${green_(`node ${result.dir ?? "<dir>"}/migration.ts`)}`);
+		appendEmittedExtensions();
+		return lines.join("\n");
+	}
+	lines.push(`${green_("✔")} ${result.summary}`);
+	lines.push("");
+	if (result.operations.length > 0) {
+		lines.push(dim_("│"));
+		for (let i = 0; i < result.operations.length; i++) {
+			const op = result.operations[i];
+			const treeChar = i === result.operations.length - 1 ? "└" : "├";
+			const destructiveMarker = op.operationClass === "destructive" ? ` ${yellow_("(destructive)")}` : "";
+			lines.push(`${dim_(treeChar)}─ ${op.label}${destructiveMarker}`);
+		}
+		if (result.operations.some((op) => op.operationClass === "destructive")) {
+			lines.push("");
+			lines.push(`${yellow_("⚠")} This migration contains destructive operations that may cause data loss.`);
+		}
+		lines.push("");
+	}
+	lines.push(dim_(`from:   ${result.from}`));
+	lines.push(dim_(`to:     ${result.to}`));
+	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 migration apply")}.`);
+	if (result.preview && result.preview.statements.length > 0) {
+		const allSql = result.preview.statements.every((s) => s.language === "sql");
+		lines.push("");
+		lines.push(dim_(allSql ? "DDL preview" : "Operation preview"));
+		lines.push("");
+		for (const statement of result.preview.statements) {
+			const trimmed = statement.text.trim();
+			if (!trimmed) continue;
+			const line = statement.language === "sql" && !trimmed.endsWith(";") ? `${trimmed};` : trimmed;
+			lines.push(line);
+		}
+	}
+	if (flags.verbose && result.timings) {
+		lines.push("");
+		lines.push(dim_(`Total time: ${result.timings.total}ms`));
+	}
+	return lines.join("\n");
+}
+/**
+* Resolve a migration package by **target contract hash** (`metadata.to`)
+* using exact match or prefix match.
+*
+* Note: matches `metadata.to` (the contract hash this migration produces),
+* not `metadata.migrationHash` (the package's content-addressed identity).
+* Tries exact match first, then prefix match (auto-prepending `sha256:` when
+* the needle omits the scheme). Returns the matched package on success, or a
+* discriminated failure indicating whether the prefix was ambiguous or simply
+* not found.
+*
+* @internal Exported for testing only.
+*/
+function resolveBundleByPrefix(bundles, needle) {
+	const exact = bundles.find((p) => p.metadata.to === needle);
+	if (exact) return ok(exact);
+	const prefixWithScheme = needle.startsWith("sha256:") ? needle : `sha256:${needle}`;
+	const candidates = bundles.filter((p) => p.metadata.to.startsWith(prefixWithScheme));
+	if (candidates.length === 1) return ok(candidates[0]);
+	if (candidates.length > 1) return notOk({
+		reason: "ambiguous",
+		count: candidates.length
+	});
+	return notOk({ reason: "not-found" });
+}
+//#endregion
+export { formatMigrationPlanOutput as n, resolveBundleByPrefix as r, createMigrationPlanCommand as t };
+
+//# sourceMappingURL=migration-plan-C6lVaHsO.mjs.map