prisma-next 0.5.0-dev.9 → 0.5.1

package/dist/{migration-status-DUMiH8_G.mjs → migration-status-By9G5p2H.mjs}

@@ -1,18 +1,21 @@
-import { t as loadConfig } from "./config-loader-C25b63rJ.mjs";
-import { _ as errorUnexpected, m as errorRuntime } from "./cli-errors-Cd79vmTH.mjs";
-import { t as createControlClient } from "./client-CrsnY58k.mjs";
-import { t as TerminalUI } from "./terminal-ui-C3ZLwQxK.mjs";
-import { _ as formatStyledHeader, a as maskConnectionUrl, c as resolveMigrationPaths, d as setCommandExamples, i as loadAllBundles, m as parseGlobalFlags, n as addGlobalOptions, o as readContractEnvelope, p as toPathDecisionResult, t as handleResult, u as setCommandDescriptions } from "./result-handler-Ba3zWQsI.mjs";
+import { t as loadConfig } from "./config-loader-B6sJjXTv.mjs";
+import { _ as errorUnexpected, m as errorRuntime, v as mapMigrationToolsError } from "./cli-errors-D3_sMh2K.mjs";
+import { a as loadMigrationPackages, d as setCommandDescriptions, f as setCommandExamples, g as parseGlobalFlags, h as toStructuralEdge, l as resolveMigrationPaths, m as toPathDecisionResult, n as collectDeclaredInvariants, o as maskConnectionUrl, s as readContractEnvelope, 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 { t as createControlClient } from "./client-BCnP7cHo.mjs";
+import { t as buildContractSpaceAggregate } from "./contract-space-aggregate-loader-BrwKK6Q6.mjs";
 import { Command } from "commander";
-import { notOk, ok } from "@prisma-next/utils/result";
 import { ifDefined } from "@prisma-next/utils/defined";
-import { EMPTY_CONTRACT_HASH } from "@prisma-next/migration-tools/constants";
-import { findPath, findPathWithDecision, findReachableLeaves } from "@prisma-next/migration-tools/dag";
+import { notOk, ok } from "@prisma-next/utils/result";
+import { createControlStack } from "@prisma-next/framework-components/control";
+import { findPath, findPathWithDecision, findReachableLeaves } from "@prisma-next/migration-tools/migration-graph";
 import { bold, cyan, dim, magenta, yellow } from "colorette";
+import { graphWalkStrategy } from "@prisma-next/migration-tools/aggregate";
+import { EMPTY_CONTRACT_HASH } from "@prisma-next/migration-tools/constants";
+import { MigrationToolsError, errorNoInvariantPath, errorUnknownInvariant } from "@prisma-next/migration-tools/errors";
 import { readRefs, resolveRef } from "@prisma-next/migration-tools/refs";
-import { MigrationToolsError } from "@prisma-next/migration-tools/types";
 import dagre from "@dagrejs/dagre";
-
 //#region src/utils/formatters/graph-types.ts
 /**
 * Immutable directed graph with adjacency-list indexing.
@@ -52,7 +55,6 @@ var RenderGraph = class {
 		return this.forward.get(nodeId) ?? [];
 	}
 };
-
 //#endregion
 //#region src/utils/formatters/graph-migration-mapper.ts
 /**
@@ -100,7 +102,8 @@ function migrationGraphToRenderInput(input) {
 	for (const [, entries] of graph.forwardChain) for (const entry of entries) {
 		const status = statusByDirName.get(entry.dirName);
 		const icon = status ? STATUS_ICON[status] : "";
-		const label = `${entry.dirName}${icon}`;
+		const invariantsSuffix = entry.invariants.length > 0 ? `  provides [${entry.invariants.map((id) => JSON.stringify(id)).join(", ")}]` : "";
+		const label = `${entry.dirName}${icon}${invariantsSuffix}`;
 		edgeList.push({
 			from: toShortId(entry.from),
 			to: toShortId(entry.to),
@@ -171,7 +174,6 @@ function migrationGraphToRenderInput(input) {
 		relevantPaths
 	};
 }
-
 //#endregion
 //#region src/utils/formatters/graph-render.ts
 /**
@@ -1086,9 +1088,24 @@ function isLinearGraph(graph) {
 	for (const node of graph.nodes) if (graph.outgoing(node.id).filter((e) => e.style !== "dashed").length > 1) return false;
 	return true;
 }
-
 //#endregion
 //#region src/commands/migration-status.ts
+/**
+* Sum per-space `pendingCount` into a cross-space total, but only when
+* every loaded space reports a defined `pendingCount`. Returns
+* `undefined` if any space is on the marker-unknown / offline path
+* (where `pendingCount` is intentionally absent), so JSON consumers can
+* distinguish "no pending" from "unknown".
+*/
+function computeTotalPendingAcrossSpaces(spaces) {
+	if (spaces.length === 0) return void 0;
+	let total = 0;
+	for (const s of spaces) {
+		if (s.pendingCount === void 0) return void 0;
+		total += s.pendingCount;
+	}
+	return total;
+}
 function summarizeOps(ops) {
 	if (ops.length === 0) return {
 		summary: "0 ops",
@@ -1194,7 +1211,7 @@ function buildMigrationEntries(chain, packages, mode, markerHash, edgeStatuses)
 			dirName: migration.dirName,
 			from: migration.from,
 			to: migration.to,
-			migrationId: migration.migrationId,
+			migrationHash: migration.migrationHash,
 			operationCount: ops.length,
 			operationSummary: summary,
 			hasDestructive,
@@ -1239,37 +1256,117 @@ function determineLimit(opts) {
 	if (Number.isNaN(parsed)) return DEFAULT_LIMIT;
 	return parsed;
 }
+/**
+* Build the aggregate enumeration of contract spaces for the status
+* output. Loads the aggregate from disk (lossy on failure — extension
+* spaces are simply omitted, the existing single-space app behaviour
+* keeps working), reads per-space marker rows when online, and uses
+* {@link graphWalkStrategy} to compute each space's pending count.
+*
+* Sub-spec § `migration status` semantics — the aggregate-walking
+* version reports per-space marker + pending state alongside the
+* cross-space totals.
+*/
+async function loadAggregateStatusSpaces(args) {
+	const loaded = await buildContractSpaceAggregate({
+		targetId: args.targetId,
+		migrationsDir: args.migrationsDir,
+		appContract: args.validateContract(args.appContractRaw),
+		extensionPacks: args.extensionPacks,
+		validateContract: args.validateContract
+	});
+	if (!loaded.ok) return [];
+	const aggregate = loaded.value;
+	const orderedMembers = [...aggregate.extensions, aggregate.app];
+	const rows = [];
+	for (const member of orderedMembers) {
+		const liveMarker = args.markersBySpace?.get(member.spaceId) ?? null;
+		const isApp = member.spaceId === aggregate.app.spaceId;
+		if (member.migrations.graph.nodes.size === 0) {
+			rows.push({
+				spaceId: member.spaceId,
+				kind: isApp ? "app" : "extension",
+				headHash: member.headRef.hash,
+				...args.markersBySpace !== null ? {
+					markerHash: liveMarker?.storageHash ?? null,
+					status: member.headRef.hash === EMPTY_CONTRACT_HASH ? "up-to-date" : "never-planned",
+					pendingCount: 0
+				} : {}
+			});
+			continue;
+		}
+		if (args.markersBySpace === null) {
+			rows.push({
+				spaceId: member.spaceId,
+				kind: isApp ? "app" : "extension",
+				headHash: member.headRef.hash
+			});
+			continue;
+		}
+		const walked = graphWalkStrategy({
+			aggregateTargetId: aggregate.targetId,
+			member,
+			currentMarker: liveMarker
+		});
+		let pendingCount = 0;
+		let status;
+		if (walked.kind === "ok") {
+			pendingCount = walked.result.migrationEdges?.length ?? 0;
+			if (liveMarker === null) status = pendingCount === 0 ? "no-marker" : "pending";
+			else status = pendingCount === 0 ? "up-to-date" : "pending";
+		} else status = "unreachable";
+		rows.push({
+			spaceId: member.spaceId,
+			kind: isApp ? "app" : "extension",
+			headHash: member.headRef.hash,
+			markerHash: liveMarker?.storageHash ?? null,
+			pendingCount,
+			...status ? { status } : {}
+		});
+	}
+	return rows;
+}
+/**
+* Read the raw contract.json bytes from disk for the aggregate
+* loader. Returns `null` if the file is missing or unparseable —
+* the existing `readContractEnvelope` path will report the same
+* problem via a status diagnostic, no need to double-surface.
+*/
+async function loadContractRawSafely(config) {
+	try {
+		const path = (await import("./command-helpers-BeZHkxV8.mjs").then((n) => n.r)).resolveContractPath(config);
+		const raw = await (await import("node:fs/promises")).readFile(path, "utf-8");
+		return JSON.parse(raw);
+	} catch {
+		return null;
+	}
+}
 async function executeMigrationStatusCommand(options, flags, ui) {
 	const config = await loadConfig(options.config);
-	const { configPath, migrationsDir, migrationsRelative, refsDir } = resolveMigrationPaths(options.config, config);
+	const { configPath, appMigrationsDir, appMigrationsRelative, migrationsDir, refsDir } = resolveMigrationPaths(options.config, config);
 	const dbConnection = options.db ?? config.db?.connection;
 	const hasDriver = !!config.driver;
 	let activeRefName;
 	let activeRefHash;
+	let activeRefEntry;
 	let allRefs = {};
 	try {
 		allRefs = await readRefs(refsDir);
 	} catch (error) {
-		if (MigrationToolsError.is(error)) return notOk(errorRuntime(error.message, {
-			why: error.why,
-			fix: error.fix,
-			meta: { code: error.code }
-		}));
+		if (MigrationToolsError.is(error)) return notOk(mapMigrationToolsError(error));
 		throw error;
 	}
 	if (options.ref) {
 		activeRefName = options.ref;
 		try {
-			activeRefHash = resolveRef(allRefs, activeRefName).hash;
+			activeRefEntry = resolveRef(allRefs, activeRefName);
+			activeRefHash = activeRefEntry.hash;
 		} catch (error) {
-			if (MigrationToolsError.is(error)) return notOk(errorRuntime(error.message, {
-				why: error.why,
-				fix: error.fix,
-				meta: { code: error.code }
-			}));
+			if (MigrationToolsError.is(error)) return notOk(mapMigrationToolsError(error));
 			throw error;
 		}
 	}
+	const requiredInvariants = [...activeRefEntry?.invariants ?? []].sort();
 	const statusRefs = Object.entries(allRefs).map(([name, entry]) => ({
 		name,
 		hash: entry.hash,
@@ -1281,7 +1378,7 @@ async function executeMigrationStatusCommand(options, flags, ui) {
 			value: configPath
 		}, {
 			label: "migrations",
-			value: migrationsRelative
+			value: appMigrationsRelative
 		}];
 		if (dbConnection && hasDriver) details.push({
 			label: "database",
@@ -1291,6 +1388,10 @@ async function executeMigrationStatusCommand(options, flags, ui) {
 			label: "ref",
 			value: activeRefName
 		});
+		if (activeRefEntry && activeRefEntry.invariants.length > 0) details.push({
+			label: "required",
+			value: formatInvariantList(activeRefEntry.invariants)
+		});
 		const header = formatStyledHeader({
 			command: "migration status",
 			description: "Show migration history and applied status",
@@ -1314,13 +1415,9 @@ async function executeMigrationStatusCommand(options, flags, ui) {
 	let bundles;
 	let graph;
 	try {
-		({bundles, graph} = await loadAllBundles(migrationsDir));
+		({bundles, graph} = await loadMigrationPackages(appMigrationsDir));
 	} catch (error) {
-		if (MigrationToolsError.is(error)) return notOk(errorRuntime(error.message, {
-			why: error.why,
-			fix: error.fix,
-			meta: { code: error.code }
-		}));
+		if (MigrationToolsError.is(error)) return notOk(mapMigrationToolsError(error));
 		return notOk(errorUnexpected(error instanceof Error ? error.message : String(error), { why: `Failed to read migrations directory: ${error instanceof Error ? error.message : String(error)}` }));
 	}
 	if (bundles.length === 0) {
@@ -1337,7 +1434,8 @@ async function executeMigrationStatusCommand(options, flags, ui) {
 			targetHash: EMPTY_CONTRACT_HASH,
 			contractHash,
 			summary: "No migrations found",
-			diagnostics
+			diagnostics,
+			requiredInvariants
 		});
 	}
 	let targetHash;
@@ -1354,7 +1452,9 @@ async function executeMigrationStatusCommand(options, flags, ui) {
 		});
 	}
 	let markerHash;
+	let markerInvariants = [];
 	let mode = "offline";
+	let allMarkers = null;
 	if (dbConnection && hasDriver) {
 		const client = createControlClient({
 			family: config.family,
@@ -1365,14 +1465,48 @@ async function executeMigrationStatusCommand(options, flags, ui) {
 		});
 		try {
 			await client.connect(dbConnection);
-			markerHash = (await client.readMarker())?.storageHash;
+			const marker = await client.readMarker();
+			markerHash = marker?.storageHash;
+			markerInvariants = marker?.invariants ?? [];
 			mode = "online";
+			if (typeof client.readAllMarkers === "function") allMarkers = await client.readAllMarkers();
+			else allMarkers = null;
 		} catch {
 			if (!flags.json && !flags.quiet) ui.warn("Could not connect to database — showing offline status");
 		} finally {
 			await client.close();
 		}
 	}
+	const contractRawForAggregate = await loadContractRawSafely(config);
+	let aggregateSpaces = [];
+	if (contractRawForAggregate !== null) {
+		const stack = createControlStack(config);
+		const familyInstance = config.family.create(stack);
+		try {
+			aggregateSpaces = await loadAggregateStatusSpaces({
+				targetId: config.target.targetId,
+				migrationsDir,
+				appContractRaw: contractRawForAggregate,
+				extensionPacks: config.extensionPacks ?? [],
+				validateContract: (json) => familyInstance.validateContract(json),
+				markersBySpace: allMarkers
+			});
+		} catch {
+			aggregateSpaces = [];
+		}
+	}
+	const totalPendingAcrossSpaces = computeTotalPendingAcrossSpaces(aggregateSpaces);
+	if (activeRefEntry && activeRefEntry.invariants.length > 0) {
+		const declared = collectDeclaredInvariants(graph);
+		const known = new Set(declared);
+		if (mode === "online") for (const id of markerInvariants) known.add(id);
+		const unknown = activeRefEntry.invariants.filter((id) => !known.has(id));
+		if (unknown.length > 0) return notOk(mapMigrationToolsError(errorUnknownInvariant({
+			...ifDefined("refName", activeRefName),
+			unknown,
+			declared: [...declared].sort()
+		})));
+	}
 	if (mode === "online" && markerHash !== void 0 && !graph.nodes.has(markerHash) && markerHash !== contractHash) {
 		const hints = [];
 		if (graph.nodes.has(contractHash)) hints.push("Run 'prisma-next db sign' to overwrite the marker if the database already matches the contract", "Run 'prisma-next db update' to push the current contract to the database", "Run 'prisma-next contract infer' to make your contract match the database", "Run 'prisma-next db verify' to inspect the database state");
@@ -1392,6 +1526,7 @@ async function executeMigrationStatusCommand(options, flags, ui) {
 			summary: `${bundles.length} migration(s) on disk`,
 			diagnostics,
 			markerHash,
+			requiredInvariants,
 			...statusRefs.length > 0 ? { refs: statusRefs } : {}
 		});
 	}
@@ -1416,6 +1551,7 @@ async function executeMigrationStatusCommand(options, flags, ui) {
 		summary: `${bundles.length} migration(s) on disk`,
 		diagnostics,
 		...ifDefined("markerHash", markerHash),
+		requiredInvariants,
 		...statusRefs.length > 0 ? { refs: statusRefs } : {},
 		graph,
 		bundles,
@@ -1430,35 +1566,68 @@ async function executeMigrationStatusCommand(options, flags, ui) {
 	const entries = buildMigrationEntries(chain, bundles, mode, markerHash, edgeStatuses);
 	const pendingCount = edgeStatuses.filter((e) => e.status === "pending").length;
 	const appliedCount = edgeStatuses.filter((e) => e.status === "applied").length;
+	let appliedInvariants;
+	let missingInvariants;
+	let effectiveRequired = /* @__PURE__ */ new Set();
+	if (mode === "online") {
+		const markerSet = new Set(markerInvariants);
+		effectiveRequired = new Set(requiredInvariants.filter((id) => !markerSet.has(id)));
+		appliedInvariants = requiredInvariants.filter((id) => markerSet.has(id));
+		missingInvariants = [...effectiveRequired].sort();
+	}
+	const hasInvariantWork = effectiveRequired.size > 0;
+	const missingList = [...effectiveRequired].sort().join(", ");
 	let summary;
 	if (mode === "online") if (markerHash !== void 0 && !graph.nodes.has(markerHash) && markerHash === contractHash) summary = `${bundles.length} migration(s) on disk`;
-	else if (activeRefHash && markerHash !== void 0) summary = summarizeRefDistance(graph, markerHash, activeRefHash, activeRefName);
-	else if (pendingCount === 0) summary = `Database is up to date (${appliedCount} migration${appliedCount !== 1 ? "s" : ""} applied)`;
+	else if (activeRefHash && markerHash !== void 0) {
+		const distance = summarizeRefDistance(graph, markerHash, activeRefHash, activeRefName);
+		summary = hasInvariantWork ? `${distance} — missing invariant(s): ${missingList}` : distance;
+	} else if (pendingCount === 0 && !hasInvariantWork) summary = `Database is up to date (${appliedCount} migration${appliedCount !== 1 ? "s" : ""} applied)`;
+	else if (pendingCount === 0 && hasInvariantWork) summary = `Missing invariant(s): ${missingList} — run 'prisma-next migration apply --ref ${activeRefName ?? "<ref>"}' to apply`;
 	else if (markerHash === void 0) summary = `${pendingCount} pending migration(s) — database has no marker`;
 	else summary = `${pendingCount} pending migration(s) — run 'prisma-next migration apply' to apply`;
 	else summary = `${entries.length} migration(s) on disk`;
-	if (mode === "online") if (markerHash !== void 0 && !graph.nodes.has(markerHash) && markerHash === contractHash) diagnostics.push({
-		code: "MIGRATION.MARKER_NOT_IN_HISTORY",
-		severity: "warn",
-		message: "Database matches the current contract but was updated directly (not via migration apply)",
-		hints: ["Run 'prisma-next migration plan' to plan a migration to your current contract"]
-	});
-	else if (pendingCount > 0) diagnostics.push({
-		code: "MIGRATION.DATABASE_BEHIND",
-		severity: "info",
-		message: `${pendingCount} migration(s) pending`,
-		hints: ["Run 'prisma-next migration apply' to apply pending migrations"]
-	});
-	else diagnostics.push({
-		code: "MIGRATION.UP_TO_DATE",
-		severity: "info",
-		message: "Database is up to date",
-		hints: []
-	});
 	let pathDecision;
-	if (mode === "online" && markerHash !== void 0) {
-		const decision = findPathWithDecision(graph, markerHash, targetHash, activeRefName);
-		if (decision) pathDecision = toPathDecisionResult(decision);
+	let routingUnreachable = false;
+	if (mode === "online") {
+		const outcome = findPathWithDecision(graph, markerHash ?? EMPTY_CONTRACT_HASH, targetHash, {
+			...ifDefined("refName", activeRefName),
+			required: effectiveRequired
+		});
+		if (outcome.kind === "ok") pathDecision = toPathDecisionResult(outcome.decision);
+		else if (outcome.kind === "unsatisfiable") return notOk(mapMigrationToolsError(errorNoInvariantPath({
+			...ifDefined("refName", activeRefName),
+			required: [...effectiveRequired].sort(),
+			missing: outcome.missing,
+			structuralPath: outcome.structuralPath.map(toStructuralEdge)
+		})));
+		else routingUnreachable = true;
+	}
+	if (mode === "online") {
+		if (markerHash !== void 0 && !graph.nodes.has(markerHash) && markerHash === contractHash) diagnostics.push({
+			code: "MIGRATION.MARKER_NOT_IN_HISTORY",
+			severity: "warn",
+			message: "Database matches the current contract but was updated directly (not via migration apply)",
+			hints: ["Run 'prisma-next migration plan' to plan a migration to your current contract"]
+		});
+		else if (pendingCount > 0) diagnostics.push({
+			code: "MIGRATION.DATABASE_BEHIND",
+			severity: "info",
+			message: `${pendingCount} migration(s) pending`,
+			hints: ["Run 'prisma-next migration apply' to apply pending migrations"]
+		});
+		else if (hasInvariantWork) diagnostics.push({
+			code: "MIGRATION.INVARIANTS_PENDING",
+			severity: "info",
+			message: `Missing required invariant(s): ${missingList}`,
+			hints: [`Run 'prisma-next migration apply --ref ${activeRefName ?? "<ref>"}' to apply a path that covers the required invariants`]
+		});
+		else if (!routingUnreachable) diagnostics.push({
+			code: "MIGRATION.UP_TO_DATE",
+			severity: "info",
+			message: "Database is up to date",
+			hints: []
+		});
 	}
 	return ok({
 		ok: true,
@@ -1469,13 +1638,18 @@ async function executeMigrationStatusCommand(options, flags, ui) {
 		summary,
 		diagnostics,
 		...ifDefined("markerHash", markerHash),
+		requiredInvariants,
+		...ifDefined("appliedInvariants", appliedInvariants),
+		...ifDefined("missingInvariants", missingInvariants),
 		...statusRefs.length > 0 ? { refs: statusRefs } : {},
 		...ifDefined("pathDecision", pathDecision),
 		graph,
 		bundles,
 		edgeStatuses,
 		...ifDefined("activeRefHash", activeRefHash),
-		...ifDefined("activeRefName", activeRefName)
+		...ifDefined("activeRefName", activeRefName),
+		spaces: aggregateSpaces,
+		...ifDefined("totalPendingAcrossSpaces", totalPendingAcrossSpaces)
 	});
 }
 function createMigrationStatusCommand() {
@@ -1490,7 +1664,7 @@ function createMigrationStatusCommand() {
 		});
 		const exitCode = handleResult(await executeMigrationStatusCommand(options, flags, ui), flags, ui, (statusResult) => {
 			if (flags.json) {
-				const { graph: _g, bundles: _b, edgeStatuses: _es, activeRefHash: _arh, activeRefName: _arn, diverged: _d, ...jsonResult } = statusResult;
+				const { graph: _graph, bundles: _bundles, edgeStatuses: _edgeStatuses, activeRefHash: _activeRefHash, activeRefName: _activeRefName, diverged: _diverged, ...jsonResult } = statusResult;
 				ui.output(JSON.stringify(jsonResult, null, 2));
 			} else if (!flags.quiet) {
 				const colorize = flags.color !== false;
@@ -1540,17 +1714,48 @@ function formatStatusSummary(result, colorize) {
 	const hasUnknown = result.migrations.some((e) => e.status === "unknown");
 	const pendingCount = result.migrations.filter((e) => e.status === "pending").length;
 	const hasWarnings = result.diagnostics?.some((d) => d.severity === "warn") ?? false;
+	const hasInvariantPending = result.diagnostics?.some((d) => d.code === "MIGRATION.INVARIANTS_PENDING") ?? false;
 	if (result.mode === "online") if (hasUnknown || hasWarnings) lines.push(`${c(yellow, "⚠")} ${result.summary}`);
-	else if (pendingCount === 0) lines.push(`${c(cyan, "✔")} ${result.summary}`);
+	else if (pendingCount === 0 && !hasInvariantPending) lines.push(`${c(cyan, "✔")} ${result.summary}`);
 	else lines.push(`${c(yellow, "⧗")} ${result.summary}`);
 	else lines.push(result.summary);
+	if (result.requiredInvariants.length > 0) if (result.appliedInvariants !== void 0 && result.missingInvariants !== void 0) {
+		lines.push(`${c(dim, "applied  ")}${formatInvariantList(result.appliedInvariants)}`);
+		lines.push(`${c(dim, "missing  ")}${formatInvariantList(result.missingInvariants)}`);
+	} else lines.push(`${c(dim, "applied  ")}(unknown — connect a database to evaluate)`);
 	const warnings = result.diagnostics?.filter((d) => d.severity === "warn") ?? [];
 	for (const diag of warnings) {
 		lines.push(`${c(yellow, "⚠")} ${diag.message}`);
 		for (const hint of diag.hints) lines.push(`  ${c(dim, hint)}`);
 	}
+	if (result.spaces?.some((s) => s.kind === "extension")) {
+		const total = result.totalPendingAcrossSpaces ?? 0;
+		lines.push("");
+		lines.push(c(dim, "spaces"));
+		for (const space of result.spaces) lines.push(formatSpaceLine(space, c));
+		if (total > 0) {
+			lines.push("");
+			lines.push(`${c(yellow, "⧗")} ${total} pending migration(s) across ${result.spaces.length} space(s) — run 'prisma-next migration apply' to apply`);
+		}
+	}
 	return lines.join("\n");
 }
+function formatSpaceLine(space, c) {
+	const glyph = (() => {
+		if (space.status === "up-to-date" || space.status === "no-marker") return c(cyan, "✓");
+		if (space.status === "pending") return c(yellow, "⧗");
+		if (space.status === "unreachable" || space.status === "never-planned") return c(magenta, "✗");
+		return " ";
+	})();
+	const tag = space.kind === "app" ? "[app]" : "[ext]";
+	const head = space.headHash.slice(0, 8);
+	const marker = space.markerHash === void 0 ? "(unknown)" : space.markerHash === null ? "(no marker)" : space.markerHash.slice(0, 8);
+	const pending = space.pendingCount === void 0 ? "" : space.pendingCount === 0 ? c(dim, " (up to date)") : c(yellow, ` (${space.pendingCount} pending)`);
+	return `  ${glyph} ${c(dim, tag)} ${space.spaceId} → head ${c(dim, head)}, marker ${c(dim, marker)}${pending}`;
+}
+function formatInvariantList(ids) {
+	return ids.length === 0 ? "(none)" : ids.join(", ");
+}
 function summarizeRefDistance(graph, markerHash, refHash, refName) {
 	if (markerHash === refHash) return `At ref "${refName}" target`;
 	const pathToRef = findPath(graph, markerHash, refHash);
@@ -1559,7 +1764,7 @@ function summarizeRefDistance(graph, markerHash, refHash, refName) {
 	if (pathFromRef) return `${pathFromRef.length} migration(s) ahead of ref "${refName}"`;
 	return `No path between database marker and ref "${refName}" target`;
 }
-
 //#endregion
-export { deriveEdgeStatuses as n, createMigrationStatusCommand as t };
-//# sourceMappingURL=migration-status-DUMiH8_G.mjs.map
+export { loadAggregateStatusSpaces as a, formatStatusSummary as i, createMigrationStatusCommand as n, deriveEdgeStatuses as r, computeTotalPendingAcrossSpaces as t };
+
+//# sourceMappingURL=migration-status-By9G5p2H.mjs.map