@prisma-next/cli 0.12.0-dev.52 → 0.12.0-dev.54

package/dist/{migration-graph-space-render-CeNXh_Wy.mjs → migration-graph-space-render-B0HkTNj3.mjs}

@@ -143,9 +143,14 @@ function refineAdjacency(rows, nodeColumn, position, forwardInDegree, forwardOut
 		if (row.kind !== "edge" || row.edge === void 0 || row.laneIndex === void 0) return row;
 		const divergenceBranchEdge = row.edge.kind === "forward" && !(row.convergenceProducer ?? false) && (forwardOutDegree.get(row.edge.from) ?? 0) >= 2 && branchLaneForEdge(row.edge) !== void 0;
 		const adjacency = row.convergenceProducer === true && convergenceProducerUsesShortAdjacency(row.edge, row.laneIndex, forwardProducersByTo, producerLaneByHash) ? classifyForwardShortConvergenceAdjacency(rows, rowIndex, row.edge, row.laneIndex) : classifyLayoutAdjacency(rows, rowIndex, row.edge, row.laneIndex, row.passThroughLanes ?? [], nodeColumn, position, forwardInDegree, row.convergenceProducer ?? false, divergenceBranchEdge);
+		const existingLaneEdge = /* @__PURE__ */ new Map();
+		for (const lane of row.passThroughLanes ?? []) {
+			const cell = row.cells[lane];
+			if (cell !== void 0 && "migrationHash" in cell && cell.migrationHash !== void 0) existingLaneEdge.set(lane, cell.migrationHash);
+		}
 		return {
 			...row,
-			cells: buildEdgeCells(row.edge, row.laneIndex, row.passThroughLanes ?? [], adjacency, row.cells.length)
+			cells: buildEdgeCells(row.edge, row.laneIndex, row.passThroughLanes ?? [], adjacency, row.cells.length, existingLaneEdge)
 		};
 	});
 }
@@ -164,48 +169,100 @@ function classifyEdgeAdjacency(edge, position) {
 function emptyCells(width) {
 	return Array.from({ length: width }, () => ({ kind: "empty" }));
 }
-function buildBranchConnectorCells(startLane, endLane, fanTargetLanes, activeLanes, gridWidth) {
+/** Returns `{ migrationHash: hash }` when hash is defined, otherwise `{}`. */
+function hashProp(hash) {
+	return hash !== void 0 ? { migrationHash: hash } : {};
+}
+/** Returns `{ arcMigrationHash: hash }` when hash is defined, otherwise `{}`. */
+function arcHashProp(hash) {
+	return hash !== void 0 ? { arcMigrationHash: hash } : {};
+}
+function buildBranchConnectorCells(startLane, endLane, fanTargetLanes, activeLanes, gridWidth, trunkEdgeHash, fanEdgeHashByLane, laneEdgeByIndex) {
 	const cells = emptyCells(gridWidth);
 	for (let lane = 0; lane < gridWidth; lane++) {
 		if (activeLanes.has(lane) && (lane < startLane || lane > endLane)) {
-			cells[lane] = { kind: "vertical-pass" };
+			cells[lane] = {
+				kind: "vertical-pass",
+				...hashProp(laneEdgeByIndex.get(lane))
+			};
 			continue;
 		}
-		if (lane === startLane) cells[lane] = { kind: "branch-tee" };
-		else if (lane === endLane) cells[lane] = { kind: "branch-corner" };
-		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" };
+		if (lane === startLane) cells[lane] = {
+			kind: "branch-tee",
+			...hashProp(trunkEdgeHash)
+		};
+		else if (lane === endLane) cells[lane] = {
+			kind: "branch-corner",
+			...hashProp(fanEdgeHashByLane.get(lane))
+		};
+		else if (lane > startLane && lane < endLane) if (fanTargetLanes.has(lane)) cells[lane] = {
+			kind: "branch-tee",
+			...hashProp(fanEdgeHashByLane.get(lane))
+		};
+		else if (activeLanes.has(lane)) cells[lane] = {
+			kind: "arc-crossing",
+			...hashProp(laneEdgeByIndex.get(lane)),
+			...arcHashProp(fanEdgeHashByLane.get(endLane))
+		};
+		else cells[lane] = {
+			kind: "branch-tee",
+			...hashProp(fanEdgeHashByLane.get(lane))
+		};
 	}
 	return cells;
 }
-function buildMergeConnectorCells(startLane, endLane, fanTargetLanes, activeLanes, gridWidth) {
+function buildMergeConnectorCells(startLane, endLane, fanTargetLanes, activeLanes, gridWidth, laneEdgeByIndex) {
 	const cells = emptyCells(gridWidth);
 	for (let lane = 0; lane < gridWidth; lane++) {
 		if (activeLanes.has(lane) && (lane < startLane || lane > endLane)) {
-			cells[lane] = { kind: "vertical-pass" };
+			cells[lane] = {
+				kind: "vertical-pass",
+				...hashProp(laneEdgeByIndex.get(lane))
+			};
 			continue;
 		}
-		if (lane === startLane) cells[lane] = { kind: "merge-tee" };
-		else if (lane === endLane) cells[lane] = { kind: "merge-corner" };
-		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" };
+		if (lane === startLane) cells[lane] = {
+			kind: "merge-tee",
+			...hashProp(laneEdgeByIndex.get(lane))
+		};
+		else if (lane === endLane) cells[lane] = {
+			kind: "merge-corner",
+			...hashProp(laneEdgeByIndex.get(lane))
+		};
+		else if (lane > startLane && lane < endLane) if (fanTargetLanes.has(lane)) cells[lane] = {
+			kind: "merge-tee",
+			...hashProp(laneEdgeByIndex.get(lane))
+		};
+		else if (activeLanes.has(lane)) cells[lane] = {
+			kind: "arc-crossing",
+			...hashProp(laneEdgeByIndex.get(lane)),
+			...arcHashProp(laneEdgeByIndex.get(endLane))
+		};
+		else cells[lane] = {
+			kind: "horizontal-pass",
+			...hashProp(laneEdgeByIndex.get(startLane))
+		};
 	}
 	return cells;
 }
-function buildNodeCells(contractHash, nodeColumn, activeLanes, gridWidth) {
+function buildNodeCells(contractHash, nodeColumn, activeLanes, gridWidth, laneEdgeByIndex) {
 	const cells = emptyCells(gridWidth);
-	for (const lane of activeLanes) if (lane !== nodeColumn && lane < gridWidth) cells[lane] = { kind: "vertical-pass" };
+	for (const lane of activeLanes) if (lane !== nodeColumn && lane < gridWidth) cells[lane] = {
+		kind: "vertical-pass",
+		...hashProp(laneEdgeByIndex.get(lane))
+	};
 	if (nodeColumn < gridWidth) cells[nodeColumn] = {
 		kind: "node",
 		contractHash
 	};
 	return cells;
 }
-function buildEdgeCells(edge, laneIndex, passThroughLanes, adjacency, gridWidth) {
+function buildEdgeCells(edge, laneIndex, passThroughLanes, adjacency, gridWidth, laneEdgeByIndex) {
 	const cells = emptyCells(gridWidth);
-	for (const lane of passThroughLanes) if (lane < gridWidth) cells[lane] = { kind: "vertical-pass" };
+	for (const lane of passThroughLanes) if (lane < gridWidth) cells[lane] = {
+		kind: "vertical-pass",
+		...hashProp(laneEdgeByIndex.get(lane))
+	};
 	if (laneIndex < gridWidth) cells[laneIndex] = {
 		kind: "edge-lane",
 		migrationHash: edge.migrationHash,
@@ -357,6 +414,7 @@ function applySkipRollbackRouting(rows, skipRollbacks, position, nodeColumn, edg
 		const maxCoSourcedLane = Math.max(...coSourcedLanes);
 		const coLandingLanes = routes.filter((other) => other.edge.to === edge.to).map((other) => other.backLane);
 		const maxCoLandingLane = Math.max(...coLandingLanes);
+		const { migrationHash: arcHash } = edge;
 		const sourceRow = result[sourceRowIndex];
 		if (sourceRow !== void 0) {
 			const cells = sourceRow.cells;
@@ -368,22 +426,43 @@ function applySkipRollbackRouting(rows, skipRollbacks, position, nodeColumn, edg
 			};
 			for (let lane = nodeCol + 1; lane < backLane; lane += 1) {
 				if (coSourcedLanes.includes(lane)) {
-					cells[lane] = { kind: "arc-branch-tee" };
+					cells[lane] = {
+						kind: "arc-branch-tee",
+						...hashProp(routes.find((r) => r.backLane === lane && r.edge.from === edge.from)?.edge.migrationHash)
+					};
 					continue;
 				}
 				const existing = cells[lane];
-				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" };
+				if (existing !== void 0 && existing.kind !== "empty" && existing.kind !== "horizontal-pass" && existing.kind !== "arc-land-bridge" || routes.some((other) => other.edge.migrationHash !== arcHash && other.backLane === lane && routeCrossesRow(other, sourceRowIndex, result))) cells[lane] = {
+					kind: "arc-crossing",
+					...hashProp(existing !== void 0 && "migrationHash" in existing ? existing.migrationHash : void 0),
+					arcMigrationHash: arcHash
+				};
+				else cells[lane] = {
+					kind: "horizontal-pass",
+					migrationHash: arcHash
+				};
 			}
-			cells[backLane] = backLane < maxCoSourcedLane ? { kind: "arc-branch-tee" } : { kind: "arc-branch-corner" };
+			cells[backLane] = backLane < maxCoSourcedLane ? {
+				kind: "arc-branch-tee",
+				migrationHash: arcHash
+			} : {
+				kind: "arc-branch-corner",
+				migrationHash: arcHash
+			};
 		}
 		const edgeRow = result[edgeRowIndex];
 		if (edgeRow !== void 0) {
 			const cells = edgeRow.cells;
 			ensureCellWidth(cells, backLane + 1);
-			cells[nodeCol] = { kind: "vertical-pass" };
+			const forwardLaneCell = cells[nodeCol];
+			cells[nodeCol] = {
+				kind: "vertical-pass",
+				...hashProp(forwardLaneCell !== void 0 && "migrationHash" in forwardLaneCell ? forwardLaneCell.migrationHash : void 0)
+			};
 			cells[backLane] = {
 				kind: "edge-lane",
-				migrationHash: edge.migrationHash,
+				migrationHash: arcHash,
 				edgeKind: edge.kind,
 				ownsLabel: true,
 				adjacency: "node-skipping-rollback"
@@ -401,7 +480,10 @@ 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-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" };
+			if (existing?.kind !== "arc-land-corner" && existing?.kind !== "arc-land-tee" && existing?.kind !== "arc-land-bridge" && existing?.kind !== "arc-branch-corner" && existing?.kind !== "arc-branch-tee" && existing?.kind !== "arc-crossing") cells[backLane] = {
+				kind: "vertical-pass",
+				migrationHash: arcHash
+			};
 		}
 		const targetRow = result[targetRowIndex];
 		if (targetRow !== void 0) {
@@ -414,19 +496,39 @@ function applySkipRollbackRouting(rows, skipRollbacks, position, nodeColumn, edg
 			};
 			for (let lane = targetCol + 1; lane < backLane; lane += 1) {
 				if (coLandingLanes.includes(lane)) {
-					cells[lane] = { kind: "arc-land-tee" };
+					cells[lane] = {
+						kind: "arc-land-tee",
+						...hashProp(routes.find((r) => r.backLane === lane && r.edge.to === edge.to)?.edge.migrationHash)
+					};
 					continue;
 				}
 				const existing = cells[lane];
-				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" };
+				if (existing !== void 0 && existing.kind !== "empty" && existing.kind !== "horizontal-pass" && existing.kind !== "arc-land-bridge" && existing.kind !== "arc-land-tee" || routes.some((other) => other.edge.migrationHash !== arcHash && other.backLane === lane && routeCrossesRow(other, targetRowIndex, result))) cells[lane] = {
+					kind: "arc-crossing",
+					...hashProp(existing !== void 0 && "migrationHash" in existing ? existing.migrationHash : void 0),
+					arcMigrationHash: arcHash
+				};
+				else cells[lane] = {
+					kind: "arc-land-bridge",
+					migrationHash: arcHash
+				};
 			}
-			cells[backLane] = backLane < maxCoLandingLane ? { kind: "arc-land-tee" } : { kind: "arc-land-corner" };
+			cells[backLane] = backLane < maxCoLandingLane ? {
+				kind: "arc-land-tee",
+				migrationHash: arcHash
+			} : {
+				kind: "arc-land-corner",
+				migrationHash: arcHash
+			};
 			for (const other of routes) {
 				if (other.backLane <= backLane) continue;
 				if (!routeCrossesRow(other, targetRowIndex, result)) continue;
 				ensureCellWidth(cells, other.backLane + 1);
 				const existing = cells[other.backLane];
-				if (existing?.kind !== "arc-land-corner" && existing?.kind !== "arc-land-tee" && existing?.kind !== "arc-land-bridge" && existing?.kind !== "node") cells[other.backLane] = { kind: "vertical-pass" };
+				if (existing?.kind !== "arc-land-corner" && existing?.kind !== "arc-land-tee" && existing?.kind !== "arc-land-bridge" && existing?.kind !== "node") cells[other.backLane] = {
+					kind: "vertical-pass",
+					migrationHash: other.edge.migrationHash
+				};
 			}
 		}
 	}
@@ -476,6 +578,7 @@ function layoutComponent(componentNodes, allEdges) {
 	const nodeColumn = /* @__PURE__ */ new Map();
 	const edgeColumn = /* @__PURE__ */ new Map();
 	const producerLaneByHash = /* @__PURE__ */ new Map();
+	const laneEdgeByIndex = /* @__PURE__ */ new Map();
 	let gridWidth = 1;
 	function ensureGridWidth(minWidth) {
 		if (minWidth > gridWidth) gridWidth = minWidth;
@@ -514,21 +617,22 @@ function layoutComponent(componentNodes, allEdges) {
 			startLane,
 			endLane,
 			branchCount: laneIndices.length,
-			cells: buildMergeConnectorCells(startLane, endLane, fanTargetLanes, activeLanes, gridWidth)
+			cells: buildMergeConnectorCells(startLane, endLane, fanTargetLanes, activeLanes, gridWidth, laneEdgeByIndex)
 		});
 		for (const index of laneIndices) if (index !== startLane) setLane(index, null);
 		return startLane;
 	}
-	function emitBranchConnector(contractHash, startLane, endLane, branchCount, fanTargetLanes) {
+	function emitBranchConnector(contractHash, startLane, endLane, branchCount, fanTargetLanes, fanEdgeHashByLane) {
 		ensureGridWidth(endLane + 1);
 		const activeLanes = new Set(activeLaneIndices());
+		const trunkEdgeHash = fanEdgeHashByLane.get(startLane) ?? laneEdgeByIndex.get(startLane);
 		rows.push({
 			kind: "branch-connector",
 			contractHash,
 			startLane,
 			endLane,
 			branchCount,
-			cells: buildBranchConnectorCells(startLane, endLane, new Set(fanTargetLanes), activeLanes, gridWidth)
+			cells: buildBranchConnectorCells(startLane, endLane, new Set(fanTargetLanes), activeLanes, gridWidth, trunkEdgeHash, fanEdgeHashByLane, laneEdgeByIndex)
 		});
 	}
 	function emitEdgeRow(edge, lane, convergenceProducer) {
@@ -540,7 +644,7 @@ function layoutComponent(componentNodes, allEdges) {
 			edge,
 			laneIndex: lane,
 			passThroughLanes: passThrough,
-			cells: buildEdgeCells(edge, lane, passThrough, adjacency, gridWidth)
+			cells: buildEdgeCells(edge, lane, passThrough, adjacency, gridWidth, laneEdgeByIndex)
 		};
 		rows.push(convergenceProducer ? {
 			...row,
@@ -548,6 +652,7 @@ function layoutComponent(componentNodes, allEdges) {
 		} : row);
 		edgeColumn.set(edge.migrationHash, lane);
 		if (convergenceProducer) producerLaneByHash.set(edge.migrationHash, lane);
+		laneEdgeByIndex.set(lane, edge.migrationHash);
 	}
 	function emitNodeRow(contractHash, column) {
 		ensureGridWidth(column + 1);
@@ -555,7 +660,7 @@ function layoutComponent(componentNodes, allEdges) {
 		rows.push({
 			kind: "node",
 			contractHash,
-			cells: buildNodeCells(contractHash, column, passThrough, gridWidth)
+			cells: buildNodeCells(contractHash, column, passThrough, gridWidth, laneEdgeByIndex)
 		});
 		nodeColumn.set(contractHash, column);
 	}
@@ -601,7 +706,21 @@ function layoutComponent(componentNodes, allEdges) {
 		}
 		if (groups.length >= 2) {
 			const endLane = Math.max(...laneForGroup);
-			emitBranchConnector(node, column, endLane, groups.length, laneForGroup);
+			const fanEdgeHashByLane = /* @__PURE__ */ new Map();
+			for (let groupIndex = 0; groupIndex < groups.length; groupIndex++) {
+				const group = groups[groupIndex];
+				const lane = laneForGroup[groupIndex];
+				if (group === void 0 || lane === void 0) continue;
+				const firstEdge = group.edges[0];
+				if (firstEdge !== void 0) fanEdgeHashByLane.set(lane, firstEdge.migrationHash);
+			}
+			emitBranchConnector(node, column, endLane, groups.length, laneForGroup, fanEdgeHashByLane);
+			for (let groupIndex = 0; groupIndex < groups.length; groupIndex++) {
+				const fanLane = laneForGroup[groupIndex];
+				if (fanLane === void 0) continue;
+				const fanHash = fanEdgeHashByLane.get(fanLane);
+				if (fanHash !== void 0) laneEdgeByIndex.set(fanLane, fanHash);
+			}
 		}
 		for (let groupIndex = 0; groupIndex < groups.length; groupIndex++) {
 			const group = groups[groupIndex];
@@ -1349,20 +1468,23 @@ function buildRefsByHashFromListEntries(entries) {
 function formatEmptyStateLine(spaceId, style) {
 	return style.emptyState(`There are no migrations in migrations/${spaceId}/ yet`);
 }
-function renderSpaceTreeBlock(spaceId, migrations, multiSpace, glyphMode, style, colorize, liveContractHash, graphForSpace, globalMaxEdgeTreePrefixWidth, globalMaxDirNameWidth) {
+function renderSpaceTreeBlock(spaceId, migrations, multiSpace, glyphMode, style, colorize, liveContractHash, graphForSpace, appSpaceId, globalMaxEdgeTreePrefixWidth, globalMaxDirNameWidth) {
 	if (migrations.length === 0) {
 		const emptyLine = formatEmptyStateLine(spaceId, style);
 		if (!multiSpace) return [emptyLine];
 		return [style.spaceHeading(`${spaceId}:`), `  ${emptyLine}`];
 	}
+	const graph = graphForSpace(spaceId) ?? migrationGraphFromListEntries(migrations);
+	const isAppSpace = appSpaceId === void 0 ? void 0 : spaceId === appSpaceId;
 	const treeOutput = renderMigrationGraphSpaceTree({
-		graph: graphForSpace(spaceId) ?? migrationGraphFromListEntries(migrations),
+		graph,
 		migrations,
 		liveContractHash,
 		glyphMode,
 		colorize,
 		refsByHash: buildRefsByHashFromListEntries(migrations),
 		styler: style,
+		...isAppSpace !== void 0 ? { isAppSpace } : {},
 		...globalMaxEdgeTreePrefixWidth !== void 0 ? { globalMaxEdgeTreePrefixWidth } : {},
 		...globalMaxDirNameWidth !== void 0 ? { globalMaxDirNameWidth } : {}
 	});
@@ -1383,6 +1505,7 @@ function renderMigrationListWithStyle(result, style, glyphMode = "unicode", opti
 	const colorize = options.colorize ?? false;
 	const liveContractHash = options.liveContractHash ?? EMPTY_CONTRACT_HASH;
 	const graphForSpace = options.graphForSpace ?? (() => void 0);
+	const appSpaceId = options.appSpaceId;
 	const globalLayoutInputs = multiSpace ? result.spaces.filter((space) => space.migrations.length > 0).map((space) => ({
 		graph: graphForSpace(space.space) ?? migrationGraphFromListEntries(space.migrations),
 		liveContractHash
@@ -1393,7 +1516,7 @@ function renderMigrationListWithStyle(result, style, glyphMode = "unicode", opti
 	for (let index = 0; index < result.spaces.length; index++) {
 		const space = result.spaces[index];
 		if (index > 0) lines.push("");
-		lines.push(...renderSpaceTreeBlock(space.space, space.migrations, multiSpace, glyphMode, style, colorize, liveContractHash, graphForSpace, globalMaxEdgeTreePrefixWidth, globalMaxDirNameWidth));
+		lines.push(...renderSpaceTreeBlock(space.space, space.migrations, multiSpace, glyphMode, style, colorize, liveContractHash, graphForSpace, appSpaceId, globalMaxEdgeTreePrefixWidth, globalMaxDirNameWidth));
 	}
 	if (result.spaces.reduce((count, space) => count + space.migrations.length, 0) > 0) {
 		lines.push("");
@@ -1410,7 +1533,7 @@ function styleMarkerName(name) {
 	return name === "contract" ? bold(green(name)) : green(name);
 }
 function plainMarkers(names) {
-	return `<${names.join(", ")}>`;
+	return names.map((name) => `@${name}`).join(" ");
 }
 function formatContractNodeOverlays(styler, markers, refs) {
 	const parts = [];
@@ -1444,8 +1567,8 @@ function styleRefName(name) {
 * - `glyph` (`→` / `⟲` / `∅`): dim
 * - `lane` (graph gutter lines `│` and fan/join connectors `├─┐` / `├─┘`): dim
 * - `invariants` (`{...}`): yellow
-* - `markers` (`<...>`): green; the `contract` desired-state marker inside is
-*   green-bold (`db` is plain green)
+* - `markers` (`@contract @db`): green; the `contract` desired-state marker is
+*   green-bold (`db` is plain green); the `@` sigil is applied to each name
 * - `refs` (`(...)`): green (the active ref is bolded separately by the tree styler)
 * - `spaceHeading` (`<spaceId>:`): bold
 * - `summary`: dim
@@ -1465,10 +1588,8 @@ function createAnsiMigrationListStyler(opts) {
 		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;
+			const sigil = green("@");
+			return names.map((name) => sigil + styleMarkerName(name)).join(" ");
 		},
 		refs: (names) => {
 			const open = green("(");
@@ -1560,12 +1681,71 @@ function arrowForEdgeKind(kind, palette) {
 	return palette.edgeArrow[kind];
 }
 /**
-* 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.
+* Forced-color functions that always emit ANSI regardless of the ambient TTY
+* environment (NO_COLOR, piped output). Used for:
+*
+* - `forcedBold`: branch-coloured migration names pair their lane hue with bold;
+*   both must emit so the name is deterministically bold + hue.
+* - `forcedDim`: off-path path-highlight override (migrate --show).
+*   The renderer gates this behind `opts.colorize`; the forced variant ensures
+*   ANSI is emitted in controlled environments (e.g. tests with `NO_COLOR=1`)
+*   when the caller explicitly requests colour. Without forcing, `dim()` from
+*   the ambient module-level import no-ops under NO_COLOR, making the
+*   path-highlight unreachable in tests.
 */
-const { bold: forcedBold } = createColors({ useColor: true });
+const { bold: forcedBold, dim: forcedDim, greenBright: forcedGreen } = createColors({ useColor: true });
+/**
+* The two styles used in `migrate --show` path-highlight mode.
+*
+* In path-highlight mode the normal by-branch rotating-colour logic
+* (`LANE_COLOR_CYCLE` / `laneStylerForColumn`) is suppressed entirely.
+* Every glyph, name, and hash is styled by its on-path / off-path role,
+* never by lane column index.
+*
+* - `onPath`: neutral single-path style — exactly how a linear (no-branch)
+*   section renders today. Lane glyphs are dim, names are bold, hashes use
+*   the default `sourceHash`/`destHash` colours. No rotation hue is applied.
+*   This is identical to how the pgvector single-path section renders.
+* - `offPath`: uniform dim grey on every cell (name, hashes, lane glyphs,
+*   direction arrows).
+*
+* To change the on-path or off-path colour in future, edit this object only.
+*/
+const PATH_HIGHLIGHT_STYLES = {
+	/**
+	* Lane/glyph/arrow stylers for on-path cells.
+	*
+	* - lane: `forcedGreen` when colour is on — bright green so the on-path
+	*   branch glyphs (`│ ├ ╯ ↑`) and node markers (`○`/`∅`) are visually
+	*   distinct from off-path (dim grey). Uses forced ANSI so it survives
+	*   NO_COLOR in tests. Identity when `colorize` is false.
+	* - arrow: identity (plain, no colouring)
+	* - dirName: `bold` (ambient bold — name stays white/bold, not green)
+	* - hashOverride: undefined — `style.sourceHash`/`style.destHash` apply
+	*   normally (cyan) so hashes keep their existing neutral colour.
+	*
+	* `style` is the same `MigrationListStyler` the tree renderer uses.
+	* Rotation (`LANE_COLOR_CYCLE`) is never applied to on-path cells.
+	*/
+	onPath: (_style, colorize) => ({
+		lane: colorize ? forcedGreen : (text) => text,
+		arrow: (text) => text,
+		dirName: (text) => bold(text),
+		hashOverride: void 0
+	}),
+	/**
+	* Lane/glyph/arrow/hash stylers for off-path cells.
+	* Uniform dim grey on everything — uses `forcedDim` so ANSI is emitted even
+	* under NO_COLOR (test environments use `colorize:true` + NO_COLOR=1 to verify dim).
+	* Returns identity functions when colour is off (`colorize: false`).
+	*/
+	offPath: (colorize) => ({
+		lane: colorize ? forcedDim : (text) => text,
+		arrow: colorize ? forcedDim : (text) => text,
+		dirName: colorize ? forcedDim : (text) => text,
+		hashOverride: colorize ? forcedDim : void 0
+	})
+};
 function laneStylerForColumn(colorColumn, colorize, style) {
 	return stylerForLaneColumn(colorColumn, colorize, style.lane);
 }
@@ -1605,24 +1785,30 @@ function renderConnectorTee(pair, glyphColumn, dashColumn, colorize, style) {
 * marker takes its own lane's hue (so each node visibly belongs to its branch);
 * the connector follows the arc it belongs to (its owning back-lane hue).
 * Direction arrows are handled elsewhere — they take their edge's lane hue too.
+*
+* When `laneOverride` is provided (for path-highlight rows), it replaces the
+* marker styler. `arcLaneOverride` (if provided) replaces the connector styler
+* independently — this matters when the node is on-path but the arc belongs to
+* an off-path rollback edge, which must render dim rather than green.
 */
-function renderNodeMarkerPair(pair, nodeColumn, arcColumn, colorize, style) {
-	const marker = laneStylerForColumn(nodeColumn, colorize, style);
-	const connector = laneStylerForColumn(arcColumn, colorize, style);
+function renderNodeMarkerPair(pair, nodeColumn, arcColumn, colorize, style, laneOverride, arcLaneOverride) {
+	const marker = laneOverride ?? laneStylerForColumn(nodeColumn, colorize, style);
+	const connector = arcLaneOverride ?? laneOverride ?? laneStylerForColumn(arcColumn, colorize, style);
 	return marker(pair.slice(0, 1)) + connector(pair.slice(1));
 }
-function renderCellPair(cell, column, colors, colorize, style, palette) {
+function renderCellPair(cell, column, colors, colorize, style, palette, laneOverride, arrowOverride, arcLaneOverride) {
 	const laneColumn = colors.lane[column] ?? column;
-	const lane = laneStylerForColumn(laneColumn, colorize, style);
+	const lane = laneOverride ?? laneStylerForColumn(laneColumn, colorize, style);
+	const arrow = arrowOverride ?? ((text) => branchStylerOrDefault(column, colorize, style.kind)(text));
 	switch (cell.kind) {
 		case "node": {
 			const arcColumn = colors.connector[column] ?? 0;
-			if (cell.arcLand === true) return renderNodeMarkerPair(palette.arcLand, column, arcColumn, colorize, style);
-			if (cell.arcTee === true) return renderNodeMarkerPair(palette.arcTee, column, arcColumn, colorize, style);
+			if (cell.arcLand === true) return renderNodeMarkerPair(palette.arcLand, column, arcColumn, colorize, style, laneOverride, arcLaneOverride);
+			if (cell.arcTee === true) return renderNodeMarkerPair(palette.arcTee, column, arcColumn, colorize, style, laneOverride, arcLaneOverride);
 			return lane(palette.node);
 		}
 		case "vertical-pass": return lane(palette.verticalPass);
-		case "edge-lane": return cell.ownsLabel ? lane(palette.verticalPass.trimEnd()) + branchStylerOrDefault(column, colorize, style.kind)(arrowForEdgeKind(cell.edgeKind, palette)) : lane(palette.verticalPass);
+		case "edge-lane": return cell.ownsLabel ? lane(palette.verticalPass.trimEnd()) + arrow(arrowForEdgeKind(cell.edgeKind, palette)) : lane(palette.verticalPass);
 		case "branch-tee": return lane(palette.branchTee);
 		case "merge-tee": return lane(palette.mergeTee);
 		case "branch-corner": return lane(palette.branchCorner);
@@ -1630,14 +1816,26 @@ function renderCellPair(cell, column, colors, colorize, style, palette) {
 		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-land-tee": return laneOverride !== void 0 ? laneOverride(palette.arcLandTee) : renderConnectorTee(palette.arcLandTee, laneColumn, colors.dash[column] ?? laneColumn, colorize, style);
 		case "arc-crossing": return lane(palette.arcLandBridge);
 		case "arc-land-bridge": return lane(palette.arcLandBridge);
 		case "horizontal-pass": return lane(palette.horizontalPass);
 		case "empty": return "  ";
 	}
 }
-function renderConnectorRow(row, gridWidth, colorize, style, palette) {
+/**
+* Render a branch-connector or merge-connector row.
+*
+* `columnLaneOverride` is an optional per-column map populated when path-highlight
+* annotations are active (`migrate --show`). For each column in the connector's
+* lane range, the map supplies the override styler (dim for off-path) that should
+* replace the normal rotating-lane colour for that column. Columns absent from the
+* map (on-path or unannotated) use the standard `laneStylerForColumn` logic unchanged.
+* This ensures off-path branch connectors appear dim rather than in their rotation
+* colour (e.g. magenta).
+*/
+function renderConnectorRow(row, gridWidth, colorize, style, palette, columnLaneOverride) {
+	const resolvedLane = (column) => columnLaneOverride?.get(column) ?? laneStylerForColumn(column, colorize, style);
 	const isMerge = row.kind === "merge-connector";
 	if (row.cells.length > 0) {
 		const colors = resolveConnectorLaneColors(row.cells, row.startLane ?? 0);
@@ -1648,6 +1846,43 @@ function renderConnectorRow(row, gridWidth, colorize, style, palette) {
 			if (cell === void 0) continue;
 			const glyphColumn = colors.glyph[column] ?? column;
 			const dashColumn = colors.dash[column] ?? glyphColumn;
+			const override = columnLaneOverride?.get(glyphColumn);
+			const dashOverrideForPathHighlight = columnLaneOverride?.get(dashColumn) ?? override;
+			if (override !== void 0 || columnLaneOverride !== void 0 && dashOverrideForPathHighlight !== void 0) {
+				const effectiveOverride = override ?? dashOverrideForPathHighlight;
+				if (effectiveOverride === void 0) {
+					out += "  ";
+					continue;
+				}
+				switch (cell.kind) {
+					case "branch-tee":
+					case "merge-tee": {
+						const pair = seenTee ? palette.connectorBranchTeeCo : palette.connectorBranchTee;
+						out += effectiveOverride(pair.slice(0, 1)) + effectiveOverride(pair.slice(1));
+						seenTee = true;
+						break;
+					}
+					case "branch-corner":
+						out += effectiveOverride(palette.branchCorner);
+						break;
+					case "merge-corner":
+						out += effectiveOverride(palette.mergeCorner);
+						break;
+					case "vertical-pass":
+						out += effectiveOverride(palette.verticalPass);
+						break;
+					case "horizontal-pass":
+						out += effectiveOverride(palette.horizontalPass);
+						break;
+					case "arc-crossing": {
+						const arcCrossingDashOverride = columnLaneOverride?.get(dashColumn) ?? effectiveOverride;
+						out += effectiveOverride(palette.arcCrossing.slice(0, 1)) + arcCrossingDashOverride(palette.arcCrossing.slice(1));
+						break;
+					}
+					default: out += "  ";
+				}
+				continue;
+			}
 			const lane = laneStylerForColumn(glyphColumn, colorize, style);
 			switch (cell.kind) {
 				case "branch-tee":
@@ -1681,7 +1916,7 @@ function renderConnectorRow(row, gridWidth, colorize, style, palette) {
 	}
 	const start = row.startLane ?? 0;
 	const end = row.endLane ?? start;
-	const runLane = laneStylerForColumn(end, colorize, style);
+	const runLane = resolvedLane(end);
 	let out = "";
 	for (let column = 0; column < gridWidth; column++) if (column < start || column > end) out += "  ";
 	else if (column === start) out += runLane(palette.connectorBranchTee);
@@ -1699,7 +1934,7 @@ function overlayNamesForContract(contractHash, opts) {
 	const refs = [];
 	const userRefs = opts.refsByHash?.get(contractHash);
 	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.isAppSpace !== false && opts.contractHash === contractHash && contractHash !== EMPTY_CONTRACT_HASH) markers.push(CONTRACT_MARKER_NAME);
 	if (opts.dbHash === contractHash) markers.push(DB_MARKER_NAME);
 	markers.sort((a, b) => {
 		if (a === "contract") return -1;
@@ -1726,6 +1961,7 @@ function createTreeStyler(opts) {
 function formatEdgeAnnotationSuffix(migrationHash, opts, style) {
 	const annotation = opts.edgeAnnotationsByHash?.get(migrationHash);
 	if (annotation === void 0) return "";
+	const isOffPath = annotation.pathHighlight === "off-path";
 	const segments = [];
 	if (annotation.operationCount !== void 0) segments.push(`${annotation.operationCount} ops`);
 	if (annotation.invariants !== void 0 && annotation.invariants.length > 0) segments.push(style.invariants(annotation.invariants));
@@ -1740,15 +1976,31 @@ function formatEdgeAnnotationSuffix(migrationHash, opts, style) {
 			segments.push(styler(`${glyph} ${label}`));
 		}
 	}
+	if (annotation.pathHighlight === "on-path") {
+		const glyph = opts.glyphMode === "ascii" ? ">" : "↑";
+		segments.push(`${glyph} will run`);
+	}
 	if (segments.length === 0) return "";
-	return `  ${segments.join("  ")}`;
+	const suffix = `  ${segments.join("  ")}`;
+	return opts.colorize && isOffPath ? forcedDim(suffix) : suffix;
 }
-function formatEdgeHashColumn(edge, style, hashLength, palette) {
+/**
+* Format the `from → to` hash data column for an edge row.
+*
+* When `hashOverride` is provided (off-path → `dim`), it replaces ALL sub-stylers
+* (`sourceHash`, `destHash`, arrow `glyph`) so dim reaches every character without
+* inner ANSI codes (e.g. the dim+cyan of `sourceHash`) overriding it. On-path edges
+* carry no override. Without an override, the normal `style` sub-stylers apply.
+*/
+function formatEdgeHashColumn(edge, style, hashLength, palette, hashOverride) {
+	const src = hashOverride ?? style.sourceHash;
+	const dst = hashOverride ?? style.destHash;
+	const glyph = hashOverride ?? style.glyph;
 	if (edge.kind === "self") {
 		const hash = abbreviateHash(edge.from, hashLength, palette.emptySource);
-		return `${padFromHashColumn(style.sourceHash(hash), hashLength)} ${style.glyph(palette.forwardArrow)} ${style.destHash(hash)}`;
+		return `${padFromHashColumn(src(hash), hashLength)} ${glyph(palette.forwardArrow)} ${dst(hash)}`;
 	}
-	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))}`;
+	return `${edge.from === EMPTY_CONTRACT_HASH ? padFromHashColumn(glyph(palette.emptySource), hashLength) : padFromHashColumn(src(abbreviateHash(edge.from, hashLength, palette.emptySource)), hashLength)} ${glyph(palette.forwardArrow)} ${dst(abbreviateHash(edge.to, hashLength, palette.emptySource))}`;
 }
 function padVisible(text, targetWidth) {
 	const padding = Math.max(0, targetWidth - stringWidth(text));
@@ -1807,6 +2059,60 @@ function renderMigrationGraphTree(model, opts) {
 	const effectiveMaxDirNameLen = opts.globalMaxDirNameWidth ?? maxDirNameLen;
 	const maxEdgePrefixWidth = opts.globalMaxEdgeTreePrefixWidth ?? maxEdgeTreePrefixWidth(model.rows, wideLabelColumn);
 	const edgeDirNameWidth = rowDirNameWidth(maxEdgePrefixWidth, effectiveMaxDirNameLen, dirNameGap);
+	const contractHighlights = /* @__PURE__ */ new Map();
+	if (opts.edgeAnnotationsByHash) for (const row of model.rows) {
+		if (row.kind !== "edge" || row.edge === void 0) continue;
+		const annotation = opts.edgeAnnotationsByHash.get(row.edge.migrationHash);
+		if (annotation?.pathHighlight === void 0) continue;
+		const highlight = annotation.pathHighlight;
+		for (const hash of [row.edge.from, row.edge.to]) {
+			if (hash === EMPTY_CONTRACT_HASH) continue;
+			if (contractHighlights.get(hash) !== "on-path") contractHighlights.set(hash, highlight);
+		}
+	}
+	const pathHighlightActive = opts.edgeAnnotationsByHash !== void 0;
+	/**
+	* Resolve the lane and arrow overrides for a row in path-highlight mode.
+	* - on-path → neutral single-path style (style.lane for glyphs, plain arrow, bold name).
+	*   Rotation colour is suppressed; `style.sourceHash`/`style.destHash` apply for hashes.
+	* - off-path → uniform dim grey (forcedDim) on every glyph, arrow, name, and hash.
+	* - undefined → `undefined` (no override). Unannotated rows use normal rotation. This covers
+	*   both non-path-highlight commands (graph/status/list) and any annotation without pathHighlight.
+	* - When pathHighlightActive is false: always returns undefined, preserving normal rotation.
+	*/
+	function pathStyleForHighlight(highlight) {
+		if (!pathHighlightActive || highlight === void 0) return void 0;
+		if (highlight === "off-path") {
+			const s = PATH_HIGHLIGHT_STYLES.offPath(opts.colorize);
+			return {
+				lane: s.lane,
+				arrow: s.arrow,
+				dirName: s.dirName,
+				hashOverride: s.hashOverride
+			};
+		}
+		const s = PATH_HIGHLIGHT_STYLES.onPath(style, opts.colorize);
+		return {
+			lane: s.lane,
+			arrow: s.arrow,
+			dirName: s.dirName,
+			hashOverride: s.hashOverride
+		};
+	}
+	/**
+	* Lane override for a given highlight in path-highlight mode.
+	* Returns the `lane` part only — used for per-cell overrides.
+	*/
+	function pathLaneFor(highlight) {
+		return pathStyleForHighlight(highlight)?.lane;
+	}
+	/**
+	* Arrow override for a given highlight in path-highlight mode.
+	* Returns the `arrow` part only — used for edge-lane cell arrow rendering.
+	*/
+	function pathArrowFor(highlight) {
+		return pathStyleForHighlight(highlight)?.arrow;
+	}
 	const lines = [];
 	for (let rowIndex = 0; rowIndex < model.rows.length; rowIndex++) {
 		const row = model.rows[rowIndex];
@@ -1816,11 +2122,58 @@ function renderMigrationGraphTree(model, opts) {
 			continue;
 		}
 		if (row.kind === "branch-connector" || row.kind === "merge-connector") {
-			lines.push(trimTrailingWhitespace(renderConnectorRow(row, gridWidth, opts.colorize, style, palette)));
+			let connectorColumnOverride;
+			if (pathHighlightActive && opts.colorize) {
+				connectorColumnOverride = /* @__PURE__ */ new Map();
+				for (let col = 0; col < row.cells.length; col++) {
+					const cell = row.cells[col];
+					if (cell === void 0 || cell.kind === "empty") continue;
+					const hashForCell = "migrationHash" in cell && cell.migrationHash !== void 0 ? cell.migrationHash : void 0;
+					if (hashForCell === void 0) continue;
+					const highlight = opts.edgeAnnotationsByHash?.get(hashForCell)?.pathHighlight;
+					const override = pathLaneFor(highlight);
+					if (override !== void 0) connectorColumnOverride.set(col, override);
+				}
+				if (connectorColumnOverride.size === 0) connectorColumnOverride = void 0;
+			}
+			lines.push(trimTrailingWhitespace(renderConnectorRow(row, gridWidth, opts.colorize, style, palette, connectorColumnOverride)));
 			continue;
 		}
+		let rowPathHighlight;
+		if (row.kind === "edge" && row.edge !== void 0) rowPathHighlight = opts.edgeAnnotationsByHash?.get(row.edge.migrationHash)?.pathHighlight;
+		else if (row.kind === "node" && row.contractHash !== void 0) rowPathHighlight = contractHighlights.get(row.contractHash);
+		const rowStyle = pathStyleForHighlight(rowPathHighlight);
+		const rowLaneOverride = rowStyle?.lane;
+		const rowArrowOverride = rowStyle?.arrow;
 		const cellColors = resolveRowArcLaneColors(row.cells);
-		let gutter = row.cells.map((cell, column) => renderCellPair(cell, column, cellColors, opts.colorize, style, palette)).join("");
+		let gutter = row.cells.map((cell, column) => {
+			let laneOverride = rowLaneOverride;
+			let arrowOverride = rowArrowOverride;
+			let arcLaneOverride;
+			if (pathHighlightActive) {
+				if (cell.kind === "edge-lane") {
+					const cellHighlight = opts.edgeAnnotationsByHash?.get(cell.migrationHash)?.pathHighlight;
+					laneOverride = pathLaneFor(cellHighlight);
+					arrowOverride = pathArrowFor(cellHighlight);
+				} else if (cell.kind === "node" && (cell.arcTee === true || cell.arcLand === true)) {
+					const arcColumn = cellColors.connector[column] ?? 0;
+					const arcCell = row.cells[arcColumn];
+					const arcHash = arcCell !== void 0 && "migrationHash" in arcCell ? arcCell.migrationHash : void 0;
+					if (arcHash !== void 0) {
+						const arcHighlight = opts.edgeAnnotationsByHash?.get(arcHash)?.pathHighlight;
+						arcLaneOverride = pathLaneFor(arcHighlight);
+					}
+				} else if (cell.kind !== "node" && cell.kind !== "empty") {
+					const hashForCell = cell.kind === "arc-crossing" && "arcMigrationHash" in cell && cell.arcMigrationHash !== void 0 ? cell.arcMigrationHash : "migrationHash" in cell && cell.migrationHash !== void 0 ? cell.migrationHash : void 0;
+					if (hashForCell !== void 0) {
+						const cellHighlight = opts.edgeAnnotationsByHash?.get(hashForCell)?.pathHighlight;
+						laneOverride = pathLaneFor(cellHighlight);
+						arrowOverride = pathArrowFor(cellHighlight);
+					}
+				}
+			}
+			return renderCellPair(cell, column, cellColors, opts.colorize, style, palette, laneOverride, arrowOverride, arcLaneOverride);
+		}).join("");
 		let laneSpan = row.cells.length;
 		if (row.kind === "node") if ((row.contractHash ?? EMPTY_CONTRACT_HASH) === EMPTY_CONTRACT_HASH) laneSpan = 1;
 		else {
@@ -1832,15 +2185,39 @@ function renderMigrationGraphTree(model, opts) {
 			laneSpan = lastActiveColumn >= 0 ? lastActiveColumn + 1 : 1;
 		}
 		const labelColumn = row.kind === "edge" ? maxEdgePrefixWidth : wideLabelColumn !== void 0 && (nodeHasArcDecoration(row) || row.contractHash !== void 0) ? wideLabelColumn : laneSpan * 2 + LABEL_GAP;
-		if (row.kind === "edge" && row.edge?.from === EMPTY_CONTRACT_HASH && (row.laneIndex ?? 0) === 0) gutter = row.cells.slice(0, 1).map((cell, column) => renderCellPair(cell, column, cellColors, opts.colorize, style, palette)).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("");
+		if (row.kind === "edge" && row.edge?.from === EMPTY_CONTRACT_HASH && (row.laneIndex ?? 0) === 0) gutter = row.cells.slice(0, 1).map((cell, column) => renderCellPair(cell, column, cellColors, opts.colorize, style, palette, rowLaneOverride, rowArrowOverride)).join("");
+		else if (row.kind === "node" && laneSpan < row.cells.length && !nodeHasArcDecoration(row)) gutter = row.cells.slice(0, laneSpan).map((cell, column) => {
+			let cellLaneOverride = rowLaneOverride;
+			let cellArrowOverride = rowArrowOverride;
+			if (pathHighlightActive && cell.kind !== "node" && cell.kind !== "empty") {
+				const hashForCell = cell.kind === "arc-crossing" && "arcMigrationHash" in cell && cell.arcMigrationHash !== void 0 ? cell.arcMigrationHash : "migrationHash" in cell && cell.migrationHash !== void 0 ? cell.migrationHash : void 0;
+				if (hashForCell !== void 0) {
+					const cellHighlight = opts.edgeAnnotationsByHash?.get(hashForCell)?.pathHighlight;
+					cellLaneOverride = pathLaneFor(cellHighlight);
+					cellArrowOverride = pathArrowFor(cellHighlight);
+				}
+			}
+			return renderCellPair(cell, column, cellColors, opts.colorize, style, palette, cellLaneOverride, cellArrowOverride);
+		}).join("");
 		else if (gutter.length < laneSpan * 2) gutter = gutter.padEnd(laneSpan * 2, " ");
 		const dirNameWidth = row.kind === "edge" ? edgeDirNameWidth : rowDirNameWidth(labelColumn, maxDirNameLen, dirNameGap);
 		const gutterPad = padVisible(gutter, labelColumn);
 		if (row.kind === "node") {
 			const contractHash = row.contractHash ?? EMPTY_CONTRACT_HASH;
 			if (contractHash === EMPTY_CONTRACT_HASH) {
-				const trailingLanes = row.cells.slice(1).map((cell, offset) => renderCellPair(cell, offset + 1, cellColors, opts.colorize, style, palette)).join("");
+				const trailingLanes = row.cells.slice(1).map((cell, offset) => {
+					let cellLaneOverride = rowLaneOverride;
+					let cellArrowOverride = rowArrowOverride;
+					if (pathHighlightActive && cell.kind !== "node" && cell.kind !== "empty") {
+						const hashForCell = cell.kind === "arc-crossing" && "arcMigrationHash" in cell && cell.arcMigrationHash !== void 0 ? cell.arcMigrationHash : "migrationHash" in cell && cell.migrationHash !== void 0 ? cell.migrationHash : void 0;
+						if (hashForCell !== void 0) {
+							const cellHighlight = opts.edgeAnnotationsByHash?.get(hashForCell)?.pathHighlight;
+							cellLaneOverride = pathLaneFor(cellHighlight);
+							cellArrowOverride = pathArrowFor(cellHighlight);
+						}
+					}
+					return renderCellPair(cell, offset + 1, cellColors, opts.colorize, style, palette, cellLaneOverride, cellArrowOverride);
+				}).join("");
 				const emptyGutter = palette.emptySource.padEnd(2, " ") + trailingLanes;
 				const overlays = overlayNamesForContract(contractHash, opts);
 				if (overlays.markers.length === 0 && overlays.refs.length === 0) {
@@ -1851,7 +2228,7 @@ function renderMigrationGraphTree(model, opts) {
 				lines.push(trimTrailingWhitespace(`${emptyGutter}${" ".repeat(LABEL_GAP)}${overlay}`));
 				continue;
 			}
-			const hashText = style.sourceHash(abbreviateHash(contractHash, hashLength, palette.emptySource));
+			const hashText = (rowStyle?.hashOverride ?? style.sourceHash)(abbreviateHash(contractHash, hashLength, palette.emptySource));
 			const overlays = overlayNamesForContract(contractHash, opts);
 			const hasOverlays = overlays.markers.length > 0 || overlays.refs.length > 0;
 			const overlayPad = hasOverlays ? " ".repeat(LABEL_GAP) : "";
@@ -1863,19 +2240,44 @@ 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 > 0 ? (text) => forcedBold(laneColorForColumn(laneIndex)(text)) : style.dirName)(edge.dirName)}${dirNamePadding}`;
-		const hashColumn = formatEdgeHashColumn(edge, style, hashLength, palette);
+		const edgeGutterPad = padVisible(gutter, labelColumn);
+		let dirName;
+		if (rowStyle !== void 0) dirName = `${(rowStyle.dirName ?? style.dirName)(edge.dirName)}${dirNamePadding}`;
+		else dirName = `${(opts.colorize && laneIndex > 0 ? (text) => forcedBold(laneColorForColumn(laneIndex)(text)) : style.dirName)(edge.dirName)}${dirNamePadding}`;
+		const hashColumnOverride = rowStyle?.hashOverride;
+		const hashColumn = formatEdgeHashColumn(edge, style, hashLength, palette, hashColumnOverride);
 		const annotationSuffix = formatEdgeAnnotationSuffix(edge.migrationHash, opts, style);
-		lines.push(trimTrailingWhitespace(`${gutterPad}${dirName}${hashColumn}${annotationSuffix}`));
+		lines.push(trimTrailingWhitespace(`${edgeGutterPad}${dirName}${hashColumn}${annotationSuffix}`));
 	}
 	return lines.join("\n");
 }
+/**
+* Format a single on-path migration row for the `migrate --show` run-list.
+*
+* Uses the SAME styling as the tree renderer's on-path rows (PATH_HIGHLIGHT_STYLES.onPath)
+* so the run-list and graph tree are byte-for-byte identical in their name/hash columns.
+* The gutter is omitted — the list has no graph structure.
+*
+* This is the SINGLE code path for on-path row styling shared by both the graph tree
+* and the "Will run, in order:" list. To change the on-path colour, edit PATH_HIGHLIGHT_STYLES.
+*/
+function formatOnPathMigrationRow(dirName, from, to, dirNameWidth, colorize, glyphMode) {
+	const palette = paletteFor(glyphMode);
+	const style = createAnsiMigrationListStyler({ useColor: colorize });
+	const styledDirName = `${PATH_HIGHLIGHT_STYLES.onPath(style, colorize).dirName(dirName)}${" ".repeat(Math.max(0, dirNameWidth - dirName.length))}`;
+	const hashLength = 7;
+	const emptySource = palette.emptySource;
+	const fromAbbr = from === EMPTY_CONTRACT_HASH ? padFromHashColumn(style.glyph(emptySource), hashLength) : padFromHashColumn(style.sourceHash(abbreviateHashShort(from, hashLength)), hashLength);
+	const toAbbr = to === EMPTY_CONTRACT_HASH ? style.glyph(emptySource) : style.destHash(abbreviateHashShort(to, hashLength));
+	return `${styledDirName}  ${fromAbbr} ${style.glyph(palette.forwardArrow)} ${toAbbr}`;
+}
+function abbreviateHashShort(hash, length) {
+	return (hash.startsWith("sha256:") ? hash.slice(7) : hash).slice(0, length);
+}
 function formatLegendExampleMarkers(colorize) {
-	if (!colorize) return "<contract, db>";
-	const open = green("<");
-	const close = green(">");
-	const separator = green(", ");
-	return open + green("contract") + separator + green("db") + close;
+	if (!colorize) return "@contract @db";
+	const sigil = green("@");
+	return `${sigil + bold(green("contract"))} ${sigil}${green("db")}`;
 }
 /**
 * A compact key for the tree visual language: the contract node glyph, the
@@ -1903,7 +2305,7 @@ function renderMigrationGraphLegend(opts) {
 		`  ${style.kind(palette.edgeArrow.self)} ${style.summary("migration without schema change")}`,
 		appliedPending,
 		`  ${style.kind(palette.emptySource)} ${style.summary("empty database (baseline)")}`,
-		`  ${exampleMarkers} ${style.summary("live markers (contract on disk, database state)")}`,
+		`  ${exampleMarkers} ${style.summary("reserved markers — also typeable as --from/--to tokens")}`,
 		`  ${exampleRefs} ${style.summary("user-defined refs")}`,
 		`  ${sampleArrow}   ${style.summary("migration from contract aaaaaa to bbbbbb")}`
 	].join("\n");
@@ -1938,12 +2340,14 @@ function computeGlobalMaxDirNameWidth(inputs) {
 	return globalMax;
 }
 function renderMigrationGraphSpaceTreeInternal(input) {
-	const layout = buildMigrationGraphLayout(buildMigrationGraphRows(input.graph, { contractHash: input.liveContractHash }));
+	const appSpace = input.isAppSpace !== false;
+	const layout = buildMigrationGraphLayout(buildMigrationGraphRows(input.graph, { ...appSpace ? { contractHash: input.liveContractHash } : {} }));
 	const listOverlay = buildEdgeAnnotationsByHashFromListEntries(input.migrations);
 	const edgeAnnotationsByHash = input.statusOverlayByHash === void 0 ? listOverlay : mergeMigrationEdgeAnnotations(listOverlay, input.statusOverlayByHash);
 	return renderMigrationGraphTree(layout, {
 		refsByHash: input.refsByHash ?? buildRefsByHashFromListEntries(input.migrations),
 		contractHash: input.liveContractHash,
+		isAppSpace: appSpace,
 		edgeAnnotationsByHash,
 		colorize: input.colorize,
 		glyphMode: input.glyphMode,
@@ -1961,6 +2365,6 @@ function indentMigrationGraphTreeBlock(treeOutput, indent) {
 	return treeOutput.split("\n").map((line) => line.length === 0 ? line : `${indent}${line}`).join("\n");
 }
 //#endregion
-export { renderMigrationGraphLegend as a, renderMigrationListWithStyle as c, migrationListForwardArrow as d, renderMigrationGraphSpaceTree as i, abbreviateContractHash as l, computeGlobalMaxEdgeTreePrefixWidth as n, createAnsiMigrationListStyler as o, indentMigrationGraphTreeBlock as r, IDENTITY_MIGRATION_LIST_STYLER as s, computeGlobalMaxDirNameWidth as t, migrationListEmptySource as u };
+export { buildMigrationGraphLayout as _, computeMaxDirNameLengthForLayout as a, renderMigrationGraphLegend as c, IDENTITY_MIGRATION_LIST_STYLER as d, renderMigrationListWithStyle as f, buildMigrationGraphRows as g, migrationListForwardArrow as h, renderMigrationGraphSpaceTree as i, renderMigrationGraphTree as l, migrationListEmptySource as m, computeGlobalMaxEdgeTreePrefixWidth as n, computeMaxEdgeTreePrefixWidthForLayout as o, abbreviateContractHash as p, indentMigrationGraphTreeBlock as r, formatOnPathMigrationRow as s, computeGlobalMaxDirNameWidth as t, createAnsiMigrationListStyler as u };
 
-//# sourceMappingURL=migration-graph-space-render-CeNXh_Wy.mjs.map
+//# sourceMappingURL=migration-graph-space-render-B0HkTNj3.mjs.map