prisma-next 0.12.0-dev.3 → 0.12.0-dev.31

package/dist/migration-graph-space-render-dmLLWift.mjs

@@ -0,0 +1,1966 @@
+import { bold, createColors, cyan, cyanBright, dim, green, yellow } 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 coLandingLanes = routes.filter((other) => other.edge.to === edge.to).map((other) => other.backLane);
+		const maxCoLandingLane = Math.max(...coLandingLanes);
+		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-tee" && 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) {
+				if (coLandingLanes.includes(lane)) {
+					cells[lane] = { kind: "arc-land-tee" };
+					continue;
+				}
+				const existing = cells[lane];
+				cells[lane] = existing !== void 0 && existing.kind !== "empty" && existing.kind !== "horizontal-pass" && existing.kind !== "arc-land-bridge" && existing.kind !== "arc-land-tee" || routes.some((other) => other.edge.migrationHash !== edge.migrationHash && other.backLane === lane && routeCrossesRow(other, targetRowIndex, result)) ? { kind: "arc-crossing" } : { kind: "arc-land-bridge" };
+			}
+			cells[backLane] = backLane < maxCoLandingLane ? { kind: "arc-land-tee" } : { 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-tee" && 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-list-graph-topology.ts
+function compareDirNameDesc(a, b) {
+	return b.dirName.localeCompare(a.dirName);
+}
+function bumpDegree(map, key) {
+	map.set(key, (map.get(key) ?? 0) + 1);
+}
+function compareNodesRootFirst(a, b) {
+	if (a === EMPTY_CONTRACT_HASH) return -1;
+	if (b === EMPTY_CONTRACT_HASH) return 1;
+	return a.localeCompare(b);
+}
+/**
+* Shortest-path distance of each node from the forward roots, over the given
+* candidate edges. Roots are the in-degree-0 nodes (baseline first, then lex);
+* a rooted component therefore distances every node by how many forward steps
+* it sits from a root. A component with no root (a pure cycle) is seeded from
+* its single lexically-smallest node so the cycle still gets a stable layering.
+*
+* Crucially this is *shortest* path, not longest: a backward (rollback) edge
+* `deep → shallow` never offers a shorter route to the already-shallower
+* target, so it is inert here. Distances are thus stable whether or not the
+* rollbacks are still in the candidate set — which is what lets the peel below
+* tell a genuine back-edge (target strictly shallower than source) apart from a
+* forward edge that merely happens to share the back-edge's cycle.
+*/
+function forwardDistances(nodes, candidates) {
+	const inDegree = /* @__PURE__ */ new Map();
+	for (const node of nodes) inDegree.set(node, 0);
+	for (const edge of candidates) bumpDegree(inDegree, edge.to);
+	const roots = [...nodes].filter((node) => (inDegree.get(node) ?? 0) === 0);
+	roots.sort(compareNodesRootFirst);
+	const seeds = roots.length > 0 ? roots : [...nodes].sort(compareNodesRootFirst).slice(0, 1);
+	const dist = /* @__PURE__ */ new Map();
+	for (const seed of seeds) dist.set(seed, 0);
+	const maxPasses = nodes.size;
+	for (let pass = 0; pass < maxPasses; pass++) {
+		let changed = false;
+		for (const edge of candidates) {
+			const base = dist.get(edge.from);
+			if (base === void 0) continue;
+			const next = base + 1;
+			if (next < (dist.get(edge.to) ?? Number.POSITIVE_INFINITY)) {
+				dist.set(edge.to, next);
+				changed = true;
+			}
+		}
+		if (!changed) break;
+	}
+	for (const node of nodes) if (!dist.has(node)) dist.set(node, 0);
+	return dist;
+}
+function canReachForward(start, goal, candidates) {
+	if (start === goal) return true;
+	const outgoing = /* @__PURE__ */ new Map();
+	for (const edge of candidates) {
+		const bucket = outgoing.get(edge.from);
+		if (bucket) bucket.push(edge.to);
+		else outgoing.set(edge.from, [edge.to]);
+	}
+	const visited = new Set([start]);
+	const queue = [start];
+	while (queue.length > 0) {
+		const node = queue.shift();
+		if (node === void 0) continue;
+		for (const next of outgoing.get(node) ?? []) {
+			if (next === goal) return true;
+			if (!visited.has(next)) {
+				visited.add(next);
+				queue.push(next);
+			}
+		}
+	}
+	return false;
+}
+/**
+* Demote node-skipping rollbacks left forward by the DFS. An edge `from → to`
+* is a rollback exactly when both hold:
+*   1. `to` is a forward-ancestor of `from` — `to` can still reach `from` over
+*      the other forward edges, so the edge closes a cycle; and
+*   2. `to` is strictly shallower than `from` (smaller forward distance) — the
+*      edge points back toward the root rather than advancing history.
+*
+* Condition 2 is the discriminator: in a cycle created by a rollback every edge
+* satisfies condition 1, but only the rollback itself runs deep → shallow. The
+* forward chain edges run shallow → deep and are never peeled, however many
+* rollbacks converge on the same target. Tight back-edges whose source and
+* target sit at the same distance (mutual two-node cycles) are already resolved
+* by the DFS immediate-parent rule, so they never reach this pass. One edge is
+* peeled per iteration (dirName-descending tie-break) and distances/reachability
+* are recomputed, making the outcome independent of edge input order.
+*/
+function peelNodeSkippingRollbacks(nodes, kindByMigrationHash, nonSelf) {
+	let candidates = nonSelf.filter((edge) => kindByMigrationHash.get(edge.hash) === "forward");
+	while (candidates.length > 0) {
+		const dist = forwardDistances(nodes, candidates);
+		const backEdges = candidates.filter((edge) => {
+			if ((dist.get(edge.to) ?? 0) >= (dist.get(edge.from) ?? 0)) return false;
+			const without = candidates.filter((candidate) => candidate !== edge);
+			return canReachForward(edge.to, edge.from, without);
+		});
+		if (backEdges.length === 0) break;
+		backEdges.sort(compareDirNameDesc);
+		const rollback = backEdges[0];
+		if (rollback === void 0) break;
+		kindByMigrationHash.set(rollback.hash, "rollback");
+		candidates = candidates.filter((edge) => edge !== rollback);
+	}
+}
+/**
+* DFS with dirName-descending traversal. A GRAY target is a rollback only when it
+* is the immediate DFS parent of the source — cross-links to other GRAY nodes
+* stay forward. A follow-up peel pass demotes node-skipping rollbacks (target is
+* a forward-ancestor of the source and sits strictly shallower than it).
+*/
+function classifyNormalizedEdges(edges) {
+	const nodes = /* @__PURE__ */ new Set();
+	const kindByMigrationHash = /* @__PURE__ */ new Map();
+	const outgoingByFrom = /* @__PURE__ */ new Map();
+	const nonSelf = [];
+	for (const edge of edges) {
+		nodes.add(edge.from);
+		nodes.add(edge.to);
+		if (edge.from === edge.to) {
+			kindByMigrationHash.set(edge.hash, "self");
+			continue;
+		}
+		nonSelf.push(edge);
+		const bucket = outgoingByFrom.get(edge.from);
+		if (bucket) bucket.push(edge);
+		else outgoingByFrom.set(edge.from, [edge]);
+	}
+	for (const bucket of outgoingByFrom.values()) bucket.sort(compareDirNameDesc);
+	const nonSelfInDegree = /* @__PURE__ */ new Map();
+	for (const node of nodes) nonSelfInDegree.set(node, 0);
+	for (const bucket of outgoingByFrom.values()) for (const edge of bucket) bumpDegree(nonSelfInDegree, edge.to);
+	const dfsRoots = [];
+	for (const node of nodes) if ((nonSelfInDegree.get(node) ?? 0) === 0) dfsRoots.push(node);
+	dfsRoots.sort((a, b) => {
+		if (a === EMPTY_CONTRACT_HASH) return -1;
+		if (b === EMPTY_CONTRACT_HASH) return 1;
+		return a.localeCompare(b);
+	});
+	if (dfsRoots.length === 0) dfsRoots.push(...[...nodes].sort((a, b) => a.localeCompare(b)));
+	const WHITE = 0;
+	const GRAY = 1;
+	const BLACK = 2;
+	const color = /* @__PURE__ */ new Map();
+	const dfsParent = /* @__PURE__ */ new Map();
+	for (const node of nodes) color.set(node, WHITE);
+	const stack = [];
+	function isImmediateDfsParent(ancestor, node) {
+		return dfsParent.get(node) === ancestor;
+	}
+	function pushFrame(node, parent) {
+		color.set(node, GRAY);
+		dfsParent.set(node, parent);
+		stack.push({
+			node,
+			outgoing: outgoingByFrom.get(node) ?? [],
+			index: 0
+		});
+	}
+	function runDfsFrom(root) {
+		if (color.get(root) !== WHITE) return;
+		pushFrame(root, void 0);
+		while (stack.length > 0) {
+			const frame = stack[stack.length - 1];
+			if (frame === void 0) break;
+			if (frame.index >= frame.outgoing.length) {
+				color.set(frame.node, BLACK);
+				stack.pop();
+				continue;
+			}
+			const edge = frame.outgoing[frame.index];
+			frame.index += 1;
+			if (edge === void 0) continue;
+			const v = edge.to;
+			const vColor = color.get(v);
+			if (vColor === GRAY && isImmediateDfsParent(v, frame.node)) kindByMigrationHash.set(edge.hash, "rollback");
+			else {
+				kindByMigrationHash.set(edge.hash, "forward");
+				if (vColor === WHITE) pushFrame(v, frame.node);
+			}
+		}
+	}
+	for (const root of dfsRoots) runDfsFrom(root);
+	const remainingWhite = [...nodes].filter((node) => color.get(node) === WHITE);
+	remainingWhite.sort((a, b) => a.localeCompare(b));
+	for (const root of remainingWhite) runDfsFrom(root);
+	peelNodeSkippingRollbacks(nodes, kindByMigrationHash, nonSelf);
+	const forwardInDegree = /* @__PURE__ */ new Map();
+	const forwardOutDegree = /* @__PURE__ */ new Map();
+	for (const edge of edges) {
+		if (kindByMigrationHash.get(edge.hash) !== "forward") continue;
+		bumpDegree(forwardOutDegree, edge.from);
+		bumpDegree(forwardInDegree, edge.to);
+	}
+	return {
+		kindByMigrationHash,
+		forwardInDegree,
+		forwardOutDegree
+	};
+}
+/**
+* Classify forward/rollback/self for a `MigrationGraph` edge set (Tier-3).
+*/
+function classifyMigrationGraphTopology(graph) {
+	const normalized = [];
+	for (const edges of graph.forwardChain.values()) for (const edge of edges) normalized.push({
+		hash: edge.migrationHash,
+		from: edge.from,
+		to: edge.to,
+		dirName: edge.dirName
+	});
+	return classifyNormalizedEdges(normalized);
+}
+//#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 maxRank(rank) {
+	let max = 0;
+	for (const value of rank.values()) if (value > max) max = value;
+	return max;
+}
+function layerNodesByLongestForwardPath(componentNodes, topology, graph, contractHash) {
+	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);
+	if (contractHash !== void 0 && contractHash !== EMPTY_CONTRACT_HASH && componentNodes.has(contractHash) && (forwardOut.get(contractHash) ?? []).length === 0) rank.set(contractHash, maxRank(rank) + 1);
+	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 isForwardLeaf(node, edges) {
+	return !edges.some((e) => e.kind === "forward" && e.from === node && e.from !== e.to);
+}
+function forwardReachableFrom(start, forwardTo) {
+	const reachable = new Set([start]);
+	const queue = [start];
+	while (queue.length > 0) {
+		const node = queue.shift();
+		if (node === void 0) continue;
+		for (const next of forwardTo.get(node) ?? []) if (!reachable.has(next)) {
+			reachable.add(next);
+			queue.push(next);
+		}
+	}
+	return reachable;
+}
+function buildForwardToMap(edges) {
+	const forwardTo = /* @__PURE__ */ new Map();
+	for (const edge of edges) {
+		if (edge.kind !== "forward" || edge.from === edge.to) continue;
+		const bucket = forwardTo.get(edge.from);
+		if (bucket) bucket.push(edge.to);
+		else forwardTo.set(edge.from, [edge.to]);
+	}
+	return forwardTo;
+}
+function sortEdgesForContractHashTrunk(edges, contractHash) {
+	if (contractHash === void 0 || contractHash === EMPTY_CONTRACT_HASH || !isForwardLeaf(contractHash, edges)) return edges;
+	const preferredLeaf = contractHash;
+	const forwardTo = buildForwardToMap(edges);
+	const reachability = /* @__PURE__ */ new Map();
+	function canReachContractHash(from) {
+		let cached = reachability.get(from);
+		if (cached === void 0) {
+			cached = forwardReachableFrom(from, forwardTo);
+			reachability.set(from, cached);
+		}
+		return cached.has(preferredLeaf);
+	}
+	function trunkBias(edge) {
+		if (edge.kind !== "forward" || edge.from === edge.to) return 0;
+		if (edge.to === preferredLeaf) return 2;
+		if (canReachContractHash(edge.to)) return 1;
+		return 0;
+	}
+	return edges.map((edge, index) => ({
+		edge,
+		index,
+		bias: trunkBias(edge)
+	})).sort((a, b) => {
+		if (a.edge.from !== b.edge.from) return a.index - b.index;
+		if (a.bias !== b.bias) return b.bias - a.bias;
+		return a.index - b.index;
+	}).map(({ edge }) => edge);
+}
+function rebuildEdgeLookupMaps(edges) {
+	const edgesByFrom = /* @__PURE__ */ new Map();
+	const edgesByTo = /* @__PURE__ */ new Map();
+	for (const classified of edges) {
+		const fromBucket = edgesByFrom.get(classified.from);
+		if (fromBucket) fromBucket.push(classified);
+		else edgesByFrom.set(classified.from, [classified]);
+		const toBucket = edgesByTo.get(classified.to);
+		if (toBucket) toBucket.push(classified);
+		else edgesByTo.set(classified.to, [classified]);
+	}
+	return {
+		edgesByFrom,
+		edgesByTo
+	};
+}
+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 = [];
+	for (const edgeList of graph.forwardChain.values()) for (const edge of edgeList) {
+		const kind = topology.kindByMigrationHash.get(edge.migrationHash) ?? "forward";
+		edges.push({
+			migrationHash: edge.migrationHash,
+			from: edge.from,
+			to: edge.to,
+			dirName: edge.dirName,
+			kind
+		});
+	}
+	const sortedEdges = sortEdgesForContractHashTrunk(edges, options.contractHash);
+	const { edgesByFrom, edgesByTo } = rebuildEdgeLookupMaps(sortedEdges);
+	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, options.contractHash);
+		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: sortedEdges,
+		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);
+}
+/**
+* Style a structural glyph by its resolved colour column. Column 0 and the
+* neutral sentinel render dim (`dimLane`); columns ≥ 1 take a palette hue.
+*/
+function stylerForLaneColumn(colorColumn, colorize, dimLane) {
+	if (!colorize || colorColumn <= 0) return dimLane;
+	return laneColorForColumn(colorColumn);
+}
+/**
+* Resolve per-cell colour columns for a node/arc row. Scanning right-to-left
+* lets each arc segment inherit the hue of the arc it leads into.
+*/
+function resolveRowArcLaneColors(cells) {
+	const lane = new Array(cells.length);
+	const connector = new Array(cells.length);
+	const dash = new Array(cells.length);
+	let arcCorner = 0;
+	let landingAnchor = 0;
+	for (let column = cells.length - 1; column >= 0; column--) {
+		const cell = cells[column];
+		connector[column] = landingAnchor !== 0 ? landingAnchor : arcCorner;
+		switch (cell?.kind) {
+			case "arc-branch-corner":
+				arcCorner = column;
+				lane[column] = column;
+				dash[column] = column;
+				break;
+			case "arc-land-corner":
+				arcCorner = column;
+				landingAnchor = column;
+				lane[column] = column;
+				dash[column] = column;
+				break;
+			case "arc-branch-tee":
+				lane[column] = column;
+				dash[column] = column;
+				break;
+			case "arc-land-tee":
+				lane[column] = column;
+				dash[column] = landingAnchor === 0 ? column : landingAnchor;
+				landingAnchor = column;
+				break;
+			case "arc-crossing":
+			case "arc-land-bridge": {
+				const served = landingAnchor !== 0 ? landingAnchor : arcCorner;
+				lane[column] = served;
+				dash[column] = served;
+				break;
+			}
+			case "horizontal-pass":
+				lane[column] = arcCorner === 0 ? column : arcCorner;
+				dash[column] = lane[column] ?? column;
+				break;
+			case "node":
+				lane[column] = column;
+				dash[column] = column;
+				arcCorner = 0;
+				landingAnchor = 0;
+				break;
+			default:
+				lane[column] = column;
+				dash[column] = column;
+				arcCorner = 0;
+				landingAnchor = 0;
+		}
+	}
+	return {
+		lane,
+		connector,
+		dash
+	};
+}
+/**
+* Resolve per-cell connector colours. Scanning right-to-left, a corner or an
+* intermediate tee anchors its own lane, but a tee's trailing dash leads into
+* the branch on its right.
+*/
+function resolveConnectorLaneColors(cells, startLane) {
+	const glyph = new Array(cells.length);
+	const dash = new Array(cells.length);
+	let owner = 0;
+	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 === 0 ? column : owner;
+				glyph[column] = column;
+				dash[column] = served;
+			} else {
+				dash[column] = owner === 0 ? column : owner;
+				glyph[column] = column;
+				owner = column;
+			}
+			break;
+		case "arc-crossing":
+			glyph[column] = column;
+			dash[column] = owner === 0 ? column : owner;
+			owner = column;
+			break;
+		case "horizontal-pass": {
+			const served = owner === 0 ? column : owner;
+			glyph[column] = served;
+			dash[column] = served;
+			break;
+		}
+		default:
+			glyph[column] = column;
+			dash[column] = column;
+	}
+	return {
+		glyph,
+		dash
+	};
+}
+function migrationListForwardArrow(glyphMode) {
+	return glyphMode === "ascii" ? "->" : "→";
+}
+function migrationListEmptySource(glyphMode) {
+	return glyphMode === "ascii" ? "-" : "∅";
+}
+function abbreviateContractHash(hash) {
+	return (hash.startsWith("sha256:") ? hash.slice(7) : hash).slice(0, 7);
+}
+function padFromHashColumn(text, width) {
+	const padding = Math.max(0, width - stringWidth(text));
+	return `${" ".repeat(padding)}${text}`;
+}
+//#endregion
+//#region src/utils/formatters/migration-list-render.ts
+const IDENTITY_MIGRATION_LIST_STYLER = {
+	kind: (text) => text,
+	dirName: (text) => text,
+	sourceHash: (text) => text,
+	destHash: (text) => text,
+	glyph: (text) => text,
+	lane: (text) => text,
+	invariants: (ids) => `{${ids.join(", ")}}`,
+	refs: (names) => `(${names.join(", ")})`,
+	spaceHeading: (text) => text,
+	summary: (text) => text,
+	emptyState: (text) => text
+};
+function canonicalFrom(from) {
+	return from ?? EMPTY_CONTRACT_HASH;
+}
+function migrationGraphFromListEntries(entries) {
+	const nodes = /* @__PURE__ */ new Set();
+	const forwardChain = /* @__PURE__ */ new Map();
+	const reverseChain = /* @__PURE__ */ new Map();
+	const migrationByHash = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		const from = canonicalFrom(entry.from);
+		const edge = {
+			from,
+			to: entry.to,
+			migrationHash: entry.migrationHash,
+			dirName: entry.dirName,
+			createdAt: entry.createdAt,
+			invariants: entry.providedInvariants
+		};
+		nodes.add(from);
+		nodes.add(entry.to);
+		const forward = forwardChain.get(from);
+		if (forward) forward.push(edge);
+		else forwardChain.set(from, [edge]);
+		const reverse = reverseChain.get(entry.to);
+		if (reverse) reverse.push(edge);
+		else reverseChain.set(entry.to, [edge]);
+		migrationByHash.set(entry.migrationHash, edge);
+	}
+	return {
+		nodes,
+		forwardChain,
+		reverseChain,
+		migrationByHash
+	};
+}
+function buildEdgeAnnotationsByHashFromListEntries(entries) {
+	const annotations = /* @__PURE__ */ new Map();
+	for (const entry of entries) annotations.set(entry.migrationHash, {
+		operationCount: entry.operationCount,
+		invariants: entry.providedInvariants
+	});
+	return annotations;
+}
+function buildRefsByHashFromListEntries(entries) {
+	const refsByHash = /* @__PURE__ */ new Map();
+	for (const entry of entries) if (entry.refs.length > 0) refsByHash.set(entry.to, entry.refs);
+	return refsByHash;
+}
+function formatEmptyStateLine(spaceId, style) {
+	return style.emptyState(`There are no migrations in migrations/${spaceId}/ yet`);
+}
+function renderSpaceTreeBlock(spaceId, migrations, multiSpace, glyphMode, style, colorize, liveContractHash, graphForSpace, globalMaxEdgeTreePrefixWidth, globalMaxDirNameWidth) {
+	if (migrations.length === 0) {
+		const emptyLine = formatEmptyStateLine(spaceId, style);
+		if (!multiSpace) return [emptyLine];
+		return [style.spaceHeading(`${spaceId}:`), `  ${emptyLine}`];
+	}
+	const treeOutput = renderMigrationGraphSpaceTree({
+		graph: graphForSpace(spaceId) ?? migrationGraphFromListEntries(migrations),
+		migrations,
+		liveContractHash,
+		glyphMode,
+		colorize,
+		refsByHash: buildRefsByHashFromListEntries(migrations),
+		styler: style,
+		...globalMaxEdgeTreePrefixWidth !== void 0 ? { globalMaxEdgeTreePrefixWidth } : {},
+		...globalMaxDirNameWidth !== void 0 ? { globalMaxDirNameWidth } : {}
+	});
+	if (!multiSpace) return treeOutput.length === 0 ? [] : [treeOutput];
+	const indented = indentMigrationGraphTreeBlock(treeOutput, "  ");
+	return [style.spaceHeading(`${spaceId}:`), indented];
+}
+/**
+* Compose the styled `migration list` human output via the shared tree
+* renderer. Each on-disk migration is one edge row with package-fact
+* annotations; refs decorate destination contract nodes.
+*
+* `options.colorize` must match whether `style` emits ANSI (e.g. both true for
+* `createAnsiMigrationListStyler({ useColor: true })`).
+*/
+function renderMigrationListWithStyle(result, style, glyphMode = "unicode", options = {}) {
+	const multiSpace = result.spaces.length > 1;
+	const colorize = options.colorize ?? false;
+	const liveContractHash = options.liveContractHash ?? EMPTY_CONTRACT_HASH;
+	const graphForSpace = options.graphForSpace ?? (() => void 0);
+	const globalLayoutInputs = multiSpace ? result.spaces.filter((space) => space.migrations.length > 0).map((space) => ({
+		graph: graphForSpace(space.spaceId) ?? migrationGraphFromListEntries(space.migrations),
+		liveContractHash
+	})) : [];
+	const globalMaxEdgeTreePrefixWidth = globalLayoutInputs.length > 0 ? computeGlobalMaxEdgeTreePrefixWidth(globalLayoutInputs) : void 0;
+	const globalMaxDirNameWidth = globalLayoutInputs.length > 0 ? computeGlobalMaxDirNameWidth(globalLayoutInputs) : void 0;
+	const lines = [];
+	for (let index = 0; index < result.spaces.length; index++) {
+		const space = result.spaces[index];
+		if (index > 0) lines.push("");
+		lines.push(...renderSpaceTreeBlock(space.spaceId, space.migrations, multiSpace, glyphMode, style, colorize, liveContractHash, graphForSpace, globalMaxEdgeTreePrefixWidth, globalMaxDirNameWidth));
+	}
+	if (result.spaces.reduce((count, space) => count + space.migrations.length, 0) > 0) {
+		lines.push("");
+		lines.push(style.summary(result.summary));
+	}
+	return lines.join("\n");
+}
+//#endregion
+//#region src/utils/formatters/migration-list-styler.ts
+function hasMarkersFormatter(styler) {
+	return "markers" in styler && typeof styler.markers === "function";
+}
+function styleMarkerName(name) {
+	return name === "contract" ? bold(green(name)) : green(name);
+}
+function plainMarkers(names) {
+	return `<${names.join(", ")}>`;
+}
+function formatContractNodeOverlays(styler, markers, refs) {
+	const parts = [];
+	if (markers.length > 0) parts.push(hasMarkersFormatter(styler) ? styler.markers(markers) : plainMarkers(markers));
+	if (refs.length > 0) parts.push(styler.refs(refs));
+	return parts.join(" ");
+}
+/**
+* The current contract overlay marker. Unlike user refs, this names the user's
+* declared desired state — the implicit base/target for `plan` / `migrate` —
+* not a stored label. It is emphasized (bold) so it stands out from plain refs
+* (including the live-database `db` marker, which is just another ref).
+*/
+const CONTRACT_MARKER_NAME = "contract";
+function styleRefName(name) {
+	return green(name);
+}
+/**
+* Build a {@link MigrationListStyler} that decorates `migration list`
+* tokens with ANSI SGR codes. When `useColor` is `false` (non-TTY,
+* `--no-color`, `NO_COLOR=1`, piped output) the function returns the
+* shared identity styler so callers get plain text with zero ANSI
+* bytes — pipe-friendly by construction.
+*
+* Palette:
+*
+* - `dirName`: bold
+* - `sourceHash`: dim cyan
+* - `destHash`: bright cyan
+* - `kind` (`*` / `↩` / `⟲`): bright — the signal; lanes and arrows dim
+* - `glyph` (`→` / `⟲` / `∅`): dim
+* - `lane` (graph gutter lines `│` and fan/join connectors `├─┐` / `├─┘`): dim
+* - `invariants` (`{...}`): yellow
+* - `markers` (`<...>`): green; the `contract` desired-state marker inside is
+*   green-bold (`db` is plain green)
+* - `refs` (`(...)`): green (the active ref is bolded separately by the tree styler)
+* - `spaceHeading` (`<spaceId>:`): bold
+* - `summary`: dim
+* - `emptyState`: dim
+*/
+function createAnsiMigrationListStyler(opts) {
+	if (!opts.useColor) return {
+		...IDENTITY_MIGRATION_LIST_STYLER,
+		markers: plainMarkers
+	};
+	return {
+		kind: (text) => text,
+		dirName: (text) => bold(text),
+		sourceHash: (text) => dim(cyan(text)),
+		destHash: (text) => cyanBright(text),
+		glyph: (text) => dim(text),
+		lane: (text) => dim(text),
+		invariants: (ids) => yellow(`{${ids.join(", ")}}`),
+		markers: (names) => {
+			const open = green("<");
+			const close = green(">");
+			const separator = green(", ");
+			return open + names.map(styleMarkerName).join(separator) + close;
+		},
+		refs: (names) => {
+			const open = green("(");
+			const close = green(")");
+			const separator = green(", ");
+			return open + names.map(styleRefName).join(separator) + close;
+		},
+		spaceHeading: (text) => bold(text),
+		summary: (text) => dim(text),
+		emptyState: (text) => dim(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: "╯ ",
+	arcLandTee: "┴─",
+	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: "/ ",
+	arcLandTee: "+-",
+	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 overlayStatusGlyphs(mode) {
+	return mode === "ascii" ? {
+		applied: "+",
+		pending: ">"
+	} : {
+		applied: "✓",
+		pending: "⧗"
+	};
+}
+function arrowForEdgeKind(kind, palette) {
+	return palette.edgeArrow[kind];
+}
+/**
+* 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 });
+function laneStylerForColumn(colorColumn, colorize, style) {
+	return stylerForLaneColumn(colorColumn, colorize, style.lane);
+}
+/**
+* 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 <= 0) return fallback;
+	return laneColorForColumn(column);
+}
+/**
+* Render a crossing tee (`┼─`): the junction stays dim/neutral so neither arc
+* steals the cell; the trailing dash takes the served lane hue.
+*/
+function renderArcCrossing(pair, dashColumn, colorize, style) {
+	const junction = colorize ? style.lane : (text) => text;
+	const dash = laneStylerForColumn(dashColumn, colorize, style);
+	return junction(pair.slice(0, 1)) + dash(pair.slice(1));
+}
+/**
+* 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 laneColumn = colors.lane[column] ?? column;
+	const lane = laneStylerForColumn(laneColumn, colorize, style);
+	switch (cell.kind) {
+		case "node": {
+			const arcColumn = colors.connector[column] ?? 0;
+			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-land-tee": return renderConnectorTee(palette.arcLandTee, laneColumn, colors.dash[column] ?? laneColumn, colorize, style);
+		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 += renderArcCrossing(palette.arcCrossing, 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 markers = [];
+	const refs = [];
+	const userRefs = opts.refsByHash?.get(contractHash);
+	if (userRefs) refs.push(...[...userRefs].sort((a, b) => a.localeCompare(b)));
+	if (opts.contractHash === contractHash && contractHash !== EMPTY_CONTRACT_HASH) markers.push(CONTRACT_MARKER_NAME);
+	if (opts.dbHash === contractHash) markers.push(DB_MARKER_NAME);
+	markers.sort((a, b) => {
+		if (a === "contract") return -1;
+		if (b === "contract") return 1;
+		return a.localeCompare(b);
+	});
+	return {
+		markers,
+		refs
+	};
+}
+function createTreeStyler(opts) {
+	const base = opts.styler ?? 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 formatEdgeAnnotationSuffix(migrationHash, opts, style) {
+	const annotation = opts.edgeAnnotationsByHash?.get(migrationHash);
+	if (annotation === void 0) return "";
+	const segments = [];
+	if (annotation.operationCount !== void 0) segments.push(`${annotation.operationCount} ops`);
+	if (annotation.invariants !== void 0 && annotation.invariants.length > 0) segments.push(style.invariants(annotation.invariants));
+	const status = annotation.status;
+	if (status !== void 0) {
+		const glyphs = overlayStatusGlyphs(opts.glyphMode ?? "unicode");
+		const glyph = status === "applied" ? glyphs.applied : glyphs.pending;
+		const label = status === "applied" ? "applied" : "pending";
+		if (!opts.colorize) segments.push(`${glyph} ${label}`);
+		else {
+			const styler = status === "applied" ? green : yellow;
+			segments.push(styler(`${glyph} ${label}`));
+		}
+	}
+	if (segments.length === 0) return "";
+	return `  ${segments.join("  ")}`;
+}
+function formatEdgeHashColumn(edge, style, hashLength, palette) {
+	if (edge.kind === "self") {
+		const hash = abbreviateHash(edge.from, hashLength, palette.emptySource);
+		return `${padFromHashColumn(style.sourceHash(hash), hashLength)} ${style.glyph(palette.forwardArrow)} ${style.destHash(hash)}`;
+	}
+	return `${edge.from === EMPTY_CONTRACT_HASH ? padFromHashColumn(style.glyph(palette.emptySource), hashLength) : padFromHashColumn(style.sourceHash(abbreviateHash(edge.from, hashLength, palette.emptySource)), hashLength)} ${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 maxEdgeTreePrefixWidth(rows, wideLabelColumn) {
+	let max = 0;
+	for (const row of rows) {
+		if (row.kind !== "edge" || row.edge === void 0) continue;
+		max = Math.max(max, edgeLabelColumn(row, wideLabelColumn));
+	}
+	return max;
+}
+function computeMaxEdgeTreePrefixWidthForLayout(model) {
+	const wideLabelColumn = gridUsesSkipRollbackArcs(model.rows) ? gridWidthForModel(model.rows) * 2 + 4 : void 0;
+	return maxEdgeTreePrefixWidth(model.rows, wideLabelColumn);
+}
+function computeMaxDirNameLengthForLayout(model) {
+	return maxDirNameLength(model.rows.filter((row) => row.kind === "edge" && row.edge !== void 0).map((row) => row.edge));
+}
+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 effectiveMaxDirNameLen = opts.globalMaxDirNameWidth ?? maxDirNameLen;
+	const maxEdgePrefixWidth = opts.globalMaxEdgeTreePrefixWidth ?? maxEdgeTreePrefixWidth(model.rows, wideLabelColumn);
+	const edgeDirNameWidth = rowDirNameWidth(maxEdgePrefixWidth, effectiveMaxDirNameLen, dirNameGap);
+	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 = resolveRowArcLaneColors(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" ? maxEdgePrefixWidth : 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 = row.kind === "edge" ? edgeDirNameWidth : rowDirNameWidth(labelColumn, maxDirNameLen, dirNameGap);
+		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 overlays = overlayNamesForContract(contractHash, opts);
+				if (overlays.markers.length === 0 && overlays.refs.length === 0) {
+					lines.push(trimTrailingWhitespace(emptyGutter));
+					continue;
+				}
+				const overlay = formatContractNodeOverlays(style, overlays.markers, overlays.refs);
+				lines.push(trimTrailingWhitespace(`${emptyGutter}${" ".repeat(LABEL_GAP)}${overlay}`));
+				continue;
+			}
+			const hashText = style.sourceHash(abbreviateHash(contractHash, hashLength, palette.emptySource));
+			const overlays = overlayNamesForContract(contractHash, opts);
+			const hasOverlays = overlays.markers.length > 0 || overlays.refs.length > 0;
+			const overlayPad = hasOverlays ? " ".repeat(LABEL_GAP) : "";
+			const overlay = hasOverlays ? formatContractNodeOverlays(style, overlays.markers, overlays.refs) : "";
+			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 > 0 ? (text) => forcedBold(laneColorForColumn(laneIndex)(text)) : style.dirName)(edge.dirName)}${dirNamePadding}`;
+		const hashColumn = formatEdgeHashColumn(edge, style, hashLength, palette);
+		const annotationSuffix = formatEdgeAnnotationSuffix(edge.migrationHash, opts, style);
+		lines.push(trimTrailingWhitespace(`${gutterPad}${dirName}${hashColumn}${annotationSuffix}`));
+	}
+	return lines.join("\n");
+}
+function formatLegendExampleMarkers(colorize) {
+	if (!colorize) return "<contract, db>";
+	const open = green("<");
+	const close = green(">");
+	const separator = green(", ");
+	return open + green("contract") + separator + green("db") + close;
+}
+/**
+* A compact key for the tree visual language: the contract node glyph, the
+* in-lane direction arrows, the empty baseline, the system-marker `<…>` and
+* user-ref `(…)` bracket conventions (two illustrative example lines), 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 tree 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")}`;
+	const statusGlyphs = overlayStatusGlyphs(opts.glyphMode ?? "unicode");
+	const appliedPending = opts.colorize ? `  ${green(statusGlyphs.applied)} ${style.summary("applied")}   ${yellow(statusGlyphs.pending)} ${style.summary("pending")}` : `  ${statusGlyphs.applied} ${style.summary("applied")}   ${statusGlyphs.pending} ${style.summary("pending")}`;
+	const exampleMarkers = formatLegendExampleMarkers(opts.colorize);
+	const exampleRefs = opts.colorize ? style.refs(["prod", "staging"]) : "(prod, staging)";
+	return [
+		"Legend:",
+		`  ${style.kind(node)} ${style.summary("contract")}   ${style.kind(palette.edgeArrow.forward)} ${style.summary("forward")}   ${style.kind(palette.edgeArrow.rollback)} ${style.summary("rollback")}`,
+		`  ${style.kind(palette.edgeArrow.self)} ${style.summary("migration without schema change")}`,
+		appliedPending,
+		`  ${style.kind(palette.emptySource)} ${style.summary("empty database (baseline)")}`,
+		`  ${exampleMarkers} ${style.summary("live markers (contract on disk, database state)")}`,
+		`  ${exampleRefs} ${style.summary("user-defined refs")}`,
+		`  ${sampleArrow}   ${style.summary("migration from contract aaaaaa to bbbbbb")}`
+	].join("\n");
+}
+//#endregion
+//#region src/utils/formatters/migration-graph-space-render.ts
+function mergeMigrationEdgeAnnotations(listOverlay, statusOverlay) {
+	const merged = /* @__PURE__ */ new Map();
+	for (const [migrationHash, listAnnotation] of listOverlay) {
+		const statusAnnotation = statusOverlay.get(migrationHash);
+		merged.set(migrationHash, {
+			...listAnnotation,
+			...statusAnnotation?.status !== void 0 ? { status: statusAnnotation.status } : {}
+		});
+	}
+	return merged;
+}
+function computeGlobalMaxEdgeTreePrefixWidth(inputs) {
+	let globalMax = 0;
+	for (const input of inputs) {
+		const layout = buildMigrationGraphLayout(buildMigrationGraphRows(input.graph, { contractHash: input.liveContractHash }));
+		globalMax = Math.max(globalMax, computeMaxEdgeTreePrefixWidthForLayout(layout));
+	}
+	return globalMax;
+}
+function computeGlobalMaxDirNameWidth(inputs) {
+	let globalMax = 0;
+	for (const input of inputs) {
+		const layout = buildMigrationGraphLayout(buildMigrationGraphRows(input.graph, { contractHash: input.liveContractHash }));
+		globalMax = Math.max(globalMax, computeMaxDirNameLengthForLayout(layout));
+	}
+	return globalMax;
+}
+function renderMigrationGraphSpaceTreeInternal(input) {
+	const layout = buildMigrationGraphLayout(buildMigrationGraphRows(input.graph, { contractHash: input.liveContractHash }));
+	const listOverlay = buildEdgeAnnotationsByHashFromListEntries(input.migrations);
+	const edgeAnnotationsByHash = input.statusOverlayByHash === void 0 ? listOverlay : mergeMigrationEdgeAnnotations(listOverlay, input.statusOverlayByHash);
+	return renderMigrationGraphTree(layout, {
+		refsByHash: input.refsByHash ?? buildRefsByHashFromListEntries(input.migrations),
+		contractHash: input.liveContractHash,
+		edgeAnnotationsByHash,
+		colorize: input.colorize,
+		glyphMode: input.glyphMode,
+		...input.dbHash !== void 0 ? { dbHash: input.dbHash } : {},
+		...input.styler !== void 0 ? { styler: input.styler } : {},
+		...input.globalMaxEdgeTreePrefixWidth !== void 0 ? { globalMaxEdgeTreePrefixWidth: input.globalMaxEdgeTreePrefixWidth } : {},
+		...input.globalMaxDirNameWidth !== void 0 ? { globalMaxDirNameWidth: input.globalMaxDirNameWidth } : {}
+	});
+}
+function renderMigrationGraphSpaceTree(input) {
+	return renderMigrationGraphSpaceTreeInternal(input);
+}
+function indentMigrationGraphTreeBlock(treeOutput, indent) {
+	if (treeOutput.length === 0) return treeOutput;
+	return treeOutput.split("\n").map((line) => line.length === 0 ? line : `${indent}${line}`).join("\n");
+}
+//#endregion
+export { renderMigrationGraphLegend as a, renderMigrationListWithStyle as c, renderMigrationGraphSpaceTree as i, abbreviateContractHash as l, computeGlobalMaxEdgeTreePrefixWidth as n, createAnsiMigrationListStyler as o, indentMigrationGraphTreeBlock as r, IDENTITY_MIGRATION_LIST_STYLER as s, computeGlobalMaxDirNameWidth as t };
+
+//# sourceMappingURL=migration-graph-space-render-dmLLWift.mjs.map