@prisma/orm-toolchain 0.16.0-dev.36

package/dist/migration-check-CcG-fB8r-CDs5C9vt.mjs

@@ -0,0 +1,597 @@
+import { t as MigrationToolsError } from "./errors-IpZm1Skp-BH495dRd.mjs";
+import { r as readContractSnapshotJson, t as contractSnapshotDir } from "./contract-snapshot-store-sf5nP4mb-MLpG-ihh.mjs";
+import { n as verifyMigrationHash } from "./hash-DH8hl5Rq-BpM2t3Nu.mjs";
+import "./constants-CM-w38DQ-Cz_EXbOc.mjs";
+import { a as isValidSpaceId, c as spaceMigrationDirectory, l as spaceRefsDirectory, o as listContractSpaceDirectories } from "./verify-contract-spaces-BZDcJsuA-De8v4Z4T.mjs";
+import { A as errorSpaceNotFound, I as formatErrorJson, L as formatErrorOutput, Q as mapRefResolutionError, W as formatStyledHeader, _ as errorInvalidSpaceId, at as resolveMigrationPaths, c as errorAmbiguousMigrationRef, ct as setCommandExamples, it as resolveContractPath, lt as setCommandSeeAlso, o as createTerminalUI, r as addGlobalOptions, st as setCommandDescriptions, tt as parseGlobalFlagsOrExit } from "./command-helpers-CAoXqAY9-DWUBcTXM.mjs";
+import { r as loadConfig } from "./exports-Dl2aGAk7.mjs";
+import { s as loadContractSpaceAggregate } from "./aggregate-B4mhR4Sk.mjs";
+import { n as buildReadAggregate, s as toDeclaredExtensionsFromRaw } from "./contract-space-aggregate-loader-CFH-336b-BhAyRQEL.mjs";
+import { r as parseMigrationRef } from "./ref-resolution-BjJBWPjX.mjs";
+import { i as resolveTargetPathAcrossSpaces, n as looksLikePath, r as resolveAppTargetPath, t as findPackageByDirPath } from "./migration-path-target-D3Sj55PI-BICblCuk.mjs";
+import { ifDefined } from "@prisma/orm-framework/utils/defined";
+import { notOk, ok } from "@prisma/orm-framework/utils/result";
+import { join, relative } from "pathe";
+import { readFile } from "node:fs/promises";
+import { createControlStack } from "@prisma/orm-framework/components/control";
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { Command } from "commander";
+//#region ../../../1-framework/3-tooling/cli/dist/migration-check-CcG-fB8r.mjs
+function migrationPathRelative$1(dirPath) {
+	return relative(process.cwd(), dirPath);
+}
+function migrationFileRelative$1(dirPath, fileName) {
+	return join(migrationPathRelative$1(dirPath), fileName);
+}
+/**
+* Map one {@link IntegrityViolation} onto a `migration check` failure row.
+* Sole catalogue mapping from integrity violations to `MIGRATION.CHECK_*` codes.
+*/
+function integrityViolationToCheckFailure(violation, migrationsDir) {
+	const spaceRelative = (spaceId) => migrationPathRelative$1(join(migrationsDir, spaceId));
+	const packageRelative = (spaceId, dirName) => migrationPathRelative$1(join(migrationsDir, spaceId, dirName));
+	const refRelative = (spaceId, refName) => migrationPathRelative$1(join(migrationsDir, spaceId, "refs", `${refName}.json`));
+	switch (violation.kind) {
+		case "hashMismatch": return {
+			space: violation.spaceId,
+			code: "MIGRATION.CHECK_HASH_MISMATCH",
+			where: migrationFileRelative$1(join(migrationsDir, violation.spaceId, violation.dirName), "migration.json"),
+			why: `Stored hash ${violation.stored} does not match recomputed hash ${violation.computed}`,
+			fix: "Re-emit the migration package or restore from version control."
+		};
+		case "providedInvariantsMismatch": return {
+			space: violation.spaceId,
+			code: "MIGRATION.CHECK_PROVIDED_INVARIANTS_MISMATCH",
+			where: packageRelative(violation.spaceId, violation.dirName),
+			why: `Migration "${violation.dirName}" providedInvariants in migration.json disagrees with ops.json.`,
+			fix: "Re-emit the migration package so migration.json and ops.json agree."
+		};
+		case "packageUnloadable": return {
+			space: violation.spaceId,
+			code: "MIGRATION.CHECK_PACKAGE_UNLOADABLE",
+			where: packageRelative(violation.spaceId, violation.dirName),
+			why: `Migration "${violation.dirName}" could not be loaded: ${violation.detail}`,
+			fix: "Re-emit the migration package or restore from version control."
+		};
+		case "sameSourceAndTarget": return {
+			space: violation.spaceId,
+			code: "MIGRATION.CHECK_NOOP_SELF_EDGE",
+			where: packageRelative(violation.spaceId, violation.dirName),
+			why: `Migration "${violation.dirName}" in space "${violation.spaceId}" has source equal to target (${violation.hash}) with no data invariant — a true no-op self-edge.`,
+			fix: "Add a data operation if this self-edge was meant to carry a data invariant, or delete the migration if it is a true no-op."
+		};
+		case "orphanSpaceDir": return {
+			space: violation.spaceId,
+			code: "MIGRATION.CHECK_ORPHAN_SPACE_DIR",
+			where: spaceRelative(violation.spaceId),
+			why: `Contract-space directory "${violation.spaceId}" exists on disk but no extension declares it.`,
+			fix: "Remove the orphan directory, or declare the extension in `extensions`."
+		};
+		case "declaredButUnmigrated": return {
+			space: violation.spaceId,
+			code: "MIGRATION.CHECK_DECLARED_BUT_UNMIGRATED",
+			where: spaceRelative(violation.spaceId),
+			why: `Extension "${violation.spaceId}" is declared in \`extensions\` but has no on-disk migrations directory.`,
+			fix: "Re-emit the extension contract-space artefacts with `prisma-next contract emit` and migration planning, or remove the extension from `extensions` if it is unused."
+		};
+		case "headRefMissing": return {
+			space: violation.spaceId,
+			code: "MIGRATION.CHECK_HEAD_REF_MISSING",
+			where: refRelative(violation.spaceId, "head"),
+			why: `Head ref \`refs/head.json\` is missing for contract space "${violation.spaceId}".`,
+			fix: "Re-emit the contract-space migrations and head ref artefacts, or restore `refs/head.json` from version control."
+		};
+		case "headRefNotInGraph": return {
+			space: violation.spaceId,
+			code: "MIGRATION.CHECK_HEAD_REF_NOT_IN_GRAPH",
+			where: refRelative(violation.spaceId, "head"),
+			why: `Head ref ${violation.hash} for contract space "${violation.spaceId}" is not present in its migration graph.`,
+			fix: "Re-emit the contract space migrations, or restore the missing migration package."
+		};
+		case "refUnreadable": return {
+			space: violation.spaceId,
+			code: "MIGRATION.CHECK_REF_UNREADABLE",
+			where: refRelative(violation.spaceId, violation.refName),
+			why: `Ref "${violation.refName}" for contract space "${violation.spaceId}" is unreadable: ${violation.detail}`,
+			fix: "Repair or remove the corrupt ref file."
+		};
+		case "targetMismatch": return {
+			space: violation.spaceId,
+			code: "MIGRATION.CHECK_TARGET_MISMATCH",
+			where: spaceRelative(violation.spaceId),
+			why: `Contract space "${violation.spaceId}" targets "${violation.actual}" but the project targets "${violation.expected}".`,
+			fix: "Update the extension to target the configured database, or change the project target."
+		};
+		case "disjointness": return {
+			space: "app",
+			code: "MIGRATION.CHECK_SPACE_DISJOINTNESS_VIOLATION",
+			where: migrationPathRelative$1(migrationsDir),
+			why: `Storage element "${violation.element}" is claimed by multiple contract spaces: ${violation.claimedBy.join(", ")}.`,
+			fix: "Update the contracts so each storage element is owned by exactly one contract space."
+		};
+		case "contractUnreadable": return {
+			space: violation.spaceId,
+			code: "MIGRATION.CHECK_CONTRACT_UNREADABLE",
+			where: migrationFileRelative$1(join(migrationsDir, violation.spaceId), "contract.json"),
+			why: `Contract for space "${violation.spaceId}" is unreadable: ${violation.detail}`,
+			fix: "Re-emit the extension contract artefacts, or fix the descriptor producing the invalid contract."
+		};
+		case "duplicateMigrationHash": return {
+			space: violation.spaceId,
+			code: "MIGRATION.CHECK_DUPLICATE_MIGRATION_HASH",
+			where: spaceRelative(violation.spaceId),
+			why: `Multiple migrations in space "${violation.spaceId}" share migrationHash "${violation.migrationHash}" (${violation.dirNames.join(", ")}).`,
+			fix: "Re-emit one of the conflicting packages so each migrationHash is unique."
+		};
+	}
+}
+function migrationPathRelative(dirPath) {
+	return relative(process.cwd(), dirPath);
+}
+function migrationFileRelative(dirPath, fileName) {
+	return join(migrationPathRelative(dirPath), fileName);
+}
+function checkFileExists(spaceId, dirPath, dirName, fileName) {
+	if (!existsSync(join(dirPath, fileName))) return {
+		space: spaceId,
+		code: "MIGRATION.CHECK_FILE_MISSING",
+		where: migrationFileRelative(dirPath, fileName),
+		why: `${fileName} is missing from ${dirName}`,
+		fix: "Re-emit the migration package or restore from version control."
+	};
+	return null;
+}
+/**
+* Snapshot-store consistency check for one migration package (D6.5):
+* absent store entry is not an issue (runner independence, ADR 199 — a
+* package dir with only `migration.json` + `ops.json` is legitimate); a
+* present entry whose inner `storage.storageHash` disagrees with
+* `pkg.metadata.to` is `MIGRATION.CHECK_SNAPSHOT_HASH_MISMATCH`; an unparseable store
+* entry (or a malformed `to`) is `MIGRATION.CHECK_SNAPSHOT_UNPARSEABLE`.
+*/
+async function checkSnapshotConsistency(spaceId, pkg, migrationsDir) {
+	let snapshotDir;
+	try {
+		snapshotDir = contractSnapshotDir(migrationsDir, pkg.metadata.to);
+	} catch {
+		return {
+			space: spaceId,
+			code: "MIGRATION.CHECK_SNAPSHOT_UNPARSEABLE",
+			where: migrationPathRelative(pkg.dirPath),
+			why: `Migration "${pkg.dirName}" declares to="${pkg.metadata.to}", which is not a well-formed contract snapshot hash.`,
+			fix: "Re-emit the migration package so migration.json declares a valid 64-hex to-hash."
+		};
+	}
+	let raw;
+	try {
+		raw = await readContractSnapshotJson(migrationsDir, pkg.metadata.to);
+	} catch (error) {
+		if (MigrationToolsError.is(error) && error.code === "MIGRATION.CONTRACT_SNAPSHOT_MISSING") return null;
+		return {
+			space: spaceId,
+			code: "MIGRATION.CHECK_SNAPSHOT_UNPARSEABLE",
+			where: migrationPathRelative(pkg.dirPath),
+			why: `Migration "${pkg.dirName}" has an unparseable contract snapshot at ${snapshotDir}/contract.json.`,
+			fix: "Restore migrations/snapshots/ from version control, or re-run the command that produced this migration to regenerate its snapshot."
+		};
+	}
+	const snapshotHash = (raw !== null && typeof raw === "object" ? raw : {})["storage"]?.["storageHash"];
+	if (typeof snapshotHash === "string" && snapshotHash !== pkg.metadata.to) return {
+		space: spaceId,
+		code: "MIGRATION.CHECK_SNAPSHOT_HASH_MISMATCH",
+		where: migrationPathRelative(pkg.dirPath),
+		why: `Migration "${pkg.dirName}" declares to=${pkg.metadata.to} but its contract snapshot has storageHash=${snapshotHash}`,
+		fix: "Re-emit the migration package so migration.json and its contract snapshot agree."
+	};
+	return null;
+}
+/**
+* Project the loaded {@link ContractSpaceAggregate} into the
+* {@link CheckSpace} rows the multi-space check iterates — one per on-disk
+* contract-space directory, in the aggregate's `app`-first ordering. Mirrors
+* `migration list`'s `migrationSpaceListEntriesFromAggregate`: space
+* membership matches the on-disk directories, package / ref / graph data come
+* from `aggregate.space(id)`.
+*/
+async function enumerateCheckSpaces(aggregate, projectMigrationsDir) {
+	const candidateDirs = await listContractSpaceDirectories(projectMigrationsDir);
+	const onDiskSpaceIds = new Set(candidateDirs.filter(isValidSpaceId));
+	const spaces = [];
+	for (const space of aggregate.spaces()) {
+		const spaceId = space.spaceId;
+		if (!isValidSpaceId(spaceId)) continue;
+		if (!onDiskSpaceIds.has(spaceId)) continue;
+		const migrationsDir = spaceMigrationDirectory(projectMigrationsDir, spaceId);
+		spaces.push({
+			spaceId,
+			packages: space.packages,
+			refs: space.refs,
+			graph: space.graph(),
+			migrationsDir,
+			refsDir: spaceRefsDirectory(migrationsDir),
+			projectMigrationsDir
+		});
+	}
+	return spaces;
+}
+function checkManifestFilesPresent(space) {
+	if (!existsSync(space.migrationsDir)) return [];
+	const loadedDirNames = new Set(space.packages.map((p) => p.dirName));
+	const failures = [];
+	let entries;
+	try {
+		entries = readdirSync(space.migrationsDir);
+	} catch {
+		return failures;
+	}
+	for (const entry of entries) {
+		if (entry.startsWith(".") || entry.startsWith("_") || entry === "refs") continue;
+		const entryPath = join(space.migrationsDir, entry);
+		try {
+			if (!statSync(entryPath).isDirectory()) continue;
+		} catch {
+			continue;
+		}
+		if (!loadedDirNames.has(entry)) for (const f of ["migration.json", "ops.json"]) {
+			const fail = checkFileExists(space.spaceId, entryPath, entry, f);
+			if (fail) failures.push(fail);
+		}
+	}
+	return failures;
+}
+function checkReachability(space) {
+	const allToHashes = new Set(space.packages.map((p) => p.metadata.to));
+	const failures = [];
+	for (const pkg of space.packages) if (!(pkg.metadata.from === null || allToHashes.has(pkg.metadata.from) || pkg.metadata.from === "empty")) failures.push({
+		space: space.spaceId,
+		code: "MIGRATION.CHECK_UNREACHABLE_MIGRATION",
+		where: migrationPathRelative(pkg.dirPath),
+		why: `Migration "${pkg.dirName}" starts from ${pkg.metadata.from} which no other migration produces`,
+		fix: "This migration is unreachable in the graph. Delete it or re-emit a connecting migration."
+	});
+	return failures;
+}
+function checkDanglingRefs(space) {
+	const failures = [];
+	for (const [name, entry] of Object.entries(space.refs)) if (!space.graph.nodes.has(entry.hash)) failures.push({
+		space: space.spaceId,
+		code: "MIGRATION.CHECK_DANGLING_REF",
+		where: relative(process.cwd(), join(space.refsDir, `${name}.json`)),
+		why: `Ref "${name}" points at ${entry.hash} which does not exist in the migration graph`,
+		fix: `Update the ref with \`prisma-next ref set ${name} <valid-hash>\` or delete it.`
+	});
+	return failures;
+}
+async function checkSpace(space) {
+	const snapshotFailures = await Promise.all(space.packages.map((pkg) => checkSnapshotConsistency(space.spaceId, pkg, space.projectMigrationsDir)));
+	return [
+		...checkManifestFilesPresent(space),
+		...snapshotFailures.filter((f) => f !== null),
+		...checkReachability(space),
+		...checkDanglingRefs(space)
+	];
+}
+/**
+* Policy core of the holistic `migration check`: validates `--space`,
+* narrows the pre-enumerated spaces, and runs the per-space explicit graph
+* checks (file-existence, snapshot consistency, reachability, dangling
+* refs), aggregating every failure into one {@link MigrationCheckResult}.
+*
+* `--space` validation mirrors `migration list`: an invalid id →
+* {@link errorInvalidSpaceId}; an id with no on-disk space →
+* {@link errorSpaceNotFound}. Both map to exit `PRECONDITION` at the shell.
+* Aggregate-integrity violations (which already span every space) are folded
+* in by the caller, not here.
+*/
+async function runMigrationCheck(inputs) {
+	const { spaces, spaceFilter } = inputs;
+	if (spaceFilter !== void 0 && !isValidSpaceId(spaceFilter)) return notOk(errorInvalidSpaceId(spaceFilter));
+	if (spaceFilter !== void 0 && !spaces.some((s) => s.spaceId === spaceFilter)) return notOk(errorSpaceNotFound(spaceFilter, spaces.map((s) => s.spaceId).sort()));
+	const scopedSpaces = spaceFilter !== void 0 ? spaces.filter((s) => s.spaceId === spaceFilter) : spaces;
+	const failures = (await Promise.all(scopedSpaces.map(checkSpace))).flat();
+	if (failures.length === 0) return ok({
+		ok: true,
+		failures: [],
+		summary: "All checks passed"
+	});
+	return ok({
+		ok: false,
+		failures,
+		summary: `${failures.length} integrity failure(s)`
+	});
+}
+async function loadAggregateIntegrityViolations(config, migrationsDir) {
+	try {
+		const contractJsonContent = await readFile(resolveContractPath(config), "utf-8");
+		const familyInstance = config.family.create(createControlStack(config));
+		const declaredExtensions = toDeclaredExtensionsFromRaw(config.extensions ?? []);
+		const parsedAppContract = JSON.parse(contractJsonContent);
+		return (await loadContractSpaceAggregate({
+			migrationsDir,
+			deserializeContract: (json) => familyInstance.deserializeContract(json),
+			appContract: familyInstance.deserializeContract(parsedAppContract)
+		})).checkIntegrity({
+			declaredExtensions,
+			checkContracts: true
+		});
+	} catch {
+		return [];
+	}
+}
+async function executeMigrationCheckCommand(target, options, flags, ui) {
+	const config = await loadConfig(options.config);
+	const { configPath, migrationsDir, appMigrationsDir, appMigrationsRelative } = resolveMigrationPaths(options.config, config);
+	if (!flags.json && !flags.quiet) {
+		const details = [{
+			label: "config",
+			value: configPath
+		}, {
+			label: "migrations",
+			value: appMigrationsRelative
+		}];
+		if (target) details.push({
+			label: "target",
+			value: target
+		});
+		const header = formatStyledHeader({
+			command: "migration check",
+			description: "Verify artifact and graph integrity",
+			details,
+			flags
+		});
+		ui.stderr(header);
+	}
+	const loadedAggregate = await buildReadAggregate(config, { migrationsDir });
+	if (!loadedAggregate.ok) return {
+		error: loadedAggregate.failure,
+		exitCode: 2
+	};
+	const spaces = await enumerateCheckSpaces(loadedAggregate.value.aggregate, migrationsDir);
+	if (target) return await checkSingleTarget(target, {
+		spaces,
+		...options.space !== void 0 ? { spaceFilter: options.space } : {},
+		appMigrationsDir,
+		appMigrationsRelative
+	});
+	const checkResult = await runMigrationCheck({
+		spaces,
+		...options.space !== void 0 ? { spaceFilter: options.space } : {}
+	});
+	if (!checkResult.ok) return {
+		error: checkResult.failure,
+		exitCode: 2
+	};
+	const failures = [...checkResult.value.failures];
+	const allViolations = await loadAggregateIntegrityViolations(config, migrationsDir);
+	const scopedViolations = options.space === void 0 ? allViolations : allViolations.filter((v) => v.kind !== "disjointness" && v.spaceId === options.space);
+	for (const violation of scopedViolations) failures.push(integrityViolationToCheckFailure(violation, migrationsDir));
+	if (failures.length === 0) return {
+		result: {
+			ok: true,
+			failures: [],
+			summary: "All checks passed"
+		},
+		exitCode: 0
+	};
+	return {
+		result: {
+			ok: false,
+			failures,
+			summary: `${failures.length} integrity failure(s)`
+		},
+		exitCode: 4
+	};
+}
+/**
+* Ranks ref-resolution failure kinds by how informative they are, so a
+* single-target check surfaces the most useful failure across spaces instead of
+* whichever space failed first. `not-found` (the input matched nothing here)
+* says the least; a malformed input, a wrong grammar, or an in-space ambiguity
+* all say more.
+*/
+function refFailureSpecificity(error) {
+	switch (error.kind) {
+		case "wrong-grammar": return 3;
+		case "ambiguous": return 2;
+		case "invalid-format": return 1;
+		case "not-found": return 0;
+	}
+}
+/**
+* Single-target (`check <ref/path>`) mode — resolves a migration reference
+* across all contract spaces (or the one space narrowed by `--space <id>`).
+*
+* Resolution:
+*   - filesystem path → find the owning space by checking which space's
+*     `migrationsDir` contains the resolved path; falls back to app-relative
+*     validation when the path is outside every space dir.
+*   - ref → `parseMigrationRef` against each in-scope space; collect every
+*     (space, package) hit; 0 hits = not-found, 1 = check it, >1 = ambiguity
+*     error (qualify with `--space`).
+*
+* `--space <id>` is validated the same way the holistic path does it:
+* invalid id → `errorInvalidSpaceId`; no on-disk space → `errorSpaceNotFound`.
+*/
+async function checkSingleTarget(target, inputs) {
+	const { spaces, spaceFilter, appMigrationsDir, appMigrationsRelative } = inputs;
+	if (spaceFilter !== void 0 && !isValidSpaceId(spaceFilter)) return {
+		error: errorInvalidSpaceId(spaceFilter),
+		exitCode: 2
+	};
+	if (spaceFilter !== void 0 && !spaces.some((s) => s.spaceId === spaceFilter)) return {
+		error: errorSpaceNotFound(spaceFilter, spaces.map((s) => s.spaceId).sort()),
+		exitCode: 2
+	};
+	const scopedSpaces = spaceFilter !== void 0 ? spaces.filter((s) => s.spaceId === spaceFilter) : spaces;
+	let matchedSpace;
+	let matchedPkg;
+	if (looksLikePath(target)) {
+		const resolvedPath = resolveTargetPathAcrossSpaces(target, scopedSpaces);
+		if (resolvedPath !== null) for (const space of scopedSpaces) {
+			const found = findPackageByDirPath(space.packages, resolvedPath);
+			if (found) {
+				matchedSpace = space;
+				matchedPkg = found;
+				break;
+			}
+		}
+		else {
+			const resolved = resolveAppTargetPath(target, appMigrationsDir, appMigrationsRelative);
+			if (!resolved.ok) return {
+				error: resolved.failure,
+				exitCode: 2
+			};
+			const appSpace = scopedSpaces.find((s) => s.spaceId === "app");
+			if (appSpace) {
+				matchedSpace = appSpace;
+				matchedPkg = findPackageByDirPath(appSpace.packages, resolved.value);
+			}
+		}
+	} else {
+		const hits = [];
+		let bestParseFailure;
+		for (const space of scopedSpaces) {
+			const migResult = parseMigrationRef(target, {
+				graph: space.graph,
+				refs: space.refs
+			});
+			if (!migResult.ok) {
+				if (bestParseFailure === void 0 || refFailureSpecificity(migResult.failure) > refFailureSpecificity(bestParseFailure)) bestParseFailure = migResult.failure;
+				continue;
+			}
+			const pkg = space.packages.find((p) => p.metadata.migrationHash === migResult.value.migrationHash);
+			if (pkg) hits.push({
+				space,
+				pkg
+			});
+		}
+		if (hits.length > 1) return {
+			error: errorAmbiguousMigrationRef(target, hits.map((h) => h.space.spaceId)),
+			exitCode: 2
+		};
+		if (hits.length === 1) {
+			matchedSpace = hits[0].space;
+			matchedPkg = hits[0].pkg;
+		} else if (bestParseFailure !== void 0) return {
+			error: mapRefResolutionError(bestParseFailure),
+			exitCode: 2
+		};
+	}
+	if (!matchedPkg || !matchedSpace) return {
+		result: {
+			ok: false,
+			failures: [],
+			summary: `Migration package for "${target}" not found on disk`
+		},
+		exitCode: 2
+	};
+	const failures = [...checkManifestFilesPresent(matchedSpace)];
+	for (const f of ["migration.json", "ops.json"]) {
+		const fail = checkFileExists(matchedSpace.spaceId, matchedPkg.dirPath, matchedPkg.dirName, f);
+		if (fail) failures.push(fail);
+	}
+	const verification = verifyMigrationHash(matchedPkg);
+	if (!verification.ok) failures.push({
+		space: matchedSpace.spaceId,
+		code: "MIGRATION.CHECK_HASH_MISMATCH",
+		where: migrationFileRelative(matchedPkg.dirPath, "migration.json"),
+		why: `Stored hash ${verification.storedHash} does not match recomputed hash ${verification.computedHash}`,
+		fix: "Re-emit the migration package or restore from version control."
+	});
+	const snapshotFailure = await checkSnapshotConsistency(matchedSpace.spaceId, matchedPkg, matchedSpace.projectMigrationsDir);
+	if (snapshotFailure) failures.push(snapshotFailure);
+	const resolvedSpaceId = matchedSpace.spaceId !== "app" ? matchedSpace.spaceId : void 0;
+	if (failures.length === 0) return {
+		result: {
+			ok: true,
+			failures: [],
+			summary: "All checks passed"
+		},
+		exitCode: 0,
+		...ifDefined("resolvedSpaceId", resolvedSpaceId)
+	};
+	return {
+		result: {
+			ok: false,
+			failures,
+			summary: `${failures.length} integrity failure(s)`
+		},
+		exitCode: 4,
+		...ifDefined("resolvedSpaceId", resolvedSpaceId)
+	};
+}
+function createMigrationCheckCommand() {
+	const command = new Command("check");
+	setCommandDescriptions(command, "Verify artifact and graph integrity", "Validates that on-disk migration packages are internally consistent\n(hashes match, manifests are complete) and that the graph is well-formed\n(edges connect, refs point at valid nodes). The whole-graph check spans\nevery contract space by default; pass --space <id> to narrow to one. A\nmigration reference checks a single package, resolved across all contract\nspaces (narrow with --space; an ambiguous reference is a precondition failure).\nOffline — does not consult the database.\nExit codes: 0 = all checks passed, 2 = precondition failed\n(unresolved target or unknown --space), 4 = integrity failure(s) found.");
+	setCommandExamples(command, [
+		"prisma-next migration check",
+		"prisma-next migration check --space app",
+		"prisma-next migration check 20260101-add-users",
+		"prisma-next migration check 20260101-add-users --space app",
+		"prisma-next migration check --json"
+	]);
+	setCommandSeeAlso(command, [
+		{
+			verb: "migration status",
+			oneLiner: "Show migration path and pending status"
+		},
+		{
+			verb: "migration list",
+			oneLiner: "List on-disk migrations"
+		},
+		{
+			verb: "migration graph",
+			oneLiner: "Show the migration graph topology"
+		},
+		{
+			verb: "migration show",
+			oneLiner: "Display migration package contents"
+		}
+	]);
+	command.exitOverride();
+	addGlobalOptions(command).argument("[target]", "Migration reference: directory name, hash/prefix, ref, or path").option("--config <path>", "Path to prisma-next.config.ts").option("--space <id>", "Narrow output to a single contract space").action(async (target, options) => {
+		const flags = parseGlobalFlagsOrExit(options);
+		const ui = createTerminalUI(flags);
+		let outcome;
+		try {
+			outcome = await executeMigrationCheckCommand(target, options, flags, ui);
+		} catch (error) {
+			outcome = {
+				result: {
+					ok: false,
+					failures: [],
+					summary: error instanceof Error ? error.message : String(error)
+				},
+				exitCode: 2
+			};
+		}
+		if (outcome.error) {
+			const envelope = outcome.error.toEnvelope();
+			if (flags.json) ui.output(formatErrorJson(envelope));
+			else if (!flags.quiet) ui.error(formatErrorOutput(envelope, flags));
+			process.exit(outcome.exitCode);
+		}
+		const result = outcome.result ?? {
+			ok: false,
+			failures: [],
+			summary: "No check result produced"
+		};
+		if (flags.json) ui.output(JSON.stringify(result, null, 2));
+		else if (!flags.quiet) if (result.ok) {
+			const spaceSuffix = outcome.resolvedSpaceId !== void 0 ? `  (space: ${outcome.resolvedSpaceId})` : "";
+			ui.log(`✔ ${result.summary}${spaceSuffix}`);
+		} else {
+			for (const f of result.failures) {
+				ui.log(`✗ [${f.code}] ${f.where}: ${f.why}`);
+				ui.log(`  fix: ${f.fix}`);
+			}
+			ui.log(`\n${result.summary}`);
+		}
+		process.exit(outcome.exitCode);
+	});
+	return command;
+}
+//#endregion
+export { enumerateCheckSpaces as n, runMigrationCheck as r, createMigrationCheckCommand as t };
+
+//# sourceMappingURL=migration-check-CcG-fB8r-CDs5C9vt.mjs.map