prisma-next 0.12.0-dev.4 → 0.12.0-dev.40

package/dist/migration-graph-D7DVUElV.mjs

@@ -1,1232 +0,0 @@
-import { t as loadConfig } from "./config-loader-B6sJjXTv.mjs";
-import { T as formatStyledHeader, _ as createTerminalUI, d as setCommandSeeAlso, g as parseGlobalFlagsOrExit, l as setCommandDescriptions, s as resolveMigrationPaths, t as addGlobalOptions, u as setCommandExamples, y as handleResult } from "./command-helpers-Bbw1GbwL.mjs";
-import { r as buildReadAggregate } from "./contract-space-aggregate-loader-DvZwdkrr.mjs";
-import { i as migrationGraphToRenderInput, n as graphRenderer } from "./graph-render-rFAqZujX.mjs";
-import { a as migrationListEmptySource, n as createAnsiMigrationListStyler, o as migrationListForwardArrow, s as classifyMigrationGraphTopology, t as CONTRACT_MARKER_NAME } from "./migration-list-styler-BRwF4-gy.mjs";
-import { Command } from "commander";
-import { ok } from "@prisma-next/utils/result";
-import { bold } from "colorette";
-import stringWidth from "string-width";
-import { EMPTY_CONTRACT_HASH } from "@prisma-next/migration-tools/constants";
-//#region src/utils/formatters/migration-graph-layout.ts
-function forwardEdges(edges) {
-	return edges.filter((e) => e.kind === "forward");
-}
-function buildForwardProducersByTo(edges) {
-	const byTo = /* @__PURE__ */ new Map();
-	for (const edge of edges) {
-		if (edge.kind !== "forward") continue;
-		const bucket = byTo.get(edge.to);
-		if (bucket) bucket.push(edge);
-		else byTo.set(edge.to, [edge]);
-	}
-	return byTo;
-}
-function buildForwardOutDegree(edges) {
-	const out = /* @__PURE__ */ new Map();
-	for (const edge of edges) {
-		if (edge.kind !== "forward" || edge.from === edge.to) continue;
-		out.set(edge.from, (out.get(edge.from) ?? 0) + 1);
-	}
-	return out;
-}
-function buildForwardInDegree(edges) {
-	const indeg = /* @__PURE__ */ new Map();
-	for (const edge of forwardEdges(edges)) {
-		if (edge.from === edge.to) continue;
-		indeg.set(edge.to, (indeg.get(edge.to) ?? 0) + 1);
-	}
-	return indeg;
-}
-/**
-* Distinct source contracts among a contract's forward producers. A contract is
-* a *convergence* when this count is >= 2. Multiple migrations sharing one
-* source (a multi-edge) count once — they stack in a single lane rather than
-* fanning into a convergence.
-*/
-function buildDistinctSourceCountByTo(edges) {
-	const sources = /* @__PURE__ */ new Map();
-	for (const edge of edges) {
-		if (edge.kind !== "forward" || edge.from === edge.to) continue;
-		const set = sources.get(edge.to);
-		if (set) set.add(edge.from);
-		else sources.set(edge.to, new Set([edge.from]));
-	}
-	const counts = /* @__PURE__ */ new Map();
-	for (const [to, set] of sources) counts.set(to, set.size);
-	return counts;
-}
-function splitComponents(nodes) {
-	const components = [];
-	let current = [];
-	for (const node of nodes) {
-		if (node === null) {
-			if (current.length > 0) {
-				components.push(current);
-				current = [];
-			}
-			continue;
-		}
-		current.push(node);
-	}
-	if (current.length > 0) components.push(current);
-	return components;
-}
-function classifyForwardShortConvergenceAdjacency(rows, edgeRowIndex, edge, laneIndex) {
-	for (let index = edgeRowIndex + 1; index < rows.length; index++) {
-		const row = rows[index];
-		if (row === void 0) break;
-		if (row.kind === "component-separator" || row.kind === "branch-connector") continue;
-		if (row.kind === "merge-connector") continue;
-		if (row.kind === "edge") {
-			if (row.laneIndex === laneIndex) return "node-skipping-forward";
-			continue;
-		}
-		if (row.kind === "node" && row.contractHash === edge.from) return "adjacent";
-	}
-	return "node-skipping-forward";
-}
-function convergenceProducerUsesShortAdjacency(edge, laneIndex, forwardProducersByTo, producerLaneByHash) {
-	const producers = (forwardProducersByTo.get(edge.to) ?? []).filter((candidate) => candidate.kind === "forward");
-	if (producers.length < 2) return false;
-	const fanStart = [...new Set(producers.map((producer) => producerLaneByHash.get(producer.migrationHash)).filter((candidate) => candidate !== void 0))].sort((a, b) => a - b)[0];
-	if (fanStart === void 0) return false;
-	return laneIndex === fanStart;
-}
-function classifyForwardLayoutAdjacency(rows, edgeRowIndex, edge, laneIndex, passThroughLanes, nodeColumn, convergenceProducer, divergenceBranchEdge) {
-	let sawObstruction = false;
-	const passThroughLaneSet = new Set(passThroughLanes);
-	for (let index = edgeRowIndex + 1; index < rows.length; index++) {
-		const row = rows[index];
-		if (row === void 0) break;
-		if (row.kind === "component-separator") continue;
-		if (row.kind === "merge-connector") {
-			if (convergenceProducer) {
-				if (row.contractHash === edge.from) sawObstruction = true;
-			} else if (!divergenceBranchEdge && row.contractHash !== edge.from) sawObstruction = true;
-			continue;
-		}
-		if (row.kind === "branch-connector") continue;
-		if (row.kind === "edge") {
-			if (row.laneIndex === laneIndex) return "node-skipping-forward";
-			if (!divergenceBranchEdge && row.edge !== void 0 && row.edge.to !== edge.to) sawObstruction = true;
-			continue;
-		}
-		if (row.kind === "node" && row.contractHash !== void 0) {
-			if (row.contractHash === edge.from) return sawObstruction ? "node-skipping-forward" : "adjacent";
-			const nodeCol = nodeColumn.get(row.contractHash) ?? 0;
-			if (!divergenceBranchEdge && !passThroughLaneSet.has(nodeCol)) sawObstruction = true;
-		}
-	}
-	return "node-skipping-forward";
-}
-function classifyLayoutAdjacency(rows, edgeRowIndex, edge, laneIndex, passThroughLanes, nodeColumn, position, forwardInDegree, convergenceProducer, divergenceBranchEdge) {
-	if (edge.kind === "self") return "adjacent";
-	const fromPos = position.get(edge.from);
-	const toPos = position.get(edge.to);
-	if (edge.kind === "forward") {
-		if ((forwardInDegree.get(edge.to) ?? 0) <= 1 && fromPos !== void 0 && toPos !== void 0 && fromPos === toPos + 1) return "adjacent";
-		return classifyForwardLayoutAdjacency(rows, edgeRowIndex, edge, laneIndex, passThroughLanes, nodeColumn, convergenceProducer, divergenceBranchEdge);
-	}
-	if (fromPos !== void 0 && toPos !== void 0 && toPos === fromPos + 1) return "adjacent";
-	for (let index = edgeRowIndex + 1; index < rows.length; index++) {
-		const row = rows[index];
-		if (row === void 0) break;
-		if (row.kind === "component-separator" || row.kind === "branch-connector" || row.kind === "merge-connector") continue;
-		if (row.kind === "edge") continue;
-		if (row.kind === "node") return row.contractHash === edge.to ? "adjacent" : "node-skipping-rollback";
-	}
-	return "node-skipping-rollback";
-}
-function refineAdjacency(rows, nodeColumn, position, forwardInDegree, forwardOutDegree, edges, producerLaneByHash) {
-	const forwardProducersByTo = buildForwardProducersByTo(edges);
-	function branchLaneForEdge(producer) {
-		const children = edges.filter((edge) => edge.from === producer.from && edge.kind === "forward" && edge.from !== edge.to);
-		if (children.length < 2) return void 0;
-		const index = children.findIndex((child) => child.migrationHash === producer.migrationHash);
-		return index >= 0 ? index : void 0;
-	}
-	return rows.map((row, rowIndex) => {
-		if (row.kind !== "edge" || row.edge === void 0 || row.laneIndex === void 0) return row;
-		const divergenceBranchEdge = row.edge.kind === "forward" && !(row.convergenceProducer ?? false) && (forwardOutDegree.get(row.edge.from) ?? 0) >= 2 && branchLaneForEdge(row.edge) !== void 0;
-		const adjacency = row.convergenceProducer === true && convergenceProducerUsesShortAdjacency(row.edge, row.laneIndex, forwardProducersByTo, producerLaneByHash) ? classifyForwardShortConvergenceAdjacency(rows, rowIndex, row.edge, row.laneIndex) : classifyLayoutAdjacency(rows, rowIndex, row.edge, row.laneIndex, row.passThroughLanes ?? [], nodeColumn, position, forwardInDegree, row.convergenceProducer ?? false, divergenceBranchEdge);
-		return {
-			...row,
-			cells: buildEdgeCells(row.edge, row.laneIndex, row.passThroughLanes ?? [], adjacency, row.cells.length)
-		};
-	});
-}
-function classifyEdgeAdjacency(edge, position) {
-	if (edge.kind === "self") return "adjacent";
-	const fromPos = position.get(edge.from);
-	const toPos = position.get(edge.to);
-	if (fromPos === void 0 || toPos === void 0) return "adjacent";
-	if (edge.kind === "forward") {
-		if (toPos >= fromPos) return "adjacent";
-		return fromPos === toPos + 1 ? "adjacent" : "node-skipping-forward";
-	}
-	if (toPos <= fromPos) return "adjacent";
-	return toPos === fromPos + 1 ? "adjacent" : "node-skipping-rollback";
-}
-function emptyCells(width) {
-	return Array.from({ length: width }, () => ({ kind: "empty" }));
-}
-function buildBranchConnectorCells(startLane, endLane, activeLanes, gridWidth) {
-	const cells = emptyCells(gridWidth);
-	for (let lane = 0; lane < gridWidth; lane++) {
-		if (activeLanes.has(lane) && (lane < startLane || lane > endLane)) {
-			cells[lane] = { kind: "vertical-pass" };
-			continue;
-		}
-		if (lane === startLane) cells[lane] = { kind: "branch-tee" };
-		else if (lane === endLane) cells[lane] = { kind: "branch-corner" };
-		else if (lane > startLane && lane < endLane) cells[lane] = { kind: "branch-tee" };
-	}
-	return cells;
-}
-function buildMergeConnectorCells(startLane, endLane, activeLanes, gridWidth) {
-	const cells = emptyCells(gridWidth);
-	for (let lane = 0; lane < gridWidth; lane++) {
-		if (activeLanes.has(lane) && (lane < startLane || lane > endLane)) {
-			cells[lane] = { kind: "vertical-pass" };
-			continue;
-		}
-		if (lane === startLane) cells[lane] = { kind: "merge-tee" };
-		else if (lane === endLane) cells[lane] = { kind: "merge-corner" };
-		else if (lane > startLane && lane < endLane) cells[lane] = activeLanes.has(lane) ? { kind: "merge-tee" } : { kind: "horizontal-pass" };
-	}
-	return cells;
-}
-function buildNodeCells(contractHash, nodeColumn, activeLanes, gridWidth) {
-	const cells = emptyCells(gridWidth);
-	for (const lane of activeLanes) if (lane !== nodeColumn && lane < gridWidth) cells[lane] = { kind: "vertical-pass" };
-	if (nodeColumn < gridWidth) cells[nodeColumn] = {
-		kind: "node",
-		contractHash
-	};
-	return cells;
-}
-function buildEdgeCells(edge, laneIndex, passThroughLanes, adjacency, gridWidth) {
-	const cells = emptyCells(gridWidth);
-	for (const lane of passThroughLanes) if (lane < gridWidth) cells[lane] = { kind: "vertical-pass" };
-	if (laneIndex < gridWidth) cells[laneIndex] = {
-		kind: "edge-lane",
-		migrationHash: edge.migrationHash,
-		edgeKind: edge.kind,
-		ownsLabel: true,
-		adjacency
-	};
-	return cells;
-}
-/**
-* Compute the vertical node order for a component: tips at the top (index 0),
-* roots at the bottom. This is a DFS post-order over forward edges starting
-* from forward roots, visiting children in their input (insertion) order. A
-* node is emitted only after all of its forward children, so convergence nodes
-* sit below every branch that feeds them and the longest contiguous chain reads
-* top-to-bottom without braiding.
-*/
-function computeVerticalOrder(componentNodes, forwardChildren, forwardInDegree) {
-	const WHITE = 0;
-	const GRAY = 1;
-	const BLACK = 2;
-	const color = /* @__PURE__ */ new Map();
-	for (const node of componentNodes) color.set(node, WHITE);
-	const sortRoots = (roots) => [...roots].sort((a, b) => {
-		if (a === EMPTY_CONTRACT_HASH) return -1;
-		if (b === EMPTY_CONTRACT_HASH) return 1;
-		return a.localeCompare(b);
-	});
-	let roots = sortRoots(componentNodes.filter((n) => (forwardInDegree.get(n) ?? 0) === 0));
-	if (roots.length === 0) roots = sortRoots(componentNodes);
-	const result = [];
-	function runDfs(root) {
-		if (color.get(root) !== WHITE) return;
-		const stack = [{
-			node: root,
-			children: forwardChildren.get(root) ?? [],
-			index: 0
-		}];
-		color.set(root, GRAY);
-		while (stack.length > 0) {
-			const frame = stack[stack.length - 1];
-			if (frame === void 0) break;
-			if (frame.index >= frame.children.length) {
-				color.set(frame.node, BLACK);
-				result.push(frame.node);
-				stack.pop();
-				continue;
-			}
-			const child = frame.children[frame.index];
-			frame.index += 1;
-			if (child === void 0) continue;
-			if (color.get(child.to) === WHITE) {
-				color.set(child.to, GRAY);
-				stack.push({
-					node: child.to,
-					children: forwardChildren.get(child.to) ?? [],
-					index: 0
-				});
-			}
-		}
-	}
-	for (const root of roots) runDfs(root);
-	for (const node of componentNodes) if (color.get(node) === WHITE) runDfs(node);
-	return result;
-}
-function rollbackSpan(edge, position) {
-	const top = position.get(edge.from) ?? 0;
-	return {
-		top,
-		bottom: position.get(edge.to) ?? top
-	};
-}
-function spansOverlap(a, b) {
-	return a.top <= b.bottom && b.top <= a.bottom;
-}
-function forwardMaxLane(rows, skipMigrationHashes) {
-	let max = 0;
-	for (const row of rows) {
-		if (row.kind === "edge" && row.edge !== void 0 && skipMigrationHashes.has(row.edge.migrationHash)) continue;
-		max = Math.max(max, row.laneIndex ?? 0);
-		for (const lane of row.passThroughLanes ?? []) max = Math.max(max, lane);
-		if (row.startLane !== void 0) max = Math.max(max, row.startLane, row.endLane ?? row.startLane);
-	}
-	return max;
-}
-function allocateSkipRollbackBackLanes(skipRollbacks, position, forwardMax) {
-	const sorted = [...skipRollbacks].sort((a, b) => {
-		const aTop = position.get(a.from) ?? 0;
-		const bTop = position.get(b.from) ?? 0;
-		if (aTop !== bTop) return aTop - bTop;
-		return b.dirName.localeCompare(a.dirName);
-	});
-	const occupied = [];
-	const lanes = /* @__PURE__ */ new Map();
-	let nextLane = forwardMax + 1;
-	for (const edge of sorted) {
-		const span = rollbackSpan(edge, position);
-		let lane = nextLane;
-		while (occupied.some((entry) => entry.lane === lane && spansOverlap(entry, span))) lane += 1;
-		occupied.push({
-			...span,
-			lane
-		});
-		lanes.set(edge.migrationHash, lane);
-		nextLane = Math.max(nextLane, lane + 1);
-	}
-	return lanes;
-}
-function findNodeRowIndex(rows, contractHash) {
-	return rows.findIndex((row) => row.kind === "node" && row.contractHash === contractHash);
-}
-function findEdgeRowIndex(rows, migrationHash) {
-	return rows.findIndex((row) => row.kind === "edge" && row.edge?.migrationHash === migrationHash);
-}
-function ensureCellWidth(cells, width) {
-	while (cells.length < width) cells.push({ kind: "empty" });
-}
-function cloneRow(row) {
-	return {
-		...row,
-		cells: [...row.cells]
-	};
-}
-function routeCrossesRow(route, rowIndex, rows) {
-	const sourceRow = findNodeRowIndex(rows, route.edge.from);
-	const targetRow = findNodeRowIndex(rows, route.edge.to);
-	if (sourceRow < 0 || targetRow < 0) return false;
-	return rowIndex > sourceRow && rowIndex <= targetRow;
-}
-function applySkipRollbackRouting(rows, skipRollbacks, position, nodeColumn, edgeColumn) {
-	if (skipRollbacks.length === 0) return [...rows];
-	const forwardMax = forwardMaxLane(rows, new Set(skipRollbacks.map((edge) => edge.migrationHash)));
-	const backLaneByHash = allocateSkipRollbackBackLanes(skipRollbacks, position, forwardMax);
-	const routes = skipRollbacks.map((edge) => ({
-		edge,
-		backLane: backLaneByHash.get(edge.migrationHash) ?? forwardMax + 1
-	}));
-	const result = rows.map(cloneRow);
-	for (const route of routes) {
-		const { edge, backLane } = route;
-		const nodeCol = nodeColumn.get(edge.from) ?? 0;
-		const targetCol = nodeColumn.get(edge.to) ?? 0;
-		const sourceRowIndex = findNodeRowIndex(result, edge.from);
-		const targetRowIndex = findNodeRowIndex(result, edge.to);
-		const edgeRowIndex = findEdgeRowIndex(result, edge.migrationHash);
-		if (sourceRowIndex < 0 || targetRowIndex < 0 || edgeRowIndex < 0) continue;
-		edgeColumn.set(edge.migrationHash, backLane);
-		const coSourcedLanes = routes.filter((other) => other.edge.from === edge.from).map((other) => other.backLane);
-		const maxCoSourcedLane = Math.max(...coSourcedLanes);
-		const sourceRow = result[sourceRowIndex];
-		if (sourceRow !== void 0) {
-			const cells = sourceRow.cells;
-			ensureCellWidth(cells, backLane + 1);
-			cells[nodeCol] = {
-				kind: "node",
-				contractHash: sourceRow.contractHash ?? EMPTY_CONTRACT_HASH,
-				arcTee: true
-			};
-			for (let lane = nodeCol + 1; lane < backLane; lane += 1) {
-				if (coSourcedLanes.includes(lane)) {
-					cells[lane] = { kind: "arc-branch-tee" };
-					continue;
-				}
-				const existing = cells[lane];
-				cells[lane] = existing !== void 0 && existing.kind !== "empty" && existing.kind !== "horizontal-pass" && existing.kind !== "arc-land-bridge" || routes.some((other) => other.edge.migrationHash !== edge.migrationHash && other.backLane === lane && routeCrossesRow(other, sourceRowIndex, result)) ? { kind: "arc-crossing" } : { kind: "horizontal-pass" };
-			}
-			cells[backLane] = backLane < maxCoSourcedLane ? { kind: "arc-branch-tee" } : { kind: "arc-branch-corner" };
-		}
-		const edgeRow = result[edgeRowIndex];
-		if (edgeRow !== void 0) {
-			const cells = edgeRow.cells;
-			ensureCellWidth(cells, backLane + 1);
-			cells[nodeCol] = { kind: "vertical-pass" };
-			cells[backLane] = {
-				kind: "edge-lane",
-				migrationHash: edge.migrationHash,
-				edgeKind: edge.kind,
-				ownsLabel: true,
-				adjacency: "node-skipping-rollback"
-			};
-			result[edgeRowIndex] = {
-				...edgeRow,
-				laneIndex: backLane,
-				passThroughLanes: [nodeCol]
-			};
-		}
-		for (let index = sourceRowIndex + 1; index < targetRowIndex; index += 1) {
-			if (index === edgeRowIndex) continue;
-			const row = result[index];
-			if (row === void 0) continue;
-			const cells = row.cells;
-			ensureCellWidth(cells, backLane + 1);
-			const existing = cells[backLane];
-			if (existing?.kind !== "arc-land-corner" && existing?.kind !== "arc-land-bridge" && existing?.kind !== "arc-branch-corner" && existing?.kind !== "arc-branch-tee" && existing?.kind !== "arc-crossing") cells[backLane] = { kind: "vertical-pass" };
-		}
-		const targetRow = result[targetRowIndex];
-		if (targetRow !== void 0) {
-			const cells = targetRow.cells;
-			ensureCellWidth(cells, backLane + 1);
-			cells[targetCol] = {
-				kind: "node",
-				contractHash: targetRow.contractHash ?? EMPTY_CONTRACT_HASH,
-				arcLand: true
-			};
-			for (let lane = targetCol + 1; lane < backLane; lane += 1) {
-				const existing = cells[lane];
-				cells[lane] = existing !== void 0 && existing.kind !== "empty" && existing.kind !== "horizontal-pass" && existing.kind !== "arc-land-bridge" || routes.some((other) => other.edge.migrationHash !== edge.migrationHash && other.backLane === lane && routeCrossesRow(other, targetRowIndex, result)) ? { kind: "arc-crossing" } : { kind: "arc-land-bridge" };
-			}
-			cells[backLane] = { kind: "arc-land-corner" };
-			for (const other of routes) {
-				if (other.backLane <= backLane) continue;
-				if (!routeCrossesRow(other, targetRowIndex, result)) continue;
-				ensureCellWidth(cells, other.backLane + 1);
-				const existing = cells[other.backLane];
-				if (existing?.kind !== "arc-land-corner" && existing?.kind !== "arc-land-bridge" && existing?.kind !== "node") cells[other.backLane] = { kind: "vertical-pass" };
-			}
-		}
-	}
-	return result;
-}
-function collectNodeSkippingRollbacks(edges, position) {
-	return edges.filter((edge) => edge.kind === "rollback" && classifyEdgeAdjacency(edge, position) === "node-skipping-rollback");
-}
-function layoutComponent(componentNodes, allEdges) {
-	const componentSet = new Set(componentNodes);
-	const edges = allEdges.filter((e) => componentSet.has(e.from) && componentSet.has(e.to));
-	const forwardChildren = /* @__PURE__ */ new Map();
-	const producersByTo = /* @__PURE__ */ new Map();
-	const rollbacksByFrom = /* @__PURE__ */ new Map();
-	const selfByFrom = /* @__PURE__ */ new Map();
-	for (const edge of edges) {
-		if (edge.kind === "self" || edge.from === edge.to) {
-			const bucket = selfByFrom.get(edge.from);
-			if (bucket) bucket.push(edge);
-			else selfByFrom.set(edge.from, [edge]);
-			continue;
-		}
-		if (edge.kind === "forward") {
-			const children = forwardChildren.get(edge.from);
-			if (children) children.push(edge);
-			else forwardChildren.set(edge.from, [edge]);
-			const producers = producersByTo.get(edge.to);
-			if (producers) producers.push(edge);
-			else producersByTo.set(edge.to, [edge]);
-			continue;
-		}
-		const bucket = rollbacksByFrom.get(edge.from);
-		if (bucket) bucket.push(edge);
-		else rollbacksByFrom.set(edge.from, [edge]);
-	}
-	const forwardInDegree = buildForwardInDegree(edges);
-	const forwardOutDegree = buildForwardOutDegree(edges);
-	const distinctSourceCountByTo = buildDistinctSourceCountByTo(edges);
-	const order = computeVerticalOrder(componentNodes, forwardChildren, forwardInDegree);
-	const position = /* @__PURE__ */ new Map();
-	for (let index = 0; index < order.length; index++) {
-		const node = order[index];
-		if (node !== void 0) position.set(node, index);
-	}
-	const lanes = [];
-	const rows = [];
-	const nodeColumn = /* @__PURE__ */ new Map();
-	const edgeColumn = /* @__PURE__ */ new Map();
-	const producerLaneByHash = /* @__PURE__ */ new Map();
-	let gridWidth = 1;
-	function ensureGridWidth(minWidth) {
-		if (minWidth > gridWidth) gridWidth = minWidth;
-	}
-	function setLane(index, want) {
-		while (lanes.length <= index) lanes.push(null);
-		lanes[index] = want;
-		if (want !== null) ensureGridWidth(index + 1);
-	}
-	function activeLaneIndices() {
-		const indices = [];
-		for (let index = 0; index < lanes.length; index++) if (lanes[index] !== null) indices.push(index);
-		return indices;
-	}
-	function passThroughExcept(lane) {
-		return activeLaneIndices().filter((index) => index !== lane);
-	}
-	function leftmostFreeLane() {
-		for (let index = 0; index < lanes.length; index++) if (lanes[index] === null) return index;
-		return lanes.length;
-	}
-	function lanesWanting(contract) {
-		const indices = [];
-		for (let index = 0; index < lanes.length; index++) if (lanes[index] === contract) indices.push(index);
-		return indices;
-	}
-	function emitMergeConnector(contractHash, laneIndices) {
-		const startLane = Math.min(...laneIndices);
-		const endLane = Math.max(...laneIndices);
-		ensureGridWidth(endLane + 1);
-		const activeLanes = new Set(activeLaneIndices());
-		rows.push({
-			kind: "merge-connector",
-			contractHash,
-			startLane,
-			endLane,
-			branchCount: laneIndices.length,
-			cells: buildMergeConnectorCells(startLane, endLane, activeLanes, gridWidth)
-		});
-		for (const index of laneIndices) if (index !== startLane) setLane(index, null);
-		return startLane;
-	}
-	function emitBranchConnector(contractHash, startLane, endLane, branchCount) {
-		ensureGridWidth(endLane + 1);
-		const activeLanes = new Set(activeLaneIndices());
-		rows.push({
-			kind: "branch-connector",
-			contractHash,
-			startLane,
-			endLane,
-			branchCount,
-			cells: buildBranchConnectorCells(startLane, endLane, activeLanes, gridWidth)
-		});
-	}
-	function emitEdgeRow(edge, lane, convergenceProducer) {
-		const passThrough = passThroughExcept(lane);
-		const adjacency = classifyEdgeAdjacency(edge, position);
-		ensureGridWidth(Math.max(lane, ...passThrough, 0) + 1);
-		const row = {
-			kind: "edge",
-			edge,
-			laneIndex: lane,
-			passThroughLanes: passThrough,
-			cells: buildEdgeCells(edge, lane, passThrough, adjacency, gridWidth)
-		};
-		rows.push(convergenceProducer ? {
-			...row,
-			convergenceProducer: true
-		} : row);
-		edgeColumn.set(edge.migrationHash, lane);
-		if (convergenceProducer) producerLaneByHash.set(edge.migrationHash, lane);
-	}
-	function emitNodeRow(contractHash, column) {
-		ensureGridWidth(column + 1);
-		const passThrough = activeLaneIndices().filter((index) => index !== column);
-		rows.push({
-			kind: "node",
-			contractHash,
-			cells: buildNodeCells(contractHash, column, passThrough, gridWidth)
-		});
-		nodeColumn.set(contractHash, column);
-	}
-	function producerGroups(node) {
-		const byTarget = /* @__PURE__ */ new Map();
-		for (const producer of producersByTo.get(node) ?? []) {
-			const group = byTarget.get(producer.from);
-			if (group) group.edges.push(producer);
-			else byTarget.set(producer.from, {
-				target: producer.from,
-				edges: [producer]
-			});
-		}
-		const groups = [...byTarget.values()];
-		groups.sort((a, b) => (position.get(a.target) ?? 0) - (position.get(b.target) ?? 0));
-		for (const group of groups) group.edges.sort((a, b) => b.dirName.localeCompare(a.dirName));
-		return groups;
-	}
-	function processNode(node) {
-		const wanting = lanesWanting(node);
-		let column;
-		if (wanting.length >= 2) column = emitMergeConnector(node, wanting);
-		else if (wanting.length === 1) column = wanting[0] ?? 0;
-		else column = leftmostFreeLane();
-		const selfEdges = [...selfByFrom.get(node) ?? []].sort((a, b) => b.dirName.localeCompare(a.dirName));
-		for (const selfEdge of selfEdges) emitEdgeRow(selfEdge, column, false);
-		emitNodeRow(node, column);
-		const rollbacks = [...rollbacksByFrom.get(node) ?? []].sort((a, b) => b.dirName.localeCompare(a.dirName));
-		const skipRollbacks = [];
-		const adjacentRollbacks = [];
-		for (const rollback of rollbacks) if (classifyEdgeAdjacency(rollback, position) === "node-skipping-rollback") skipRollbacks.push(rollback);
-		else adjacentRollbacks.push(rollback);
-		for (const rollback of skipRollbacks) emitEdgeRow(rollback, column, false);
-		const groups = producerGroups(node);
-		const isConvergence = (distinctSourceCountByTo.get(node) ?? 0) >= 2;
-		const laneForGroup = [];
-		for (let groupIndex = 0; groupIndex < groups.length; groupIndex++) {
-			const group = groups[groupIndex];
-			if (group === void 0) continue;
-			const lane = groupIndex === 0 ? column : leftmostFreeLane();
-			laneForGroup[groupIndex] = lane;
-			setLane(lane, group.target);
-		}
-		if (groups.length >= 2) {
-			const endLane = Math.max(...laneForGroup);
-			emitBranchConnector(node, column, endLane, groups.length);
-		}
-		for (let groupIndex = 0; groupIndex < groups.length; groupIndex++) {
-			const group = groups[groupIndex];
-			const lane = laneForGroup[groupIndex];
-			if (group === void 0 || lane === void 0) continue;
-			for (const edge of group.edges) emitEdgeRow(edge, lane, isConvergence);
-		}
-		for (const rollback of adjacentRollbacks) emitEdgeRow(rollback, column, false);
-		if (groups.length === 0) setLane(column, null);
-	}
-	for (const node of order) processNode(node);
-	return {
-		rows: applySkipRollbackRouting(refineAdjacency(rows, nodeColumn, position, forwardInDegree, forwardOutDegree, edges, producerLaneByHash), collectNodeSkippingRollbacks(edges, position), position, nodeColumn, edgeColumn),
-		nodeColumn,
-		edgeColumn
-	};
-}
-function buildMigrationGraphLayout(rowModel) {
-	if (rowModel.nodes.length === 0) return {
-		rows: [],
-		nodeColumn: /* @__PURE__ */ new Map(),
-		edgeColumn: /* @__PURE__ */ new Map()
-	};
-	const components = splitComponents(rowModel.nodes);
-	const allRows = [];
-	const nodeColumn = /* @__PURE__ */ new Map();
-	const edgeColumn = /* @__PURE__ */ new Map();
-	for (let componentIndex = 0; componentIndex < components.length; componentIndex++) {
-		if (componentIndex > 0) allRows.push({
-			kind: "component-separator",
-			cells: []
-		});
-		const component = components[componentIndex];
-		if (component === void 0 || component.length === 0) continue;
-		const result = layoutComponent(component, rowModel.edges);
-		allRows.push(...result.rows);
-		for (const [hash, column] of result.nodeColumn) nodeColumn.set(hash, column);
-		for (const [hash, column] of result.edgeColumn) edgeColumn.set(hash, column);
-	}
-	return {
-		rows: allRows,
-		nodeColumn,
-		edgeColumn
-	};
-}
-//#endregion
-//#region src/utils/formatters/migration-graph-rows.ts
-/**
-* Return the weakly-connected components of `graph` as an array of node sets,
-* ordered so the component containing EMPTY_CONTRACT_HASH comes first (if
-* present), with remaining components sorted by their lex-smallest node hash.
-*/
-function weaklyConnectedComponents(graph) {
-	const visited = /* @__PURE__ */ new Set();
-	const adjacency = /* @__PURE__ */ new Map();
-	function addAdjacent(a, b) {
-		const aList = adjacency.get(a);
-		if (aList) aList.push(b);
-		else adjacency.set(a, [b]);
-		const bList = adjacency.get(b);
-		if (bList) bList.push(a);
-		else adjacency.set(b, [a]);
-	}
-	for (const edges of graph.forwardChain.values()) for (const edge of edges) if (edge.from !== edge.to) addAdjacent(edge.from, edge.to);
-	for (const node of graph.nodes) if (!adjacency.has(node)) adjacency.set(node, []);
-	const components = [];
-	function bfsComponent(start) {
-		const component = /* @__PURE__ */ new Set();
-		const queue = [start];
-		while (queue.length > 0) {
-			const node = queue.shift();
-			if (node === void 0 || visited.has(node)) continue;
-			visited.add(node);
-			component.add(node);
-			for (const neighbor of adjacency.get(node) ?? []) if (!visited.has(neighbor)) queue.push(neighbor);
-		}
-		return component;
-	}
-	const allNodes = [...graph.nodes].sort((a, b) => {
-		if (a === EMPTY_CONTRACT_HASH) return -1;
-		if (b === EMPTY_CONTRACT_HASH) return 1;
-		return a.localeCompare(b);
-	});
-	for (const node of allNodes) if (!visited.has(node)) components.push(bfsComponent(node));
-	components.sort((a, b) => {
-		const aHasEmpty = a.has(EMPTY_CONTRACT_HASH);
-		const bHasEmpty = b.has(EMPTY_CONTRACT_HASH);
-		if (aHasEmpty && !bHasEmpty) return -1;
-		if (!aHasEmpty && bHasEmpty) return 1;
-		const aMin = [...a].sort((x, y) => x.localeCompare(y))[0] ?? "";
-		const bMin = [...b].sort((x, y) => x.localeCompare(y))[0] ?? "";
-		return aMin.localeCompare(bMin);
-	});
-	return components;
-}
-function forwardRootsInComponent(componentNodes, topology) {
-	const roots = [];
-	for (const node of componentNodes) if ((topology.forwardInDegree.get(node) ?? 0) === 0) roots.push(node);
-	roots.sort((a, b) => {
-		if (a === EMPTY_CONTRACT_HASH) return -1;
-		if (b === EMPTY_CONTRACT_HASH) return 1;
-		return a.localeCompare(b);
-	});
-	if (roots.length > 0) return roots;
-	return [...componentNodes].sort((a, b) => {
-		if (a === EMPTY_CONTRACT_HASH) return -1;
-		if (b === EMPTY_CONTRACT_HASH) return 1;
-		return a.localeCompare(b);
-	});
-}
-function compareNodesTipsFirst(a, b, rank) {
-	const rankA = rank.get(a) ?? 0;
-	const rankB = rank.get(b) ?? 0;
-	if (rankA !== rankB) return rankB - rankA;
-	if (a === EMPTY_CONTRACT_HASH) return 1;
-	if (b === EMPTY_CONTRACT_HASH) return -1;
-	return a.localeCompare(b);
-}
-/**
-* Layer nodes by longest forward-path rank from forward roots within the
-* component. Rank 0 is the root (bottom row); the maximum rank is the tip
-* (top row). Emits rank-descending with lex-ascending tie-break among siblings
-* at the same rank — stable across edge-insertion order and correct under
-* diamonds, cross-links, and rollbacks.
-*/
-function layerNodesByLongestForwardPath(componentNodes, topology, graph) {
-	const forwardOut = /* @__PURE__ */ new Map();
-	for (const node of componentNodes) forwardOut.set(node, []);
-	for (const edges of graph.forwardChain.values()) for (const edge of edges) {
-		if (!componentNodes.has(edge.from) || !componentNodes.has(edge.to)) continue;
-		if (edge.from === edge.to) continue;
-		if (topology.kindByMigrationHash.get(edge.migrationHash) !== "forward") continue;
-		const bucket = forwardOut.get(edge.from);
-		if (bucket) bucket.push(edge.to);
-	}
-	const roots = forwardRootsInComponent(componentNodes, topology);
-	const rank = /* @__PURE__ */ new Map();
-	for (const root of roots) rank.set(root, 0);
-	const maxPasses = componentNodes.size;
-	for (let pass = 0; pass < maxPasses; pass++) {
-		let changed = false;
-		for (const node of componentNodes) {
-			const base = rank.get(node);
-			if (base === void 0) continue;
-			for (const to of forwardOut.get(node) ?? []) {
-				const next = base + 1;
-				if (next > (rank.get(to) ?? -1)) {
-					rank.set(to, next);
-					changed = true;
-				}
-			}
-		}
-		if (!changed) break;
-	}
-	for (const node of componentNodes) if (!rank.has(node)) rank.set(node, 0);
-	return [...componentNodes].sort((a, b) => compareNodesTipsFirst(a, b, rank));
-}
-/**
-* Build the row model from a tolerant `MigrationGraph`.
-*
-* The row model is the first pure-data stage of the `migration graph` render
-* pipeline. It:
-* - classifies every edge as `forward`, `rollback`, or `self`;
-* - produces a deterministic vertical node ordering (tips at index 0, roots
-*   at the end) within each weakly-connected component;
-* - separates disjoint components with `null` sentinels;
-* - optionally prepends a detached current contract as its own single-node
-*   component when `contractHash` is not already in the graph.
-*
-* No columns, no lane allocation, no glyphs, no rendering.
-*/
-/**
-* Resolve the detached current contract, if any: a real contract (not the
-* empty baseline) that no migration on disk produces, so it is absent from
-* the graph. Such a contract renders as a floating node rather than
-* decorating an existing one. Returns the hash when detached, else undefined.
-*/
-function detachedContractHash(graph, contractHash) {
-	return contractHash !== void 0 && contractHash !== EMPTY_CONTRACT_HASH && !graph.nodes.has(contractHash) ? contractHash : void 0;
-}
-function buildMigrationGraphRows(graph, options = {}) {
-	const emptyModel = {
-		nodes: [],
-		edges: [],
-		edgesByFrom: /* @__PURE__ */ new Map(),
-		edgesByTo: /* @__PURE__ */ new Map()
-	};
-	if (graph.nodes.size === 0) {
-		const detached = detachedContractHash(graph, options.contractHash);
-		return detached !== void 0 ? {
-			...emptyModel,
-			nodes: [detached]
-		} : emptyModel;
-	}
-	const topology = classifyMigrationGraphTopology(graph);
-	const edges = [];
-	const edgesByFrom = /* @__PURE__ */ new Map();
-	const edgesByTo = /* @__PURE__ */ new Map();
-	for (const edgeList of graph.forwardChain.values()) for (const edge of edgeList) {
-		const kind = topology.kindByMigrationHash.get(edge.migrationHash) ?? "forward";
-		const classified = {
-			migrationHash: edge.migrationHash,
-			from: edge.from,
-			to: edge.to,
-			dirName: edge.dirName,
-			kind
-		};
-		edges.push(classified);
-		const fromBucket = edgesByFrom.get(edge.from);
-		if (fromBucket) fromBucket.push(classified);
-		else edgesByFrom.set(edge.from, [classified]);
-		const toBucket = edgesByTo.get(edge.to);
-		if (toBucket) toBucket.push(classified);
-		else edgesByTo.set(edge.to, [classified]);
-	}
-	const components = weaklyConnectedComponents(graph);
-	const nodes = [];
-	for (let i = 0; i < components.length; i++) {
-		if (i > 0) nodes.push(null);
-		const component = components[i];
-		if (component === void 0) continue;
-		const ordered = layerNodesByLongestForwardPath(component, topology, graph);
-		for (const node of ordered) nodes.push(node);
-	}
-	const detached = detachedContractHash(graph, options.contractHash);
-	if (detached !== void 0) {
-		if (nodes.length > 0) nodes.unshift(null);
-		nodes.unshift(detached);
-	}
-	return {
-		nodes,
-		edges,
-		edgesByFrom,
-		edgesByTo
-	};
-}
-//#endregion
-//#region src/utils/formatters/migration-graph-tree-render.ts
-const LABEL_GAP = 2;
-/**
-* The live-database overlay marker. Just another ref as far as styling goes —
-* the only emphasized markers are the active ref and the `contract`
-* desired-state marker (see {@link CONTRACT_MARKER_NAME}).
-*/
-const DB_MARKER_NAME = "db";
-const UNICODE_PALETTE = {
-	node: "○ ",
-	arcLand: "○◂",
-	arcTee: "○─",
-	verticalPass: "│ ",
-	branchTee: "├─",
-	mergeTee: "├─",
-	branchCorner: "╮ ",
-	mergeCorner: "╯ ",
-	arcBranchCorner: "╮ ",
-	arcBranchTee: "┬─",
-	arcLandCorner: "╯ ",
-	arcCrossing: "┼─",
-	arcLandBridge: "──",
-	horizontalPass: "──",
-	connectorBranchTee: "├─",
-	connectorBranchTeeCo: "┬─",
-	connectorMergeTeeCo: "┴─",
-	edgeArrow: {
-		forward: "↑",
-		rollback: "↓",
-		self: "⟲"
-	},
-	forwardArrow: migrationListForwardArrow("unicode"),
-	emptySource: migrationListEmptySource("unicode")
-};
-const ASCII_PALETTE = {
-	node: "* ",
-	arcLand: "*<",
-	arcTee: "*-",
-	verticalPass: "| ",
-	branchTee: "+-",
-	mergeTee: "+-",
-	branchCorner: "\\ ",
-	mergeCorner: "/ ",
-	arcBranchCorner: "\\ ",
-	arcBranchTee: "+-",
-	arcLandCorner: "/ ",
-	arcCrossing: "+-",
-	arcLandBridge: "--",
-	horizontalPass: "--",
-	connectorBranchTee: "+-",
-	connectorBranchTeeCo: "+-",
-	connectorMergeTeeCo: "+-",
-	edgeArrow: {
-		forward: "^",
-		rollback: "v",
-		self: "@"
-	},
-	forwardArrow: migrationListForwardArrow("ascii"),
-	emptySource: migrationListEmptySource("ascii")
-};
-function paletteFor(mode) {
-	return mode === "ascii" ? ASCII_PALETTE : UNICODE_PALETTE;
-}
-function arrowForEdgeKind(kind, palette) {
-	return palette.edgeArrow[kind];
-}
-/**
-* A node-marker glyph pair (`○◂`, `○─`, `*<`, `*-`) is the contract node
-* marker (`○` / `*`) followed by an arc connector (`◂` / `─` / `<` / `-`).
-* The marker is the signal and stays bright (`style.kind`); the connector is
-* gutter and stays dim (`style.lane`) — consistent with the plain node marker,
-* which is never dimmed.
-*/
-function renderNodeMarkerPair(pair, style) {
-	return style.kind(pair.slice(0, 1)) + style.lane(pair.slice(1));
-}
-function renderCellPair(cell, style, palette) {
-	switch (cell.kind) {
-		case "node":
-			if (cell.arcLand === true) return renderNodeMarkerPair(palette.arcLand, style);
-			if (cell.arcTee === true) return renderNodeMarkerPair(palette.arcTee, style);
-			return style.kind(palette.node);
-		case "vertical-pass": return style.lane(palette.verticalPass);
-		case "edge-lane": return cell.ownsLabel ? style.lane(palette.verticalPass.trimEnd()) + style.kind(arrowForEdgeKind(cell.edgeKind, palette)) : style.lane(palette.verticalPass);
-		case "branch-tee": return style.lane(palette.branchTee);
-		case "merge-tee": return style.lane(palette.mergeTee);
-		case "branch-corner": return style.lane(palette.branchCorner);
-		case "merge-corner": return style.lane(palette.mergeCorner);
-		case "arc-branch-corner": return style.lane(palette.arcBranchCorner);
-		case "arc-branch-tee": return style.lane(palette.arcBranchTee);
-		case "arc-land-corner": return style.lane(palette.arcLandCorner);
-		case "arc-crossing": return style.lane(palette.arcCrossing);
-		case "arc-land-bridge": return style.lane(palette.arcLandBridge);
-		case "horizontal-pass": return style.lane(palette.horizontalPass);
-		case "empty": return "  ";
-	}
-}
-function renderConnectorRow(row, gridWidth, style, palette) {
-	const isMerge = row.kind === "merge-connector";
-	if (row.cells.length > 0) {
-		let seenTee = false;
-		let out = "";
-		for (const cell of row.cells) switch (cell.kind) {
-			case "branch-tee":
-				out += style.lane(seenTee ? palette.connectorBranchTeeCo : palette.connectorBranchTee);
-				seenTee = true;
-				break;
-			case "merge-tee":
-				out += style.lane(seenTee ? palette.connectorMergeTeeCo : palette.connectorBranchTee);
-				seenTee = true;
-				break;
-			case "branch-corner":
-				out += style.lane(palette.branchCorner);
-				break;
-			case "merge-corner":
-				out += style.lane(palette.mergeCorner);
-				break;
-			case "vertical-pass":
-				out += style.lane(palette.verticalPass);
-				break;
-			case "horizontal-pass":
-				out += style.lane(palette.horizontalPass);
-				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;
-	let out = "";
-	for (let column = 0; column < gridWidth; column++) if (column < start || column > end) out += "  ";
-	else if (column === start) out += style.lane(palette.connectorBranchTee);
-	else if (column === end) out += style.lane(isMerge ? palette.mergeCorner : palette.branchCorner);
-	else out += style.lane(isMerge ? palette.connectorMergeTeeCo : palette.connectorBranchTeeCo);
-	return out;
-}
-function abbreviateHash(hash, hashLength, emptySource) {
-	if (hash === EMPTY_CONTRACT_HASH) return emptySource;
-	return (hash.startsWith("sha256:") ? hash.slice(7) : hash).slice(0, hashLength);
-}
-const MIN_HASH_DATA_COLUMN = 25;
-function overlayNamesForContract(contractHash, opts) {
-	const names = [];
-	const userRefs = opts.refsByHash?.get(contractHash);
-	if (userRefs) names.push(...[...userRefs].sort((a, b) => a.localeCompare(b)));
-	if (opts.dbHash === contractHash) names.push(DB_MARKER_NAME);
-	if (opts.contractHash === contractHash && contractHash !== EMPTY_CONTRACT_HASH) names.push(CONTRACT_MARKER_NAME);
-	return names;
-}
-function createTreeStyler(opts) {
-	const base = createAnsiMigrationListStyler({ useColor: opts.colorize });
-	const activeRefName = opts.activeRefName;
-	if (!opts.colorize || activeRefName === void 0) return base;
-	return {
-		...base,
-		refs: (names) => {
-			const styledNames = names.map((name) => name === activeRefName ? bold(name) : name);
-			return base.refs(styledNames);
-		}
-	};
-}
-function formatEdgeHashColumn(edge, style, hashLength, palette) {
-	if (edge.kind === "self") {
-		const hash = abbreviateHash(edge.from, hashLength, palette.emptySource);
-		return `${style.sourceHash(hash)} ${style.glyph(palette.forwardArrow)} ${style.destHash(hash)}`;
-	}
-	return `${edge.from === EMPTY_CONTRACT_HASH ? style.glyph(palette.emptySource) + " ".repeat(Math.max(0, hashLength - palette.emptySource.length)) : style.sourceHash(abbreviateHash(edge.from, hashLength, palette.emptySource))} ${style.glyph(palette.forwardArrow)} ${style.destHash(abbreviateHash(edge.to, hashLength, palette.emptySource))}`;
-}
-function padVisible(text, targetWidth) {
-	const padding = Math.max(0, targetWidth - stringWidth(text));
-	return text + " ".repeat(padding);
-}
-function gridWidthForModel(rows) {
-	return rows.reduce((max, row) => row.kind === "node" || row.kind === "edge" ? Math.max(max, row.cells.length) : max, 1);
-}
-function maxDirNameLength(edges) {
-	if (edges.length === 0) return 0;
-	return Math.max(...edges.map((edge) => edge.dirName.length));
-}
-function rowDirNameWidth(labelColumn, maxDirNameLen, dirNameGap) {
-	return Math.max(maxDirNameLen + dirNameGap, MIN_HASH_DATA_COLUMN - labelColumn);
-}
-function gridUsesSkipRollbackArcs(rows) {
-	return rows.some((row) => row.cells.some((cell) => cell.kind === "edge-lane" && cell.adjacency === "node-skipping-rollback"));
-}
-function edgeLabelColumn(row, wideLabelColumn) {
-	if (wideLabelColumn !== void 0) return wideLabelColumn;
-	const laneIndex = row.laneIndex ?? 0;
-	if (row.edge?.from === EMPTY_CONTRACT_HASH && laneIndex === 0) return (laneIndex + 1) * 2 + LABEL_GAP;
-	return row.cells.some((cell, index) => index > laneIndex && cell.kind === "vertical-pass") ? row.cells.length * 2 + LABEL_GAP : (laneIndex + 1) * 2 + LABEL_GAP;
-}
-function nodeHasArcDecoration(row) {
-	return row.cells.some((cell) => cell.kind === "node" && (cell.arcTee === true || cell.arcLand === true));
-}
-function renderMigrationGraphTree(model, opts) {
-	const palette = paletteFor(opts.glyphMode ?? "unicode");
-	const style = createTreeStyler(opts);
-	const hashLength = opts.hashLength ?? 7;
-	const gridWidth = gridWidthForModel(model.rows);
-	const wideLabelColumn = gridUsesSkipRollbackArcs(model.rows) ? gridWidth * 2 + 4 : void 0;
-	const dirNameGap = wideLabelColumn !== void 0 ? 3 : LABEL_GAP;
-	const maxDirNameLen = maxDirNameLength(model.rows.filter((row) => row.kind === "edge" && row.edge !== void 0).map((row) => row.edge));
-	const lines = [];
-	for (let rowIndex = 0; rowIndex < model.rows.length; rowIndex++) {
-		const row = model.rows[rowIndex];
-		if (row === void 0) continue;
-		if (row.kind === "component-separator") {
-			lines.push("");
-			continue;
-		}
-		if (row.kind === "branch-connector" || row.kind === "merge-connector") {
-			lines.push(renderConnectorRow(row, gridWidth, style, palette).replace(/\s+$/, ""));
-			continue;
-		}
-		let gutter = row.cells.map((cell) => renderCellPair(cell, style, palette)).join("");
-		const prevRow = model.rows[rowIndex - 1];
-		let laneSpan = row.cells.length;
-		if (row.kind === "node") {
-			const contractHash = row.contractHash ?? EMPTY_CONTRACT_HASH;
-			if (prevRow?.kind === "merge-connector" || contractHash === EMPTY_CONTRACT_HASH) laneSpan = 1;
-			else laneSpan = row.cells.length;
-		}
-		const labelColumn = row.kind === "edge" ? edgeLabelColumn(row, wideLabelColumn) : wideLabelColumn !== void 0 && (nodeHasArcDecoration(row) || row.contractHash !== void 0) ? wideLabelColumn : laneSpan * 2 + LABEL_GAP;
-		if (row.kind === "edge" && row.edge?.from === EMPTY_CONTRACT_HASH && (row.laneIndex ?? 0) === 0) gutter = row.cells.slice(0, 1).map((cell) => renderCellPair(cell, style, palette)).join("");
-		else if (row.kind === "node" && laneSpan < row.cells.length && !nodeHasArcDecoration(row)) gutter = row.cells.slice(0, laneSpan).map((cell) => renderCellPair(cell, style, palette)).join("");
-		else if (gutter.length < laneSpan * 2) gutter = gutter.padEnd(laneSpan * 2, " ");
-		const dirNameWidth = rowDirNameWidth(labelColumn, maxDirNameLen, dirNameGap);
-		const dataColumn = labelColumn + dirNameWidth;
-		const gutterPad = padVisible(gutter, labelColumn);
-		if (row.kind === "node") {
-			const contractHash = row.contractHash ?? EMPTY_CONTRACT_HASH;
-			if (contractHash === EMPTY_CONTRACT_HASH) {
-				const trailingLanes = row.cells.slice(1).map((cell) => renderCellPair(cell, style, palette)).join("");
-				const emptyGutter = palette.emptySource.padEnd(2, " ") + trailingLanes;
-				const overlayNames = overlayNamesForContract(contractHash, opts);
-				if (overlayNames.length === 0) {
-					lines.push(emptyGutter.replace(/\s+$/, ""));
-					continue;
-				}
-				const overlay = style.refs(overlayNames);
-				lines.push(`${padVisible(emptyGutter, dataColumn)}${overlay}`.replace(/\s+$/, ""));
-				continue;
-			}
-			const hashText = style.sourceHash(abbreviateHash(contractHash, hashLength, palette.emptySource));
-			const overlayNames = overlayNamesForContract(contractHash, opts);
-			const overlayPad = overlayNames.length > 0 ? " ".repeat(Math.max(0, dataColumn - labelColumn - stringWidth(hashText))) : "";
-			const overlay = overlayNames.length > 0 ? style.refs(overlayNames) : "";
-			lines.push(`${gutterPad}${hashText}${overlayPad}${overlay}`.replace(/\s+$/, ""));
-			continue;
-		}
-		const edge = row.edge;
-		if (edge === void 0) continue;
-		const dirNamePadding = " ".repeat(Math.max(0, dirNameWidth - edge.dirName.length));
-		const dirName = `${style.dirName(edge.dirName)}${dirNamePadding}`;
-		const hashColumn = formatEdgeHashColumn(edge, style, hashLength, palette);
-		lines.push(`${gutterPad}${dirName}${hashColumn}`.replace(/\s+$/, ""));
-	}
-	return lines.join("\n");
-}
-//#endregion
-//#region src/commands/migration-graph.ts
-async function executeMigrationGraphCommand(options, flags, ui) {
-	const config = await loadConfig(options.config);
-	const { configPath, appMigrationsRelative, migrationsDir } = resolveMigrationPaths(options.config, config);
-	if (!flags.json && !flags.quiet) {
-		const header = formatStyledHeader({
-			command: "migration graph",
-			description: "Show the migration graph topology",
-			details: [{
-				label: "config",
-				value: configPath
-			}, {
-				label: "migrations",
-				value: appMigrationsRelative
-			}],
-			flags
-		});
-		ui.stderr(header);
-	}
-	const loaded = await buildReadAggregate(config, { migrationsDir });
-	if (!loaded.ok) return loaded;
-	const { aggregate, contractHash } = loaded.value;
-	const graph = aggregate.app.graph();
-	return ok({
-		ok: true,
-		graph,
-		contractHash,
-		refs: Object.entries(aggregate.app.refs).map(([name, entry]) => ({
-			name,
-			hash: entry.hash,
-			active: false
-		})),
-		summary: `${graph.nodes.size} node(s), ${graph.migrationByHash.size} edge(s)`
-	});
-}
-function createMigrationGraphCommand() {
-	const command = new Command("graph");
-	setCommandDescriptions(command, "Show the migration graph topology", "Renders the migration graph topology. Offline — does not consult\nthe database. Use --tree for the condensed annotated tree\n(--ascii swaps box-drawing for pipe-friendly ASCII glyphs),\n--json for machine-readable output, or --dot for Graphviz DOT\nformat.");
-	setCommandExamples(command, [
-		"prisma-next migration graph",
-		"prisma-next migration graph --json",
-		"prisma-next migration graph --dot",
-		"prisma-next migration graph --tree",
-		"prisma-next migration graph --tree --ascii"
-	]);
-	setCommandSeeAlso(command, [
-		{
-			verb: "migration status",
-			oneLiner: "Show migration path and pending status"
-		},
-		{
-			verb: "migration log",
-			oneLiner: "Show executed migration history"
-		},
-		{
-			verb: "migration list",
-			oneLiner: "List on-disk migrations"
-		},
-		{
-			verb: "migration show",
-			oneLiner: "Display migration package contents"
-		}
-	]);
-	addGlobalOptions(command).option("--config <path>", "Path to prisma-next.config.ts").option("--dot", "Output in Graphviz DOT format").option("--tree", "Experimental condensed annotated tree renderer").option("--ascii", "Use ASCII glyphs for --tree (pipe-friendly)").action(async (options) => {
-		const flags = parseGlobalFlagsOrExit(options);
-		const ui = createTerminalUI(flags);
-		const exitCode = handleResult(await executeMigrationGraphCommand(options, flags, ui), flags, ui, (graphResult) => {
-			if (options.dot) {
-				const lines = ["digraph migrations {"];
-				for (const edge of graphResult.graph.migrationByHash.values()) {
-					const from = edge.from.slice(0, 12);
-					const to = edge.to.slice(0, 12);
-					lines.push(`  "${from}" -> "${to}" [label="${edge.dirName}"];`);
-				}
-				lines.push("}");
-				ui.output(lines.join("\n"));
-			} else if (flags.json) {
-				const nodes = [...graphResult.graph.nodes];
-				const edges = [...graphResult.graph.migrationByHash.values()].map((e) => ({
-					dirName: e.dirName,
-					from: e.from,
-					to: e.to,
-					migrationHash: e.migrationHash
-				}));
-				ui.output(JSON.stringify({
-					ok: true,
-					nodes,
-					edges,
-					summary: graphResult.summary
-				}, null, 2));
-			} else if (!flags.quiet) if (options.tree) {
-				const refsByHash = /* @__PURE__ */ new Map();
-				for (const ref of graphResult.refs) {
-					const existing = refsByHash.get(ref.hash);
-					refsByHash.set(ref.hash, existing ? [...existing, ref.name] : [ref.name]);
-				}
-				const layout = buildMigrationGraphLayout(buildMigrationGraphRows(graphResult.graph, { ...graphResult.contractHash !== null ? { contractHash: graphResult.contractHash } : {} }));
-				const activeRef = graphResult.refs.find((ref) => ref.active);
-				const treeOutput = renderMigrationGraphTree(layout, {
-					refsByHash,
-					...graphResult.contractHash !== null ? { contractHash: graphResult.contractHash } : {},
-					...activeRef !== void 0 ? { activeRefName: activeRef.name } : {},
-					colorize: flags.color !== false,
-					glyphMode: ui.resolveGlyphMode(options.ascii === true)
-				});
-				ui.output(treeOutput);
-				ui.output(`\n${graphResult.summary}`);
-			} else {
-				const renderInput = migrationGraphToRenderInput({
-					graph: graphResult.graph,
-					mode: "offline",
-					markerHash: void 0,
-					contractHash: graphResult.contractHash ?? EMPTY_CONTRACT_HASH,
-					refs: graphResult.refs,
-					activeRefHash: void 0,
-					activeRefName: void 0,
-					edgeStatuses: []
-				});
-				const graphOutput = graphRenderer.render(renderInput.graph, {
-					...renderInput.options,
-					colorize: flags.color !== false
-				});
-				ui.log(graphOutput);
-				ui.log(`\n${graphResult.summary}`);
-			}
-		});
-		process.exit(exitCode);
-	});
-	return command;
-}
-//#endregion
-export { executeMigrationGraphCommand as n, createMigrationGraphCommand as t };
-
-//# sourceMappingURL=migration-graph-D7DVUElV.mjs.map