prisma-next 0.12.0-dev.27 → 0.12.0-dev.29

package/dist/{migration-graph-tree-render-DyDBuJEX.mjs → migration-graph-space-render-dmLLWift.mjs}

@@ -945,7 +945,12 @@ function compareNodesTipsFirst(a, b, rank) {
 * at the same rank — stable across edge-insertion order and correct under
 * diamonds, cross-links, and rollbacks.
 */
-function layerNodesByLongestForwardPath(componentNodes, topology, graph) {
+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) {
@@ -975,6 +980,7 @@ function layerNodesByLongestForwardPath(componentNodes, topology, graph) {
 		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));
 }
 /**
@@ -1000,6 +1006,77 @@ function layerNodesByLongestForwardPath(componentNodes, topology, graph) {
 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: [],
@@ -1016,32 +1093,25 @@ function buildMigrationGraphRows(graph, options = {}) {
 	}
 	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 = {
+		edges.push({
 			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 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);
+		const ordered = layerNodesByLongestForwardPath(component, topology, graph, options.contractHash);
 		for (const node of ordered) nodes.push(node);
 	}
 	const detached = detachedContractHash(graph, options.contractHash);
@@ -1051,7 +1121,7 @@ function buildMigrationGraphRows(graph, options = {}) {
 	}
 	return {
 		nodes,
-		edges,
+		edges: sortedEdges,
 		edgesByFrom,
 		edgesByTo
 	};
@@ -1080,6 +1150,126 @@ function laneColorForColumn(column) {
 	if (column <= 0) return (text) => text;
 	return LANE_COLOR_CYCLE[(column - 1) % LANE_COLOR_CYCLE.length] ?? ((text) => text);
 }
+/**
+* Style a structural glyph by its resolved colour column. Column 0 and the
+* neutral sentinel render dim (`dimLane`); columns ≥ 1 take a palette hue.
+*/
+function stylerForLaneColumn(colorColumn, colorize, dimLane) {
+	if (!colorize || colorColumn <= 0) return dimLane;
+	return laneColorForColumn(colorColumn);
+}
+/**
+* Resolve per-cell colour columns for a node/arc row. Scanning right-to-left
+* lets each arc segment inherit the hue of the arc it leads into.
+*/
+function resolveRowArcLaneColors(cells) {
+	const lane = new Array(cells.length);
+	const connector = new Array(cells.length);
+	const dash = new Array(cells.length);
+	let arcCorner = 0;
+	let landingAnchor = 0;
+	for (let column = cells.length - 1; column >= 0; column--) {
+		const cell = cells[column];
+		connector[column] = landingAnchor !== 0 ? landingAnchor : arcCorner;
+		switch (cell?.kind) {
+			case "arc-branch-corner":
+				arcCorner = column;
+				lane[column] = column;
+				dash[column] = column;
+				break;
+			case "arc-land-corner":
+				arcCorner = column;
+				landingAnchor = column;
+				lane[column] = column;
+				dash[column] = column;
+				break;
+			case "arc-branch-tee":
+				lane[column] = column;
+				dash[column] = column;
+				break;
+			case "arc-land-tee":
+				lane[column] = column;
+				dash[column] = landingAnchor === 0 ? column : landingAnchor;
+				landingAnchor = column;
+				break;
+			case "arc-crossing":
+			case "arc-land-bridge": {
+				const served = landingAnchor !== 0 ? landingAnchor : arcCorner;
+				lane[column] = served;
+				dash[column] = served;
+				break;
+			}
+			case "horizontal-pass":
+				lane[column] = arcCorner === 0 ? column : arcCorner;
+				dash[column] = lane[column] ?? column;
+				break;
+			case "node":
+				lane[column] = column;
+				dash[column] = column;
+				arcCorner = 0;
+				landingAnchor = 0;
+				break;
+			default:
+				lane[column] = column;
+				dash[column] = column;
+				arcCorner = 0;
+				landingAnchor = 0;
+		}
+	}
+	return {
+		lane,
+		connector,
+		dash
+	};
+}
+/**
+* Resolve per-cell connector colours. Scanning right-to-left, a corner or an
+* intermediate tee anchors its own lane, but a tee's trailing dash leads into
+* the branch on its right.
+*/
+function resolveConnectorLaneColors(cells, startLane) {
+	const glyph = new Array(cells.length);
+	const dash = new Array(cells.length);
+	let owner = 0;
+	for (let column = cells.length - 1; column >= 0; column--) switch (cells[column]?.kind) {
+		case "branch-corner":
+		case "merge-corner":
+			owner = column;
+			glyph[column] = column;
+			dash[column] = column;
+			break;
+		case "branch-tee":
+		case "merge-tee":
+			if (column === startLane) {
+				const served = owner === 0 ? column : owner;
+				glyph[column] = column;
+				dash[column] = served;
+			} else {
+				dash[column] = owner === 0 ? column : owner;
+				glyph[column] = column;
+				owner = column;
+			}
+			break;
+		case "arc-crossing":
+			glyph[column] = column;
+			dash[column] = owner === 0 ? column : owner;
+			owner = column;
+			break;
+		case "horizontal-pass": {
+			const served = owner === 0 ? column : owner;
+			glyph[column] = served;
+			dash[column] = served;
+			break;
+		}
+		default:
+			glyph[column] = column;
+			dash[column] = column;
+	}
+	return {
+		glyph,
+		dash
+	};
+}
 function migrationListForwardArrow(glyphMode) {
 	return glyphMode === "ascii" ? "->" : "→";
 }
@@ -1089,6 +1279,10 @@ function migrationListEmptySource(glyphMode) {
 function abbreviateContractHash(hash) {
 	return (hash.startsWith("sha256:") ? hash.slice(7) : hash).slice(0, 7);
 }
+function padFromHashColumn(text, width) {
+	const padding = Math.max(0, width - stringWidth(text));
+	return `${" ".repeat(padding)}${text}`;
+}
 //#endregion
 //#region src/utils/formatters/migration-list-render.ts
 const IDENTITY_MIGRATION_LIST_STYLER = {
@@ -1155,24 +1349,25 @@ function buildRefsByHashFromListEntries(entries) {
 function formatEmptyStateLine(spaceId, style) {
 	return style.emptyState(`There are no migrations in migrations/${spaceId}/ yet`);
 }
-function indentTreeBlock(treeOutput, indent) {
-	if (treeOutput.length === 0) return treeOutput;
-	return treeOutput.split("\n").map((line) => line.length === 0 ? line : `${indent}${line}`).join("\n");
-}
-function renderSpaceTreeBlock(spaceId, migrations, multiSpace, glyphMode, style, colorize) {
+function renderSpaceTreeBlock(spaceId, migrations, multiSpace, glyphMode, style, colorize, liveContractHash, graphForSpace, globalMaxEdgeTreePrefixWidth, globalMaxDirNameWidth) {
 	if (migrations.length === 0) {
 		const emptyLine = formatEmptyStateLine(spaceId, style);
 		if (!multiSpace) return [emptyLine];
 		return [style.spaceHeading(`${spaceId}:`), `  ${emptyLine}`];
 	}
-	const treeOutput = renderMigrationGraphTree(buildMigrationGraphLayout(buildMigrationGraphRows(migrationGraphFromListEntries(migrations))), {
-		refsByHash: buildRefsByHashFromListEntries(migrations),
-		edgeAnnotationsByHash: buildEdgeAnnotationsByHashFromListEntries(migrations),
+	const treeOutput = renderMigrationGraphSpaceTree({
+		graph: graphForSpace(spaceId) ?? migrationGraphFromListEntries(migrations),
+		migrations,
+		liveContractHash,
+		glyphMode,
 		colorize,
-		glyphMode
+		refsByHash: buildRefsByHashFromListEntries(migrations),
+		styler: style,
+		...globalMaxEdgeTreePrefixWidth !== void 0 ? { globalMaxEdgeTreePrefixWidth } : {},
+		...globalMaxDirNameWidth !== void 0 ? { globalMaxDirNameWidth } : {}
 	});
 	if (!multiSpace) return treeOutput.length === 0 ? [] : [treeOutput];
-	const indented = indentTreeBlock(treeOutput, "  ");
+	const indented = indentMigrationGraphTreeBlock(treeOutput, "  ");
 	return [style.spaceHeading(`${spaceId}:`), indented];
 }
 /**
@@ -1186,11 +1381,19 @@ function renderSpaceTreeBlock(spaceId, migrations, multiSpace, glyphMode, style,
 function renderMigrationListWithStyle(result, style, glyphMode = "unicode", options = {}) {
 	const multiSpace = result.spaces.length > 1;
 	const colorize = options.colorize ?? false;
+	const liveContractHash = options.liveContractHash ?? EMPTY_CONTRACT_HASH;
+	const graphForSpace = options.graphForSpace ?? (() => void 0);
+	const globalLayoutInputs = multiSpace ? result.spaces.filter((space) => space.migrations.length > 0).map((space) => ({
+		graph: graphForSpace(space.spaceId) ?? migrationGraphFromListEntries(space.migrations),
+		liveContractHash
+	})) : [];
+	const globalMaxEdgeTreePrefixWidth = globalLayoutInputs.length > 0 ? computeGlobalMaxEdgeTreePrefixWidth(globalLayoutInputs) : void 0;
+	const globalMaxDirNameWidth = globalLayoutInputs.length > 0 ? computeGlobalMaxDirNameWidth(globalLayoutInputs) : void 0;
 	const lines = [];
 	for (let index = 0; index < result.spaces.length; index++) {
 		const space = result.spaces[index];
 		if (index > 0) lines.push("");
-		lines.push(...renderSpaceTreeBlock(space.spaceId, space.migrations, multiSpace, glyphMode, style, colorize));
+		lines.push(...renderSpaceTreeBlock(space.spaceId, space.migrations, multiSpace, glyphMode, style, colorize, liveContractHash, graphForSpace, globalMaxEdgeTreePrefixWidth, globalMaxDirNameWidth));
 	}
 	if (result.spaces.reduce((count, space) => count + space.migrations.length, 0) > 0) {
 		lines.push("");
@@ -1200,6 +1403,21 @@ function renderMigrationListWithStyle(result, style, glyphMode = "unicode", opti
 }
 //#endregion
 //#region src/utils/formatters/migration-list-styler.ts
+function hasMarkersFormatter(styler) {
+	return "markers" in styler && typeof styler.markers === "function";
+}
+function styleMarkerName(name) {
+	return name === "contract" ? bold(green(name)) : green(name);
+}
+function plainMarkers(names) {
+	return `<${names.join(", ")}>`;
+}
+function formatContractNodeOverlays(styler, markers, refs) {
+	const parts = [];
+	if (markers.length > 0) parts.push(hasMarkersFormatter(styler) ? styler.markers(markers) : plainMarkers(markers));
+	if (refs.length > 0) parts.push(styler.refs(refs));
+	return parts.join(" ");
+}
 /**
 * The current contract overlay marker. Unlike user refs, this names the user's
 * declared desired state — the implicit base/target for `plan` / `migrate` —
@@ -1208,7 +1426,7 @@ function renderMigrationListWithStyle(result, style, glyphMode = "unicode", opti
 */
 const CONTRACT_MARKER_NAME = "contract";
 function styleRefName(name) {
-	return name === "contract" ? bold(green(name)) : green(name);
+	return green(name);
 }
 /**
 * Build a {@link MigrationListStyler} that decorates `migration list`
@@ -1226,14 +1444,18 @@ function styleRefName(name) {
 * - `glyph` (`→` / `⟲` / `∅`): dim
 * - `lane` (graph gutter lines `│` and fan/join connectors `├─┐` / `├─┘`): dim
 * - `invariants` (`{...}`): yellow
-* - `refs` (`(...)`): green; the `contract` desired-state marker inside is
-*   green-bold (the active ref is bolded separately by the tree styler)
+* - `markers` (`<...>`): green; the `contract` desired-state marker inside is
+*   green-bold (`db` is plain green)
+* - `refs` (`(...)`): green (the active ref is bolded separately by the tree styler)
 * - `spaceHeading` (`<spaceId>:`): bold
 * - `summary`: dim
 * - `emptyState`: dim
 */
 function createAnsiMigrationListStyler(opts) {
-	if (!opts.useColor) return IDENTITY_MIGRATION_LIST_STYLER;
+	if (!opts.useColor) return {
+		...IDENTITY_MIGRATION_LIST_STYLER,
+		markers: plainMarkers
+	};
 	return {
 		kind: (text) => text,
 		dirName: (text) => bold(text),
@@ -1242,6 +1464,12 @@ function createAnsiMigrationListStyler(opts) {
 		glyph: (text) => dim(text),
 		lane: (text) => dim(text),
 		invariants: (ids) => yellow(`{${ids.join(", ")}}`),
+		markers: (names) => {
+			const open = green("<");
+			const close = green(">");
+			const separator = green(", ");
+			return open + names.map(styleMarkerName).join(separator) + close;
+		},
 		refs: (names) => {
 			const open = green("(");
 			const close = green(")");
@@ -1332,161 +1560,14 @@ function arrowForEdgeKind(kind, palette) {
 	return palette.edgeArrow[kind];
 }
 /**
-* The leftmost lane (column 0) renders with the neutral dim lane style rather
-* than a palette hue — in the common single-lane case it has nothing to be told
-* apart from. Used as the "no owning arc" sentinel during colour resolution.
-*/
-const NEUTRAL_LANE = 0;
-/**
 * Forced bold for branch-coloured names. A branched name pairs its lane hue
 * (also forced, via {@link laneColorForColumn}) with bold; both must emit even
 * when colorette's ambient TTY detection is off, so the colorized branch name
 * is deterministically bold + hue rather than hue-only.
 */
 const { bold: forcedBold } = createColors({ useColor: true });
-/**
-* Resolve per-cell colour columns for a row. Scanning right-to-left lets each
-* arc segment inherit the hue of the arc it leads into.
-*
-* On a converging-landing line (`○◂──────┴─┴─╯`), every horizontal dash segment
-* takes the hue of the **nearest landing anchor** — the next `arc-land-tee` or
-* `arc-land-corner` — to its right, i.e. the branch it leads into: the bridge
-* run leads into the first converging arc, and each tee's trailing `─` leads
-* into the next arc out. Tee/corner junction glyphs keep their own column hue.
-* This mirrors the forward connector's `┬─` rule (see
-* {@link resolveConnectorLaneColors}). A single (non-converging) landing has
-* only the corner as an anchor, so its whole horizontal run reads as one hue.
-*
-* The source side (`○─`, `arc-branch-tee`, `arc-branch-corner`) and pure
-* horizontal passes are unaffected: they track the nearest corner to the right
-* (`arcCorner`), so a routed back-arc's source fan still reads as one hue. A
-* crossing can only be one colour, so it takes the arc owning the horizontal
-* run at this row; the crossed vertical lane is occluded at that one cell and
-* reappears on the next row.
-*/
-function resolveRowLaneColors(cells) {
-	const lane = new Array(cells.length);
-	const connector = new Array(cells.length);
-	const dash = new Array(cells.length);
-	let arcCorner = NEUTRAL_LANE;
-	let landingAnchor = NEUTRAL_LANE;
-	for (let column = cells.length - 1; column >= 0; column--) {
-		const cell = cells[column];
-		connector[column] = landingAnchor !== NEUTRAL_LANE ? landingAnchor : arcCorner;
-		switch (cell?.kind) {
-			case "arc-branch-corner":
-				arcCorner = column;
-				lane[column] = column;
-				dash[column] = column;
-				break;
-			case "arc-land-corner":
-				arcCorner = column;
-				landingAnchor = column;
-				lane[column] = column;
-				dash[column] = column;
-				break;
-			case "arc-branch-tee":
-				lane[column] = column;
-				dash[column] = column;
-				break;
-			case "arc-land-tee":
-				lane[column] = column;
-				dash[column] = landingAnchor === NEUTRAL_LANE ? column : landingAnchor;
-				landingAnchor = column;
-				break;
-			case "arc-crossing":
-			case "arc-land-bridge": {
-				const served = landingAnchor !== NEUTRAL_LANE ? landingAnchor : arcCorner;
-				lane[column] = served;
-				dash[column] = served;
-				break;
-			}
-			case "horizontal-pass":
-				lane[column] = arcCorner === NEUTRAL_LANE ? column : arcCorner;
-				dash[column] = lane[column] ?? column;
-				break;
-			case "node":
-				lane[column] = column;
-				dash[column] = column;
-				arcCorner = NEUTRAL_LANE;
-				landingAnchor = NEUTRAL_LANE;
-				break;
-			default:
-				lane[column] = column;
-				dash[column] = column;
-				arcCorner = NEUTRAL_LANE;
-				landingAnchor = NEUTRAL_LANE;
-		}
-	}
-	return {
-		lane,
-		connector,
-		dash
-	};
-}
-/**
-* Resolve per-cell connector colours. Scanning right-to-left, a corner or an
-* intermediate tee anchors its own lane (its junction glyph takes that column),
-* but a tee's **trailing dash leads into the branch on its right** (the next
-* branch point), so `┬─` reads as "this lane, then on toward the next" rather
-* than tinting the dash with the left lane. The leading tee at `startLane` (the
-* fork/merge origin) and pure horizontal segments inherit the nearest branch
-* point to their right whole-cell, so the run into a branch — or collapsing
-* into a merge corner — stays continuous. An `arc-crossing` keeps its junction
-* glyph at its own column but re-anchors `owner` like an intermediate tee so
-* dashes on both sides lead into the nearest branch on their right. Pass-through
-* verticals outside the run keep their own column (column 0 stays neutral).
-*/
-function resolveConnectorLaneColors(cells, startLane) {
-	const glyph = new Array(cells.length);
-	const dash = new Array(cells.length);
-	let owner = NEUTRAL_LANE;
-	for (let column = cells.length - 1; column >= 0; column--) switch (cells[column]?.kind) {
-		case "branch-corner":
-		case "merge-corner":
-			owner = column;
-			glyph[column] = column;
-			dash[column] = column;
-			break;
-		case "branch-tee":
-		case "merge-tee":
-			if (column === startLane) {
-				const served = owner === NEUTRAL_LANE ? column : owner;
-				glyph[column] = column;
-				dash[column] = served;
-			} else {
-				dash[column] = owner === NEUTRAL_LANE ? column : owner;
-				glyph[column] = column;
-				owner = column;
-			}
-			break;
-		case "arc-crossing":
-			glyph[column] = column;
-			dash[column] = owner === NEUTRAL_LANE ? column : owner;
-			owner = column;
-			break;
-		case "horizontal-pass": {
-			const served = owner === NEUTRAL_LANE ? column : owner;
-			glyph[column] = served;
-			dash[column] = served;
-			break;
-		}
-		default:
-			glyph[column] = column;
-			dash[column] = column;
-	}
-	return {
-		glyph,
-		dash
-	};
-}
-/**
-* Style a structural glyph by its resolved colour column. Column 0 and the
-* neutral sentinel render dim (`style.lane`); columns ≥ 1 take a palette hue.
-*/
 function laneStylerForColumn(colorColumn, colorize, style) {
-	if (!colorize || colorColumn <= NEUTRAL_LANE) return (text) => style.lane(text);
-	return laneColorForColumn(colorColumn);
+	return stylerForLaneColumn(colorColumn, colorize, style.lane);
 }
 /**
 * Tint a branch-owned token (direction arrow, migration name) by its edge's
@@ -1496,10 +1577,19 @@ function laneStylerForColumn(colorColumn, colorize, style) {
 * colour. With colour off, the fallback (also colourless) is used unchanged.
 */
 function branchStylerOrDefault(column, colorize, fallback) {
-	if (!colorize || column <= NEUTRAL_LANE) return fallback;
+	if (!colorize || column <= 0) return fallback;
 	return laneColorForColumn(column);
 }
 /**
+* Render a crossing tee (`┼─`): the junction stays dim/neutral so neither arc
+* steals the cell; the trailing dash takes the served lane hue.
+*/
+function renderArcCrossing(pair, dashColumn, colorize, style) {
+	const junction = colorize ? style.lane : (text) => text;
+	const dash = laneStylerForColumn(dashColumn, colorize, style);
+	return junction(pair.slice(0, 1)) + dash(pair.slice(1));
+}
+/**
 * Render a connector tee (`├─` / `┬─` / `┴─`) with its junction glyph and its
 * trailing dash coloured independently: the junction anchors its own lane while
 * the dash leads into the branch on its right.
@@ -1526,7 +1616,7 @@ function renderCellPair(cell, column, colors, colorize, style, palette) {
 	const lane = laneStylerForColumn(laneColumn, colorize, style);
 	switch (cell.kind) {
 		case "node": {
-			const arcColumn = colors.connector[column] ?? NEUTRAL_LANE;
+			const arcColumn = colors.connector[column] ?? 0;
 			if (cell.arcLand === true) return renderNodeMarkerPair(palette.arcLand, column, arcColumn, colorize, style);
 			if (cell.arcTee === true) return renderNodeMarkerPair(palette.arcTee, column, arcColumn, colorize, style);
 			return lane(palette.node);
@@ -1581,7 +1671,7 @@ function renderConnectorRow(row, gridWidth, colorize, style, palette) {
 					out += lane(palette.horizontalPass);
 					break;
 				case "arc-crossing":
-					out += renderConnectorTee(palette.arcCrossing, glyphColumn, dashColumn, colorize, style);
+					out += renderArcCrossing(palette.arcCrossing, dashColumn, colorize, style);
 					break;
 				default: out += "  ";
 			}
@@ -1605,15 +1695,24 @@ function abbreviateHash(hash, hashLength, emptySource) {
 }
 const MIN_HASH_DATA_COLUMN = 25;
 function overlayNamesForContract(contractHash, opts) {
-	const names = [];
+	const markers = [];
+	const refs = [];
 	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;
+	if (userRefs) refs.push(...[...userRefs].sort((a, b) => a.localeCompare(b)));
+	if (opts.contractHash === contractHash && contractHash !== EMPTY_CONTRACT_HASH) markers.push(CONTRACT_MARKER_NAME);
+	if (opts.dbHash === contractHash) markers.push(DB_MARKER_NAME);
+	markers.sort((a, b) => {
+		if (a === "contract") return -1;
+		if (b === "contract") return 1;
+		return a.localeCompare(b);
+	});
+	return {
+		markers,
+		refs
+	};
 }
 function createTreeStyler(opts) {
-	const base = createAnsiMigrationListStyler({ useColor: opts.colorize });
+	const base = opts.styler ?? createAnsiMigrationListStyler({ useColor: opts.colorize });
 	const activeRefName = opts.activeRefName;
 	if (!opts.colorize || activeRefName === void 0) return base;
 	return {
@@ -1628,6 +1727,8 @@ function formatEdgeAnnotationSuffix(migrationHash, opts, style) {
 	const annotation = opts.edgeAnnotationsByHash?.get(migrationHash);
 	if (annotation === void 0) return "";
 	const segments = [];
+	if (annotation.operationCount !== void 0) segments.push(`${annotation.operationCount} ops`);
+	if (annotation.invariants !== void 0 && annotation.invariants.length > 0) segments.push(style.invariants(annotation.invariants));
 	const status = annotation.status;
 	if (status !== void 0) {
 		const glyphs = overlayStatusGlyphs(opts.glyphMode ?? "unicode");
@@ -1639,17 +1740,15 @@ function formatEdgeAnnotationSuffix(migrationHash, opts, style) {
 			segments.push(styler(`${glyph} ${label}`));
 		}
 	}
-	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));
 	if (segments.length === 0) return "";
-	return `${status !== void 0 ? "   " : "  "}${segments.join("  ")}`;
+	return `  ${segments.join("  ")}`;
 }
 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 `${padFromHashColumn(style.sourceHash(hash), hashLength)} ${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))}`;
+	return `${edge.from === EMPTY_CONTRACT_HASH ? padFromHashColumn(style.glyph(palette.emptySource), hashLength) : padFromHashColumn(style.sourceHash(abbreviateHash(edge.from, hashLength, palette.emptySource)), hashLength)} ${style.glyph(palette.forwardArrow)} ${style.destHash(abbreviateHash(edge.to, hashLength, palette.emptySource))}`;
 }
 function padVisible(text, targetWidth) {
 	const padding = Math.max(0, targetWidth - stringWidth(text));
@@ -1679,6 +1778,21 @@ function edgeLabelColumn(row, wideLabelColumn) {
 	if (row.edge?.from === EMPTY_CONTRACT_HASH && laneIndex === 0) return (laneIndex + 1) * 2 + LABEL_GAP;
 	return row.cells.some((cell, index) => index > laneIndex && cell.kind === "vertical-pass") ? row.cells.length * 2 + LABEL_GAP : (laneIndex + 1) * 2 + LABEL_GAP;
 }
+function maxEdgeTreePrefixWidth(rows, wideLabelColumn) {
+	let max = 0;
+	for (const row of rows) {
+		if (row.kind !== "edge" || row.edge === void 0) continue;
+		max = Math.max(max, edgeLabelColumn(row, wideLabelColumn));
+	}
+	return max;
+}
+function computeMaxEdgeTreePrefixWidthForLayout(model) {
+	const wideLabelColumn = gridUsesSkipRollbackArcs(model.rows) ? gridWidthForModel(model.rows) * 2 + 4 : void 0;
+	return maxEdgeTreePrefixWidth(model.rows, wideLabelColumn);
+}
+function computeMaxDirNameLengthForLayout(model) {
+	return maxDirNameLength(model.rows.filter((row) => row.kind === "edge" && row.edge !== void 0).map((row) => row.edge));
+}
 function nodeHasArcDecoration(row) {
 	return row.cells.some((cell) => cell.kind === "node" && (cell.arcTee === true || cell.arcLand === true));
 }
@@ -1690,6 +1804,9 @@ function renderMigrationGraphTree(model, opts) {
 	const wideLabelColumn = gridUsesSkipRollbackArcs(model.rows) ? gridWidth * 2 + 4 : void 0;
 	const dirNameGap = wideLabelColumn !== void 0 ? 3 : LABEL_GAP;
 	const maxDirNameLen = maxDirNameLength(model.rows.filter((row) => row.kind === "edge" && row.edge !== void 0).map((row) => row.edge));
+	const effectiveMaxDirNameLen = opts.globalMaxDirNameWidth ?? maxDirNameLen;
+	const maxEdgePrefixWidth = opts.globalMaxEdgeTreePrefixWidth ?? maxEdgeTreePrefixWidth(model.rows, wideLabelColumn);
+	const edgeDirNameWidth = rowDirNameWidth(maxEdgePrefixWidth, effectiveMaxDirNameLen, dirNameGap);
 	const lines = [];
 	for (let rowIndex = 0; rowIndex < model.rows.length; rowIndex++) {
 		const row = model.rows[rowIndex];
@@ -1702,7 +1819,7 @@ function renderMigrationGraphTree(model, opts) {
 			lines.push(trimTrailingWhitespace(renderConnectorRow(row, gridWidth, opts.colorize, style, palette)));
 			continue;
 		}
-		const cellColors = resolveRowLaneColors(row.cells);
+		const cellColors = resolveRowArcLaneColors(row.cells);
 		let gutter = row.cells.map((cell, column) => renderCellPair(cell, column, cellColors, opts.colorize, style, palette)).join("");
 		let laneSpan = row.cells.length;
 		if (row.kind === "node") if ((row.contractHash ?? EMPTY_CONTRACT_HASH) === EMPTY_CONTRACT_HASH) laneSpan = 1;
@@ -1714,31 +1831,31 @@ function renderMigrationGraphTree(model, opts) {
 			}
 			laneSpan = lastActiveColumn >= 0 ? lastActiveColumn + 1 : 1;
 		}
-		const labelColumn = row.kind === "edge" ? edgeLabelColumn(row, wideLabelColumn) : wideLabelColumn !== void 0 && (nodeHasArcDecoration(row) || row.contractHash !== void 0) ? wideLabelColumn : laneSpan * 2 + LABEL_GAP;
+		const labelColumn = row.kind === "edge" ? maxEdgePrefixWidth : wideLabelColumn !== void 0 && (nodeHasArcDecoration(row) || row.contractHash !== void 0) ? wideLabelColumn : laneSpan * 2 + LABEL_GAP;
 		if (row.kind === "edge" && row.edge?.from === EMPTY_CONTRACT_HASH && (row.laneIndex ?? 0) === 0) gutter = row.cells.slice(0, 1).map((cell, column) => renderCellPair(cell, column, cellColors, opts.colorize, style, palette)).join("");
 		else if (row.kind === "node" && laneSpan < row.cells.length && !nodeHasArcDecoration(row)) gutter = row.cells.slice(0, laneSpan).map((cell, column) => renderCellPair(cell, column, cellColors, opts.colorize, style, palette)).join("");
 		else if (gutter.length < laneSpan * 2) gutter = gutter.padEnd(laneSpan * 2, " ");
-		const dirNameWidth = rowDirNameWidth(labelColumn, maxDirNameLen, dirNameGap);
-		const dataColumn = labelColumn + dirNameWidth;
+		const dirNameWidth = row.kind === "edge" ? edgeDirNameWidth : rowDirNameWidth(labelColumn, maxDirNameLen, dirNameGap);
 		const gutterPad = padVisible(gutter, labelColumn);
 		if (row.kind === "node") {
 			const contractHash = row.contractHash ?? EMPTY_CONTRACT_HASH;
 			if (contractHash === EMPTY_CONTRACT_HASH) {
 				const trailingLanes = row.cells.slice(1).map((cell, offset) => renderCellPair(cell, offset + 1, cellColors, opts.colorize, style, palette)).join("");
 				const emptyGutter = palette.emptySource.padEnd(2, " ") + trailingLanes;
-				const overlayNames = overlayNamesForContract(contractHash, opts);
-				if (overlayNames.length === 0) {
+				const overlays = overlayNamesForContract(contractHash, opts);
+				if (overlays.markers.length === 0 && overlays.refs.length === 0) {
 					lines.push(trimTrailingWhitespace(emptyGutter));
 					continue;
 				}
-				const overlay = style.refs(overlayNames);
-				lines.push(trimTrailingWhitespace(`${padVisible(emptyGutter, dataColumn)}${overlay}`));
+				const overlay = formatContractNodeOverlays(style, overlays.markers, overlays.refs);
+				lines.push(trimTrailingWhitespace(`${emptyGutter}${" ".repeat(LABEL_GAP)}${overlay}`));
 				continue;
 			}
 			const hashText = style.sourceHash(abbreviateHash(contractHash, hashLength, palette.emptySource));
-			const 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) : "";
+			const overlays = overlayNamesForContract(contractHash, opts);
+			const hasOverlays = overlays.markers.length > 0 || overlays.refs.length > 0;
+			const overlayPad = hasOverlays ? " ".repeat(LABEL_GAP) : "";
+			const overlay = hasOverlays ? formatContractNodeOverlays(style, overlays.markers, overlays.refs) : "";
 			lines.push(trimTrailingWhitespace(`${gutterPad}${hashText}${overlayPad}${overlay}`));
 			continue;
 		}
@@ -1746,23 +1863,30 @@ function renderMigrationGraphTree(model, opts) {
 		if (edge === void 0) continue;
 		const dirNamePadding = " ".repeat(Math.max(0, dirNameWidth - edge.dirName.length));
 		const laneIndex = row.laneIndex ?? 0;
-		const dirName = `${(opts.colorize && laneIndex > NEUTRAL_LANE ? (text) => forcedBold(laneColorForColumn(laneIndex)(text)) : style.dirName)(edge.dirName)}${dirNamePadding}`;
+		const dirName = `${(opts.colorize && laneIndex > 0 ? (text) => forcedBold(laneColorForColumn(laneIndex)(text)) : style.dirName)(edge.dirName)}${dirNamePadding}`;
 		const hashColumn = formatEdgeHashColumn(edge, style, hashLength, palette);
 		const annotationSuffix = formatEdgeAnnotationSuffix(edge.migrationHash, opts, style);
 		lines.push(trimTrailingWhitespace(`${gutterPad}${dirName}${hashColumn}${annotationSuffix}`));
 	}
 	return lines.join("\n");
 }
+function formatLegendExampleMarkers(colorize) {
+	if (!colorize) return "<contract, db>";
+	const open = green("<");
+	const close = green(">");
+	const separator = green(", ");
+	return open + green("contract") + separator + green("db") + close;
+}
 /**
-* A compact key for the `--tree` visual language: the contract marker, the
-* in-lane direction arrows, the empty baseline, the `(refs)` overlay (including
-* the reserved `db` live-database and `contract` working-schema markers), and a
+* A compact key for the tree visual language: the contract node glyph, the
+* in-lane direction arrows, the empty baseline, the system-marker `<…>` and
+* user-ref `(…)` bracket conventions (two illustrative example lines), and a
 * worked sample of the data-column `from → to` migration hash arrow.
 *
 * Honors the same glyph palette (unicode vs ASCII) and `colorize` gate as the
 * tree renderer, so the key matches whatever the graph itself drew and stays
 * pipe-safe (zero ANSI when color is off). The caller adds the trailing blank
-* line that separates this stderr key from the graph on stdout.
+* line that separates this stderr key from the tree on stdout.
 */
 function renderMigrationGraphLegend(opts) {
 	const palette = paletteFor(opts.glyphMode ?? "unicode");
@@ -1771,17 +1895,72 @@ function renderMigrationGraphLegend(opts) {
 	const sampleArrow = `${style.sourceHash("aaaaaa")} ${style.glyph(palette.forwardArrow)} ${style.destHash("bbbbbb")}`;
 	const statusGlyphs = overlayStatusGlyphs(opts.glyphMode ?? "unicode");
 	const appliedPending = opts.colorize ? `  ${green(statusGlyphs.applied)} ${style.summary("applied")}   ${yellow(statusGlyphs.pending)} ${style.summary("pending")}` : `  ${statusGlyphs.applied} ${style.summary("applied")}   ${statusGlyphs.pending} ${style.summary("pending")}`;
+	const exampleMarkers = formatLegendExampleMarkers(opts.colorize);
+	const exampleRefs = opts.colorize ? style.refs(["prod", "staging"]) : "(prod, staging)";
 	return [
 		"Legend:",
 		`  ${style.kind(node)} ${style.summary("contract")}   ${style.kind(palette.edgeArrow.forward)} ${style.summary("forward")}   ${style.kind(palette.edgeArrow.rollback)} ${style.summary("rollback")}`,
 		`  ${style.kind(palette.edgeArrow.self)} ${style.summary("migration without schema change")}`,
 		appliedPending,
 		`  ${style.kind(palette.emptySource)} ${style.summary("empty database (baseline)")}`,
-		`  ${style.refs(["refs"])} ${style.summary(`${DB_MARKER_NAME} / ${CONTRACT_MARKER_NAME} markers`)}`,
+		`  ${exampleMarkers} ${style.summary("live markers (contract on disk, database state)")}`,
+		`  ${exampleRefs} ${style.summary("user-defined refs")}`,
 		`  ${sampleArrow}   ${style.summary("migration from contract aaaaaa to bbbbbb")}`
 	].join("\n");
 }
 //#endregion
-export { renderMigrationListWithStyle as a, buildMigrationGraphLayout as c, IDENTITY_MIGRATION_LIST_STYLER as i, renderMigrationGraphTree as n, abbreviateContractHash as o, createAnsiMigrationListStyler as r, buildMigrationGraphRows as s, renderMigrationGraphLegend as t };
+//#region src/utils/formatters/migration-graph-space-render.ts
+function mergeMigrationEdgeAnnotations(listOverlay, statusOverlay) {
+	const merged = /* @__PURE__ */ new Map();
+	for (const [migrationHash, listAnnotation] of listOverlay) {
+		const statusAnnotation = statusOverlay.get(migrationHash);
+		merged.set(migrationHash, {
+			...listAnnotation,
+			...statusAnnotation?.status !== void 0 ? { status: statusAnnotation.status } : {}
+		});
+	}
+	return merged;
+}
+function computeGlobalMaxEdgeTreePrefixWidth(inputs) {
+	let globalMax = 0;
+	for (const input of inputs) {
+		const layout = buildMigrationGraphLayout(buildMigrationGraphRows(input.graph, { contractHash: input.liveContractHash }));
+		globalMax = Math.max(globalMax, computeMaxEdgeTreePrefixWidthForLayout(layout));
+	}
+	return globalMax;
+}
+function computeGlobalMaxDirNameWidth(inputs) {
+	let globalMax = 0;
+	for (const input of inputs) {
+		const layout = buildMigrationGraphLayout(buildMigrationGraphRows(input.graph, { contractHash: input.liveContractHash }));
+		globalMax = Math.max(globalMax, computeMaxDirNameLengthForLayout(layout));
+	}
+	return globalMax;
+}
+function renderMigrationGraphSpaceTreeInternal(input) {
+	const layout = buildMigrationGraphLayout(buildMigrationGraphRows(input.graph, { contractHash: input.liveContractHash }));
+	const listOverlay = buildEdgeAnnotationsByHashFromListEntries(input.migrations);
+	const edgeAnnotationsByHash = input.statusOverlayByHash === void 0 ? listOverlay : mergeMigrationEdgeAnnotations(listOverlay, input.statusOverlayByHash);
+	return renderMigrationGraphTree(layout, {
+		refsByHash: input.refsByHash ?? buildRefsByHashFromListEntries(input.migrations),
+		contractHash: input.liveContractHash,
+		edgeAnnotationsByHash,
+		colorize: input.colorize,
+		glyphMode: input.glyphMode,
+		...input.dbHash !== void 0 ? { dbHash: input.dbHash } : {},
+		...input.styler !== void 0 ? { styler: input.styler } : {},
+		...input.globalMaxEdgeTreePrefixWidth !== void 0 ? { globalMaxEdgeTreePrefixWidth: input.globalMaxEdgeTreePrefixWidth } : {},
+		...input.globalMaxDirNameWidth !== void 0 ? { globalMaxDirNameWidth: input.globalMaxDirNameWidth } : {}
+	});
+}
+function renderMigrationGraphSpaceTree(input) {
+	return renderMigrationGraphSpaceTreeInternal(input);
+}
+function indentMigrationGraphTreeBlock(treeOutput, indent) {
+	if (treeOutput.length === 0) return treeOutput;
+	return treeOutput.split("\n").map((line) => line.length === 0 ? line : `${indent}${line}`).join("\n");
+}
+//#endregion
+export { renderMigrationGraphLegend as a, renderMigrationListWithStyle as c, renderMigrationGraphSpaceTree as i, abbreviateContractHash as l, computeGlobalMaxEdgeTreePrefixWidth as n, createAnsiMigrationListStyler as o, indentMigrationGraphTreeBlock as r, IDENTITY_MIGRATION_LIST_STYLER as s, computeGlobalMaxDirNameWidth as t };
 
-//# sourceMappingURL=migration-graph-tree-render-DyDBuJEX.mjs.map
+//# sourceMappingURL=migration-graph-space-render-dmLLWift.mjs.map