@prisma-next/cli 0.12.0-dev.6 → 0.12.0-dev.61

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

@@ -0,0 +1,2370 @@
+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);
+		const existingLaneEdge = /* @__PURE__ */ new Map();
+		for (const lane of row.passThroughLanes ?? []) {
+			const cell = row.cells[lane];
+			if (cell !== void 0 && "migrationHash" in cell && cell.migrationHash !== void 0) existingLaneEdge.set(lane, cell.migrationHash);
+		}
+		return {
+			...row,
+			cells: buildEdgeCells(row.edge, row.laneIndex, row.passThroughLanes ?? [], adjacency, row.cells.length, existingLaneEdge)
+		};
+	});
+}
+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" }));
+}
+/** Returns `{ migrationHash: hash }` when hash is defined, otherwise `{}`. */
+function hashProp(hash) {
+	return hash !== void 0 ? { migrationHash: hash } : {};
+}
+/** Returns `{ arcMigrationHash: hash }` when hash is defined, otherwise `{}`. */
+function arcHashProp(hash) {
+	return hash !== void 0 ? { arcMigrationHash: hash } : {};
+}
+function buildBranchConnectorCells(startLane, endLane, fanTargetLanes, activeLanes, gridWidth, trunkEdgeHash, fanEdgeHashByLane, laneEdgeByIndex) {
+	const cells = emptyCells(gridWidth);
+	for (let lane = 0; lane < gridWidth; lane++) {
+		if (activeLanes.has(lane) && (lane < startLane || lane > endLane)) {
+			cells[lane] = {
+				kind: "vertical-pass",
+				...hashProp(laneEdgeByIndex.get(lane))
+			};
+			continue;
+		}
+		if (lane === startLane) cells[lane] = {
+			kind: "branch-tee",
+			...hashProp(trunkEdgeHash)
+		};
+		else if (lane === endLane) cells[lane] = {
+			kind: "branch-corner",
+			...hashProp(fanEdgeHashByLane.get(lane))
+		};
+		else if (lane > startLane && lane < endLane) if (fanTargetLanes.has(lane)) cells[lane] = {
+			kind: "branch-tee",
+			...hashProp(fanEdgeHashByLane.get(lane))
+		};
+		else if (activeLanes.has(lane)) cells[lane] = {
+			kind: "arc-crossing",
+			...hashProp(laneEdgeByIndex.get(lane)),
+			...arcHashProp(fanEdgeHashByLane.get(endLane))
+		};
+		else cells[lane] = {
+			kind: "branch-tee",
+			...hashProp(fanEdgeHashByLane.get(lane))
+		};
+	}
+	return cells;
+}
+function buildMergeConnectorCells(startLane, endLane, fanTargetLanes, activeLanes, gridWidth, laneEdgeByIndex) {
+	const cells = emptyCells(gridWidth);
+	for (let lane = 0; lane < gridWidth; lane++) {
+		if (activeLanes.has(lane) && (lane < startLane || lane > endLane)) {
+			cells[lane] = {
+				kind: "vertical-pass",
+				...hashProp(laneEdgeByIndex.get(lane))
+			};
+			continue;
+		}
+		if (lane === startLane) cells[lane] = {
+			kind: "merge-tee",
+			...hashProp(laneEdgeByIndex.get(lane))
+		};
+		else if (lane === endLane) cells[lane] = {
+			kind: "merge-corner",
+			...hashProp(laneEdgeByIndex.get(lane))
+		};
+		else if (lane > startLane && lane < endLane) if (fanTargetLanes.has(lane)) cells[lane] = {
+			kind: "merge-tee",
+			...hashProp(laneEdgeByIndex.get(lane))
+		};
+		else if (activeLanes.has(lane)) cells[lane] = {
+			kind: "arc-crossing",
+			...hashProp(laneEdgeByIndex.get(lane)),
+			...arcHashProp(laneEdgeByIndex.get(endLane))
+		};
+		else cells[lane] = {
+			kind: "horizontal-pass",
+			...hashProp(laneEdgeByIndex.get(startLane))
+		};
+	}
+	return cells;
+}
+function buildNodeCells(contractHash, nodeColumn, activeLanes, gridWidth, laneEdgeByIndex) {
+	const cells = emptyCells(gridWidth);
+	for (const lane of activeLanes) if (lane !== nodeColumn && lane < gridWidth) cells[lane] = {
+		kind: "vertical-pass",
+		...hashProp(laneEdgeByIndex.get(lane))
+	};
+	if (nodeColumn < gridWidth) cells[nodeColumn] = {
+		kind: "node",
+		contractHash
+	};
+	return cells;
+}
+function buildEdgeCells(edge, laneIndex, passThroughLanes, adjacency, gridWidth, laneEdgeByIndex) {
+	const cells = emptyCells(gridWidth);
+	for (const lane of passThroughLanes) if (lane < gridWidth) cells[lane] = {
+		kind: "vertical-pass",
+		...hashProp(laneEdgeByIndex.get(lane))
+	};
+	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 { migrationHash: arcHash } = edge;
+		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",
+						...hashProp(routes.find((r) => r.backLane === lane && r.edge.from === edge.from)?.edge.migrationHash)
+					};
+					continue;
+				}
+				const existing = cells[lane];
+				if (existing !== void 0 && existing.kind !== "empty" && existing.kind !== "horizontal-pass" && existing.kind !== "arc-land-bridge" || routes.some((other) => other.edge.migrationHash !== arcHash && other.backLane === lane && routeCrossesRow(other, sourceRowIndex, result))) cells[lane] = {
+					kind: "arc-crossing",
+					...hashProp(existing !== void 0 && "migrationHash" in existing ? existing.migrationHash : void 0),
+					arcMigrationHash: arcHash
+				};
+				else cells[lane] = {
+					kind: "horizontal-pass",
+					migrationHash: arcHash
+				};
+			}
+			cells[backLane] = backLane < maxCoSourcedLane ? {
+				kind: "arc-branch-tee",
+				migrationHash: arcHash
+			} : {
+				kind: "arc-branch-corner",
+				migrationHash: arcHash
+			};
+		}
+		const edgeRow = result[edgeRowIndex];
+		if (edgeRow !== void 0) {
+			const cells = edgeRow.cells;
+			ensureCellWidth(cells, backLane + 1);
+			const forwardLaneCell = cells[nodeCol];
+			cells[nodeCol] = {
+				kind: "vertical-pass",
+				...hashProp(forwardLaneCell !== void 0 && "migrationHash" in forwardLaneCell ? forwardLaneCell.migrationHash : void 0)
+			};
+			cells[backLane] = {
+				kind: "edge-lane",
+				migrationHash: arcHash,
+				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",
+				migrationHash: arcHash
+			};
+		}
+		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",
+						...hashProp(routes.find((r) => r.backLane === lane && r.edge.to === edge.to)?.edge.migrationHash)
+					};
+					continue;
+				}
+				const existing = cells[lane];
+				if (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 !== arcHash && other.backLane === lane && routeCrossesRow(other, targetRowIndex, result))) cells[lane] = {
+					kind: "arc-crossing",
+					...hashProp(existing !== void 0 && "migrationHash" in existing ? existing.migrationHash : void 0),
+					arcMigrationHash: arcHash
+				};
+				else cells[lane] = {
+					kind: "arc-land-bridge",
+					migrationHash: arcHash
+				};
+			}
+			cells[backLane] = backLane < maxCoLandingLane ? {
+				kind: "arc-land-tee",
+				migrationHash: arcHash
+			} : {
+				kind: "arc-land-corner",
+				migrationHash: arcHash
+			};
+			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",
+					migrationHash: other.edge.migrationHash
+				};
+			}
+		}
+	}
+	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();
+	const laneEdgeByIndex = /* @__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, laneEdgeByIndex)
+		});
+		for (const index of laneIndices) if (index !== startLane) setLane(index, null);
+		return startLane;
+	}
+	function emitBranchConnector(contractHash, startLane, endLane, branchCount, fanTargetLanes, fanEdgeHashByLane) {
+		ensureGridWidth(endLane + 1);
+		const activeLanes = new Set(activeLaneIndices());
+		const trunkEdgeHash = fanEdgeHashByLane.get(startLane) ?? laneEdgeByIndex.get(startLane);
+		rows.push({
+			kind: "branch-connector",
+			contractHash,
+			startLane,
+			endLane,
+			branchCount,
+			cells: buildBranchConnectorCells(startLane, endLane, new Set(fanTargetLanes), activeLanes, gridWidth, trunkEdgeHash, fanEdgeHashByLane, laneEdgeByIndex)
+		});
+	}
+	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, laneEdgeByIndex)
+		};
+		rows.push(convergenceProducer ? {
+			...row,
+			convergenceProducer: true
+		} : row);
+		edgeColumn.set(edge.migrationHash, lane);
+		if (convergenceProducer) producerLaneByHash.set(edge.migrationHash, lane);
+		laneEdgeByIndex.set(lane, edge.migrationHash);
+	}
+	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, laneEdgeByIndex)
+		});
+		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);
+			const fanEdgeHashByLane = /* @__PURE__ */ new Map();
+			for (let groupIndex = 0; groupIndex < groups.length; groupIndex++) {
+				const group = groups[groupIndex];
+				const lane = laneForGroup[groupIndex];
+				if (group === void 0 || lane === void 0) continue;
+				const firstEdge = group.edges[0];
+				if (firstEdge !== void 0) fanEdgeHashByLane.set(lane, firstEdge.migrationHash);
+			}
+			emitBranchConnector(node, column, endLane, groups.length, laneForGroup, fanEdgeHashByLane);
+			for (let groupIndex = 0; groupIndex < groups.length; groupIndex++) {
+				const fanLane = laneForGroup[groupIndex];
+				if (fanLane === void 0) continue;
+				const fanHash = fanEdgeHashByLane.get(fanLane);
+				if (fanHash !== void 0) laneEdgeByIndex.set(fanLane, fanHash);
+			}
+		}
+		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.fromContract);
+		const edge = {
+			from,
+			to: entry.toContract,
+			migrationHash: entry.hash,
+			dirName: entry.name,
+			createdAt: entry.createdAt,
+			invariants: entry.providedInvariants
+		};
+		nodes.add(from);
+		nodes.add(entry.toContract);
+		const forward = forwardChain.get(from);
+		if (forward) forward.push(edge);
+		else forwardChain.set(from, [edge]);
+		const reverse = reverseChain.get(entry.toContract);
+		if (reverse) reverse.push(edge);
+		else reverseChain.set(entry.toContract, [edge]);
+		migrationByHash.set(entry.hash, edge);
+	}
+	return {
+		nodes,
+		forwardChain,
+		reverseChain,
+		migrationByHash
+	};
+}
+function buildEdgeAnnotationsByHashFromListEntries(entries) {
+	const annotations = /* @__PURE__ */ new Map();
+	for (const entry of entries) annotations.set(entry.hash, {
+		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.toContract, 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, appSpaceId, globalMaxEdgeTreePrefixWidth, globalMaxDirNameWidth) {
+	if (migrations.length === 0) {
+		const emptyLine = formatEmptyStateLine(spaceId, style);
+		if (!multiSpace) return [emptyLine];
+		return [style.spaceHeading(`${spaceId}:`), `  ${emptyLine}`];
+	}
+	const graph = graphForSpace(spaceId) ?? migrationGraphFromListEntries(migrations);
+	const isAppSpace = appSpaceId === void 0 ? void 0 : spaceId === appSpaceId;
+	const treeOutput = renderMigrationGraphSpaceTree({
+		graph,
+		migrations,
+		liveContractHash,
+		glyphMode,
+		colorize,
+		refsByHash: buildRefsByHashFromListEntries(migrations),
+		styler: style,
+		...isAppSpace !== void 0 ? { isAppSpace } : {},
+		...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 appSpaceId = options.appSpaceId;
+	const globalLayoutInputs = multiSpace ? result.spaces.filter((space) => space.migrations.length > 0).map((space) => ({
+		graph: graphForSpace(space.space) ?? 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.space, space.migrations, multiSpace, glyphMode, style, colorize, liveContractHash, graphForSpace, appSpaceId, 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.map((name) => `@${name}`).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` (`@contract @db`): green; the `contract` desired-state marker is
+*   green-bold (`db` is plain green); the `@` sigil is applied to each name
+* - `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 sigil = green("@");
+			return names.map((name) => sigil + styleMarkerName(name)).join(" ");
+		},
+		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-color functions that always emit ANSI regardless of the ambient TTY
+* environment (NO_COLOR, piped output). Used for:
+*
+* - `forcedBold`: branch-coloured migration names pair their lane hue with bold;
+*   both must emit so the name is deterministically bold + hue.
+* - `forcedDim`: off-path path-highlight override (migrate --show).
+*   The renderer gates this behind `opts.colorize`; the forced variant ensures
+*   ANSI is emitted in controlled environments (e.g. tests with `NO_COLOR=1`)
+*   when the caller explicitly requests colour. Without forcing, `dim()` from
+*   the ambient module-level import no-ops under NO_COLOR, making the
+*   path-highlight unreachable in tests.
+*/
+const { bold: forcedBold, dim: forcedDim, greenBright: forcedGreen } = createColors({ useColor: true });
+/**
+* The two styles used in `migrate --show` path-highlight mode.
+*
+* In path-highlight mode the normal by-branch rotating-colour logic
+* (`LANE_COLOR_CYCLE` / `laneStylerForColumn`) is suppressed entirely.
+* Every glyph, name, and hash is styled by its on-path / off-path role,
+* never by lane column index.
+*
+* - `onPath`: neutral single-path style — exactly how a linear (no-branch)
+*   section renders today. Lane glyphs are dim, names are bold, hashes use
+*   the default `sourceHash`/`destHash` colours. No rotation hue is applied.
+*   This is identical to how the pgvector single-path section renders.
+* - `offPath`: uniform dim grey on every cell (name, hashes, lane glyphs,
+*   direction arrows).
+*
+* To change the on-path or off-path colour in future, edit this object only.
+*/
+const PATH_HIGHLIGHT_STYLES = {
+	/**
+	* Lane/glyph/arrow stylers for on-path cells.
+	*
+	* - lane: `forcedGreen` when colour is on — bright green so the on-path
+	*   branch glyphs (`│ ├ ╯ ↑`) and node markers (`○`/`∅`) are visually
+	*   distinct from off-path (dim grey). Uses forced ANSI so it survives
+	*   NO_COLOR in tests. Identity when `colorize` is false.
+	* - arrow: identity (plain, no colouring)
+	* - dirName: `bold` (ambient bold — name stays white/bold, not green)
+	* - hashOverride: undefined — `style.sourceHash`/`style.destHash` apply
+	*   normally (cyan) so hashes keep their existing neutral colour.
+	*
+	* `style` is the same `MigrationListStyler` the tree renderer uses.
+	* Rotation (`LANE_COLOR_CYCLE`) is never applied to on-path cells.
+	*/
+	onPath: (_style, colorize) => ({
+		lane: colorize ? forcedGreen : (text) => text,
+		arrow: (text) => text,
+		dirName: (text) => bold(text),
+		hashOverride: void 0
+	}),
+	/**
+	* Lane/glyph/arrow/hash stylers for off-path cells.
+	* Uniform dim grey on everything — uses `forcedDim` so ANSI is emitted even
+	* under NO_COLOR (test environments use `colorize:true` + NO_COLOR=1 to verify dim).
+	* Returns identity functions when colour is off (`colorize: false`).
+	*/
+	offPath: (colorize) => ({
+		lane: colorize ? forcedDim : (text) => text,
+		arrow: colorize ? forcedDim : (text) => text,
+		dirName: colorize ? forcedDim : (text) => text,
+		hashOverride: colorize ? forcedDim : void 0
+	})
+};
+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.
+*
+* When `laneOverride` is provided (for path-highlight rows), it replaces the
+* marker styler. `arcLaneOverride` (if provided) replaces the connector styler
+* independently — this matters when the node is on-path but the arc belongs to
+* an off-path rollback edge, which must render dim rather than green.
+*/
+function renderNodeMarkerPair(pair, nodeColumn, arcColumn, colorize, style, laneOverride, arcLaneOverride) {
+	const marker = laneOverride ?? laneStylerForColumn(nodeColumn, colorize, style);
+	const connector = arcLaneOverride ?? laneOverride ?? laneStylerForColumn(arcColumn, colorize, style);
+	return marker(pair.slice(0, 1)) + connector(pair.slice(1));
+}
+function renderCellPair(cell, column, colors, colorize, style, palette, laneOverride, arrowOverride, arcLaneOverride) {
+	const laneColumn = colors.lane[column] ?? column;
+	const lane = laneOverride ?? laneStylerForColumn(laneColumn, colorize, style);
+	const arrow = arrowOverride ?? ((text) => branchStylerOrDefault(column, colorize, style.kind)(text));
+	switch (cell.kind) {
+		case "node": {
+			const arcColumn = colors.connector[column] ?? 0;
+			if (cell.arcLand === true) return renderNodeMarkerPair(palette.arcLand, column, arcColumn, colorize, style, laneOverride, arcLaneOverride);
+			if (cell.arcTee === true) return renderNodeMarkerPair(palette.arcTee, column, arcColumn, colorize, style, laneOverride, arcLaneOverride);
+			return lane(palette.node);
+		}
+		case "vertical-pass": return lane(palette.verticalPass);
+		case "edge-lane": return cell.ownsLabel ? lane(palette.verticalPass.trimEnd()) + arrow(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 laneOverride !== void 0 ? laneOverride(palette.arcLandTee) : 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 "  ";
+	}
+}
+/**
+* Render a branch-connector or merge-connector row.
+*
+* `columnLaneOverride` is an optional per-column map populated when path-highlight
+* annotations are active (`migrate --show`). For each column in the connector's
+* lane range, the map supplies the override styler (dim for off-path) that should
+* replace the normal rotating-lane colour for that column. Columns absent from the
+* map (on-path or unannotated) use the standard `laneStylerForColumn` logic unchanged.
+* This ensures off-path branch connectors appear dim rather than in their rotation
+* colour (e.g. magenta).
+*/
+function renderConnectorRow(row, gridWidth, colorize, style, palette, columnLaneOverride) {
+	const resolvedLane = (column) => columnLaneOverride?.get(column) ?? laneStylerForColumn(column, colorize, style);
+	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 override = columnLaneOverride?.get(glyphColumn);
+			const dashOverrideForPathHighlight = columnLaneOverride?.get(dashColumn) ?? override;
+			if (override !== void 0 || columnLaneOverride !== void 0 && dashOverrideForPathHighlight !== void 0) {
+				const effectiveOverride = override ?? dashOverrideForPathHighlight;
+				if (effectiveOverride === void 0) {
+					out += "  ";
+					continue;
+				}
+				switch (cell.kind) {
+					case "branch-tee":
+					case "merge-tee": {
+						const pair = seenTee ? palette.connectorBranchTeeCo : palette.connectorBranchTee;
+						out += effectiveOverride(pair.slice(0, 1)) + effectiveOverride(pair.slice(1));
+						seenTee = true;
+						break;
+					}
+					case "branch-corner":
+						out += effectiveOverride(palette.branchCorner);
+						break;
+					case "merge-corner":
+						out += effectiveOverride(palette.mergeCorner);
+						break;
+					case "vertical-pass":
+						out += effectiveOverride(palette.verticalPass);
+						break;
+					case "horizontal-pass":
+						out += effectiveOverride(palette.horizontalPass);
+						break;
+					case "arc-crossing": {
+						const arcCrossingDashOverride = columnLaneOverride?.get(dashColumn) ?? effectiveOverride;
+						out += effectiveOverride(palette.arcCrossing.slice(0, 1)) + arcCrossingDashOverride(palette.arcCrossing.slice(1));
+						break;
+					}
+					default: out += "  ";
+				}
+				continue;
+			}
+			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 = resolvedLane(end);
+	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.isAppSpace !== false && 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 isOffPath = annotation.pathHighlight === "off-path";
+	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 (annotation.pathHighlight === "on-path") {
+		const glyph = opts.glyphMode === "ascii" ? ">" : "↑";
+		segments.push(`${glyph} will run`);
+	}
+	if (segments.length === 0) return "";
+	const suffix = `  ${segments.join("  ")}`;
+	return opts.colorize && isOffPath ? forcedDim(suffix) : suffix;
+}
+/**
+* Format the `from → to` hash data column for an edge row.
+*
+* When `hashOverride` is provided (off-path → `dim`), it replaces ALL sub-stylers
+* (`sourceHash`, `destHash`, arrow `glyph`) so dim reaches every character without
+* inner ANSI codes (e.g. the dim+cyan of `sourceHash`) overriding it. On-path edges
+* carry no override. Without an override, the normal `style` sub-stylers apply.
+*/
+function formatEdgeHashColumn(edge, style, hashLength, palette, hashOverride) {
+	const src = hashOverride ?? style.sourceHash;
+	const dst = hashOverride ?? style.destHash;
+	const glyph = hashOverride ?? style.glyph;
+	if (edge.kind === "self") {
+		const hash = abbreviateHash(edge.from, hashLength, palette.emptySource);
+		return `${padFromHashColumn(src(hash), hashLength)} ${glyph(palette.forwardArrow)} ${dst(hash)}`;
+	}
+	return `${edge.from === EMPTY_CONTRACT_HASH ? padFromHashColumn(glyph(palette.emptySource), hashLength) : padFromHashColumn(src(abbreviateHash(edge.from, hashLength, palette.emptySource)), hashLength)} ${glyph(palette.forwardArrow)} ${dst(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 contractHighlights = /* @__PURE__ */ new Map();
+	if (opts.edgeAnnotationsByHash) for (const row of model.rows) {
+		if (row.kind !== "edge" || row.edge === void 0) continue;
+		const annotation = opts.edgeAnnotationsByHash.get(row.edge.migrationHash);
+		if (annotation?.pathHighlight === void 0) continue;
+		const highlight = annotation.pathHighlight;
+		for (const hash of [row.edge.from, row.edge.to]) {
+			if (hash === EMPTY_CONTRACT_HASH) continue;
+			if (contractHighlights.get(hash) !== "on-path") contractHighlights.set(hash, highlight);
+		}
+	}
+	const pathHighlightActive = opts.edgeAnnotationsByHash !== void 0;
+	/**
+	* Resolve the lane and arrow overrides for a row in path-highlight mode.
+	* - on-path → neutral single-path style (style.lane for glyphs, plain arrow, bold name).
+	*   Rotation colour is suppressed; `style.sourceHash`/`style.destHash` apply for hashes.
+	* - off-path → uniform dim grey (forcedDim) on every glyph, arrow, name, and hash.
+	* - undefined → `undefined` (no override). Unannotated rows use normal rotation. This covers
+	*   both non-path-highlight commands (graph/status/list) and any annotation without pathHighlight.
+	* - When pathHighlightActive is false: always returns undefined, preserving normal rotation.
+	*/
+	function pathStyleForHighlight(highlight) {
+		if (!pathHighlightActive || highlight === void 0) return void 0;
+		if (highlight === "off-path") {
+			const s = PATH_HIGHLIGHT_STYLES.offPath(opts.colorize);
+			return {
+				lane: s.lane,
+				arrow: s.arrow,
+				dirName: s.dirName,
+				hashOverride: s.hashOverride
+			};
+		}
+		const s = PATH_HIGHLIGHT_STYLES.onPath(style, opts.colorize);
+		return {
+			lane: s.lane,
+			arrow: s.arrow,
+			dirName: s.dirName,
+			hashOverride: s.hashOverride
+		};
+	}
+	/**
+	* Lane override for a given highlight in path-highlight mode.
+	* Returns the `lane` part only — used for per-cell overrides.
+	*/
+	function pathLaneFor(highlight) {
+		return pathStyleForHighlight(highlight)?.lane;
+	}
+	/**
+	* Arrow override for a given highlight in path-highlight mode.
+	* Returns the `arrow` part only — used for edge-lane cell arrow rendering.
+	*/
+	function pathArrowFor(highlight) {
+		return pathStyleForHighlight(highlight)?.arrow;
+	}
+	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") {
+			let connectorColumnOverride;
+			if (pathHighlightActive && opts.colorize) {
+				connectorColumnOverride = /* @__PURE__ */ new Map();
+				for (let col = 0; col < row.cells.length; col++) {
+					const cell = row.cells[col];
+					if (cell === void 0 || cell.kind === "empty") continue;
+					const hashForCell = "migrationHash" in cell && cell.migrationHash !== void 0 ? cell.migrationHash : void 0;
+					if (hashForCell === void 0) continue;
+					const highlight = opts.edgeAnnotationsByHash?.get(hashForCell)?.pathHighlight;
+					const override = pathLaneFor(highlight);
+					if (override !== void 0) connectorColumnOverride.set(col, override);
+				}
+				if (connectorColumnOverride.size === 0) connectorColumnOverride = void 0;
+			}
+			lines.push(trimTrailingWhitespace(renderConnectorRow(row, gridWidth, opts.colorize, style, palette, connectorColumnOverride)));
+			continue;
+		}
+		let rowPathHighlight;
+		if (row.kind === "edge" && row.edge !== void 0) rowPathHighlight = opts.edgeAnnotationsByHash?.get(row.edge.migrationHash)?.pathHighlight;
+		else if (row.kind === "node" && row.contractHash !== void 0) rowPathHighlight = contractHighlights.get(row.contractHash);
+		const rowStyle = pathStyleForHighlight(rowPathHighlight);
+		const rowLaneOverride = rowStyle?.lane;
+		const rowArrowOverride = rowStyle?.arrow;
+		const cellColors = resolveRowArcLaneColors(row.cells);
+		let gutter = row.cells.map((cell, column) => {
+			let laneOverride = rowLaneOverride;
+			let arrowOverride = rowArrowOverride;
+			let arcLaneOverride;
+			if (pathHighlightActive) {
+				if (cell.kind === "edge-lane") {
+					const cellHighlight = opts.edgeAnnotationsByHash?.get(cell.migrationHash)?.pathHighlight;
+					laneOverride = pathLaneFor(cellHighlight);
+					arrowOverride = pathArrowFor(cellHighlight);
+				} else if (cell.kind === "node" && (cell.arcTee === true || cell.arcLand === true)) {
+					const arcColumn = cellColors.connector[column] ?? 0;
+					const arcCell = row.cells[arcColumn];
+					const arcHash = arcCell !== void 0 && "migrationHash" in arcCell ? arcCell.migrationHash : void 0;
+					if (arcHash !== void 0) {
+						const arcHighlight = opts.edgeAnnotationsByHash?.get(arcHash)?.pathHighlight;
+						arcLaneOverride = pathLaneFor(arcHighlight);
+					}
+				} else if (cell.kind !== "node" && cell.kind !== "empty") {
+					const hashForCell = cell.kind === "arc-crossing" && "arcMigrationHash" in cell && cell.arcMigrationHash !== void 0 ? cell.arcMigrationHash : "migrationHash" in cell && cell.migrationHash !== void 0 ? cell.migrationHash : void 0;
+					if (hashForCell !== void 0) {
+						const cellHighlight = opts.edgeAnnotationsByHash?.get(hashForCell)?.pathHighlight;
+						laneOverride = pathLaneFor(cellHighlight);
+						arrowOverride = pathArrowFor(cellHighlight);
+					}
+				}
+			}
+			return renderCellPair(cell, column, cellColors, opts.colorize, style, palette, laneOverride, arrowOverride, arcLaneOverride);
+		}).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, rowLaneOverride, rowArrowOverride)).join("");
+		else if (row.kind === "node" && laneSpan < row.cells.length && !nodeHasArcDecoration(row)) gutter = row.cells.slice(0, laneSpan).map((cell, column) => {
+			let cellLaneOverride = rowLaneOverride;
+			let cellArrowOverride = rowArrowOverride;
+			if (pathHighlightActive && cell.kind !== "node" && cell.kind !== "empty") {
+				const hashForCell = cell.kind === "arc-crossing" && "arcMigrationHash" in cell && cell.arcMigrationHash !== void 0 ? cell.arcMigrationHash : "migrationHash" in cell && cell.migrationHash !== void 0 ? cell.migrationHash : void 0;
+				if (hashForCell !== void 0) {
+					const cellHighlight = opts.edgeAnnotationsByHash?.get(hashForCell)?.pathHighlight;
+					cellLaneOverride = pathLaneFor(cellHighlight);
+					cellArrowOverride = pathArrowFor(cellHighlight);
+				}
+			}
+			return renderCellPair(cell, column, cellColors, opts.colorize, style, palette, cellLaneOverride, cellArrowOverride);
+		}).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) => {
+					let cellLaneOverride = rowLaneOverride;
+					let cellArrowOverride = rowArrowOverride;
+					if (pathHighlightActive && cell.kind !== "node" && cell.kind !== "empty") {
+						const hashForCell = cell.kind === "arc-crossing" && "arcMigrationHash" in cell && cell.arcMigrationHash !== void 0 ? cell.arcMigrationHash : "migrationHash" in cell && cell.migrationHash !== void 0 ? cell.migrationHash : void 0;
+						if (hashForCell !== void 0) {
+							const cellHighlight = opts.edgeAnnotationsByHash?.get(hashForCell)?.pathHighlight;
+							cellLaneOverride = pathLaneFor(cellHighlight);
+							cellArrowOverride = pathArrowFor(cellHighlight);
+						}
+					}
+					return renderCellPair(cell, offset + 1, cellColors, opts.colorize, style, palette, cellLaneOverride, cellArrowOverride);
+				}).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 = (rowStyle?.hashOverride ?? 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 edgeGutterPad = padVisible(gutter, labelColumn);
+		let dirName;
+		if (rowStyle !== void 0) dirName = `${(rowStyle.dirName ?? style.dirName)(edge.dirName)}${dirNamePadding}`;
+		else dirName = `${(opts.colorize && laneIndex > 0 ? (text) => forcedBold(laneColorForColumn(laneIndex)(text)) : style.dirName)(edge.dirName)}${dirNamePadding}`;
+		const hashColumnOverride = rowStyle?.hashOverride;
+		const hashColumn = formatEdgeHashColumn(edge, style, hashLength, palette, hashColumnOverride);
+		const annotationSuffix = formatEdgeAnnotationSuffix(edge.migrationHash, opts, style);
+		lines.push(trimTrailingWhitespace(`${edgeGutterPad}${dirName}${hashColumn}${annotationSuffix}`));
+	}
+	return lines.join("\n");
+}
+/**
+* Format a single on-path migration row for the `migrate --show` run-list.
+*
+* Uses the SAME styling as the tree renderer's on-path rows (PATH_HIGHLIGHT_STYLES.onPath)
+* so the run-list and graph tree are byte-for-byte identical in their name/hash columns.
+* The gutter is omitted — the list has no graph structure.
+*
+* This is the SINGLE code path for on-path row styling shared by both the graph tree
+* and the "Will run, in order:" list. To change the on-path colour, edit PATH_HIGHLIGHT_STYLES.
+*/
+function formatOnPathMigrationRow(dirName, from, to, dirNameWidth, colorize, glyphMode) {
+	const palette = paletteFor(glyphMode);
+	const style = createAnsiMigrationListStyler({ useColor: colorize });
+	const styledDirName = `${PATH_HIGHLIGHT_STYLES.onPath(style, colorize).dirName(dirName)}${" ".repeat(Math.max(0, dirNameWidth - dirName.length))}`;
+	const hashLength = 7;
+	const emptySource = palette.emptySource;
+	const fromAbbr = from === EMPTY_CONTRACT_HASH ? padFromHashColumn(style.glyph(emptySource), hashLength) : padFromHashColumn(style.sourceHash(abbreviateHashShort(from, hashLength)), hashLength);
+	const toAbbr = to === EMPTY_CONTRACT_HASH ? style.glyph(emptySource) : style.destHash(abbreviateHashShort(to, hashLength));
+	return `${styledDirName}  ${fromAbbr} ${style.glyph(palette.forwardArrow)} ${toAbbr}`;
+}
+function abbreviateHashShort(hash, length) {
+	return (hash.startsWith("sha256:") ? hash.slice(7) : hash).slice(0, length);
+}
+function formatLegendExampleMarkers(colorize) {
+	if (!colorize) return "@contract @db";
+	const sigil = green("@");
+	return `${sigil + bold(green("contract"))} ${sigil}${green("db")}`;
+}
+/**
+* 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("reserved markers — also typeable as --from/--to tokens")}`,
+		`  ${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 appSpace = input.isAppSpace !== false;
+	const layout = buildMigrationGraphLayout(buildMigrationGraphRows(input.graph, { ...appSpace ? { 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,
+		isAppSpace: appSpace,
+		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 { buildMigrationGraphLayout as _, computeMaxDirNameLengthForLayout as a, renderMigrationGraphLegend as c, IDENTITY_MIGRATION_LIST_STYLER as d, renderMigrationListWithStyle as f, buildMigrationGraphRows as g, migrationListForwardArrow as h, renderMigrationGraphSpaceTree as i, renderMigrationGraphTree as l, migrationListEmptySource as m, computeGlobalMaxEdgeTreePrefixWidth as n, computeMaxEdgeTreePrefixWidthForLayout as o, abbreviateContractHash as p, indentMigrationGraphTreeBlock as r, formatOnPathMigrationRow as s, computeGlobalMaxDirNameWidth as t, createAnsiMigrationListStyler as u };
+
+//# sourceMappingURL=migration-graph-space-render-Cpg0ql8v.mjs.map