prisma-next 0.12.0-dev.2 → 0.12.0-dev.20

package/dist/{migration-graph-D7DVUElV.mjs → migration-graph-DKl_IYsF.mjs}

@@ -1,11 +1,11 @@
 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 { E as formatStyledHeader, _ as parseGlobalFlagsOrExit, b as handleResult, d as setCommandSeeAlso, l as setCommandDescriptions, s as resolveMigrationPaths, t as addGlobalOptions, u as setCommandExamples, v as createTerminalUI } from "./command-helpers-Cmdqyhz9.mjs";
+import { r as buildReadAggregate } from "./contract-space-aggregate-loader-CirAEsM8.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 { a as migrationListEmptySource, n as createAnsiMigrationListStyler, o as migrationListForwardArrow, s as classifyMigrationGraphTopology, t as CONTRACT_MARKER_NAME } from "./migration-list-styler-COQbZmXk.mjs";
 import { Command } from "commander";
 import { ok } from "@prisma-next/utils/result";
-import { bold } from "colorette";
+import { bold, createColors } 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
@@ -171,7 +171,7 @@ function classifyEdgeAdjacency(edge, position) {
 function emptyCells(width) {
 	return Array.from({ length: width }, () => ({ kind: "empty" }));
 }
-function buildBranchConnectorCells(startLane, endLane, activeLanes, gridWidth) {
+function buildBranchConnectorCells(startLane, endLane, fanTargetLanes, activeLanes, gridWidth) {
 	const cells = emptyCells(gridWidth);
 	for (let lane = 0; lane < gridWidth; lane++) {
 		if (activeLanes.has(lane) && (lane < startLane || lane > endLane)) {
@@ -180,11 +180,13 @@ function buildBranchConnectorCells(startLane, endLane, activeLanes, gridWidth) {
 		}
 		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" };
+		else if (lane > startLane && lane < endLane) if (fanTargetLanes.has(lane)) cells[lane] = { kind: "branch-tee" };
+		else if (activeLanes.has(lane)) cells[lane] = { kind: "arc-crossing" };
+		else cells[lane] = { kind: "branch-tee" };
 	}
 	return cells;
 }
-function buildMergeConnectorCells(startLane, endLane, activeLanes, gridWidth) {
+function buildMergeConnectorCells(startLane, endLane, fanTargetLanes, activeLanes, gridWidth) {
 	const cells = emptyCells(gridWidth);
 	for (let lane = 0; lane < gridWidth; lane++) {
 		if (activeLanes.has(lane) && (lane < startLane || lane > endLane)) {
@@ -193,7 +195,9 @@ function buildMergeConnectorCells(startLane, endLane, activeLanes, gridWidth) {
 		}
 		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" };
+		else if (lane > startLane && lane < endLane) if (fanTargetLanes.has(lane)) cells[lane] = { kind: "merge-tee" };
+		else if (activeLanes.has(lane)) cells[lane] = { kind: "arc-crossing" };
+		else cells[lane] = { kind: "horizontal-pass" };
 	}
 	return cells;
 }
@@ -358,6 +362,8 @@ function applySkipRollbackRouting(rows, skipRollbacks, position, nodeColumn, edg
 		edgeColumn.set(edge.migrationHash, backLane);
 		const coSourcedLanes = routes.filter((other) => other.edge.from === edge.from).map((other) => other.backLane);
 		const maxCoSourcedLane = Math.max(...coSourcedLanes);
+		const coLandingLanes = routes.filter((other) => other.edge.to === edge.to).map((other) => other.backLane);
+		const maxCoLandingLane = Math.max(...coLandingLanes);
 		const sourceRow = result[sourceRowIndex];
 		if (sourceRow !== void 0) {
 			const cells = sourceRow.cells;
@@ -402,7 +408,7 @@ function applySkipRollbackRouting(rows, skipRollbacks, position, nodeColumn, edg
 			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" };
+			if (existing?.kind !== "arc-land-corner" && existing?.kind !== "arc-land-tee" && existing?.kind !== "arc-land-bridge" && existing?.kind !== "arc-branch-corner" && existing?.kind !== "arc-branch-tee" && existing?.kind !== "arc-crossing") cells[backLane] = { kind: "vertical-pass" };
 		}
 		const targetRow = result[targetRowIndex];
 		if (targetRow !== void 0) {
@@ -414,16 +420,20 @@ function applySkipRollbackRouting(rows, skipRollbacks, position, nodeColumn, edg
 				arcLand: true
 			};
 			for (let lane = targetCol + 1; lane < backLane; lane += 1) {
+				if (coLandingLanes.includes(lane)) {
+					cells[lane] = { kind: "arc-land-tee" };
+					continue;
+				}
 				const existing = cells[lane];
-				cells[lane] = existing !== void 0 && existing.kind !== "empty" && existing.kind !== "horizontal-pass" && existing.kind !== "arc-land-bridge" || routes.some((other) => other.edge.migrationHash !== edge.migrationHash && other.backLane === lane && routeCrossesRow(other, targetRowIndex, result)) ? { kind: "arc-crossing" } : { kind: "arc-land-bridge" };
+				cells[lane] = existing !== void 0 && existing.kind !== "empty" && existing.kind !== "horizontal-pass" && existing.kind !== "arc-land-bridge" && existing.kind !== "arc-land-tee" || routes.some((other) => other.edge.migrationHash !== edge.migrationHash && other.backLane === lane && routeCrossesRow(other, targetRowIndex, result)) ? { kind: "arc-crossing" } : { kind: "arc-land-bridge" };
 			}
-			cells[backLane] = { kind: "arc-land-corner" };
+			cells[backLane] = backLane < maxCoLandingLane ? { kind: "arc-land-tee" } : { kind: "arc-land-corner" };
 			for (const other of routes) {
 				if (other.backLane <= backLane) continue;
 				if (!routeCrossesRow(other, targetRowIndex, result)) continue;
 				ensureCellWidth(cells, other.backLane + 1);
 				const existing = cells[other.backLane];
-				if (existing?.kind !== "arc-land-corner" && existing?.kind !== "arc-land-bridge" && existing?.kind !== "node") cells[other.backLane] = { kind: "vertical-pass" };
+				if (existing?.kind !== "arc-land-corner" && existing?.kind !== "arc-land-tee" && existing?.kind !== "arc-land-bridge" && existing?.kind !== "node") cells[other.backLane] = { kind: "vertical-pass" };
 			}
 		}
 	}
@@ -504,18 +514,19 @@ function layoutComponent(componentNodes, allEdges) {
 		const endLane = Math.max(...laneIndices);
 		ensureGridWidth(endLane + 1);
 		const activeLanes = new Set(activeLaneIndices());
+		const fanTargetLanes = new Set(laneIndices);
 		rows.push({
 			kind: "merge-connector",
 			contractHash,
 			startLane,
 			endLane,
 			branchCount: laneIndices.length,
-			cells: buildMergeConnectorCells(startLane, endLane, activeLanes, gridWidth)
+			cells: buildMergeConnectorCells(startLane, endLane, fanTargetLanes, activeLanes, gridWidth)
 		});
 		for (const index of laneIndices) if (index !== startLane) setLane(index, null);
 		return startLane;
 	}
-	function emitBranchConnector(contractHash, startLane, endLane, branchCount) {
+	function emitBranchConnector(contractHash, startLane, endLane, branchCount, fanTargetLanes) {
 		ensureGridWidth(endLane + 1);
 		const activeLanes = new Set(activeLaneIndices());
 		rows.push({
@@ -524,7 +535,7 @@ function layoutComponent(componentNodes, allEdges) {
 			startLane,
 			endLane,
 			branchCount,
-			cells: buildBranchConnectorCells(startLane, endLane, activeLanes, gridWidth)
+			cells: buildBranchConnectorCells(startLane, endLane, new Set(fanTargetLanes), activeLanes, gridWidth)
 		});
 	}
 	function emitEdgeRow(edge, lane, convergenceProducer) {
@@ -597,7 +608,7 @@ function layoutComponent(componentNodes, allEdges) {
 		}
 		if (groups.length >= 2) {
 			const endLane = Math.max(...laneForGroup);
-			emitBranchConnector(node, column, endLane, groups.length);
+			emitBranchConnector(node, column, endLane, groups.length, laneForGroup);
 		}
 		for (let groupIndex = 0; groupIndex < groups.length; groupIndex++) {
 			const group = groups[groupIndex];
@@ -835,6 +846,30 @@ function buildMigrationGraphRows(graph, options = {}) {
 	};
 }
 //#endregion
+//#region src/utils/formatters/migration-graph-lane-colors.ts
+const { magenta: magenta$1, cyan: cyan$1, green: green$1, yellow: yellow$1, blueBright, red: red$1 } = createColors({ useColor: true });
+const LANE_COLOR_CYCLE = [
+	magenta$1,
+	cyan$1,
+	green$1,
+	yellow$1,
+	blueBright,
+	red$1
+];
+/**
+* The hue for a gutter column. The leftmost lane (column 0) is **neutral** — it
+* has nothing to be told apart from in the common single-lane linear case, so
+* the renderer dims it rather than tinting it; the rotating palette is reserved
+* for columns ≥ 1 (where a second lane exists to distinguish). Callers must dim
+* column 0 themselves; this returns identity for it as a guard. A lane freed and
+* reused by a later branch keeps its column's hue — coloring is by position, not
+* branch identity, exactly like `git log --graph`.
+*/
+function laneColorForColumn(column) {
+	if (column <= 0) return (text) => text;
+	return LANE_COLOR_CYCLE[(column - 1) % LANE_COLOR_CYCLE.length] ?? ((text) => text);
+}
+//#endregion
 //#region src/utils/formatters/migration-graph-tree-render.ts
 const LABEL_GAP = 2;
 /**
@@ -855,6 +890,7 @@ const UNICODE_PALETTE = {
 	arcBranchCorner: "╮ ",
 	arcBranchTee: "┬─",
 	arcLandCorner: "╯ ",
+	arcLandTee: "┴─",
 	arcCrossing: "┼─",
 	arcLandBridge: "──",
 	horizontalPass: "──",
@@ -881,6 +917,7 @@ const ASCII_PALETTE = {
 	arcBranchCorner: "\\ ",
 	arcBranchTee: "+-",
 	arcLandCorner: "/ ",
+	arcLandTee: "+-",
 	arcCrossing: "+-",
 	arcLandBridge: "--",
 	horizontalPass: "--",
@@ -902,74 +939,271 @@ 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);
+}
+/**
+* Tint a branch-owned token (direction arrow, migration name) by its edge's
+* lane so the whole branch row reads in one colour. Column 0 has nothing to be
+* told apart from in the common linear chain, so it keeps the token's existing
+* default styling (`fallback`) rather than a palette hue; only lanes ≥ 1 take a
+* colour. With colour off, the fallback (also colourless) is used unchanged.
+*/
+function branchStylerOrDefault(column, colorize, fallback) {
+	if (!colorize || column <= NEUTRAL_LANE) return fallback;
+	return laneColorForColumn(column);
+}
+/**
+* Render a connector tee (`├─` / `┬─` / `┴─`) with its junction glyph and its
+* trailing dash coloured independently: the junction anchors its own lane while
+* the dash leads into the branch on its right.
+*/
+function renderConnectorTee(pair, glyphColumn, dashColumn, colorize, style) {
+	const glyph = laneStylerForColumn(glyphColumn, colorize, style);
+	if (glyphColumn === dashColumn) return glyph(pair);
+	return glyph(pair.slice(0, 1)) + laneStylerForColumn(dashColumn, colorize, style)(pair.slice(1));
+}
+/**
 * A node-marker glyph pair (`○◂`, `○─`, `*<`, `*-`) is the contract node
-* marker (`○` / `*`) followed by an arc connector (`◂` / `─` / `<` / `-`).
-* The marker 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.
+* marker (`○` / `*`) followed by an arc connector (`◂` / `─` / `<` / `-`). The
+* marker takes its own lane's hue (so each node visibly belongs to its branch);
+* the connector follows the arc it belongs to (its owning back-lane hue).
+* Direction arrows are handled elsewhere — they take their edge's lane hue too.
 */
-function renderNodeMarkerPair(pair, style) {
-	return style.kind(pair.slice(0, 1)) + style.lane(pair.slice(1));
+function renderNodeMarkerPair(pair, nodeColumn, arcColumn, colorize, style) {
+	const marker = laneStylerForColumn(nodeColumn, colorize, style);
+	const connector = laneStylerForColumn(arcColumn, colorize, style);
+	return marker(pair.slice(0, 1)) + connector(pair.slice(1));
 }
-function renderCellPair(cell, style, palette) {
+function renderCellPair(cell, column, colors, colorize, style, palette) {
+	const laneColumn = colors.lane[column] ?? column;
+	const lane = laneStylerForColumn(laneColumn, colorize, style);
 	switch (cell.kind) {
-		case "node":
-			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 "node": {
+			const arcColumn = colors.connector[column] ?? NEUTRAL_LANE;
+			if (cell.arcLand === true) return renderNodeMarkerPair(palette.arcLand, column, arcColumn, colorize, style);
+			if (cell.arcTee === true) return renderNodeMarkerPair(palette.arcTee, column, arcColumn, colorize, style);
+			return lane(palette.node);
+		}
+		case "vertical-pass": return lane(palette.verticalPass);
+		case "edge-lane": return cell.ownsLabel ? lane(palette.verticalPass.trimEnd()) + branchStylerOrDefault(column, colorize, style.kind)(arrowForEdgeKind(cell.edgeKind, palette)) : lane(palette.verticalPass);
+		case "branch-tee": return lane(palette.branchTee);
+		case "merge-tee": return lane(palette.mergeTee);
+		case "branch-corner": return lane(palette.branchCorner);
+		case "merge-corner": return lane(palette.mergeCorner);
+		case "arc-branch-corner": return lane(palette.arcBranchCorner);
+		case "arc-branch-tee": return lane(palette.arcBranchTee);
+		case "arc-land-corner": return lane(palette.arcLandCorner);
+		case "arc-land-tee": return renderConnectorTee(palette.arcLandTee, laneColumn, colors.dash[column] ?? laneColumn, colorize, style);
+		case "arc-crossing": return lane(palette.arcLandBridge);
+		case "arc-land-bridge": return lane(palette.arcLandBridge);
+		case "horizontal-pass": return lane(palette.horizontalPass);
 		case "empty": return "  ";
 	}
 }
-function renderConnectorRow(row, gridWidth, style, palette) {
+function renderConnectorRow(row, gridWidth, colorize, style, palette) {
 	const isMerge = row.kind === "merge-connector";
 	if (row.cells.length > 0) {
+		const colors = resolveConnectorLaneColors(row.cells, row.startLane ?? 0);
 		let seenTee = false;
 		let out = "";
-		for (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 = 0; column < row.cells.length; column++) {
+			const cell = row.cells[column];
+			if (cell === void 0) continue;
+			const glyphColumn = colors.glyph[column] ?? column;
+			const dashColumn = colors.dash[column] ?? glyphColumn;
+			const lane = laneStylerForColumn(glyphColumn, colorize, style);
+			switch (cell.kind) {
+				case "branch-tee":
+					out += renderConnectorTee(seenTee ? palette.connectorBranchTeeCo : palette.connectorBranchTee, glyphColumn, dashColumn, colorize, style);
+					seenTee = true;
+					break;
+				case "merge-tee":
+					out += renderConnectorTee(seenTee ? palette.connectorMergeTeeCo : palette.connectorBranchTee, glyphColumn, dashColumn, colorize, style);
+					seenTee = true;
+					break;
+				case "branch-corner":
+					out += lane(palette.branchCorner);
+					break;
+				case "merge-corner":
+					out += lane(palette.mergeCorner);
+					break;
+				case "vertical-pass":
+					out += lane(palette.verticalPass);
+					break;
+				case "horizontal-pass":
+					out += lane(palette.horizontalPass);
+					break;
+				case "arc-crossing":
+					out += renderConnectorTee(palette.arcCrossing, glyphColumn, dashColumn, colorize, style);
+					break;
+				default: out += "  ";
+			}
 		}
 		for (let column = row.cells.length; column < gridWidth; column++) out += "  ";
 		return out;
 	}
 	const start = row.startLane ?? 0;
 	const end = row.endLane ?? start;
+	const runLane = laneStylerForColumn(end, colorize, style);
 	let out = "";
 	for (let column = 0; column < gridWidth; column++) if (column < start || column > end) out += "  ";
-	else if (column === start) out += 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);
+	else if (column === start) out += runLane(palette.connectorBranchTee);
+	else if (column === end) out += runLane(isMerge ? palette.mergeCorner : palette.branchCorner);
+	else out += runLane(isMerge ? palette.connectorMergeTeeCo : palette.connectorBranchTeeCo);
 	return out;
 }
 function abbreviateHash(hash, hashLength, emptySource) {
@@ -1008,6 +1242,11 @@ function padVisible(text, targetWidth) {
 	const padding = Math.max(0, targetWidth - stringWidth(text));
 	return text + " ".repeat(padding);
 }
+const ANSI_ESCAPE = "\x1B";
+function trimTrailingWhitespace(line) {
+	const trailingSpaceBeforeReset = new RegExp(`[\\t ]+((?:${ANSI_ESCAPE}\\[[0-9;]*m)+)$`);
+	return line.replace(trailingSpaceBeforeReset, "$1").replace(/\s+$/, "");
+}
 function gridWidthForModel(rows) {
 	return rows.reduce((max, row) => row.kind === "node" || row.kind === "edge" ? Math.max(max, row.cells.length) : max, 1);
 }
@@ -1047,20 +1286,24 @@ function renderMigrationGraphTree(model, opts) {
 			continue;
 		}
 		if (row.kind === "branch-connector" || row.kind === "merge-connector") {
-			lines.push(renderConnectorRow(row, gridWidth, style, palette).replace(/\s+$/, ""));
+			lines.push(trimTrailingWhitespace(renderConnectorRow(row, gridWidth, opts.colorize, style, palette)));
 			continue;
 		}
-		let gutter = row.cells.map((cell) => renderCellPair(cell, style, palette)).join("");
-		const prevRow = model.rows[rowIndex - 1];
+		const cellColors = resolveRowLaneColors(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") {
-			const contractHash = row.contractHash ?? EMPTY_CONTRACT_HASH;
-			if (prevRow?.kind === "merge-connector" || contractHash === EMPTY_CONTRACT_HASH) laneSpan = 1;
-			else laneSpan = row.cells.length;
+		if (row.kind === "node") if ((row.contractHash ?? EMPTY_CONTRACT_HASH) === EMPTY_CONTRACT_HASH) laneSpan = 1;
+		else {
+			let lastActiveColumn = -1;
+			for (let column = row.cells.length - 1; column >= 0; column--) if (row.cells[column]?.kind !== "empty") {
+				lastActiveColumn = column;
+				break;
+			}
+			laneSpan = lastActiveColumn >= 0 ? lastActiveColumn + 1 : 1;
 		}
 		const labelColumn = row.kind === "edge" ? 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("");
+		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;
@@ -1068,35 +1311,76 @@ function renderMigrationGraphTree(model, opts) {
 		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 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) {
-					lines.push(emptyGutter.replace(/\s+$/, ""));
+					lines.push(trimTrailingWhitespace(emptyGutter));
 					continue;
 				}
 				const overlay = style.refs(overlayNames);
-				lines.push(`${padVisible(emptyGutter, dataColumn)}${overlay}`.replace(/\s+$/, ""));
+				lines.push(trimTrailingWhitespace(`${padVisible(emptyGutter, dataColumn)}${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) : "";
-			lines.push(`${gutterPad}${hashText}${overlayPad}${overlay}`.replace(/\s+$/, ""));
+			lines.push(trimTrailingWhitespace(`${gutterPad}${hashText}${overlayPad}${overlay}`));
 			continue;
 		}
 		const edge = row.edge;
 		if (edge === void 0) continue;
 		const dirNamePadding = " ".repeat(Math.max(0, dirNameWidth - edge.dirName.length));
-		const dirName = `${style.dirName(edge.dirName)}${dirNamePadding}`;
+		const laneIndex = row.laneIndex ?? 0;
+		const dirName = `${(opts.colorize && laneIndex > NEUTRAL_LANE ? (text) => forcedBold(laneColorForColumn(laneIndex)(text)) : style.dirName)(edge.dirName)}${dirNamePadding}`;
 		const hashColumn = formatEdgeHashColumn(edge, style, hashLength, palette);
-		lines.push(`${gutterPad}${dirName}${hashColumn}`.replace(/\s+$/, ""));
+		lines.push(trimTrailingWhitespace(`${gutterPad}${dirName}${hashColumn}`));
 	}
 	return lines.join("\n");
 }
+/**
+* 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
+* 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.
+*/
+function renderMigrationGraphLegend(opts) {
+	const palette = paletteFor(opts.glyphMode ?? "unicode");
+	const style = createAnsiMigrationListStyler({ useColor: opts.colorize });
+	const node = palette.node.trimEnd();
+	const sampleArrow = `${style.sourceHash("aaaaaa")} ${style.glyph(palette.forwardArrow)} ${style.destHash("bbbbbb")}`;
+	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")}`,
+		`  ${style.kind(palette.emptySource)} ${style.summary("empty database (baseline)")}`,
+		`  ${style.refs(["refs"])} ${style.summary(`${DB_MARKER_NAME} / ${CONTRACT_MARKER_NAME} markers`)}`,
+		`  ${sampleArrow}   ${style.summary("migration from contract aaaaaa to bbbbbb")}`
+	].join("\n");
+}
 //#endregion
 //#region src/commands/migration-graph.ts
+/**
+* `--legend` describes the `--tree` visual language, so passing it auto-enables
+* the tree path (it has nothing to say about the legacy dagre default).
+*/
+function migrationGraphUsesTree(options) {
+	return options.tree === true || options.legend === true;
+}
+/**
+* The legend is decoration printed alongside the command header on stderr, so
+* it is suppressed for the machine-readable / silent paths (`--json`, `--dot`,
+* `--quiet`) exactly as the header is.
+*/
+function migrationGraphShowsLegend(options, flags) {
+	return options.legend === true && options.dot !== true && flags.json !== true && flags.quiet !== true;
+}
 async function executeMigrationGraphCommand(options, flags, ui) {
 	const config = await loadConfig(options.config);
 	const { configPath, appMigrationsRelative, migrationsDir } = resolveMigrationPaths(options.config, config);
@@ -1114,6 +1398,13 @@ async function executeMigrationGraphCommand(options, flags, ui) {
 			flags
 		});
 		ui.stderr(header);
+		if (migrationGraphShowsLegend(options, flags)) {
+			ui.stderr(renderMigrationGraphLegend({
+				colorize: flags.color !== false,
+				glyphMode: ui.resolveGlyphMode(options.ascii === true)
+			}));
+			ui.stderr("");
+		}
 	}
 	const loaded = await buildReadAggregate(config, { migrationsDir });
 	if (!loaded.ok) return loaded;
@@ -1139,7 +1430,8 @@ function createMigrationGraphCommand() {
 		"prisma-next migration graph --json",
 		"prisma-next migration graph --dot",
 		"prisma-next migration graph --tree",
-		"prisma-next migration graph --tree --ascii"
+		"prisma-next migration graph --tree --ascii",
+		"prisma-next migration graph --legend"
 	]);
 	setCommandSeeAlso(command, [
 		{
@@ -1159,7 +1451,7 @@ function createMigrationGraphCommand() {
 			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) => {
+	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)").option("--legend", "Print a key for the --tree glyphs and lane colors (implies --tree)").action(async (options) => {
 		const flags = parseGlobalFlagsOrExit(options);
 		const ui = createTerminalUI(flags);
 		const exitCode = handleResult(await executeMigrationGraphCommand(options, flags, ui), flags, ui, (graphResult) => {
@@ -1186,7 +1478,7 @@ function createMigrationGraphCommand() {
 					edges,
 					summary: graphResult.summary
 				}, null, 2));
-			} else if (!flags.quiet) if (options.tree) {
+			} else if (!flags.quiet) if (migrationGraphUsesTree(options)) {
 				const refsByHash = /* @__PURE__ */ new Map();
 				for (const ref of graphResult.refs) {
 					const existing = refsByHash.get(ref.hash);
@@ -1227,6 +1519,6 @@ function createMigrationGraphCommand() {
 	return command;
 }
 //#endregion
-export { executeMigrationGraphCommand as n, createMigrationGraphCommand as t };
+export { migrationGraphUsesTree as i, executeMigrationGraphCommand as n, migrationGraphShowsLegend as r, createMigrationGraphCommand as t };
 
-//# sourceMappingURL=migration-graph-D7DVUElV.mjs.map
+//# sourceMappingURL=migration-graph-DKl_IYsF.mjs.map