prisma-next 0.11.0 → 0.12.0-dev.10

package/dist/migration-graph-C9WC-7eO.mjs

@@ -0,0 +1,1478 @@
+import { t as loadConfig } from "./config-loader-B6sJjXTv.mjs";
+import { T as formatStyledHeader, _ as createTerminalUI, d as setCommandSeeAlso, g as parseGlobalFlagsOrExit, l as setCommandDescriptions, s as resolveMigrationPaths, t as addGlobalOptions, u as setCommandExamples, y as handleResult } from "./command-helpers-Bbw1GbwL.mjs";
+import { r as buildReadAggregate } from "./contract-space-aggregate-loader-DvZwdkrr.mjs";
+import { i as migrationGraphToRenderInput, n as graphRenderer } from "./graph-render-rFAqZujX.mjs";
+import { a as migrationListEmptySource, n as createAnsiMigrationListStyler, o as migrationListForwardArrow, s as classifyMigrationGraphTopology, t as CONTRACT_MARKER_NAME } from "./migration-list-styler-BRwF4-gy.mjs";
+import { Command } from "commander";
+import { ok } from "@prisma-next/utils/result";
+import { bold, createColors } from "colorette";
+import stringWidth from "string-width";
+import { EMPTY_CONTRACT_HASH } from "@prisma-next/migration-tools/constants";
+//#region src/utils/formatters/migration-graph-layout.ts
+function forwardEdges(edges) {
+	return edges.filter((e) => e.kind === "forward");
+}
+function buildForwardProducersByTo(edges) {
+	const byTo = /* @__PURE__ */ new Map();
+	for (const edge of edges) {
+		if (edge.kind !== "forward") continue;
+		const bucket = byTo.get(edge.to);
+		if (bucket) bucket.push(edge);
+		else byTo.set(edge.to, [edge]);
+	}
+	return byTo;
+}
+function buildForwardOutDegree(edges) {
+	const out = /* @__PURE__ */ new Map();
+	for (const edge of edges) {
+		if (edge.kind !== "forward" || edge.from === edge.to) continue;
+		out.set(edge.from, (out.get(edge.from) ?? 0) + 1);
+	}
+	return out;
+}
+function buildForwardInDegree(edges) {
+	const indeg = /* @__PURE__ */ new Map();
+	for (const edge of forwardEdges(edges)) {
+		if (edge.from === edge.to) continue;
+		indeg.set(edge.to, (indeg.get(edge.to) ?? 0) + 1);
+	}
+	return indeg;
+}
+/**
+* Distinct source contracts among a contract's forward producers. A contract is
+* a *convergence* when this count is >= 2. Multiple migrations sharing one
+* source (a multi-edge) count once — they stack in a single lane rather than
+* fanning into a convergence.
+*/
+function buildDistinctSourceCountByTo(edges) {
+	const sources = /* @__PURE__ */ new Map();
+	for (const edge of edges) {
+		if (edge.kind !== "forward" || edge.from === edge.to) continue;
+		const set = sources.get(edge.to);
+		if (set) set.add(edge.from);
+		else sources.set(edge.to, new Set([edge.from]));
+	}
+	const counts = /* @__PURE__ */ new Map();
+	for (const [to, set] of sources) counts.set(to, set.size);
+	return counts;
+}
+function splitComponents(nodes) {
+	const components = [];
+	let current = [];
+	for (const node of nodes) {
+		if (node === null) {
+			if (current.length > 0) {
+				components.push(current);
+				current = [];
+			}
+			continue;
+		}
+		current.push(node);
+	}
+	if (current.length > 0) components.push(current);
+	return components;
+}
+function classifyForwardShortConvergenceAdjacency(rows, edgeRowIndex, edge, laneIndex) {
+	for (let index = edgeRowIndex + 1; index < rows.length; index++) {
+		const row = rows[index];
+		if (row === void 0) break;
+		if (row.kind === "component-separator" || row.kind === "branch-connector") continue;
+		if (row.kind === "merge-connector") continue;
+		if (row.kind === "edge") {
+			if (row.laneIndex === laneIndex) return "node-skipping-forward";
+			continue;
+		}
+		if (row.kind === "node" && row.contractHash === edge.from) return "adjacent";
+	}
+	return "node-skipping-forward";
+}
+function convergenceProducerUsesShortAdjacency(edge, laneIndex, forwardProducersByTo, producerLaneByHash) {
+	const producers = (forwardProducersByTo.get(edge.to) ?? []).filter((candidate) => candidate.kind === "forward");
+	if (producers.length < 2) return false;
+	const fanStart = [...new Set(producers.map((producer) => producerLaneByHash.get(producer.migrationHash)).filter((candidate) => candidate !== void 0))].sort((a, b) => a - b)[0];
+	if (fanStart === void 0) return false;
+	return laneIndex === fanStart;
+}
+function classifyForwardLayoutAdjacency(rows, edgeRowIndex, edge, laneIndex, passThroughLanes, nodeColumn, convergenceProducer, divergenceBranchEdge) {
+	let sawObstruction = false;
+	const passThroughLaneSet = new Set(passThroughLanes);
+	for (let index = edgeRowIndex + 1; index < rows.length; index++) {
+		const row = rows[index];
+		if (row === void 0) break;
+		if (row.kind === "component-separator") continue;
+		if (row.kind === "merge-connector") {
+			if (convergenceProducer) {
+				if (row.contractHash === edge.from) sawObstruction = true;
+			} else if (!divergenceBranchEdge && row.contractHash !== edge.from) sawObstruction = true;
+			continue;
+		}
+		if (row.kind === "branch-connector") continue;
+		if (row.kind === "edge") {
+			if (row.laneIndex === laneIndex) return "node-skipping-forward";
+			if (!divergenceBranchEdge && row.edge !== void 0 && row.edge.to !== edge.to) sawObstruction = true;
+			continue;
+		}
+		if (row.kind === "node" && row.contractHash !== void 0) {
+			if (row.contractHash === edge.from) return sawObstruction ? "node-skipping-forward" : "adjacent";
+			const nodeCol = nodeColumn.get(row.contractHash) ?? 0;
+			if (!divergenceBranchEdge && !passThroughLaneSet.has(nodeCol)) sawObstruction = true;
+		}
+	}
+	return "node-skipping-forward";
+}
+function classifyLayoutAdjacency(rows, edgeRowIndex, edge, laneIndex, passThroughLanes, nodeColumn, position, forwardInDegree, convergenceProducer, divergenceBranchEdge) {
+	if (edge.kind === "self") return "adjacent";
+	const fromPos = position.get(edge.from);
+	const toPos = position.get(edge.to);
+	if (edge.kind === "forward") {
+		if ((forwardInDegree.get(edge.to) ?? 0) <= 1 && fromPos !== void 0 && toPos !== void 0 && fromPos === toPos + 1) return "adjacent";
+		return classifyForwardLayoutAdjacency(rows, edgeRowIndex, edge, laneIndex, passThroughLanes, nodeColumn, convergenceProducer, divergenceBranchEdge);
+	}
+	if (fromPos !== void 0 && toPos !== void 0 && toPos === fromPos + 1) return "adjacent";
+	for (let index = edgeRowIndex + 1; index < rows.length; index++) {
+		const row = rows[index];
+		if (row === void 0) break;
+		if (row.kind === "component-separator" || row.kind === "branch-connector" || row.kind === "merge-connector") continue;
+		if (row.kind === "edge") continue;
+		if (row.kind === "node") return row.contractHash === edge.to ? "adjacent" : "node-skipping-rollback";
+	}
+	return "node-skipping-rollback";
+}
+function refineAdjacency(rows, nodeColumn, position, forwardInDegree, forwardOutDegree, edges, producerLaneByHash) {
+	const forwardProducersByTo = buildForwardProducersByTo(edges);
+	function branchLaneForEdge(producer) {
+		const children = edges.filter((edge) => edge.from === producer.from && edge.kind === "forward" && edge.from !== edge.to);
+		if (children.length < 2) return void 0;
+		const index = children.findIndex((child) => child.migrationHash === producer.migrationHash);
+		return index >= 0 ? index : void 0;
+	}
+	return rows.map((row, rowIndex) => {
+		if (row.kind !== "edge" || row.edge === void 0 || row.laneIndex === void 0) return row;
+		const divergenceBranchEdge = row.edge.kind === "forward" && !(row.convergenceProducer ?? false) && (forwardOutDegree.get(row.edge.from) ?? 0) >= 2 && branchLaneForEdge(row.edge) !== void 0;
+		const adjacency = row.convergenceProducer === true && convergenceProducerUsesShortAdjacency(row.edge, row.laneIndex, forwardProducersByTo, producerLaneByHash) ? classifyForwardShortConvergenceAdjacency(rows, rowIndex, row.edge, row.laneIndex) : classifyLayoutAdjacency(rows, rowIndex, row.edge, row.laneIndex, row.passThroughLanes ?? [], nodeColumn, position, forwardInDegree, row.convergenceProducer ?? false, divergenceBranchEdge);
+		return {
+			...row,
+			cells: buildEdgeCells(row.edge, row.laneIndex, row.passThroughLanes ?? [], adjacency, row.cells.length)
+		};
+	});
+}
+function classifyEdgeAdjacency(edge, position) {
+	if (edge.kind === "self") return "adjacent";
+	const fromPos = position.get(edge.from);
+	const toPos = position.get(edge.to);
+	if (fromPos === void 0 || toPos === void 0) return "adjacent";
+	if (edge.kind === "forward") {
+		if (toPos >= fromPos) return "adjacent";
+		return fromPos === toPos + 1 ? "adjacent" : "node-skipping-forward";
+	}
+	if (toPos <= fromPos) return "adjacent";
+	return toPos === fromPos + 1 ? "adjacent" : "node-skipping-rollback";
+}
+function emptyCells(width) {
+	return Array.from({ length: width }, () => ({ kind: "empty" }));
+}
+function buildBranchConnectorCells(startLane, endLane, fanTargetLanes, activeLanes, gridWidth) {
+	const cells = emptyCells(gridWidth);
+	for (let lane = 0; lane < gridWidth; lane++) {
+		if (activeLanes.has(lane) && (lane < startLane || lane > endLane)) {
+			cells[lane] = { kind: "vertical-pass" };
+			continue;
+		}
+		if (lane === startLane) cells[lane] = { kind: "branch-tee" };
+		else if (lane === endLane) cells[lane] = { kind: "branch-corner" };
+		else if (lane > startLane && lane < endLane) if (fanTargetLanes.has(lane)) cells[lane] = { kind: "branch-tee" };
+		else if (activeLanes.has(lane)) cells[lane] = { kind: "arc-crossing" };
+		else cells[lane] = { kind: "branch-tee" };
+	}
+	return cells;
+}
+function buildMergeConnectorCells(startLane, endLane, fanTargetLanes, activeLanes, gridWidth) {
+	const cells = emptyCells(gridWidth);
+	for (let lane = 0; lane < gridWidth; lane++) {
+		if (activeLanes.has(lane) && (lane < startLane || lane > endLane)) {
+			cells[lane] = { kind: "vertical-pass" };
+			continue;
+		}
+		if (lane === startLane) cells[lane] = { kind: "merge-tee" };
+		else if (lane === endLane) cells[lane] = { kind: "merge-corner" };
+		else if (lane > startLane && lane < endLane) if (fanTargetLanes.has(lane)) cells[lane] = { kind: "merge-tee" };
+		else if (activeLanes.has(lane)) cells[lane] = { kind: "arc-crossing" };
+		else cells[lane] = { kind: "horizontal-pass" };
+	}
+	return cells;
+}
+function buildNodeCells(contractHash, nodeColumn, activeLanes, gridWidth) {
+	const cells = emptyCells(gridWidth);
+	for (const lane of activeLanes) if (lane !== nodeColumn && lane < gridWidth) cells[lane] = { kind: "vertical-pass" };
+	if (nodeColumn < gridWidth) cells[nodeColumn] = {
+		kind: "node",
+		contractHash
+	};
+	return cells;
+}
+function buildEdgeCells(edge, laneIndex, passThroughLanes, adjacency, gridWidth) {
+	const cells = emptyCells(gridWidth);
+	for (const lane of passThroughLanes) if (lane < gridWidth) cells[lane] = { kind: "vertical-pass" };
+	if (laneIndex < gridWidth) cells[laneIndex] = {
+		kind: "edge-lane",
+		migrationHash: edge.migrationHash,
+		edgeKind: edge.kind,
+		ownsLabel: true,
+		adjacency
+	};
+	return cells;
+}
+/**
+* Compute the vertical node order for a component: tips at the top (index 0),
+* roots at the bottom. This is a DFS post-order over forward edges starting
+* from forward roots, visiting children in their input (insertion) order. A
+* node is emitted only after all of its forward children, so convergence nodes
+* sit below every branch that feeds them and the longest contiguous chain reads
+* top-to-bottom without braiding.
+*/
+function computeVerticalOrder(componentNodes, forwardChildren, forwardInDegree) {
+	const WHITE = 0;
+	const GRAY = 1;
+	const BLACK = 2;
+	const color = /* @__PURE__ */ new Map();
+	for (const node of componentNodes) color.set(node, WHITE);
+	const sortRoots = (roots) => [...roots].sort((a, b) => {
+		if (a === EMPTY_CONTRACT_HASH) return -1;
+		if (b === EMPTY_CONTRACT_HASH) return 1;
+		return a.localeCompare(b);
+	});
+	let roots = sortRoots(componentNodes.filter((n) => (forwardInDegree.get(n) ?? 0) === 0));
+	if (roots.length === 0) roots = sortRoots(componentNodes);
+	const result = [];
+	function runDfs(root) {
+		if (color.get(root) !== WHITE) return;
+		const stack = [{
+			node: root,
+			children: forwardChildren.get(root) ?? [],
+			index: 0
+		}];
+		color.set(root, GRAY);
+		while (stack.length > 0) {
+			const frame = stack[stack.length - 1];
+			if (frame === void 0) break;
+			if (frame.index >= frame.children.length) {
+				color.set(frame.node, BLACK);
+				result.push(frame.node);
+				stack.pop();
+				continue;
+			}
+			const child = frame.children[frame.index];
+			frame.index += 1;
+			if (child === void 0) continue;
+			if (color.get(child.to) === WHITE) {
+				color.set(child.to, GRAY);
+				stack.push({
+					node: child.to,
+					children: forwardChildren.get(child.to) ?? [],
+					index: 0
+				});
+			}
+		}
+	}
+	for (const root of roots) runDfs(root);
+	for (const node of componentNodes) if (color.get(node) === WHITE) runDfs(node);
+	return result;
+}
+function rollbackSpan(edge, position) {
+	const top = position.get(edge.from) ?? 0;
+	return {
+		top,
+		bottom: position.get(edge.to) ?? top
+	};
+}
+function spansOverlap(a, b) {
+	return a.top <= b.bottom && b.top <= a.bottom;
+}
+function forwardMaxLane(rows, skipMigrationHashes) {
+	let max = 0;
+	for (const row of rows) {
+		if (row.kind === "edge" && row.edge !== void 0 && skipMigrationHashes.has(row.edge.migrationHash)) continue;
+		max = Math.max(max, row.laneIndex ?? 0);
+		for (const lane of row.passThroughLanes ?? []) max = Math.max(max, lane);
+		if (row.startLane !== void 0) max = Math.max(max, row.startLane, row.endLane ?? row.startLane);
+	}
+	return max;
+}
+function allocateSkipRollbackBackLanes(skipRollbacks, position, forwardMax) {
+	const sorted = [...skipRollbacks].sort((a, b) => {
+		const aTop = position.get(a.from) ?? 0;
+		const bTop = position.get(b.from) ?? 0;
+		if (aTop !== bTop) return aTop - bTop;
+		return b.dirName.localeCompare(a.dirName);
+	});
+	const occupied = [];
+	const lanes = /* @__PURE__ */ new Map();
+	let nextLane = forwardMax + 1;
+	for (const edge of sorted) {
+		const span = rollbackSpan(edge, position);
+		let lane = nextLane;
+		while (occupied.some((entry) => entry.lane === lane && spansOverlap(entry, span))) lane += 1;
+		occupied.push({
+			...span,
+			lane
+		});
+		lanes.set(edge.migrationHash, lane);
+		nextLane = Math.max(nextLane, lane + 1);
+	}
+	return lanes;
+}
+function findNodeRowIndex(rows, contractHash) {
+	return rows.findIndex((row) => row.kind === "node" && row.contractHash === contractHash);
+}
+function findEdgeRowIndex(rows, migrationHash) {
+	return rows.findIndex((row) => row.kind === "edge" && row.edge?.migrationHash === migrationHash);
+}
+function ensureCellWidth(cells, width) {
+	while (cells.length < width) cells.push({ kind: "empty" });
+}
+function cloneRow(row) {
+	return {
+		...row,
+		cells: [...row.cells]
+	};
+}
+function routeCrossesRow(route, rowIndex, rows) {
+	const sourceRow = findNodeRowIndex(rows, route.edge.from);
+	const targetRow = findNodeRowIndex(rows, route.edge.to);
+	if (sourceRow < 0 || targetRow < 0) return false;
+	return rowIndex > sourceRow && rowIndex <= targetRow;
+}
+function applySkipRollbackRouting(rows, skipRollbacks, position, nodeColumn, edgeColumn) {
+	if (skipRollbacks.length === 0) return [...rows];
+	const forwardMax = forwardMaxLane(rows, new Set(skipRollbacks.map((edge) => edge.migrationHash)));
+	const backLaneByHash = allocateSkipRollbackBackLanes(skipRollbacks, position, forwardMax);
+	const routes = skipRollbacks.map((edge) => ({
+		edge,
+		backLane: backLaneByHash.get(edge.migrationHash) ?? forwardMax + 1
+	}));
+	const result = rows.map(cloneRow);
+	for (const route of routes) {
+		const { edge, backLane } = route;
+		const nodeCol = nodeColumn.get(edge.from) ?? 0;
+		const targetCol = nodeColumn.get(edge.to) ?? 0;
+		const sourceRowIndex = findNodeRowIndex(result, edge.from);
+		const targetRowIndex = findNodeRowIndex(result, edge.to);
+		const edgeRowIndex = findEdgeRowIndex(result, edge.migrationHash);
+		if (sourceRowIndex < 0 || targetRowIndex < 0 || edgeRowIndex < 0) continue;
+		edgeColumn.set(edge.migrationHash, backLane);
+		const coSourcedLanes = routes.filter((other) => other.edge.from === edge.from).map((other) => other.backLane);
+		const maxCoSourcedLane = Math.max(...coSourcedLanes);
+		const sourceRow = result[sourceRowIndex];
+		if (sourceRow !== void 0) {
+			const cells = sourceRow.cells;
+			ensureCellWidth(cells, backLane + 1);
+			cells[nodeCol] = {
+				kind: "node",
+				contractHash: sourceRow.contractHash ?? EMPTY_CONTRACT_HASH,
+				arcTee: true
+			};
+			for (let lane = nodeCol + 1; lane < backLane; lane += 1) {
+				if (coSourcedLanes.includes(lane)) {
+					cells[lane] = { kind: "arc-branch-tee" };
+					continue;
+				}
+				const existing = cells[lane];
+				cells[lane] = existing !== void 0 && existing.kind !== "empty" && existing.kind !== "horizontal-pass" && existing.kind !== "arc-land-bridge" || routes.some((other) => other.edge.migrationHash !== edge.migrationHash && other.backLane === lane && routeCrossesRow(other, sourceRowIndex, result)) ? { kind: "arc-crossing" } : { kind: "horizontal-pass" };
+			}
+			cells[backLane] = backLane < maxCoSourcedLane ? { kind: "arc-branch-tee" } : { kind: "arc-branch-corner" };
+		}
+		const edgeRow = result[edgeRowIndex];
+		if (edgeRow !== void 0) {
+			const cells = edgeRow.cells;
+			ensureCellWidth(cells, backLane + 1);
+			cells[nodeCol] = { kind: "vertical-pass" };
+			cells[backLane] = {
+				kind: "edge-lane",
+				migrationHash: edge.migrationHash,
+				edgeKind: edge.kind,
+				ownsLabel: true,
+				adjacency: "node-skipping-rollback"
+			};
+			result[edgeRowIndex] = {
+				...edgeRow,
+				laneIndex: backLane,
+				passThroughLanes: [nodeCol]
+			};
+		}
+		for (let index = sourceRowIndex + 1; index < targetRowIndex; index += 1) {
+			if (index === edgeRowIndex) continue;
+			const row = result[index];
+			if (row === void 0) continue;
+			const cells = row.cells;
+			ensureCellWidth(cells, backLane + 1);
+			const existing = cells[backLane];
+			if (existing?.kind !== "arc-land-corner" && existing?.kind !== "arc-land-bridge" && existing?.kind !== "arc-branch-corner" && existing?.kind !== "arc-branch-tee" && existing?.kind !== "arc-crossing") cells[backLane] = { kind: "vertical-pass" };
+		}
+		const targetRow = result[targetRowIndex];
+		if (targetRow !== void 0) {
+			const cells = targetRow.cells;
+			ensureCellWidth(cells, backLane + 1);
+			cells[targetCol] = {
+				kind: "node",
+				contractHash: targetRow.contractHash ?? EMPTY_CONTRACT_HASH,
+				arcLand: true
+			};
+			for (let lane = targetCol + 1; lane < backLane; lane += 1) {
+				const existing = cells[lane];
+				cells[lane] = existing !== void 0 && existing.kind !== "empty" && existing.kind !== "horizontal-pass" && existing.kind !== "arc-land-bridge" || routes.some((other) => other.edge.migrationHash !== edge.migrationHash && other.backLane === lane && routeCrossesRow(other, targetRowIndex, result)) ? { kind: "arc-crossing" } : { kind: "arc-land-bridge" };
+			}
+			cells[backLane] = { kind: "arc-land-corner" };
+			for (const other of routes) {
+				if (other.backLane <= backLane) continue;
+				if (!routeCrossesRow(other, targetRowIndex, result)) continue;
+				ensureCellWidth(cells, other.backLane + 1);
+				const existing = cells[other.backLane];
+				if (existing?.kind !== "arc-land-corner" && existing?.kind !== "arc-land-bridge" && existing?.kind !== "node") cells[other.backLane] = { kind: "vertical-pass" };
+			}
+		}
+	}
+	return result;
+}
+function collectNodeSkippingRollbacks(edges, position) {
+	return edges.filter((edge) => edge.kind === "rollback" && classifyEdgeAdjacency(edge, position) === "node-skipping-rollback");
+}
+function layoutComponent(componentNodes, allEdges) {
+	const componentSet = new Set(componentNodes);
+	const edges = allEdges.filter((e) => componentSet.has(e.from) && componentSet.has(e.to));
+	const forwardChildren = /* @__PURE__ */ new Map();
+	const producersByTo = /* @__PURE__ */ new Map();
+	const rollbacksByFrom = /* @__PURE__ */ new Map();
+	const selfByFrom = /* @__PURE__ */ new Map();
+	for (const edge of edges) {
+		if (edge.kind === "self" || edge.from === edge.to) {
+			const bucket = selfByFrom.get(edge.from);
+			if (bucket) bucket.push(edge);
+			else selfByFrom.set(edge.from, [edge]);
+			continue;
+		}
+		if (edge.kind === "forward") {
+			const children = forwardChildren.get(edge.from);
+			if (children) children.push(edge);
+			else forwardChildren.set(edge.from, [edge]);
+			const producers = producersByTo.get(edge.to);
+			if (producers) producers.push(edge);
+			else producersByTo.set(edge.to, [edge]);
+			continue;
+		}
+		const bucket = rollbacksByFrom.get(edge.from);
+		if (bucket) bucket.push(edge);
+		else rollbacksByFrom.set(edge.from, [edge]);
+	}
+	const forwardInDegree = buildForwardInDegree(edges);
+	const forwardOutDegree = buildForwardOutDegree(edges);
+	const distinctSourceCountByTo = buildDistinctSourceCountByTo(edges);
+	const order = computeVerticalOrder(componentNodes, forwardChildren, forwardInDegree);
+	const position = /* @__PURE__ */ new Map();
+	for (let index = 0; index < order.length; index++) {
+		const node = order[index];
+		if (node !== void 0) position.set(node, index);
+	}
+	const lanes = [];
+	const rows = [];
+	const nodeColumn = /* @__PURE__ */ new Map();
+	const edgeColumn = /* @__PURE__ */ new Map();
+	const producerLaneByHash = /* @__PURE__ */ new Map();
+	let gridWidth = 1;
+	function ensureGridWidth(minWidth) {
+		if (minWidth > gridWidth) gridWidth = minWidth;
+	}
+	function setLane(index, want) {
+		while (lanes.length <= index) lanes.push(null);
+		lanes[index] = want;
+		if (want !== null) ensureGridWidth(index + 1);
+	}
+	function activeLaneIndices() {
+		const indices = [];
+		for (let index = 0; index < lanes.length; index++) if (lanes[index] !== null) indices.push(index);
+		return indices;
+	}
+	function passThroughExcept(lane) {
+		return activeLaneIndices().filter((index) => index !== lane);
+	}
+	function leftmostFreeLane() {
+		for (let index = 0; index < lanes.length; index++) if (lanes[index] === null) return index;
+		return lanes.length;
+	}
+	function lanesWanting(contract) {
+		const indices = [];
+		for (let index = 0; index < lanes.length; index++) if (lanes[index] === contract) indices.push(index);
+		return indices;
+	}
+	function emitMergeConnector(contractHash, laneIndices) {
+		const startLane = Math.min(...laneIndices);
+		const endLane = Math.max(...laneIndices);
+		ensureGridWidth(endLane + 1);
+		const activeLanes = new Set(activeLaneIndices());
+		const fanTargetLanes = new Set(laneIndices);
+		rows.push({
+			kind: "merge-connector",
+			contractHash,
+			startLane,
+			endLane,
+			branchCount: laneIndices.length,
+			cells: buildMergeConnectorCells(startLane, endLane, fanTargetLanes, activeLanes, gridWidth)
+		});
+		for (const index of laneIndices) if (index !== startLane) setLane(index, null);
+		return startLane;
+	}
+	function emitBranchConnector(contractHash, startLane, endLane, branchCount, fanTargetLanes) {
+		ensureGridWidth(endLane + 1);
+		const activeLanes = new Set(activeLaneIndices());
+		rows.push({
+			kind: "branch-connector",
+			contractHash,
+			startLane,
+			endLane,
+			branchCount,
+			cells: buildBranchConnectorCells(startLane, endLane, new Set(fanTargetLanes), activeLanes, gridWidth)
+		});
+	}
+	function emitEdgeRow(edge, lane, convergenceProducer) {
+		const passThrough = passThroughExcept(lane);
+		const adjacency = classifyEdgeAdjacency(edge, position);
+		ensureGridWidth(Math.max(lane, ...passThrough, 0) + 1);
+		const row = {
+			kind: "edge",
+			edge,
+			laneIndex: lane,
+			passThroughLanes: passThrough,
+			cells: buildEdgeCells(edge, lane, passThrough, adjacency, gridWidth)
+		};
+		rows.push(convergenceProducer ? {
+			...row,
+			convergenceProducer: true
+		} : row);
+		edgeColumn.set(edge.migrationHash, lane);
+		if (convergenceProducer) producerLaneByHash.set(edge.migrationHash, lane);
+	}
+	function emitNodeRow(contractHash, column) {
+		ensureGridWidth(column + 1);
+		const passThrough = activeLaneIndices().filter((index) => index !== column);
+		rows.push({
+			kind: "node",
+			contractHash,
+			cells: buildNodeCells(contractHash, column, passThrough, gridWidth)
+		});
+		nodeColumn.set(contractHash, column);
+	}
+	function producerGroups(node) {
+		const byTarget = /* @__PURE__ */ new Map();
+		for (const producer of producersByTo.get(node) ?? []) {
+			const group = byTarget.get(producer.from);
+			if (group) group.edges.push(producer);
+			else byTarget.set(producer.from, {
+				target: producer.from,
+				edges: [producer]
+			});
+		}
+		const groups = [...byTarget.values()];
+		groups.sort((a, b) => (position.get(a.target) ?? 0) - (position.get(b.target) ?? 0));
+		for (const group of groups) group.edges.sort((a, b) => b.dirName.localeCompare(a.dirName));
+		return groups;
+	}
+	function processNode(node) {
+		const wanting = lanesWanting(node);
+		let column;
+		if (wanting.length >= 2) column = emitMergeConnector(node, wanting);
+		else if (wanting.length === 1) column = wanting[0] ?? 0;
+		else column = leftmostFreeLane();
+		const selfEdges = [...selfByFrom.get(node) ?? []].sort((a, b) => b.dirName.localeCompare(a.dirName));
+		for (const selfEdge of selfEdges) emitEdgeRow(selfEdge, column, false);
+		emitNodeRow(node, column);
+		const rollbacks = [...rollbacksByFrom.get(node) ?? []].sort((a, b) => b.dirName.localeCompare(a.dirName));
+		const skipRollbacks = [];
+		const adjacentRollbacks = [];
+		for (const rollback of rollbacks) if (classifyEdgeAdjacency(rollback, position) === "node-skipping-rollback") skipRollbacks.push(rollback);
+		else adjacentRollbacks.push(rollback);
+		for (const rollback of skipRollbacks) emitEdgeRow(rollback, column, false);
+		const groups = producerGroups(node);
+		const isConvergence = (distinctSourceCountByTo.get(node) ?? 0) >= 2;
+		const laneForGroup = [];
+		for (let groupIndex = 0; groupIndex < groups.length; groupIndex++) {
+			const group = groups[groupIndex];
+			if (group === void 0) continue;
+			const lane = groupIndex === 0 ? column : leftmostFreeLane();
+			laneForGroup[groupIndex] = lane;
+			setLane(lane, group.target);
+		}
+		if (groups.length >= 2) {
+			const endLane = Math.max(...laneForGroup);
+			emitBranchConnector(node, column, endLane, groups.length, laneForGroup);
+		}
+		for (let groupIndex = 0; groupIndex < groups.length; groupIndex++) {
+			const group = groups[groupIndex];
+			const lane = laneForGroup[groupIndex];
+			if (group === void 0 || lane === void 0) continue;
+			for (const edge of group.edges) emitEdgeRow(edge, lane, isConvergence);
+		}
+		for (const rollback of adjacentRollbacks) emitEdgeRow(rollback, column, false);
+		if (groups.length === 0) setLane(column, null);
+	}
+	for (const node of order) processNode(node);
+	return {
+		rows: applySkipRollbackRouting(refineAdjacency(rows, nodeColumn, position, forwardInDegree, forwardOutDegree, edges, producerLaneByHash), collectNodeSkippingRollbacks(edges, position), position, nodeColumn, edgeColumn),
+		nodeColumn,
+		edgeColumn
+	};
+}
+function buildMigrationGraphLayout(rowModel) {
+	if (rowModel.nodes.length === 0) return {
+		rows: [],
+		nodeColumn: /* @__PURE__ */ new Map(),
+		edgeColumn: /* @__PURE__ */ new Map()
+	};
+	const components = splitComponents(rowModel.nodes);
+	const allRows = [];
+	const nodeColumn = /* @__PURE__ */ new Map();
+	const edgeColumn = /* @__PURE__ */ new Map();
+	for (let componentIndex = 0; componentIndex < components.length; componentIndex++) {
+		if (componentIndex > 0) allRows.push({
+			kind: "component-separator",
+			cells: []
+		});
+		const component = components[componentIndex];
+		if (component === void 0 || component.length === 0) continue;
+		const result = layoutComponent(component, rowModel.edges);
+		allRows.push(...result.rows);
+		for (const [hash, column] of result.nodeColumn) nodeColumn.set(hash, column);
+		for (const [hash, column] of result.edgeColumn) edgeColumn.set(hash, column);
+	}
+	return {
+		rows: allRows,
+		nodeColumn,
+		edgeColumn
+	};
+}
+//#endregion
+//#region src/utils/formatters/migration-graph-rows.ts
+/**
+* Return the weakly-connected components of `graph` as an array of node sets,
+* ordered so the component containing EMPTY_CONTRACT_HASH comes first (if
+* present), with remaining components sorted by their lex-smallest node hash.
+*/
+function weaklyConnectedComponents(graph) {
+	const visited = /* @__PURE__ */ new Set();
+	const adjacency = /* @__PURE__ */ new Map();
+	function addAdjacent(a, b) {
+		const aList = adjacency.get(a);
+		if (aList) aList.push(b);
+		else adjacency.set(a, [b]);
+		const bList = adjacency.get(b);
+		if (bList) bList.push(a);
+		else adjacency.set(b, [a]);
+	}
+	for (const edges of graph.forwardChain.values()) for (const edge of edges) if (edge.from !== edge.to) addAdjacent(edge.from, edge.to);
+	for (const node of graph.nodes) if (!adjacency.has(node)) adjacency.set(node, []);
+	const components = [];
+	function bfsComponent(start) {
+		const component = /* @__PURE__ */ new Set();
+		const queue = [start];
+		while (queue.length > 0) {
+			const node = queue.shift();
+			if (node === void 0 || visited.has(node)) continue;
+			visited.add(node);
+			component.add(node);
+			for (const neighbor of adjacency.get(node) ?? []) if (!visited.has(neighbor)) queue.push(neighbor);
+		}
+		return component;
+	}
+	const allNodes = [...graph.nodes].sort((a, b) => {
+		if (a === EMPTY_CONTRACT_HASH) return -1;
+		if (b === EMPTY_CONTRACT_HASH) return 1;
+		return a.localeCompare(b);
+	});
+	for (const node of allNodes) if (!visited.has(node)) components.push(bfsComponent(node));
+	components.sort((a, b) => {
+		const aHasEmpty = a.has(EMPTY_CONTRACT_HASH);
+		const bHasEmpty = b.has(EMPTY_CONTRACT_HASH);
+		if (aHasEmpty && !bHasEmpty) return -1;
+		if (!aHasEmpty && bHasEmpty) return 1;
+		const aMin = [...a].sort((x, y) => x.localeCompare(y))[0] ?? "";
+		const bMin = [...b].sort((x, y) => x.localeCompare(y))[0] ?? "";
+		return aMin.localeCompare(bMin);
+	});
+	return components;
+}
+function forwardRootsInComponent(componentNodes, topology) {
+	const roots = [];
+	for (const node of componentNodes) if ((topology.forwardInDegree.get(node) ?? 0) === 0) roots.push(node);
+	roots.sort((a, b) => {
+		if (a === EMPTY_CONTRACT_HASH) return -1;
+		if (b === EMPTY_CONTRACT_HASH) return 1;
+		return a.localeCompare(b);
+	});
+	if (roots.length > 0) return roots;
+	return [...componentNodes].sort((a, b) => {
+		if (a === EMPTY_CONTRACT_HASH) return -1;
+		if (b === EMPTY_CONTRACT_HASH) return 1;
+		return a.localeCompare(b);
+	});
+}
+function compareNodesTipsFirst(a, b, rank) {
+	const rankA = rank.get(a) ?? 0;
+	const rankB = rank.get(b) ?? 0;
+	if (rankA !== rankB) return rankB - rankA;
+	if (a === EMPTY_CONTRACT_HASH) return 1;
+	if (b === EMPTY_CONTRACT_HASH) return -1;
+	return a.localeCompare(b);
+}
+/**
+* Layer nodes by longest forward-path rank from forward roots within the
+* component. Rank 0 is the root (bottom row); the maximum rank is the tip
+* (top row). Emits rank-descending with lex-ascending tie-break among siblings
+* at the same rank — stable across edge-insertion order and correct under
+* diamonds, cross-links, and rollbacks.
+*/
+function layerNodesByLongestForwardPath(componentNodes, topology, graph) {
+	const forwardOut = /* @__PURE__ */ new Map();
+	for (const node of componentNodes) forwardOut.set(node, []);
+	for (const edges of graph.forwardChain.values()) for (const edge of edges) {
+		if (!componentNodes.has(edge.from) || !componentNodes.has(edge.to)) continue;
+		if (edge.from === edge.to) continue;
+		if (topology.kindByMigrationHash.get(edge.migrationHash) !== "forward") continue;
+		const bucket = forwardOut.get(edge.from);
+		if (bucket) bucket.push(edge.to);
+	}
+	const roots = forwardRootsInComponent(componentNodes, topology);
+	const rank = /* @__PURE__ */ new Map();
+	for (const root of roots) rank.set(root, 0);
+	const maxPasses = componentNodes.size;
+	for (let pass = 0; pass < maxPasses; pass++) {
+		let changed = false;
+		for (const node of componentNodes) {
+			const base = rank.get(node);
+			if (base === void 0) continue;
+			for (const to of forwardOut.get(node) ?? []) {
+				const next = base + 1;
+				if (next > (rank.get(to) ?? -1)) {
+					rank.set(to, next);
+					changed = true;
+				}
+			}
+		}
+		if (!changed) break;
+	}
+	for (const node of componentNodes) if (!rank.has(node)) rank.set(node, 0);
+	return [...componentNodes].sort((a, b) => compareNodesTipsFirst(a, b, rank));
+}
+/**
+* Build the row model from a tolerant `MigrationGraph`.
+*
+* The row model is the first pure-data stage of the `migration graph` render
+* pipeline. It:
+* - classifies every edge as `forward`, `rollback`, or `self`;
+* - produces a deterministic vertical node ordering (tips at index 0, roots
+*   at the end) within each weakly-connected component;
+* - separates disjoint components with `null` sentinels;
+* - optionally prepends a detached current contract as its own single-node
+*   component when `contractHash` is not already in the graph.
+*
+* No columns, no lane allocation, no glyphs, no rendering.
+*/
+/**
+* Resolve the detached current contract, if any: a real contract (not the
+* empty baseline) that no migration on disk produces, so it is absent from
+* the graph. Such a contract renders as a floating node rather than
+* decorating an existing one. Returns the hash when detached, else undefined.
+*/
+function detachedContractHash(graph, contractHash) {
+	return contractHash !== void 0 && contractHash !== EMPTY_CONTRACT_HASH && !graph.nodes.has(contractHash) ? contractHash : void 0;
+}
+function buildMigrationGraphRows(graph, options = {}) {
+	const emptyModel = {
+		nodes: [],
+		edges: [],
+		edgesByFrom: /* @__PURE__ */ new Map(),
+		edgesByTo: /* @__PURE__ */ new Map()
+	};
+	if (graph.nodes.size === 0) {
+		const detached = detachedContractHash(graph, options.contractHash);
+		return detached !== void 0 ? {
+			...emptyModel,
+			nodes: [detached]
+		} : emptyModel;
+	}
+	const topology = classifyMigrationGraphTopology(graph);
+	const edges = [];
+	const edgesByFrom = /* @__PURE__ */ new Map();
+	const edgesByTo = /* @__PURE__ */ new Map();
+	for (const edgeList of graph.forwardChain.values()) for (const edge of edgeList) {
+		const kind = topology.kindByMigrationHash.get(edge.migrationHash) ?? "forward";
+		const classified = {
+			migrationHash: edge.migrationHash,
+			from: edge.from,
+			to: edge.to,
+			dirName: edge.dirName,
+			kind
+		};
+		edges.push(classified);
+		const fromBucket = edgesByFrom.get(edge.from);
+		if (fromBucket) fromBucket.push(classified);
+		else edgesByFrom.set(edge.from, [classified]);
+		const toBucket = edgesByTo.get(edge.to);
+		if (toBucket) toBucket.push(classified);
+		else edgesByTo.set(edge.to, [classified]);
+	}
+	const components = weaklyConnectedComponents(graph);
+	const nodes = [];
+	for (let i = 0; i < components.length; i++) {
+		if (i > 0) nodes.push(null);
+		const component = components[i];
+		if (component === void 0) continue;
+		const ordered = layerNodesByLongestForwardPath(component, topology, graph);
+		for (const node of ordered) nodes.push(node);
+	}
+	const detached = detachedContractHash(graph, options.contractHash);
+	if (detached !== void 0) {
+		if (nodes.length > 0) nodes.unshift(null);
+		nodes.unshift(detached);
+	}
+	return {
+		nodes,
+		edges,
+		edgesByFrom,
+		edgesByTo
+	};
+}
+//#endregion
+//#region src/utils/formatters/migration-graph-lane-colors.ts
+const { magenta: magenta$1, cyan: cyan$1, green: green$1, yellow: yellow$1, blueBright, red: red$1 } = createColors({ useColor: true });
+const LANE_COLOR_CYCLE = [
+	magenta$1,
+	cyan$1,
+	green$1,
+	yellow$1,
+	blueBright,
+	red$1
+];
+/**
+* The hue for a gutter column. The leftmost lane (column 0) is **neutral** — it
+* has nothing to be told apart from in the common single-lane linear case, so
+* the renderer dims it rather than tinting it; the rotating palette is reserved
+* for columns ≥ 1 (where a second lane exists to distinguish). Callers must dim
+* column 0 themselves; this returns identity for it as a guard. A lane freed and
+* reused by a later branch keeps its column's hue — coloring is by position, not
+* branch identity, exactly like `git log --graph`.
+*/
+function laneColorForColumn(column) {
+	if (column <= 0) return (text) => text;
+	return LANE_COLOR_CYCLE[(column - 1) % LANE_COLOR_CYCLE.length] ?? ((text) => text);
+}
+//#endregion
+//#region src/utils/formatters/migration-graph-tree-render.ts
+const LABEL_GAP = 2;
+/**
+* The live-database overlay marker. Just another ref as far as styling goes —
+* the only emphasized markers are the active ref and the `contract`
+* desired-state marker (see {@link CONTRACT_MARKER_NAME}).
+*/
+const DB_MARKER_NAME = "db";
+const UNICODE_PALETTE = {
+	node: "○ ",
+	arcLand: "○◂",
+	arcTee: "○─",
+	verticalPass: "│ ",
+	branchTee: "├─",
+	mergeTee: "├─",
+	branchCorner: "╮ ",
+	mergeCorner: "╯ ",
+	arcBranchCorner: "╮ ",
+	arcBranchTee: "┬─",
+	arcLandCorner: "╯ ",
+	arcCrossing: "┼─",
+	arcLandBridge: "──",
+	horizontalPass: "──",
+	connectorBranchTee: "├─",
+	connectorBranchTeeCo: "┬─",
+	connectorMergeTeeCo: "┴─",
+	edgeArrow: {
+		forward: "↑",
+		rollback: "↓",
+		self: "⟲"
+	},
+	forwardArrow: migrationListForwardArrow("unicode"),
+	emptySource: migrationListEmptySource("unicode")
+};
+const ASCII_PALETTE = {
+	node: "* ",
+	arcLand: "*<",
+	arcTee: "*-",
+	verticalPass: "| ",
+	branchTee: "+-",
+	mergeTee: "+-",
+	branchCorner: "\\ ",
+	mergeCorner: "/ ",
+	arcBranchCorner: "\\ ",
+	arcBranchTee: "+-",
+	arcLandCorner: "/ ",
+	arcCrossing: "+-",
+	arcLandBridge: "--",
+	horizontalPass: "--",
+	connectorBranchTee: "+-",
+	connectorBranchTeeCo: "+-",
+	connectorMergeTeeCo: "+-",
+	edgeArrow: {
+		forward: "^",
+		rollback: "v",
+		self: "@"
+	},
+	forwardArrow: migrationListForwardArrow("ascii"),
+	emptySource: migrationListEmptySource("ascii")
+};
+function paletteFor(mode) {
+	return mode === "ascii" ? ASCII_PALETTE : UNICODE_PALETTE;
+}
+function arrowForEdgeKind(kind, palette) {
+	return palette.edgeArrow[kind];
+}
+/**
+* The leftmost lane (column 0) renders with the neutral dim lane style rather
+* than a palette hue — in the common single-lane case it has nothing to be told
+* apart from. Used as the "no owning arc" sentinel during colour resolution.
+*/
+const NEUTRAL_LANE = 0;
+/**
+* Forced bold for branch-coloured names. A branched name pairs its lane hue
+* (also forced, via {@link laneColorForColumn}) with bold; both must emit even
+* when colorette's ambient TTY detection is off, so the colorized branch name
+* is deterministically bold + hue rather than hue-only.
+*/
+const { bold: forcedBold } = createColors({ useColor: true });
+/**
+* Resolve per-cell colour columns for a row. Scanning right-to-left lets each
+* arc bridge inherit the corner column that closes it (the arc's back-lane), so
+* the whole arc — vertical run (already its own column), horizontal bridges,
+* corners, crossings, and the `◂`/`─` connector — reads as a single continuous
+* hue. A crossing can only be one colour, so rather than leave it dim (wrong for
+* both crossing lines) it takes the arc owning the horizontal run at this row
+* (the nearest corner to its right); the crossed vertical lane is simply
+* occluded at that one cell and reappears on the next row.
+*/
+function resolveRowLaneColors(cells) {
+	const lane = new Array(cells.length);
+	const connector = new Array(cells.length);
+	let arcCorner = NEUTRAL_LANE;
+	for (let column = cells.length - 1; column >= 0; column--) {
+		const cell = cells[column];
+		connector[column] = arcCorner;
+		switch (cell?.kind) {
+			case "arc-branch-corner":
+			case "arc-land-corner":
+				arcCorner = column;
+				lane[column] = column;
+				break;
+			case "arc-branch-tee":
+				lane[column] = column;
+				break;
+			case "arc-crossing":
+			case "arc-land-bridge":
+				lane[column] = arcCorner;
+				break;
+			case "horizontal-pass":
+				lane[column] = arcCorner === NEUTRAL_LANE ? column : arcCorner;
+				break;
+			case "node":
+				lane[column] = column;
+				arcCorner = NEUTRAL_LANE;
+				break;
+			default:
+				lane[column] = column;
+				arcCorner = NEUTRAL_LANE;
+		}
+	}
+	return {
+		lane,
+		connector
+	};
+}
+/**
+* Resolve per-cell connector colours. Scanning right-to-left, a corner or an
+* intermediate tee anchors its own lane (its junction glyph takes that column),
+* but a tee's **trailing dash leads into the branch on its right** (the next
+* branch point), so `┬─` reads as "this lane, then on toward the next" rather
+* than tinting the dash with the left lane. The leading tee at `startLane` (the
+* fork/merge origin) and pure horizontal segments inherit the nearest branch
+* point to their right whole-cell, so the run into a branch — or collapsing
+* into a merge corner — stays continuous. Pass-through verticals outside the
+* run keep their own column (column 0 stays neutral).
+*/
+function resolveConnectorLaneColors(cells, startLane) {
+	const glyph = new Array(cells.length);
+	const dash = new Array(cells.length);
+	let owner = NEUTRAL_LANE;
+	for (let column = cells.length - 1; column >= 0; column--) switch (cells[column]?.kind) {
+		case "branch-corner":
+		case "merge-corner":
+			owner = column;
+			glyph[column] = column;
+			dash[column] = column;
+			break;
+		case "branch-tee":
+		case "merge-tee":
+			if (column === startLane) {
+				const served = owner === NEUTRAL_LANE ? column : owner;
+				glyph[column] = column;
+				dash[column] = served;
+			} else {
+				dash[column] = owner === NEUTRAL_LANE ? column : owner;
+				glyph[column] = column;
+				owner = column;
+			}
+			break;
+		case "arc-crossing":
+			glyph[column] = column;
+			dash[column] = column;
+			break;
+		case "horizontal-pass": {
+			const served = owner === NEUTRAL_LANE ? column : owner;
+			glyph[column] = served;
+			dash[column] = served;
+			break;
+		}
+		default:
+			glyph[column] = column;
+			dash[column] = column;
+	}
+	return {
+		glyph,
+		dash
+	};
+}
+/**
+* Style a structural glyph by its resolved colour column. Column 0 and the
+* neutral sentinel render dim (`style.lane`); columns ≥ 1 take a palette hue.
+*/
+function laneStylerForColumn(colorColumn, colorize, style) {
+	if (!colorize || colorColumn <= NEUTRAL_LANE) return (text) => style.lane(text);
+	return laneColorForColumn(colorColumn);
+}
+/**
+* Tint a branch-owned token (direction arrow, migration name) by its edge's
+* lane so the whole branch row reads in one colour. Column 0 has nothing to be
+* told apart from in the common linear chain, so it keeps the token's existing
+* default styling (`fallback`) rather than a palette hue; only lanes ≥ 1 take a
+* colour. With colour off, the fallback (also colourless) is used unchanged.
+*/
+function branchStylerOrDefault(column, colorize, fallback) {
+	if (!colorize || column <= NEUTRAL_LANE) return fallback;
+	return laneColorForColumn(column);
+}
+/**
+* Render a connector tee (`├─` / `┬─` / `┴─`) with its junction glyph and its
+* trailing dash coloured independently: the junction anchors its own lane while
+* the dash leads into the branch on its right.
+*/
+function renderConnectorTee(pair, glyphColumn, dashColumn, colorize, style) {
+	const glyph = laneStylerForColumn(glyphColumn, colorize, style);
+	if (glyphColumn === dashColumn) return glyph(pair);
+	return glyph(pair.slice(0, 1)) + laneStylerForColumn(dashColumn, colorize, style)(pair.slice(1));
+}
+/**
+* A node-marker glyph pair (`○◂`, `○─`, `*<`, `*-`) is the contract node
+* marker (`○` / `*`) followed by an arc connector (`◂` / `─` / `<` / `-`). The
+* marker takes its own lane's hue (so each node visibly belongs to its branch);
+* the connector follows the arc it belongs to (its owning back-lane hue).
+* Direction arrows are handled elsewhere — they take their edge's lane hue too.
+*/
+function renderNodeMarkerPair(pair, nodeColumn, arcColumn, colorize, style) {
+	const marker = laneStylerForColumn(nodeColumn, colorize, style);
+	const connector = laneStylerForColumn(arcColumn, colorize, style);
+	return marker(pair.slice(0, 1)) + connector(pair.slice(1));
+}
+function renderCellPair(cell, column, colors, colorize, style, palette) {
+	const lane = laneStylerForColumn(colors.lane[column] ?? column, colorize, style);
+	switch (cell.kind) {
+		case "node": {
+			const arcColumn = colors.connector[column] ?? NEUTRAL_LANE;
+			if (cell.arcLand === true) return renderNodeMarkerPair(palette.arcLand, column, arcColumn, colorize, style);
+			if (cell.arcTee === true) return renderNodeMarkerPair(palette.arcTee, column, arcColumn, colorize, style);
+			return lane(palette.node);
+		}
+		case "vertical-pass": return lane(palette.verticalPass);
+		case "edge-lane": return cell.ownsLabel ? lane(palette.verticalPass.trimEnd()) + branchStylerOrDefault(column, colorize, style.kind)(arrowForEdgeKind(cell.edgeKind, palette)) : lane(palette.verticalPass);
+		case "branch-tee": return lane(palette.branchTee);
+		case "merge-tee": return lane(palette.mergeTee);
+		case "branch-corner": return lane(palette.branchCorner);
+		case "merge-corner": return lane(palette.mergeCorner);
+		case "arc-branch-corner": return lane(palette.arcBranchCorner);
+		case "arc-branch-tee": return lane(palette.arcBranchTee);
+		case "arc-land-corner": return lane(palette.arcLandCorner);
+		case "arc-crossing": return lane(palette.arcLandBridge);
+		case "arc-land-bridge": return lane(palette.arcLandBridge);
+		case "horizontal-pass": return lane(palette.horizontalPass);
+		case "empty": return "  ";
+	}
+}
+function renderConnectorRow(row, gridWidth, colorize, style, palette) {
+	const isMerge = row.kind === "merge-connector";
+	if (row.cells.length > 0) {
+		const colors = resolveConnectorLaneColors(row.cells, row.startLane ?? 0);
+		let seenTee = false;
+		let out = "";
+		for (let column = 0; column < row.cells.length; column++) {
+			const cell = row.cells[column];
+			if (cell === void 0) continue;
+			const glyphColumn = colors.glyph[column] ?? column;
+			const dashColumn = colors.dash[column] ?? glyphColumn;
+			const lane = laneStylerForColumn(glyphColumn, colorize, style);
+			switch (cell.kind) {
+				case "branch-tee":
+					out += renderConnectorTee(seenTee ? palette.connectorBranchTeeCo : palette.connectorBranchTee, glyphColumn, dashColumn, colorize, style);
+					seenTee = true;
+					break;
+				case "merge-tee":
+					out += renderConnectorTee(seenTee ? palette.connectorMergeTeeCo : palette.connectorBranchTee, glyphColumn, dashColumn, colorize, style);
+					seenTee = true;
+					break;
+				case "branch-corner":
+					out += lane(palette.branchCorner);
+					break;
+				case "merge-corner":
+					out += lane(palette.mergeCorner);
+					break;
+				case "vertical-pass":
+					out += lane(palette.verticalPass);
+					break;
+				case "horizontal-pass":
+					out += lane(palette.horizontalPass);
+					break;
+				case "arc-crossing":
+					out += renderConnectorTee(palette.arcCrossing, glyphColumn, dashColumn, colorize, style);
+					break;
+				default: out += "  ";
+			}
+		}
+		for (let column = row.cells.length; column < gridWidth; column++) out += "  ";
+		return out;
+	}
+	const start = row.startLane ?? 0;
+	const end = row.endLane ?? start;
+	const runLane = laneStylerForColumn(end, colorize, style);
+	let out = "";
+	for (let column = 0; column < gridWidth; column++) if (column < start || column > end) out += "  ";
+	else if (column === start) out += runLane(palette.connectorBranchTee);
+	else if (column === end) out += runLane(isMerge ? palette.mergeCorner : palette.branchCorner);
+	else out += runLane(isMerge ? palette.connectorMergeTeeCo : palette.connectorBranchTeeCo);
+	return out;
+}
+function abbreviateHash(hash, hashLength, emptySource) {
+	if (hash === EMPTY_CONTRACT_HASH) return emptySource;
+	return (hash.startsWith("sha256:") ? hash.slice(7) : hash).slice(0, hashLength);
+}
+const MIN_HASH_DATA_COLUMN = 25;
+function overlayNamesForContract(contractHash, opts) {
+	const names = [];
+	const userRefs = opts.refsByHash?.get(contractHash);
+	if (userRefs) names.push(...[...userRefs].sort((a, b) => a.localeCompare(b)));
+	if (opts.dbHash === contractHash) names.push(DB_MARKER_NAME);
+	if (opts.contractHash === contractHash && contractHash !== EMPTY_CONTRACT_HASH) names.push(CONTRACT_MARKER_NAME);
+	return names;
+}
+function createTreeStyler(opts) {
+	const base = createAnsiMigrationListStyler({ useColor: opts.colorize });
+	const activeRefName = opts.activeRefName;
+	if (!opts.colorize || activeRefName === void 0) return base;
+	return {
+		...base,
+		refs: (names) => {
+			const styledNames = names.map((name) => name === activeRefName ? bold(name) : name);
+			return base.refs(styledNames);
+		}
+	};
+}
+function formatEdgeHashColumn(edge, style, hashLength, palette) {
+	if (edge.kind === "self") {
+		const hash = abbreviateHash(edge.from, hashLength, palette.emptySource);
+		return `${style.sourceHash(hash)} ${style.glyph(palette.forwardArrow)} ${style.destHash(hash)}`;
+	}
+	return `${edge.from === EMPTY_CONTRACT_HASH ? style.glyph(palette.emptySource) + " ".repeat(Math.max(0, hashLength - palette.emptySource.length)) : style.sourceHash(abbreviateHash(edge.from, hashLength, palette.emptySource))} ${style.glyph(palette.forwardArrow)} ${style.destHash(abbreviateHash(edge.to, hashLength, palette.emptySource))}`;
+}
+function padVisible(text, targetWidth) {
+	const padding = Math.max(0, targetWidth - stringWidth(text));
+	return text + " ".repeat(padding);
+}
+const ANSI_ESCAPE = "\x1B";
+function trimTrailingWhitespace(line) {
+	const trailingSpaceBeforeReset = new RegExp(`[\\t ]+((?:${ANSI_ESCAPE}\\[[0-9;]*m)+)$`);
+	return line.replace(trailingSpaceBeforeReset, "$1").replace(/\s+$/, "");
+}
+function gridWidthForModel(rows) {
+	return rows.reduce((max, row) => row.kind === "node" || row.kind === "edge" ? Math.max(max, row.cells.length) : max, 1);
+}
+function maxDirNameLength(edges) {
+	if (edges.length === 0) return 0;
+	return Math.max(...edges.map((edge) => edge.dirName.length));
+}
+function rowDirNameWidth(labelColumn, maxDirNameLen, dirNameGap) {
+	return Math.max(maxDirNameLen + dirNameGap, MIN_HASH_DATA_COLUMN - labelColumn);
+}
+function gridUsesSkipRollbackArcs(rows) {
+	return rows.some((row) => row.cells.some((cell) => cell.kind === "edge-lane" && cell.adjacency === "node-skipping-rollback"));
+}
+function edgeLabelColumn(row, wideLabelColumn) {
+	if (wideLabelColumn !== void 0) return wideLabelColumn;
+	const laneIndex = row.laneIndex ?? 0;
+	if (row.edge?.from === EMPTY_CONTRACT_HASH && laneIndex === 0) return (laneIndex + 1) * 2 + LABEL_GAP;
+	return row.cells.some((cell, index) => index > laneIndex && cell.kind === "vertical-pass") ? row.cells.length * 2 + LABEL_GAP : (laneIndex + 1) * 2 + LABEL_GAP;
+}
+function nodeHasArcDecoration(row) {
+	return row.cells.some((cell) => cell.kind === "node" && (cell.arcTee === true || cell.arcLand === true));
+}
+function renderMigrationGraphTree(model, opts) {
+	const palette = paletteFor(opts.glyphMode ?? "unicode");
+	const style = createTreeStyler(opts);
+	const hashLength = opts.hashLength ?? 7;
+	const gridWidth = gridWidthForModel(model.rows);
+	const wideLabelColumn = gridUsesSkipRollbackArcs(model.rows) ? gridWidth * 2 + 4 : void 0;
+	const dirNameGap = wideLabelColumn !== void 0 ? 3 : LABEL_GAP;
+	const maxDirNameLen = maxDirNameLength(model.rows.filter((row) => row.kind === "edge" && row.edge !== void 0).map((row) => row.edge));
+	const lines = [];
+	for (let rowIndex = 0; rowIndex < model.rows.length; rowIndex++) {
+		const row = model.rows[rowIndex];
+		if (row === void 0) continue;
+		if (row.kind === "component-separator") {
+			lines.push("");
+			continue;
+		}
+		if (row.kind === "branch-connector" || row.kind === "merge-connector") {
+			lines.push(trimTrailingWhitespace(renderConnectorRow(row, gridWidth, opts.colorize, style, palette)));
+			continue;
+		}
+		const cellColors = resolveRowLaneColors(row.cells);
+		let gutter = row.cells.map((cell, column) => renderCellPair(cell, column, cellColors, opts.colorize, style, palette)).join("");
+		let laneSpan = row.cells.length;
+		if (row.kind === "node") if ((row.contractHash ?? EMPTY_CONTRACT_HASH) === EMPTY_CONTRACT_HASH) laneSpan = 1;
+		else {
+			let lastActiveColumn = -1;
+			for (let column = row.cells.length - 1; column >= 0; column--) if (row.cells[column]?.kind !== "empty") {
+				lastActiveColumn = column;
+				break;
+			}
+			laneSpan = lastActiveColumn >= 0 ? lastActiveColumn + 1 : 1;
+		}
+		const labelColumn = row.kind === "edge" ? edgeLabelColumn(row, wideLabelColumn) : wideLabelColumn !== void 0 && (nodeHasArcDecoration(row) || row.contractHash !== void 0) ? wideLabelColumn : laneSpan * 2 + LABEL_GAP;
+		if (row.kind === "edge" && row.edge?.from === EMPTY_CONTRACT_HASH && (row.laneIndex ?? 0) === 0) gutter = row.cells.slice(0, 1).map((cell, column) => renderCellPair(cell, column, cellColors, opts.colorize, style, palette)).join("");
+		else if (row.kind === "node" && laneSpan < row.cells.length && !nodeHasArcDecoration(row)) gutter = row.cells.slice(0, laneSpan).map((cell, column) => renderCellPair(cell, column, cellColors, opts.colorize, style, palette)).join("");
+		else if (gutter.length < laneSpan * 2) gutter = gutter.padEnd(laneSpan * 2, " ");
+		const dirNameWidth = rowDirNameWidth(labelColumn, maxDirNameLen, dirNameGap);
+		const dataColumn = labelColumn + dirNameWidth;
+		const gutterPad = padVisible(gutter, labelColumn);
+		if (row.kind === "node") {
+			const contractHash = row.contractHash ?? EMPTY_CONTRACT_HASH;
+			if (contractHash === EMPTY_CONTRACT_HASH) {
+				const trailingLanes = row.cells.slice(1).map((cell, offset) => renderCellPair(cell, offset + 1, cellColors, opts.colorize, style, palette)).join("");
+				const emptyGutter = palette.emptySource.padEnd(2, " ") + trailingLanes;
+				const overlayNames = overlayNamesForContract(contractHash, opts);
+				if (overlayNames.length === 0) {
+					lines.push(trimTrailingWhitespace(emptyGutter));
+					continue;
+				}
+				const overlay = style.refs(overlayNames);
+				lines.push(trimTrailingWhitespace(`${padVisible(emptyGutter, dataColumn)}${overlay}`));
+				continue;
+			}
+			const hashText = style.sourceHash(abbreviateHash(contractHash, hashLength, palette.emptySource));
+			const overlayNames = overlayNamesForContract(contractHash, opts);
+			const overlayPad = overlayNames.length > 0 ? " ".repeat(Math.max(0, dataColumn - labelColumn - stringWidth(hashText))) : "";
+			const overlay = overlayNames.length > 0 ? style.refs(overlayNames) : "";
+			lines.push(trimTrailingWhitespace(`${gutterPad}${hashText}${overlayPad}${overlay}`));
+			continue;
+		}
+		const edge = row.edge;
+		if (edge === void 0) continue;
+		const dirNamePadding = " ".repeat(Math.max(0, dirNameWidth - edge.dirName.length));
+		const laneIndex = row.laneIndex ?? 0;
+		const dirName = `${(opts.colorize && laneIndex > NEUTRAL_LANE ? (text) => forcedBold(laneColorForColumn(laneIndex)(text)) : style.dirName)(edge.dirName)}${dirNamePadding}`;
+		const hashColumn = formatEdgeHashColumn(edge, style, hashLength, palette);
+		lines.push(trimTrailingWhitespace(`${gutterPad}${dirName}${hashColumn}`));
+	}
+	return lines.join("\n");
+}
+/**
+* A compact key for the `--tree` visual language: the contract marker, the
+* in-lane direction arrows, the empty baseline, the `(refs)` overlay (including
+* the reserved `db` live-database and `contract` working-schema markers), and a
+* worked sample of the data-column `from → to` migration hash arrow.
+*
+* Honors the same glyph palette (unicode vs ASCII) and `colorize` gate as the
+* tree renderer, so the key matches whatever the graph itself drew and stays
+* pipe-safe (zero ANSI when color is off). The caller adds the trailing blank
+* line that separates this stderr key from the graph on stdout.
+*/
+function renderMigrationGraphLegend(opts) {
+	const palette = paletteFor(opts.glyphMode ?? "unicode");
+	const style = createAnsiMigrationListStyler({ useColor: opts.colorize });
+	const node = palette.node.trimEnd();
+	const sampleArrow = `${style.sourceHash("aaaaaa")} ${style.glyph(palette.forwardArrow)} ${style.destHash("bbbbbb")}`;
+	return [
+		"Legend:",
+		`  ${style.kind(node)} contract   ${style.kind(palette.edgeArrow.forward)} forward   ${style.kind(palette.edgeArrow.rollback)} rollback`,
+		`  ${style.kind(palette.edgeArrow.self)} migration without schema change`,
+		`  ${style.glyph(palette.emptySource)} empty database (baseline)`,
+		`  ${style.refs(["refs"])} ${DB_MARKER_NAME} / ${CONTRACT_MARKER_NAME} markers`,
+		`  ${sampleArrow}   migration from contract aaaaaa to bbbbbb`
+	].join("\n");
+}
+//#endregion
+//#region src/commands/migration-graph.ts
+/**
+* `--legend` describes the `--tree` visual language, so passing it auto-enables
+* the tree path (it has nothing to say about the legacy dagre default).
+*/
+function migrationGraphUsesTree(options) {
+	return options.tree === true || options.legend === true;
+}
+/**
+* The legend is decoration printed alongside the command header on stderr, so
+* it is suppressed for the machine-readable / silent paths (`--json`, `--dot`,
+* `--quiet`) exactly as the header is.
+*/
+function migrationGraphShowsLegend(options, flags) {
+	return options.legend === true && options.dot !== true && flags.json !== true && flags.quiet !== true;
+}
+async function executeMigrationGraphCommand(options, flags, ui) {
+	const config = await loadConfig(options.config);
+	const { configPath, appMigrationsRelative, migrationsDir } = resolveMigrationPaths(options.config, config);
+	if (!flags.json && !flags.quiet) {
+		const header = formatStyledHeader({
+			command: "migration graph",
+			description: "Show the migration graph topology",
+			details: [{
+				label: "config",
+				value: configPath
+			}, {
+				label: "migrations",
+				value: appMigrationsRelative
+			}],
+			flags
+		});
+		ui.stderr(header);
+		if (migrationGraphShowsLegend(options, flags)) {
+			ui.stderr(renderMigrationGraphLegend({
+				colorize: flags.color !== false,
+				glyphMode: ui.resolveGlyphMode(options.ascii === true)
+			}));
+			ui.stderr("");
+		}
+	}
+	const loaded = await buildReadAggregate(config, { migrationsDir });
+	if (!loaded.ok) return loaded;
+	const { aggregate, contractHash } = loaded.value;
+	const graph = aggregate.app.graph();
+	return ok({
+		ok: true,
+		graph,
+		contractHash,
+		refs: Object.entries(aggregate.app.refs).map(([name, entry]) => ({
+			name,
+			hash: entry.hash,
+			active: false
+		})),
+		summary: `${graph.nodes.size} node(s), ${graph.migrationByHash.size} edge(s)`
+	});
+}
+function createMigrationGraphCommand() {
+	const command = new Command("graph");
+	setCommandDescriptions(command, "Show the migration graph topology", "Renders the migration graph topology. Offline — does not consult\nthe database. Use --tree for the condensed annotated tree\n(--ascii swaps box-drawing for pipe-friendly ASCII glyphs),\n--json for machine-readable output, or --dot for Graphviz DOT\nformat.");
+	setCommandExamples(command, [
+		"prisma-next migration graph",
+		"prisma-next migration graph --json",
+		"prisma-next migration graph --dot",
+		"prisma-next migration graph --tree",
+		"prisma-next migration graph --tree --ascii",
+		"prisma-next migration graph --legend"
+	]);
+	setCommandSeeAlso(command, [
+		{
+			verb: "migration status",
+			oneLiner: "Show migration path and pending status"
+		},
+		{
+			verb: "migration log",
+			oneLiner: "Show executed migration history"
+		},
+		{
+			verb: "migration list",
+			oneLiner: "List on-disk migrations"
+		},
+		{
+			verb: "migration show",
+			oneLiner: "Display migration package contents"
+		}
+	]);
+	addGlobalOptions(command).option("--config <path>", "Path to prisma-next.config.ts").option("--dot", "Output in Graphviz DOT format").option("--tree", "Experimental condensed annotated tree renderer").option("--ascii", "Use ASCII glyphs for --tree (pipe-friendly)").option("--legend", "Print a key for the --tree glyphs and lane colors (implies --tree)").action(async (options) => {
+		const flags = parseGlobalFlagsOrExit(options);
+		const ui = createTerminalUI(flags);
+		const exitCode = handleResult(await executeMigrationGraphCommand(options, flags, ui), flags, ui, (graphResult) => {
+			if (options.dot) {
+				const lines = ["digraph migrations {"];
+				for (const edge of graphResult.graph.migrationByHash.values()) {
+					const from = edge.from.slice(0, 12);
+					const to = edge.to.slice(0, 12);
+					lines.push(`  "${from}" -> "${to}" [label="${edge.dirName}"];`);
+				}
+				lines.push("}");
+				ui.output(lines.join("\n"));
+			} else if (flags.json) {
+				const nodes = [...graphResult.graph.nodes];
+				const edges = [...graphResult.graph.migrationByHash.values()].map((e) => ({
+					dirName: e.dirName,
+					from: e.from,
+					to: e.to,
+					migrationHash: e.migrationHash
+				}));
+				ui.output(JSON.stringify({
+					ok: true,
+					nodes,
+					edges,
+					summary: graphResult.summary
+				}, null, 2));
+			} else if (!flags.quiet) if (migrationGraphUsesTree(options)) {
+				const refsByHash = /* @__PURE__ */ new Map();
+				for (const ref of graphResult.refs) {
+					const existing = refsByHash.get(ref.hash);
+					refsByHash.set(ref.hash, existing ? [...existing, ref.name] : [ref.name]);
+				}
+				const layout = buildMigrationGraphLayout(buildMigrationGraphRows(graphResult.graph, { ...graphResult.contractHash !== null ? { contractHash: graphResult.contractHash } : {} }));
+				const activeRef = graphResult.refs.find((ref) => ref.active);
+				const treeOutput = renderMigrationGraphTree(layout, {
+					refsByHash,
+					...graphResult.contractHash !== null ? { contractHash: graphResult.contractHash } : {},
+					...activeRef !== void 0 ? { activeRefName: activeRef.name } : {},
+					colorize: flags.color !== false,
+					glyphMode: ui.resolveGlyphMode(options.ascii === true)
+				});
+				ui.output(treeOutput);
+				ui.output(`\n${graphResult.summary}`);
+			} else {
+				const renderInput = migrationGraphToRenderInput({
+					graph: graphResult.graph,
+					mode: "offline",
+					markerHash: void 0,
+					contractHash: graphResult.contractHash ?? EMPTY_CONTRACT_HASH,
+					refs: graphResult.refs,
+					activeRefHash: void 0,
+					activeRefName: void 0,
+					edgeStatuses: []
+				});
+				const graphOutput = graphRenderer.render(renderInput.graph, {
+					...renderInput.options,
+					colorize: flags.color !== false
+				});
+				ui.log(graphOutput);
+				ui.log(`\n${graphResult.summary}`);
+			}
+		});
+		process.exit(exitCode);
+	});
+	return command;
+}
+//#endregion
+export { migrationGraphUsesTree as i, executeMigrationGraphCommand as n, migrationGraphShowsLegend as r, createMigrationGraphCommand as t };
+
+//# sourceMappingURL=migration-graph-C9WC-7eO.mjs.map