@prisma-next/cli 0.12.0-dev.67 → 0.12.0-dev.69

package/dist/migration-graph-command-render-BAOzyYF6.mjs

@@ -0,0 +1,1822 @@
+import { ifDefined } from "@prisma-next/utils/defined";
+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-occlusion-render.ts
+/**
+* Occlusion renderer for the line/plane/occlusion migration-graph.
+*
+* Per cell: pick the topmost-plane line (lowest plane number = drawn on top),
+* look up its glyph, apply colour from the line's lane or role. Lower-plane
+* lines are occluded (not drawn).
+*
+* Colour is forced via createColors({ useColor: true }) regardless of NO_COLOR.
+*/
+const palette = createColors({ useColor: true });
+const LANE_COLORIZERS = [
+	palette.white,
+	palette.cyan,
+	palette.yellow,
+	palette.blueBright,
+	palette.magenta,
+	palette.green
+];
+function laneColor(lane) {
+	return LANE_COLORIZERS[lane % LANE_COLORIZERS.length] ?? ((t) => t);
+}
+/**
+* The colourizer for a lane's hue (lane0 = white, lane1 = cyan, …). Exported
+* so the per-row LABEL renderer can tint a migration name in its lane's colour,
+* matching the node `○`, the edges, and the arrows drawn in the gutter — one
+* colour per lane across glyph and text.
+*/
+function laneColorizer(lane) {
+	return laneColor(lane);
+}
+function roleColor(role) {
+	return role === "on-path" ? palette.greenBright : palette.dim;
+}
+const UNICODE_ALPHABET = {
+	vertical: "│",
+	horizontal: "─",
+	cornerUpRight: "╰",
+	cornerDownRight: "╭",
+	cornerUpLeft: "╯",
+	cornerDownLeft: "╮",
+	arrowUp: "↑",
+	arrowDown: "↓",
+	node: "○",
+	selfLoop: "⟲",
+	landingArrow: "◂",
+	fallback: "?"
+};
+const ASCII_ALPHABET = {
+	vertical: "|",
+	horizontal: "-",
+	cornerUpRight: "\\",
+	cornerDownRight: "/",
+	cornerUpLeft: "/",
+	cornerDownLeft: "\\",
+	arrowUp: "^",
+	arrowDown: "v",
+	node: "*",
+	selfLoop: "@",
+	landingArrow: "<",
+	fallback: "?"
+};
+function alphabetFor(mode) {
+	return mode === "ascii" ? ASCII_ALPHABET : UNICODE_ALPHABET;
+}
+function glyphFor(dirs, alphabet) {
+	const has = (d) => dirs.has(d);
+	if (has("up") && has("down") && !has("left") && !has("right")) return alphabet.vertical;
+	if (has("left") && has("right") && !has("up") && !has("down")) return alphabet.horizontal;
+	if (has("up") && has("right") && !has("down") && !has("left")) return alphabet.cornerUpRight;
+	if (has("down") && has("right") && !has("up") && !has("left")) return alphabet.cornerDownRight;
+	if (has("up") && has("left") && !has("down") && !has("right")) return alphabet.cornerUpLeft;
+	if (has("down") && has("left") && !has("up") && !has("right")) return alphabet.cornerDownLeft;
+	if (has("up") && !has("down") && !has("left") && !has("right")) return alphabet.arrowUp;
+	if (has("down") && !has("up") && !has("left") && !has("right")) return alphabet.arrowDown;
+	return alphabet.fallback;
+}
+const NO_COLOR = (t) => t;
+function renderCell(cell, colorEnabled, alphabet) {
+	if (cell.node !== void 0) return (!colorEnabled ? NO_COLOR : cell.node.role !== void 0 ? roleColor(cell.node.role) : laneColor(cell.node.lane))(alphabet.node);
+	if (cell.lines.length === 0) return " ";
+	const topLine = cell.lines.reduce((best, current) => {
+		if (current.plane < best.plane) return current;
+		if (current.plane > best.plane) return best;
+		if (current.line.role === "on-path" && best.line.role !== "on-path") return current;
+		return best;
+	}, cell.lines[0]);
+	const glyph = topLine.selfLoop === true ? alphabet.selfLoop : topLine.landingArrow === true ? alphabet.landingArrow : glyphFor(topLine.directions, alphabet);
+	return (!colorEnabled ? NO_COLOR : topLine.line.role !== void 0 ? roleColor(topLine.line.role) : laneColor(topLine.line.lane))(glyph);
+}
+/**
+* Render a single grid row to a coloured string. A completely empty row returns
+* the empty string (the row is NOT dropped) so callers that pair grid rows with
+* an external per-row label list keep a 1:1 index correspondence. `renderGrid`
+* itself drops empty rows for its standalone output.
+*/
+function renderGridRow(row, opts = {}) {
+	let lastNonEmpty = -1;
+	for (let i = row.length - 1; i >= 0; i--) {
+		const cell = row[i];
+		if (cell !== void 0 && (cell.lines.length > 0 || cell.node !== void 0)) {
+			lastNonEmpty = i;
+			break;
+		}
+	}
+	if (lastNonEmpty < 0) return "";
+	const colsPerLane = opts.colsPerLane ?? 2;
+	const colorEnabled = opts.colorize ?? true;
+	const alphabet = alphabetFor(opts.glyphMode ?? "unicode");
+	const lastConnectorCol = Math.floor(lastNonEmpty / colsPerLane) * colsPerLane + (colsPerLane - 1);
+	const renderThrough = Math.max(lastNonEmpty, lastConnectorCol);
+	let line = "";
+	for (let col = 0; col <= Math.min(renderThrough, row.length - 1); col++) {
+		const cell = row[col];
+		line += cell === void 0 ? " " : renderCell(cell, colorEnabled, alphabet);
+	}
+	return line;
+}
+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-graph-grid-layout.ts
+/**
+* Grid layout for the line/plane/occlusion migration-graph renderer.
+*
+* Produces a Grid (rows × cells) from a MigrationGraphRowModel. Each node
+* emits: fork connector, self-loop rows, node row, merge connector, and
+* inbound migration rows — in display order (tips first, then roots).
+*/
+function buildLaneAssignment(nodes, edges) {
+	const allNodes = /* @__PURE__ */ new Set();
+	for (const n of nodes) if (n !== null) allNodes.add(n);
+	const fwdEdges = edges.filter((e) => e.kind === "forward" && e.from !== e.to);
+	const outbound = /* @__PURE__ */ new Map();
+	const inbound = /* @__PURE__ */ new Map();
+	for (const edge of fwdEdges) {
+		const ob = outbound.get(edge.from);
+		if (ob) ob.push(edge);
+		else outbound.set(edge.from, [edge]);
+		const ib = inbound.get(edge.to);
+		if (ib) ib.push(edge);
+		else inbound.set(edge.to, [edge]);
+	}
+	for (const list of outbound.values()) list.sort((a, b) => a.dirName.localeCompare(b.dirName));
+	for (const list of inbound.values()) list.sort((a, b) => a.dirName.localeCompare(b.dirName));
+	const nodeRank = /* @__PURE__ */ new Map();
+	for (const n of allNodes) nodeRank.set(n, 0);
+	for (let pass = 0; pass < allNodes.size; pass++) {
+		let changed = false;
+		for (const [from, edges] of outbound) {
+			const base = nodeRank.get(from) ?? 0;
+			for (const e of edges) {
+				const next = base + 1;
+				if (next > (nodeRank.get(e.to) ?? 0)) {
+					nodeRank.set(e.to, next);
+					changed = true;
+				}
+			}
+		}
+		if (!changed) break;
+	}
+	const nodeLane = /* @__PURE__ */ new Map();
+	let nextLane = 0;
+	const roots = [];
+	for (const n of allNodes) if ((inbound.get(n) ?? []).length === 0) roots.push(n);
+	roots.sort((a, b) => {
+		if (a === EMPTY_CONTRACT_HASH) return -1;
+		if (b === EMPTY_CONTRACT_HASH) return 1;
+		return a.localeCompare(b);
+	});
+	const bfsQueue = [];
+	for (const root of roots) if (!nodeLane.has(root)) {
+		nodeLane.set(root, nextLane++);
+		bfsQueue.push({
+			node: root,
+			lane: nodeLane.get(root)
+		});
+	}
+	let head = 0;
+	while (head < bfsQueue.length) {
+		const { node, lane } = bfsQueue[head++];
+		const children = outbound.get(node) ?? [];
+		let first = true;
+		for (const childEdge of children) {
+			const child = childEdge.to;
+			if (!nodeLane.has(child)) {
+				const childLane = first ? lane : nextLane++;
+				nodeLane.set(child, childLane);
+				bfsQueue.push({
+					node: child,
+					lane: childLane
+				});
+			}
+			first = false;
+		}
+	}
+	for (const n of allNodes) if (!nodeLane.has(n)) nodeLane.set(n, nextLane++);
+	return {
+		nodeLane,
+		nodeRank,
+		numLanes: nextLane
+	};
+}
+function computeDisplayOrder(nodes, nodeLane, nodeRank) {
+	const seen = /* @__PURE__ */ new Set();
+	const result = [];
+	for (const n of nodes) {
+		if (n === null || seen.has(n)) continue;
+		seen.add(n);
+		result.push({
+			hash: n,
+			lane: nodeLane.get(n) ?? 0,
+			rank: nodeRank.get(n) ?? 0
+		});
+	}
+	result.sort((a, b) => b.rank - a.rank || a.lane - b.lane);
+	return result;
+}
+/** Create an empty cell. */
+function emptyCell() {
+	return { lines: [] };
+}
+function buildGrid(rowModel, opts = {}, highlight = {
+	mode: "flat",
+	onPath: /* @__PURE__ */ new Set()
+}) {
+	const colsPerLane = opts.colsPerLane ?? 2;
+	const isFocus = highlight.mode === "focus";
+	const { nodeLane, nodeRank, numLanes } = buildLaneAssignment(rowModel.nodes, rowModel.edges);
+	const displayOrder = computeDisplayOrder(rowModel.nodes, nodeLane, nodeRank);
+	const displayIndex = /* @__PURE__ */ new Map();
+	displayOrder.forEach((d, i) => {
+		displayIndex.set(d.hash, i);
+	});
+	const rollbackEdges = rowModel.edges.filter((e) => e.kind === "rollback" && e.from !== e.to);
+	const adjacentRollbacks = [];
+	const skippingRollbacks = [];
+	for (const e of rollbackEdges) {
+		const si = displayIndex.get(e.from);
+		const ti = displayIndex.get(e.to);
+		if (si === void 0 || ti === void 0) continue;
+		if (ti === si + 1) adjacentRollbacks.push(e);
+		else skippingRollbacks.push(e);
+	}
+	const colourLaneOf = /* @__PURE__ */ new Map();
+	[...skippingRollbacks].sort((a, b) => a.dirName.localeCompare(b.dirName)).forEach((e, i) => {
+		colourLaneOf.set(e.migrationHash, numLanes + i);
+	});
+	const geomOrder = [...skippingRollbacks].sort((a, b) => {
+		const ta = displayIndex.get(a.to) ?? 0;
+		const tb = displayIndex.get(b.to) ?? 0;
+		if (ta !== tb) return tb - ta;
+		return (displayIndex.get(a.from) ?? 0) - (displayIndex.get(b.from) ?? 0);
+	});
+	const geomLaneOf = /* @__PURE__ */ new Map();
+	const outermost = numLanes + skippingRollbacks.length - 1;
+	geomOrder.forEach((e, i) => {
+		geomLaneOf.set(e.migrationHash, outermost - i);
+	});
+	const routedBackArcs = skippingRollbacks.map((e) => ({
+		edge: e,
+		sourceIndex: displayIndex.get(e.from) ?? 0,
+		targetIndex: displayIndex.get(e.to) ?? 0,
+		geomLane: geomLaneOf.get(e.migrationHash) ?? numLanes,
+		colourLane: colourLaneOf.get(e.migrationHash) ?? numLanes
+	}));
+	const backArcsBySource = /* @__PURE__ */ new Map();
+	const backArcsByTarget = /* @__PURE__ */ new Map();
+	for (const arc of routedBackArcs) {
+		const sb = backArcsBySource.get(arc.edge.from);
+		if (sb) sb.push(arc);
+		else backArcsBySource.set(arc.edge.from, [arc]);
+		const tb = backArcsByTarget.get(arc.edge.to);
+		if (tb) tb.push(arc);
+		else backArcsByTarget.set(arc.edge.to, [arc]);
+	}
+	const adjacentBySource = /* @__PURE__ */ new Map();
+	const adjacentByTarget = /* @__PURE__ */ new Map();
+	for (const e of adjacentRollbacks) {
+		const b = adjacentBySource.get(e.from);
+		if (b) b.push(e);
+		else adjacentBySource.set(e.from, [e]);
+		const t = adjacentByTarget.get(e.to);
+		if (t) t.push(e);
+		else adjacentByTarget.set(e.to, [e]);
+	}
+	for (const list of adjacentBySource.values()) list.sort((a, b) => a.dirName.localeCompare(b.dirName));
+	const totalCols = (numLanes + skippingRollbacks.length) * colsPerLane;
+	const fwdEdges = rowModel.edges.filter((e) => e.kind === "forward" && e.from !== e.to);
+	const selfEdges = rowModel.edges.filter((e) => e.kind === "self");
+	const outboundFwd = /* @__PURE__ */ new Map();
+	const inboundFwd = /* @__PURE__ */ new Map();
+	for (const e of fwdEdges) {
+		const ob = outboundFwd.get(e.from);
+		if (ob) ob.push(e);
+		else outboundFwd.set(e.from, [e]);
+		const ib = inboundFwd.get(e.to);
+		if (ib) ib.push(e);
+		else inboundFwd.set(e.to, [e]);
+	}
+	for (const list of outboundFwd.values()) list.sort((a, b) => a.dirName.localeCompare(b.dirName));
+	for (const list of inboundFwd.values()) list.sort((a, b) => a.dirName.localeCompare(b.dirName));
+	const selfEdgesByNode = /* @__PURE__ */ new Map();
+	for (const e of selfEdges) {
+		const bucket = selfEdgesByNode.get(e.from);
+		if (bucket) bucket.push(e);
+		else selfEdgesByNode.set(e.from, [e]);
+	}
+	for (const list of selfEdgesByNode.values()) list.sort((a, b) => a.dirName.localeCompare(b.dirName));
+	function roleOf(migrationHash) {
+		if (!isFocus) return void 0;
+		return highlight.onPath.has(migrationHash) ? "on-path" : "off-path";
+	}
+	const onPathNodes = /* @__PURE__ */ new Set();
+	if (isFocus) {
+		for (const e of [
+			...fwdEdges,
+			...selfEdges,
+			...rollbackEdges
+		]) if (highlight.onPath.has(e.migrationHash)) {
+			onPathNodes.add(e.from);
+			onPathNodes.add(e.to);
+		}
+	}
+	function nodeRoleOf(hash) {
+		if (!isFocus) return void 0;
+		return onPathNodes.has(hash) ? "on-path" : "off-path";
+	}
+	function planeOf(lane, role) {
+		if (!isFocus) return lane;
+		return role === "on-path" ? 0 : lane + 1;
+	}
+	function lineRefFor(edge, lane) {
+		return {
+			migrationHash: edge.migrationHash,
+			dirName: edge.dirName,
+			lane,
+			role: roleOf(edge.migrationHash)
+		};
+	}
+	/** Synthetic LineRef for a lane carrying a representative edge's role (pass-through). */
+	function passLineRef(lane, dirName, migHash) {
+		return {
+			migrationHash: migHash,
+			dirName,
+			lane,
+			role: roleOf(migHash)
+		};
+	}
+	function vertCell(line) {
+		return { lines: [{
+			line,
+			directions: new Set(["up", "down"]),
+			plane: planeOf(line.lane, line.role)
+		}] };
+	}
+	function dirCell(line, dirs) {
+		return { lines: [{
+			line,
+			directions: dirs,
+			plane: planeOf(line.lane, line.role)
+		}] };
+	}
+	function nodeCell(nodeRef) {
+		return {
+			node: nodeRef,
+			lines: []
+		};
+	}
+	const laneCurrentEdge = /* @__PURE__ */ new Map();
+	function getRepLine(lane) {
+		const e = laneCurrentEdge.get(lane);
+		if (e) return lineRefFor(e, lane);
+		return passLineRef(lane, `lane${lane}`, `lane${lane}`);
+	}
+	const activeLanes = /* @__PURE__ */ new Set();
+	const grid = [];
+	function makeRow() {
+		return Array.from({ length: totalCols }, () => emptyCell());
+	}
+	function placeVerticals(row, skip) {
+		for (const lane of activeLanes) {
+			if (skip.has(lane)) continue;
+			const railCol = lane * colsPerLane;
+			const cell = row[railCol];
+			if (cell !== void 0 && cell.lines.length === 0 && !cell.node) row[railCol] = vertCell(getRepLine(lane));
+		}
+	}
+	const activeBackArcs = /* @__PURE__ */ new Set();
+	function backArcLine(arc) {
+		return {
+			migrationHash: arc.edge.migrationHash,
+			dirName: arc.edge.dirName,
+			lane: arc.colourLane,
+			role: roleOf(arc.edge.migrationHash)
+		};
+	}
+	function backArcPlane(arc) {
+		const role = roleOf(arc.edge.migrationHash);
+		if (!isFocus) return arc.colourLane;
+		return role === "on-path" ? 0 : arc.colourLane + 1;
+	}
+	function composeLine(row, col, line, dirs, plane, extra) {
+		const existing = row[col];
+		const cellLine = {
+			line,
+			directions: dirs,
+			plane,
+			...extra?.landingArrow ? { landingArrow: true } : {}
+		};
+		if (existing && (existing.lines.length > 0 || existing.node)) row[col] = {
+			...existing,
+			lines: [...existing.lines, cellLine]
+		};
+		else row[col] = { lines: [cellLine] };
+	}
+	function placeBackVerticals(row) {
+		for (const arc of activeBackArcs) composeLine(row, arc.geomLane * colsPerLane, backArcLine(arc), new Set(["up", "down"]), backArcPlane(arc));
+		placeAdjacentOverlays(row);
+	}
+	const activeAdjacent = /* @__PURE__ */ new Set();
+	function placeAdjacentOverlays(row) {
+		for (const adj of activeAdjacent) {
+			const railCol = adj.lane * colsPerLane;
+			if (row[railCol]?.node) continue;
+			const line = lineRefFor(adj.edge, adj.lane);
+			composeLine(row, railCol, line, new Set(["up", "down"]), planeOf(adj.lane, line.role));
+		}
+	}
+	function emitBackArcTee(row, nodeLaneNum, arc) {
+		const nodeRail = nodeLaneNum * colsPerLane;
+		const geomRail = arc.geomLane * colsPerLane;
+		const line = backArcLine(arc);
+		const plane = backArcPlane(arc);
+		for (let col = nodeRail + 1; col < geomRail; col++) composeLine(row, col, line, new Set(["left", "right"]), plane);
+		composeLine(row, geomRail, line, new Set(["down", "left"]), plane);
+	}
+	function emitBackArcLanding(row, nodeLaneNum, arc) {
+		const nodeRail = nodeLaneNum * colsPerLane;
+		const geomRail = arc.geomLane * colsPerLane;
+		const line = backArcLine(arc);
+		const plane = backArcPlane(arc);
+		composeLine(row, nodeRail + 1, line, new Set(["left", "right"]), plane, { landingArrow: true });
+		for (let col = nodeRail + 2; col < geomRail; col++) composeLine(row, col, line, new Set(["left", "right"]), plane);
+		composeLine(row, geomRail, line, new Set(["up", "left"]), plane);
+	}
+	function emitConnectorRow(trunkLane, branchEntries, connectorType, trunkEdge) {
+		const row = makeRow();
+		const sorted = [...branchEntries].sort((a, b) => a.lane - b.lane);
+		if (sorted.length === 0) return row;
+		const branchByLane = /* @__PURE__ */ new Map();
+		for (const b of sorted) branchByLane.set(b.lane, b.edge);
+		let continuousLane = trunkLane;
+		if (isFocus) if (trunkEdge && highlight.onPath.has(trunkEdge.migrationHash)) continuousLane = trunkLane;
+		else {
+			const onPathBranch = sorted.find((b) => highlight.onPath.has(b.edge.migrationHash));
+			if (onPathBranch) continuousLane = onPathBranch.lane;
+		}
+		const trunkRailCol = trunkLane * colsPerLane;
+		const continuousRailCol = continuousLane * colsPerLane;
+		function addLine(col, line, dirs) {
+			const existing = row[col];
+			const cellLine = {
+				line,
+				directions: dirs,
+				plane: planeOf(line.lane, line.role)
+			};
+			row[col] = existing && existing.lines.length > 0 ? {
+				...existing,
+				lines: [...existing.lines, cellLine]
+			} : { lines: [cellLine] };
+		}
+		const cornerLeftDown = connectorType === "merge" ? new Set(["left", "down"]) : new Set(["left", "up"]);
+		for (let i = 0; i < sorted.length; i++) {
+			const b = sorted[i];
+			if (b.lane === continuousLane) continue;
+			const branchLine = lineRefFor(b.edge, b.lane);
+			const railCol = b.lane * colsPerLane;
+			addLine(railCol, branchLine, cornerLeftDown);
+			const leftBound = i === 0 ? trunkRailCol + 1 : sorted[i - 1].lane * colsPerLane + 1;
+			for (let col = leftBound; col < railCol; col++) addLine(col, branchLine, new Set(["left", "right"]));
+		}
+		const continuousLine = continuousLane === trunkLane ? trunkEdge ? lineRefFor(trunkEdge, trunkLane) : getRepLine(trunkLane) : lineRefFor(branchByLane.get(continuousLane), continuousLane);
+		if (continuousLane === trunkLane) addLine(trunkRailCol, continuousLine, new Set(["up", "down"]));
+		else {
+			addLine(trunkRailCol, continuousLine, connectorType === "merge" ? new Set(["up", "right"]) : new Set(["down", "right"]));
+			for (let col = trunkRailCol + 1; col < continuousRailCol; col++) addLine(col, continuousLine, new Set(["left", "right"]));
+			addLine(continuousRailCol, continuousLine, cornerLeftDown);
+		}
+		placeVerticals(row, new Set([trunkLane, ...sorted.map((b) => b.lane)]));
+		placeBackVerticals(row);
+		return row;
+	}
+	for (const nodeDisplay of displayOrder) {
+		const { hash: nodeHash } = nodeDisplay;
+		const nodeLaneNum = nodeLane.get(nodeHash) ?? 0;
+		activeLanes.add(nodeLaneNum);
+		const outEdges = outboundFwd.get(nodeHash) ?? [];
+		if (outEdges.length > 1) {
+			const trunkChildLane = nodeLane.get(outEdges[0].to) ?? nodeLaneNum;
+			const branchEntries = outEdges.slice(1).map((e) => ({
+				lane: nodeLane.get(e.to) ?? 0,
+				edge: e
+			})).filter((b) => b.lane !== trunkChildLane && activeLanes.has(b.lane));
+			if (branchEntries.length > 0) {
+				const trunkEdge = outEdges[0];
+				const connRow = emitConnectorRow(nodeLaneNum, branchEntries, "fork", trunkEdge);
+				grid.push(connRow);
+				assertSingleOwner(connRow, isFocus);
+				for (const b of branchEntries) activeLanes.delete(b.lane);
+			}
+		}
+		const selfMigrations = selfEdgesByNode.get(nodeHash) ?? [];
+		for (const selfEdge of selfMigrations) {
+			const row = makeRow();
+			const railCol = nodeLaneNum * colsPerLane;
+			const connCol = nodeLaneNum * colsPerLane + 1;
+			const line = lineRefFor(selfEdge, nodeLaneNum);
+			row[railCol] = vertCell(line);
+			row[connCol] = { lines: [{
+				line,
+				directions: /* @__PURE__ */ new Set(),
+				plane: planeOf(nodeLaneNum, line.role),
+				selfLoop: true
+			}] };
+			placeVerticals(row, new Set([nodeLaneNum]));
+			placeBackVerticals(row);
+			grid.push(row);
+		}
+		{
+			const row = makeRow();
+			const railCol = nodeLaneNum * colsPerLane;
+			row[railCol] = nodeCell({
+				contractHash: nodeHash,
+				isEmpty: nodeHash === EMPTY_CONTRACT_HASH,
+				lane: nodeLaneNum,
+				role: nodeRoleOf(nodeHash)
+			});
+			placeVerticals(row, new Set([nodeLaneNum]));
+			const landingArcs = backArcsByTarget.get(nodeHash) ?? [];
+			for (const arc of landingArcs) activeBackArcs.delete(arc);
+			for (const adj of [...activeAdjacent]) if (adj.edge.to === nodeHash) activeAdjacent.delete(adj);
+			placeBackVerticals(row);
+			for (const arc of landingArcs) emitBackArcLanding(row, nodeLaneNum, arc);
+			const teeArcs = backArcsBySource.get(nodeHash) ?? [];
+			for (const arc of teeArcs) emitBackArcTee(row, nodeLaneNum, arc);
+			grid.push(row);
+			for (const arc of teeArcs) activeBackArcs.add(arc);
+			for (const adj of adjacentBySource.get(nodeHash) ?? []) activeAdjacent.add({
+				lane: nodeLaneNum,
+				edge: adj
+			});
+		}
+		const inEdges = inboundFwd.get(nodeHash) ?? [];
+		inEdges.sort((a, b) => a.dirName.localeCompare(b.dirName));
+		for (const edge of inEdges) {
+			const edgeLane = Math.max(nodeLane.get(edge.from) ?? 0, nodeLane.get(edge.to) ?? 0);
+			laneCurrentEdge.set(edgeLane, edge);
+		}
+		{
+			const teeArcs = backArcsBySource.get(nodeHash) ?? [];
+			for (const arc of teeArcs) {
+				const row = makeRow();
+				const railCol = arc.geomLane * colsPerLane;
+				const connCol = railCol + 1;
+				const line = backArcLine(arc);
+				const plane = backArcPlane(arc);
+				composeLine(row, railCol, line, new Set(["up", "down"]), plane);
+				composeLine(row, connCol, line, new Set(["down"]), plane);
+				placeVerticals(row, /* @__PURE__ */ new Set());
+				placeBackVerticals(row);
+				grid.push(row);
+			}
+		}
+		if (inEdges.length > 1) {
+			const branchEntries = inEdges.slice(1).map((e) => ({
+				lane: nodeLane.get(e.from) ?? 0,
+				edge: e
+			}));
+			const trunkEdge = inEdges[0];
+			const connRow = emitConnectorRow(nodeLaneNum, branchEntries, "merge", trunkEdge);
+			grid.push(connRow);
+			assertSingleOwner(connRow, isFocus);
+			for (const b of branchEntries) activeLanes.add(b.lane);
+		}
+		for (const edge of inEdges) {
+			const fromLane = nodeLane.get(edge.from) ?? 0;
+			const toLane = nodeLane.get(edge.to) ?? 0;
+			const edgeLane = Math.max(fromLane, toLane);
+			const row = makeRow();
+			const railCol = edgeLane * colsPerLane;
+			const connCol = edgeLane * colsPerLane + 1;
+			const line = lineRefFor(edge, edgeLane);
+			row[railCol] = vertCell(line);
+			row[connCol] = dirCell(line, new Set(["up"]));
+			placeVerticals(row, new Set([edgeLane]));
+			placeBackVerticals(row);
+			grid.push(row);
+		}
+		{
+			const adjacents = adjacentBySource.get(nodeHash) ?? [];
+			for (const adj of adjacents) {
+				const row = makeRow();
+				const connCol = nodeLaneNum * colsPerLane + 1;
+				const line = lineRefFor(adj, nodeLaneNum);
+				const plane = planeOf(nodeLaneNum, line.role);
+				composeLine(row, connCol, line, new Set(["down"]), plane);
+				placeVerticals(row, /* @__PURE__ */ new Set());
+				placeBackVerticals(row);
+				grid.push(row);
+			}
+		}
+		if (inEdges.length === 0) activeLanes.delete(nodeLaneNum);
+	}
+	return grid;
+}
+function assertSingleOwner(row, isFocus) {
+	for (const cell of row) {
+		if (cell.lines.length <= 1) continue;
+		let topPlane = Number.POSITIVE_INFINITY;
+		for (const cl of cell.lines) if (cl.plane < topPlane) topPlane = cl.plane;
+		const top = cell.lines.filter((cl) => cl.plane === topPlane);
+		if (top.length > 1) {
+			if (isFocus) {
+				if (new Set(top.map((cl) => cl.line.role)).size > 1) throw new Error("migration-graph layout: single-owner invariant violated — two differently-roled lines share the top plane in one cell");
+			}
+		}
+	}
+}
+//#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-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;
+}
+/**
+* Translate `migrate --show` per-edge path-highlight annotations into a
+* {@link Highlight}. With any `pathHighlight` present the result is focus mode
+* (on-path lifted green, off-path dim); otherwise flat (lane-rotation colour).
+*/
+function highlightFromEdgeAnnotations(edgeAnnotationsByHash) {
+	const onPath = /* @__PURE__ */ new Set();
+	let anyPathHighlight = false;
+	for (const [migrationHash, annotation] of edgeAnnotationsByHash) {
+		if (annotation.pathHighlight === void 0) continue;
+		anyPathHighlight = true;
+		if (annotation.pathHighlight === "on-path") onPath.add(migrationHash);
+	}
+	return anyPathHighlight ? {
+		mode: "focus",
+		onPath
+	} : {
+		mode: "flat",
+		onPath: /* @__PURE__ */ new Set()
+	};
+}
+function buildGridForInput(input) {
+	const rowModel = buildMigrationGraphRows(input.graph, { contractHash: input.liveContractHash });
+	return {
+		grid: buildGrid(rowModel, {}, {
+			mode: "flat",
+			onPath: /* @__PURE__ */ new Set()
+		}),
+		rowModel
+	};
+}
+/**
+* The widest gutter→label column across the given space layouts. Cross-space
+* callers pass this back in so every section's labels share one column.
+*/
+function computeGlobalMaxEdgeTreePrefixWidth(inputs, glyphMode = "unicode") {
+	let globalMax = 0;
+	for (const input of inputs) {
+		const { grid } = buildGridForInput(input);
+		globalMax = Math.max(globalMax, computeLabelColumn(grid, glyphMode));
+	}
+	return globalMax;
+}
+function computeGlobalMaxDirNameWidth(inputs) {
+	let globalMax = 0;
+	for (const input of inputs) {
+		const { rowModel } = buildGridForInput(input);
+		globalMax = Math.max(globalMax, computeMaxDirNameWidth(rowModel));
+	}
+	return globalMax;
+}
+function renderMigrationGraphSpaceTreeInternal(input) {
+	const appSpace = input.isAppSpace !== false;
+	const rowModel = buildMigrationGraphRows(input.graph, { ...appSpace ? { contractHash: input.liveContractHash } : {} });
+	const listOverlay = buildEdgeAnnotationsByHashFromListEntries(input.migrations);
+	const edgeAnnotationsByHash = input.statusOverlayByHash === void 0 ? listOverlay : mergeMigrationEdgeAnnotations(listOverlay, input.statusOverlayByHash);
+	return renderMigrationGraphCommand({
+		grid: buildGrid(rowModel, {}, highlightFromEdgeAnnotations(edgeAnnotationsByHash)),
+		rowModel,
+		colorize: input.colorize,
+		glyphMode: input.glyphMode,
+		contractHash: input.liveContractHash,
+		isAppSpace: appSpace,
+		edgeAnnotationsByHash,
+		refsByHash: input.refsByHash ?? buildRefsByHashFromListEntries(input.migrations),
+		...input.dbHash !== void 0 ? { dbHash: input.dbHash } : {},
+		...input.styler !== void 0 ? { styler: input.styler } : {},
+		...input.globalMaxEdgeTreePrefixWidth !== void 0 ? { globalLabelColumn: 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
+//#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-labels.ts
+/**
+* Per-row label formatting for the command graph renderer.
+*
+* The command graph renderer ({@link renderMigrationGraphCommand}) derives the
+* graph structure — rows, gutter, lane colours — from the grid pipeline. The
+* per-row LABEL (contract hash + markers + refs for node rows;
+* migration name + `from → to` + ops/status/will-run for migration rows) is
+* formatted here. This module owns ONLY label text + styling; it knows nothing
+* about lanes, gutters, or grid geometry.
+*
+* The label format (hash abbreviation, `from → to` arrow column, `@contract`/
+* `@db` markers, `(refs)`, ops/status/will-run suffix, the legend) is the same
+* as the previous renderer — that part was never the bug.
+*/
+/**
+* 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";
+/**
+* Forced-color functions that always emit ANSI regardless of the ambient TTY
+* environment (NO_COLOR, piped output). Used so on-path green / off-path dim are
+* deterministically emitted in tests that request colour while NO_COLOR is set.
+*/
+const { dim: forcedDim, bold: forcedBold } = createColors({ useColor: true });
+const { greenBright: forcedGreen } = createColors({ useColor: true });
+/**
+* The two label styles used in `migrate --show` path-highlight mode.
+*
+* - `onPath`: bold name, neutral hashes (the on-path lane glyphs are coloured
+*   green by the grid renderer, not here).
+* - `offPath`: uniform dim grey on the name and the whole hash column.
+*
+* To change the on-path / off-path label colour in future, edit this object.
+*/
+const PATH_HIGHLIGHT_STYLES = {
+	onPath: (_style, colorize) => ({
+		lane: colorize ? forcedGreen : (text) => text,
+		arrow: (text) => text,
+		dirName: (text) => bold(text),
+		hashOverride: void 0
+	}),
+	offPath: (colorize) => ({
+		lane: colorize ? forcedDim : (text) => text,
+		arrow: colorize ? forcedDim : (text) => text,
+		dirName: colorize ? forcedDim : (text) => text,
+		hashOverride: colorize ? forcedDim : void 0
+	})
+};
+function abbreviateHash(hash, hashLength, emptySource) {
+	if (hash === EMPTY_CONTRACT_HASH) return emptySource;
+	return (hash.startsWith("sha256:") ? hash.slice(7) : hash).slice(0, hashLength);
+}
+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 createLabelStyler(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 overlayStatusGlyphs(mode) {
+	return mode === "ascii" ? {
+		applied: "+",
+		pending: ">"
+	} : {
+		applied: "✓",
+		pending: "⧗"
+	};
+}
+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
+* so dim reaches every character without inner ANSI codes overriding it.
+*/
+function formatEdgeHashColumn(edge, style, hashLength, glyphMode, hashOverride) {
+	const emptySource = migrationListEmptySource(glyphMode);
+	const forwardArrow = migrationListForwardArrow(glyphMode);
+	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, emptySource);
+		return `${padFromHashColumn(src(hash), hashLength)} ${glyph(forwardArrow)} ${dst(hash)}`;
+	}
+	return `${edge.from === EMPTY_CONTRACT_HASH ? padFromHashColumn(glyph(emptySource), hashLength) : padFromHashColumn(src(abbreviateHash(edge.from, hashLength, emptySource)), hashLength)} ${glyph(forwardArrow)} ${dst(abbreviateHash(edge.to, hashLength, emptySource))}`;
+}
+/**
+* The label text for a contract node row: the abbreviated hash (or the `∅`
+* empty-source token for the baseline) followed by its `@contract`/`@db` markers
+* and `(refs)`, with two spaces between the hash and the overlay block.
+*/
+function formatNodeLabel(contractHash, opts, nodeHighlight) {
+	const style = createLabelStyler(opts);
+	const hashLength = opts.hashLength ?? 7;
+	const emptySource = migrationListEmptySource(opts.glyphMode ?? "unicode");
+	const overlays = overlayNamesForContract(contractHash, opts);
+	const hasOverlays = overlays.markers.length > 0 || overlays.refs.length > 0;
+	const offPath = nodeHighlight === "off-path" && opts.colorize;
+	const hashText = contractHash === EMPTY_CONTRACT_HASH ? (offPath ? forcedDim : style.glyph)(emptySource) : (offPath ? forcedDim : style.sourceHash)(abbreviateHash(contractHash, hashLength, emptySource));
+	if (!hasOverlays) return hashText;
+	return `${hashText}  ${formatContractNodeOverlays(style, overlays.markers, overlays.refs)}`;
+}
+/**
+* The label text for a migration row: the migration name (padded to
+* `dirNameWidth`) followed by the `from → to` hash column and the annotation
+* suffix (ops / status / will-run).
+*
+* In flat mode the name is tinted with its lane's hue (`lane` ≥ 0), so the node
+* `○`, the edges/arrows in the gutter, and the name all read in one colour. In
+* focus mode the on-path/off-path role overrides the lane hue (bold / dim).
+*/
+function formatMigrationLabel(edge, dirNameWidth, opts, lane) {
+	const style = createLabelStyler(opts);
+	const hashLength = opts.hashLength ?? 7;
+	const glyphMode = opts.glyphMode ?? "unicode";
+	const highlight = opts.edgeAnnotationsByHash?.get(edge.migrationHash)?.pathHighlight;
+	let dirNameStyler;
+	let hashOverride;
+	if (highlight === "on-path") {
+		dirNameStyler = (text) => bold(text);
+		hashOverride = void 0;
+	} else if (highlight === "off-path") {
+		dirNameStyler = opts.colorize ? forcedDim : style.dirName;
+		hashOverride = opts.colorize ? forcedDim : void 0;
+	} else if (opts.colorize && lane !== void 0) {
+		dirNameStyler = (text) => forcedBold(laneColorizer(lane)(text));
+		hashOverride = void 0;
+	} else {
+		dirNameStyler = style.dirName;
+		hashOverride = void 0;
+	}
+	const dirNamePadding = " ".repeat(Math.max(0, dirNameWidth - edge.dirName.length));
+	return `${`${dirNameStyler(edge.dirName)}${dirNamePadding}`}${formatEdgeHashColumn(edge, style, hashLength, glyphMode, hashOverride)}${formatEdgeAnnotationSuffix(edge.migrationHash, opts, style)}`;
+}
+/**
+* Format a single on-path migration row for the `migrate --show` run-list.
+* Shares PATH_HIGHLIGHT_STYLES.onPath with the graph tree so the run-list and
+* the graph are byte-for-byte identical in their name/hash columns.
+*/
+function formatOnPathMigrationRow(dirName, from, to, dirNameWidth, colorize, 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 = migrationListEmptySource(glyphMode);
+	const forwardArrow = migrationListForwardArrow(glyphMode);
+	const fromAbbr = from === EMPTY_CONTRACT_HASH ? padFromHashColumn(style.glyph(emptySource), hashLength) : padFromHashColumn(style.sourceHash(abbreviateHash(from, hashLength, emptySource)), hashLength);
+	const toAbbr = to === EMPTY_CONTRACT_HASH ? style.glyph(emptySource) : style.destHash(abbreviateHash(to, hashLength, emptySource));
+	return `${styledDirName}  ${fromAbbr} ${style.glyph(forwardArrow)} ${toAbbr}`;
+}
+function legendGlyphs(mode) {
+	return mode === "ascii" ? {
+		node: "*",
+		forward: "^",
+		rollback: "v",
+		self: "@"
+	} : {
+		node: "○",
+		forward: "↑",
+		rollback: "↓",
+		self: "⟲"
+	};
+}
+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 `(…)` conventions, and a worked sample of the data-column hash arrow.
+*/
+function renderMigrationGraphLegend(opts) {
+	const glyphMode = opts.glyphMode ?? "unicode";
+	const style = createAnsiMigrationListStyler({ useColor: opts.colorize });
+	const glyphs = legendGlyphs(glyphMode);
+	const emptySource = migrationListEmptySource(glyphMode);
+	const forwardArrow = migrationListForwardArrow(glyphMode);
+	const sampleArrow = `${style.sourceHash("aaaaaa")} ${style.glyph(forwardArrow)} ${style.destHash("bbbbbb")}`;
+	const statusGlyphs = overlayStatusGlyphs(glyphMode);
+	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(glyphs.node)} ${style.summary("contract")}   ${style.kind(glyphs.forward)} ${style.summary("forward")}   ${style.kind(glyphs.rollback)} ${style.summary("rollback")}`,
+		`  ${style.kind(glyphs.self)} ${style.summary("migration without schema change")}`,
+		appliedPending,
+		`  ${style.kind(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-command-render.ts
+/**
+* Command graph renderer: composes the gutter (from the grid) with per-row labels.
+*
+* Pipeline: buildMigrationGraphRows → buildGrid → renderMigrationGraphCommand
+*
+* Each grid row is classified by its cells: a node row gets a contract label;
+* a migration arrow row gets a migration label; connector rows get no label.
+* Label format and styling live in `./migration-graph-labels`.
+*/
+const LABEL_GAP = 2;
+const MIN_HASH_DATA_COLUMN = 25;
+/**
+* Classify a grid row by its own cells:
+*   - a cell carrying a NodeRef → node row (contract label);
+*   - a cell whose top line is an arrow ({up}/{down}/self-loop) → migration row;
+*   - otherwise → no label.
+*
+* A migration's arrow appears in exactly one grid row (the forward `↑` row, the
+* adjacent-rollback `↓` row, or the self-loop `⟲` row), so each migration gets
+* exactly one label, on the row that draws its arrow.
+*
+* Two distinct migrations with identical content (same from/to/ops) hash to the
+* SAME migration hash, so the arrow line is matched on BOTH its hash and its
+* `dirName` (which the LineRef carries per-row) — otherwise both rows would
+* resolve to one edge and the other migration's name would be lost.
+*/
+function classifyRow(row, edgesByHash) {
+	for (const cell of row) if (cell.node !== void 0) return {
+		kind: "node",
+		contractHash: cell.node.contractHash
+	};
+	for (const cell of row) {
+		const arrow = arrowLine(cell);
+		if (arrow === void 0) continue;
+		const candidates = edgesByHash.get(arrow.line.migrationHash) ?? [];
+		const edge = candidates.find((e) => e.dirName === arrow.line.dirName) ?? candidates[0];
+		if (edge !== void 0) return {
+			kind: "migration",
+			edge,
+			lane: arrow.line.lane
+		};
+	}
+	return { kind: "none" };
+}
+/**
+* Return the cell's arrow line if it carries one — a self-loop, or a line whose
+* directions are exactly `{up}` or `{down}` (the migration-direction arrows).
+* Connector/corner/vertical lines are not arrows and yield `undefined`.
+*/
+function arrowLine(cell) {
+	for (const line of cell.lines) {
+		if (line.selfLoop === true) return line;
+		if (line.landingArrow === true) continue;
+		const dirs = line.directions;
+		if (dirs.size !== 1) continue;
+		if (dirs.has("up") || dirs.has("down")) return line;
+	}
+}
+/**
+* Resolve each contract's path-highlight role from the edges incident on it.
+* On-path wins: a contract touched by any on-path edge is on-path. Empty unless
+* focus-mode annotations are present.
+*/
+function resolveNodeHighlights(rowModel, edgeAnnotationsByHash) {
+	const result = /* @__PURE__ */ new Map();
+	if (edgeAnnotationsByHash === void 0) return result;
+	for (const edge of rowModel.edges) {
+		const highlight = edgeAnnotationsByHash.get(edge.migrationHash)?.pathHighlight;
+		if (highlight === void 0) continue;
+		for (const hash of [edge.from, edge.to]) {
+			if (hash === EMPTY_CONTRACT_HASH) continue;
+			if (result.get(hash) !== "on-path") result.set(hash, highlight);
+		}
+	}
+	return result;
+}
+function maxDirNameLength(edges) {
+	let max = 0;
+	for (const edge of edges) max = Math.max(max, edge.dirName.length);
+	return max;
+}
+/**
+* The label column for a render: the widest gutter (visible width) across every
+* row, plus the label gap. Labels begin here so they line up regardless of how
+* deep the lane structure runs on any one row. A cross-space override widens it
+* so sibling space sections share one column.
+*/
+function computeLabelColumn(grid, glyphMode) {
+	let maxGutter = 0;
+	for (const row of grid) {
+		const gutter = renderGridRow(row, {
+			colorize: false,
+			glyphMode
+		});
+		maxGutter = Math.max(maxGutter, stringWidth(gutter));
+	}
+	return maxGutter + LABEL_GAP;
+}
+function computeMaxDirNameWidth(rowModel) {
+	return maxDirNameLength(rowModel.edges);
+}
+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 renderMigrationGraphCommand(input) {
+	const { grid, rowModel } = input;
+	const glyphMode = input.glyphMode;
+	const edgesByHash = /* @__PURE__ */ new Map();
+	for (const edge of rowModel.edges) {
+		const bucket = edgesByHash.get(edge.migrationHash);
+		if (bucket) bucket.push(edge);
+		else edgesByHash.set(edge.migrationHash, [edge]);
+	}
+	const labelOpts = {
+		colorize: input.colorize,
+		glyphMode,
+		...ifDefined("refsByHash", input.refsByHash),
+		...ifDefined("edgeAnnotationsByHash", input.edgeAnnotationsByHash),
+		...ifDefined("dbHash", input.dbHash),
+		...ifDefined("contractHash", input.contractHash),
+		...ifDefined("isAppSpace", input.isAppSpace),
+		...ifDefined("activeRefName", input.activeRefName),
+		...ifDefined("styler", input.styler)
+	};
+	const nodeHighlights = resolveNodeHighlights(rowModel, input.edgeAnnotationsByHash);
+	const labelColumn = input.globalLabelColumn ?? computeLabelColumn(grid, glyphMode);
+	const maxDirNameLen = input.globalMaxDirNameWidth ?? maxDirNameLength(rowModel.edges);
+	const dirNameWidth = Math.max(maxDirNameLen + LABEL_GAP, MIN_HASH_DATA_COLUMN - labelColumn);
+	const lines = [];
+	for (const row of grid) {
+		const gutter = renderGridRow(row, {
+			colorize: input.colorize,
+			glyphMode
+		});
+		const identity = classifyRow(row, edgesByHash);
+		if (identity.kind === "none") {
+			lines.push(trimTrailingWhitespace(gutter));
+			continue;
+		}
+		const gutterPad = padVisible(gutter, labelColumn);
+		if (identity.kind === "node") {
+			const label = formatNodeLabel(identity.contractHash, labelOpts, nodeHighlights.get(identity.contractHash));
+			lines.push(trimTrailingWhitespace(label.length === 0 ? gutter : `${gutterPad}${label}`));
+			continue;
+		}
+		const label = formatMigrationLabel(identity.edge, dirNameWidth, labelOpts, identity.lane);
+		lines.push(trimTrailingWhitespace(`${gutterPad}${label}`));
+	}
+	return lines.join("\n");
+}
+//#endregion
+export { migrationListEmptySource as _, renderMigrationGraphLegend as a, renderMigrationListWithStyle as c, highlightFromEdgeAnnotations as d, indentMigrationGraphTreeBlock as f, abbreviateContractHash as g, buildGrid as h, formatOnPathMigrationRow as i, computeGlobalMaxDirNameWidth as l, buildMigrationGraphRows as m, computeMaxDirNameWidth as n, createAnsiMigrationListStyler as o, renderMigrationGraphSpaceTree as p, renderMigrationGraphCommand as r, IDENTITY_MIGRATION_LIST_STYLER as s, computeLabelColumn as t, computeGlobalMaxEdgeTreePrefixWidth as u, migrationListForwardArrow as v };
+
+//# sourceMappingURL=migration-graph-command-render-BAOzyYF6.mjs.map