prisma-next 0.8.0 → 0.9.0-dev.1

package/dist/{migration-status-By9G5p2H.mjs → graph-render-eJDcLWny.mjs}

@@ -1,20 +1,7 @@
-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 { ifDefined } from "@prisma-next/utils/defined";
-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 { findPath } 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 dagre from "@dagrejs/dagre";
 //#region src/utils/formatters/graph-types.ts
 /**
@@ -1089,682 +1076,6 @@ function isLinearGraph(graph) {
 	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",
-		hasDestructive: false
-	};
-	const classes = /* @__PURE__ */ new Map();
-	for (const op of ops) classes.set(op.operationClass, (classes.get(op.operationClass) ?? 0) + 1);
-	const hasDestructive = classes.has("destructive");
-	const count = ops.length;
-	const noun = count === 1 ? "op" : "ops";
-	if (classes.size === 1) return {
-		summary: `${count} ${noun} (all ${[...classes.keys()][0]})`,
-		hasDestructive
-	};
-	const destructiveCount = classes.get("destructive");
-	if (destructiveCount) return {
-		summary: `${count} ${noun} (${destructiveCount} destructive)`,
-		hasDestructive
-	};
-	return {
-		summary: `${count} ${noun} (${[...classes.entries()].map(([cls, n]) => `${n} ${cls}`).join(", ")})`,
-		hasDestructive
-	};
-}
-/**
-* Derive per-edge status across the full graph using path analysis.
-*
-* - **applied**: edge is on the path from root to the DB marker
-* - **pending**: edge is on the path from the DB marker to the target
-*   (and the marker is reachable from root, i.e. it's on the same branch)
-* - **unreachable**: edge is on the path from root to the target but the DB
-*   marker is on a different branch — `apply` can't reach these edges
-*   without the DB first moving to this branch
-*
-* Returns statuses only for edges that have a known status (skips offline
-* and edges not on any relevant path).
-*
-* @internal Exported for testing only.
-*/
-function deriveEdgeStatuses(graph, targetHash, contractHash, markerHash, mode) {
-	if (mode === "offline") return [];
-	const edgeKey = (e) => `${e.from}\0${e.to}`;
-	const effectiveMarker = markerHash ?? EMPTY_CONTRACT_HASH;
-	const appliedPath = markerHash !== void 0 ? findPath(graph, EMPTY_CONTRACT_HASH, markerHash) : null;
-	const pendingPath = findPath(graph, effectiveMarker, targetHash);
-	const targetPath = findPath(graph, EMPTY_CONTRACT_HASH, targetHash);
-	const statuses = [];
-	const assignedKeys = /* @__PURE__ */ new Set();
-	if (appliedPath) for (const e of appliedPath) {
-		assignedKeys.add(edgeKey(e));
-		statuses.push({
-			dirName: e.dirName,
-			status: "applied"
-		});
-	}
-	if (pendingPath) for (const e of pendingPath) {
-		assignedKeys.add(edgeKey(e));
-		statuses.push({
-			dirName: e.dirName,
-			status: "pending"
-		});
-	}
-	if (contractHash !== EMPTY_CONTRACT_HASH && contractHash !== targetHash && graph.nodes.has(contractHash)) {
-		const beyondTarget = findPath(graph, targetHash, contractHash);
-		if (beyondTarget) {
-			for (const e of beyondTarget) if (!assignedKeys.has(edgeKey(e))) {
-				assignedKeys.add(edgeKey(e));
-				statuses.push({
-					dirName: e.dirName,
-					status: "pending"
-				});
-			}
-		}
-	}
-	if (targetPath) {
-		for (const e of targetPath) if (!assignedKeys.has(edgeKey(e))) statuses.push({
-			dirName: e.dirName,
-			status: "unreachable"
-		});
-	}
-	return statuses;
-}
-/**
-* @param mode    — 'online' if we connected to the database, 'offline' otherwise
-* @param markerHash — the marker hash from the database, or undefined if no marker row / offline
-*/
-function buildMigrationEntries(chain, packages, mode, markerHash, edgeStatuses) {
-	const pkgByDirName = new Map(packages.map((p) => [p.dirName, p]));
-	const statusByDirName = edgeStatuses ? new Map(edgeStatuses.map((e) => [e.dirName, e.status])) : void 0;
-	const markerInChain = markerHash === void 0 || chain.some((e) => e.to === markerHash);
-	const entries = [];
-	let reachedMarker = mode === "online" && markerHash === void 0;
-	for (const migration of chain) {
-		const ops = pkgByDirName.get(migration.dirName)?.ops ?? [];
-		const { summary, hasDestructive } = summarizeOps(ops);
-		let status;
-		const edgeStatus = statusByDirName?.get(migration.dirName);
-		if (edgeStatus) status = edgeStatus;
-		else if (mode === "offline" || !markerInChain) status = "unknown";
-		else if (reachedMarker) status = "pending";
-		else status = "applied";
-		entries.push({
-			dirName: migration.dirName,
-			from: migration.from,
-			to: migration.to,
-			migrationHash: migration.migrationHash,
-			operationCount: ops.length,
-			operationSummary: summary,
-			hasDestructive,
-			status
-		});
-		if (!reachedMarker && migration.to === markerHash) reachedMarker = true;
-	}
-	return entries;
-}
-/**
-* Resolve the migration chain to display in status output.
-*
-* When offline or the marker is at EMPTY, the chain is simply the shortest
-* path from EMPTY to the target — all structural paths are equivalent per
-* the spec, so the deterministic shortest path is the canonical display.
-*
-* When online with a non-empty marker, the chain routes *through* the marker:
-* EMPTY→marker (applied history) + marker→target (pending edges). This ensures
-* the displayed chain includes the marker node so applied/pending status is
-* correct. Without this, BFS from EMPTY to target could pick a shortest path
-* that bypasses the marker entirely (e.g. in a diamond graph), causing the
-* marker to appear "diverged" when it isn't.
-*/
-function resolveDisplayChain(graph, targetHash, markerHash) {
-	if (markerHash === void 0) return findPath(graph, EMPTY_CONTRACT_HASH, targetHash);
-	const toMarker = findPath(graph, EMPTY_CONTRACT_HASH, markerHash);
-	if (!toMarker) return findPath(graph, EMPTY_CONTRACT_HASH, targetHash);
-	if (markerHash === targetHash) return toMarker;
-	const fromMarker = findPath(graph, markerHash, targetHash);
-	if (fromMarker) return [...toMarker, ...fromMarker];
-	const toTarget = findPath(graph, EMPTY_CONTRACT_HASH, targetHash);
-	if (!toTarget) return null;
-	const targetToMarker = findPath(graph, targetHash, markerHash);
-	if (targetToMarker) return [...toTarget, ...targetToMarker];
-	return toTarget;
-}
-const DEFAULT_LIMIT = 10;
-function determineLimit(opts) {
-	if (opts.all) return;
-	if (!opts.limit) return DEFAULT_LIMIT;
-	const parsed = Number.parseInt(opts.limit, 10);
-	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, 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(mapMigrationToolsError(error));
-		throw error;
-	}
-	if (options.ref) {
-		activeRefName = options.ref;
-		try {
-			activeRefEntry = resolveRef(allRefs, activeRefName);
-			activeRefHash = activeRefEntry.hash;
-		} catch (error) {
-			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,
-		active: name === activeRefName
-	}));
-	if (!flags.json && !flags.quiet) {
-		const details = [{
-			label: "config",
-			value: configPath
-		}, {
-			label: "migrations",
-			value: appMigrationsRelative
-		}];
-		if (dbConnection && hasDriver) details.push({
-			label: "database",
-			value: maskConnectionUrl(String(dbConnection))
-		});
-		if (activeRefName) details.push({
-			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",
-			details,
-			flags
-		});
-		ui.stderr(header);
-	}
-	const diagnostics = [];
-	let contractHash = EMPTY_CONTRACT_HASH;
-	try {
-		contractHash = (await readContractEnvelope(config)).storageHash;
-	} catch (error) {
-		diagnostics.push({
-			code: "CONTRACT.UNREADABLE",
-			severity: "warn",
-			message: `Could not read contract: ${error instanceof Error ? error.message : "unknown error"}`,
-			hints: ["Run 'prisma-next contract emit' to generate a valid contract"]
-		});
-	}
-	let bundles;
-	let graph;
-	try {
-		({bundles, graph} = await loadMigrationPackages(appMigrationsDir));
-	} catch (error) {
-		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) {
-		if (contractHash !== EMPTY_CONTRACT_HASH) diagnostics.push({
-			code: "CONTRACT.AHEAD",
-			severity: "warn",
-			message: "No migration exists for the current contract",
-			hints: ["Run 'prisma-next migration plan' to generate a migration for the current contract"]
-		});
-		return ok({
-			ok: true,
-			mode: dbConnection && hasDriver ? "online" : "offline",
-			migrations: [],
-			targetHash: EMPTY_CONTRACT_HASH,
-			contractHash,
-			summary: "No migrations found",
-			diagnostics,
-			requiredInvariants
-		});
-	}
-	let targetHash;
-	if (activeRefHash) targetHash = activeRefHash;
-	else if (graph.nodes.has(contractHash)) targetHash = contractHash;
-	else {
-		const leaves = findReachableLeaves(graph, EMPTY_CONTRACT_HASH);
-		if (leaves.length === 1) targetHash = leaves[0];
-		else diagnostics.push({
-			code: "MIGRATION.DIVERGED",
-			severity: "warn",
-			message: "There are multiple valid migration paths — you must select a target",
-			hints: ["Use '--ref <name>' to select a target", "Or 'prisma-next migration ref set <name> <hash>' to create one"]
-		});
-	}
-	let markerHash;
-	let markerInvariants = [];
-	let mode = "offline";
-	let allMarkers = null;
-	if (dbConnection && hasDriver) {
-		const client = createControlClient({
-			family: config.family,
-			target: config.target,
-			adapter: config.adapter,
-			driver: config.driver,
-			extensionPacks: config.extensionPacks ?? []
-		});
-		try {
-			await client.connect(dbConnection);
-			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");
-		else hints.push("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");
-		diagnostics.push({
-			code: "MIGRATION.MARKER_NOT_IN_HISTORY",
-			severity: "warn",
-			message: "Database was updated outside the migration system (marker does not match any migration)",
-			hints
-		});
-		return ok({
-			ok: true,
-			mode,
-			migrations: [],
-			targetHash: EMPTY_CONTRACT_HASH,
-			contractHash,
-			summary: `${bundles.length} migration(s) on disk`,
-			diagnostics,
-			markerHash,
-			requiredInvariants,
-			...statusRefs.length > 0 ? { refs: statusRefs } : {}
-		});
-	}
-	if (mode === "online" && markerHash === void 0) diagnostics.push({
-		code: "MIGRATION.NO_MARKER",
-		severity: "warn",
-		message: "Database has not been initialized — no migration marker found",
-		hints: ["Run 'prisma-next migration apply' to apply pending migrations"]
-	});
-	if (targetHash && contractHash !== EMPTY_CONTRACT_HASH && !graph.nodes.has(contractHash) && markerHash !== contractHash) diagnostics.push({
-		code: "CONTRACT.AHEAD",
-		severity: "warn",
-		message: "Contract has changed since the last migration was planned",
-		hints: ["Run 'prisma-next migration plan' to generate a migration for the current contract"]
-	});
-	if (!targetHash) return ok({
-		ok: true,
-		mode,
-		migrations: [],
-		targetHash: EMPTY_CONTRACT_HASH,
-		contractHash,
-		summary: `${bundles.length} migration(s) on disk`,
-		diagnostics,
-		...ifDefined("markerHash", markerHash),
-		requiredInvariants,
-		...statusRefs.length > 0 ? { refs: statusRefs } : {},
-		graph,
-		bundles,
-		diverged: true
-	});
-	const chain = resolveDisplayChain(graph, targetHash, markerHash);
-	if (!chain) return notOk(errorRuntime("Cannot reconstruct migration history", {
-		why: `No path from ${EMPTY_CONTRACT_HASH} to target ${targetHash}`,
-		fix: "The migration history may have gaps. Check the migrations directory for missing or corrupted packages."
-	}));
-	const edgeStatuses = deriveEdgeStatuses(graph, targetHash, contractHash, markerHash, mode);
-	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) {
-		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`;
-	let pathDecision;
-	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,
-		mode,
-		migrations: entries,
-		targetHash,
-		contractHash,
-		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),
-		spaces: aggregateSpaces,
-		...ifDefined("totalPendingAcrossSpaces", totalPendingAcrossSpaces)
-	});
-}
-function createMigrationStatusCommand() {
-	const command = new Command("status");
-	setCommandDescriptions(command, "Show migration history and applied status", "Displays the migration history in order. When a database connection\nis available, shows which migrations are applied and which are pending.\nWithout a database connection, shows the history from disk only.");
-	setCommandExamples(command, ["prisma-next migration status", "prisma-next migration status --db $DATABASE_URL"]);
-	addGlobalOptions(command).option("--db <url>", "Database connection string").option("--config <path>", "Path to prisma-next.config.ts").option("--ref <name>", "Target ref name from migrations/refs/").option("--graph", "Show the full migration graph with all branches").option("--limit <n>", "Maximum number of migrations to display (default: 10)").option("--all", "Show full history (disables truncation)").action(async (options) => {
-		const flags = parseGlobalFlags(options);
-		const ui = new TerminalUI({
-			color: flags.color,
-			interactive: flags.interactive
-		});
-		const exitCode = handleResult(await executeMigrationStatusCommand(options, flags, ui), flags, ui, (statusResult) => {
-			if (flags.json) {
-				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;
-				if (statusResult.graph) {
-					const limit = determineLimit(options);
-					const renderInput = migrationGraphToRenderInput({
-						graph: statusResult.graph,
-						mode: statusResult.mode,
-						markerHash: statusResult.markerHash,
-						contractHash: statusResult.contractHash,
-						refs: statusResult.refs,
-						activeRefHash: statusResult.activeRefHash,
-						activeRefName: statusResult.activeRefName,
-						edgeStatuses: statusResult.edgeStatuses
-					});
-					const graphToRender = options.graph || statusResult.diverged ? renderInput.graph : extractRelevantSubgraph(renderInput.graph, renderInput.relevantPaths);
-					const dagreOptions = !options.graph && isLinearGraph(graphToRender) ? { ranksep: 1 } : void 0;
-					const renderOptions = {
-						...renderInput.options,
-						colorize,
-						...ifDefined("limit", limit),
-						...ifDefined("dagreOptions", dagreOptions)
-					};
-					const graphOutput = graphRenderer.render(graphToRender, renderOptions);
-					ui.log(graphOutput);
-					if (statusResult.mode === "online") ui.log(formatLegend(colorize));
-				}
-				ui.log("");
-				ui.log(formatStatusSummary(statusResult, colorize));
-			}
-		});
-		process.exit(exitCode);
-	});
-	return command;
-}
-function formatLegend(colorize) {
-	const c = (fn, s) => colorize ? fn(s) : s;
-	return c(dim, [
-		`${c(cyan, "✓")} applied`,
-		`${c(yellow, "⧗")} pending`,
-		`${c(magenta, "✗")} unreachable`
-	].join("  "));
-}
-function formatStatusSummary(result, colorize) {
-	const c = (fn, s) => colorize ? fn(s) : s;
-	const lines = [];
-	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 && !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);
-	if (pathToRef) return `${pathToRef.length} migration(s) behind ref "${refName}"`;
-	const pathFromRef = findPath(graph, refHash, markerHash);
-	if (pathFromRef) return `${pathFromRef.length} migration(s) ahead of ref "${refName}"`;
-	return `No path between database marker and ref "${refName}" target`;
-}
-//#endregion
-export { loadAggregateStatusSpaces as a, formatStatusSummary as i, createMigrationStatusCommand as n, deriveEdgeStatuses as r, computeTotalPendingAcrossSpaces as t };
+export { migrationGraphToRenderInput as i, graphRenderer as n, isLinearGraph as r, extractRelevantSubgraph as t };
 
-//# sourceMappingURL=migration-status-By9G5p2H.mjs.map
+//# sourceMappingURL=graph-render-eJDcLWny.mjs.map