@prisma-next/cli 0.3.0-dev.11 → 0.3.0-dev.114

package/dist/migration-status-B7OVZ-Ka.mjs

@@ -0,0 +1,1576 @@
+import { t as loadConfig } from "./config-loader-d_KF19Tw.mjs";
+import { _ as errorUnexpected, m as errorRuntime } from "./cli-errors-ByGuoqNj.mjs";
+import { t as createControlClient } from "./client-612RJJD_.mjs";
+import { c as readContractEnvelope, f as setCommandDescriptions, g as parseGlobalFlags, h as toPathDecisionResult, i as addGlobalOptions, o as loadMigrationBundles, p as setCommandExamples, r as handleResult, s as maskConnectionUrl, t as TerminalUI, u as resolveMigrationPaths, y as formatStyledHeader } from "./terminal-ui-DAcMBRKf.mjs";
+import { Command } from "commander";
+import { notOk, ok } from "@prisma-next/utils/result";
+import { ifDefined } from "@prisma-next/utils/defined";
+import { EMPTY_CONTRACT_HASH } from "@prisma-next/core-control-plane/constants";
+import { findPath, findPathWithDecision, findReachableLeaves } from "@prisma-next/migration-tools/dag";
+import { MigrationToolsError } from "@prisma-next/migration-tools/types";
+import { bold, cyan, dim, magenta, yellow } from "colorette";
+import { readRefs, resolveRef } from "@prisma-next/migration-tools/refs";
+import dagre from "@dagrejs/dagre";
+
+//#region src/utils/formatters/graph-types.ts
+/**
+* Immutable directed graph with adjacency-list indexing.
+*
+* Built once from flat arrays of nodes and edges, then passed around as
+* the primary graph representation for rendering, traversal, truncation,
+* and subgraph extraction.
+*/
+var RenderGraph = class {
+	nodes;
+	edges;
+	/** Forward adjacency: node id → outgoing edges. */
+	forward;
+	/** Set of node ids that have at least one incoming edge. */
+	incomingNodes;
+	/** Node lookup by id. */
+	nodeById;
+	constructor(nodes, edges) {
+		this.nodes = nodes;
+		this.edges = edges;
+		const fwd = /* @__PURE__ */ new Map();
+		const inc = /* @__PURE__ */ new Set();
+		const byId = /* @__PURE__ */ new Map();
+		for (const n of nodes) byId.set(n.id, n);
+		for (const e of edges) {
+			const list = fwd.get(e.from);
+			if (list) list.push(e);
+			else fwd.set(e.from, [e]);
+			inc.add(e.to);
+		}
+		this.forward = fwd;
+		this.incomingNodes = inc;
+		this.nodeById = byId;
+	}
+	/** Outgoing edges from a node (empty array if none). */
+	outgoing(nodeId) {
+		return this.forward.get(nodeId) ?? [];
+	}
+};
+
+//#endregion
+//#region src/utils/formatters/graph-migration-mapper.ts
+/**
+* Maps MigrationGraph + status info to the generic graph renderer types.
+*/
+const STATUS_ICON = {
+	applied: " ✓",
+	pending: " ⧗",
+	unreachable: " ✗"
+};
+/** Shorten a contract hash for display: strip sha256: prefix, take 7 chars. */
+function shortHash(hash) {
+	return (hash.startsWith("sha256:") ? hash.slice(7) : hash).slice(0, 7);
+}
+function toShortId(hash) {
+	return hash === EMPTY_CONTRACT_HASH ? "∅" : shortHash(hash);
+}
+/**
+* Convert a MigrationGraph + status info into the generic graph renderer types.
+*/
+function migrationGraphToRenderInput(input) {
+	const { graph, mode, markerHash, contractHash, refs, activeRefHash, edgeStatuses } = input;
+	const statusByDirName = new Map(edgeStatuses?.map((e) => [e.dirName, e.status]));
+	const nodeList = [];
+	for (const nodeId of graph.nodes) {
+		const markers = [];
+		if (mode === "online" && markerHash === nodeId) markers.push({ kind: "db" });
+		if (refs) {
+			for (const ref of refs) if (ref.hash === nodeId) markers.push({
+				kind: "ref",
+				name: ref.name,
+				active: ref.active
+			});
+		}
+		if (contractHash === nodeId && contractHash !== EMPTY_CONTRACT_HASH) markers.push({
+			kind: "contract",
+			planned: true
+		});
+		nodeList.push({
+			id: toShortId(nodeId),
+			markers: markers.length > 0 ? markers : void 0
+		});
+	}
+	if (contractHash !== EMPTY_CONTRACT_HASH && !graph.nodes.has(contractHash)) {
+		const detachedMarkers = [];
+		if (mode === "online" && markerHash === contractHash) detachedMarkers.push({ kind: "db" });
+		detachedMarkers.push({
+			kind: "contract",
+			planned: false
+		});
+		nodeList.push({
+			id: shortHash(contractHash),
+			markers: detachedMarkers,
+			style: "detached"
+		});
+	}
+	const edgeList = [];
+	for (const [, entries] of graph.forwardChain) for (const entry of entries) {
+		const status = statusByDirName.get(entry.dirName);
+		const icon = status ? STATUS_ICON[status] : "";
+		const label = `${entry.dirName}${icon}`;
+		edgeList.push({
+			from: toShortId(entry.from),
+			to: toShortId(entry.to),
+			label,
+			...ifDefined("colorHint", status)
+		});
+	}
+	const relevantPaths = [];
+	const rootId = EMPTY_CONTRACT_HASH;
+	function addPathFromRoot(targetHash) {
+		if (!graph.nodes.has(targetHash)) return;
+		const raw = findPath(graph, rootId, targetHash);
+		if (raw && raw.length > 0) relevantPaths.push([toShortId(rootId), ...raw.map((e) => toShortId(e.to))]);
+	}
+	function addPathBetween(fromHash, toHash) {
+		if (!graph.nodes.has(fromHash) || !graph.nodes.has(toHash)) return;
+		const raw = findPath(graph, fromHash, toHash);
+		if (raw && raw.length > 0) relevantPaths.push([toShortId(fromHash), ...raw.map((e) => toShortId(e.to))]);
+	}
+	if (mode === "online" && markerHash) addPathFromRoot(markerHash);
+	if (activeRefHash && activeRefHash !== markerHash) addPathFromRoot(activeRefHash);
+	if (contractHash !== EMPTY_CONTRACT_HASH) {
+		let contractReached = false;
+		if (markerHash && markerHash !== contractHash) {
+			if (findPath(graph, markerHash, contractHash)) {
+				addPathBetween(markerHash, contractHash);
+				contractReached = true;
+			}
+		}
+		if (activeRefHash && activeRefHash !== markerHash && activeRefHash !== contractHash) {
+			if (findPath(graph, activeRefHash, contractHash)) {
+				addPathBetween(activeRefHash, contractHash);
+				contractReached = true;
+			}
+		}
+		if (!contractReached && contractHash !== (markerHash ?? activeRefHash)) addPathFromRoot(contractHash);
+	}
+	if (relevantPaths.length === 0) addPathFromRoot([...graph.forwardChain.values()].flat().pop()?.to ?? EMPTY_CONTRACT_HASH);
+	let spineTargetHash;
+	if (activeRefHash && graph.nodes.has(activeRefHash)) spineTargetHash = activeRefHash;
+	else if (contractHash !== EMPTY_CONTRACT_HASH && graph.nodes.has(contractHash)) spineTargetHash = contractHash;
+	else spineTargetHash = [...graph.forwardChain.values()].flat().pop()?.to ?? EMPTY_CONTRACT_HASH;
+	return {
+		graph: new RenderGraph(nodeList, edgeList),
+		options: {
+			spineTarget: toShortId(spineTargetHash),
+			rootId: "∅",
+			colorize: true
+		},
+		relevantPaths
+	};
+}
+
+//#endregion
+//#region src/utils/formatters/graph-render.ts
+/**
+* Terminal graph renderer.
+*
+* Renders directed graphs as ASCII/box-drawing art for terminal output. Uses
+* dagre for automatic layout (rank assignment + coordinate placement), then
+* stamps the result onto a {@link CharGrid} — a sparse character canvas that
+* resolves box-drawing junctions, color priority, and label placement.
+*
+* ## Rendering pipeline
+*
+* 1. **Layout** — dagre assigns (x, y) coordinates to nodes and polyline
+*    control points to edges. We use `rankdir: 'TB'` (top-to-bottom).
+* 2. **Orthogonalization** — dagre's polylines may contain diagonal segments.
+*    {@link selectBestVariant} resolves each diagonal into an L-shaped bend,
+*    enumerating all 2^N combinations and picking the variant with fewest
+*    corners and shortest total length.
+* 3. **Edge stamping** — orthogonal segments are stamped onto the CharGrid as
+*    directional bitmasks. The grid resolves overlapping directions into the
+*    correct box-drawing character (│, ─, ┌, ┼, etc.).
+* 4. **Label placement** — edge labels are placed adjacent to their polyline
+*    segments, preferring horizontal (branch-specific) segments over shared
+*    vertical trunks to avoid ambiguity.
+* 5. **Arrowheads** — ▾ ▴ ◂ ▸ placed one cell before the terminal point.
+* 6. **Node stamping** — `○ nodeId` with inline marker tags (db, contract,
+*    ref names).
+* 7. **Elided indicator** — when truncation is active, `┊ (N earlier
+*    migrations)` is stamped above the visible root.
+* 8. **Detached nodes** — rendered below the graph with `◇` and a dotted
+*    connector.
+*
+* ## Graph filtering
+*
+* The caller controls what graph is rendered: the full graph, or a subgraph
+* extracted via {@link extractRelevantSubgraph} (union of relevant paths).
+* The renderer itself is agnostic — it renders whatever graph it receives.
+*
+* Truncation is supported via `options.limit`.
+*
+* ## Color accessibility
+*
+* Uses a CVD-safe palette — no red/green contrast. Shape and icon always
+* carry meaning; color only reinforces.
+*/
+function segment(from, to) {
+	return {
+		from,
+		to
+	};
+}
+function isVertical(seg) {
+	return seg.from.x === seg.to.x;
+}
+function manhattanLength(seg) {
+	return Math.abs(seg.to.x - seg.from.x) + Math.abs(seg.to.y - seg.from.y);
+}
+/** Rotating palette for ref marker names, cycling through these for each ref. */
+const REF_COLORS = [
+	yellow,
+	magenta,
+	bold,
+	cyan
+];
+/** Build the color palette, respecting the `colorize` flag. When false, all color functions become identity. */
+function buildColors(colorize) {
+	const c = (fn) => colorize ? fn : (s) => s;
+	return {
+		spine: c(cyan),
+		branch: c(dim),
+		backward: c(magenta),
+		applied: c(cyan),
+		pending: c(yellow),
+		unreachable: c(magenta),
+		node: c(cyan),
+		label: c(dim),
+		marker: c(bold),
+		ref: (index) => c(REF_COLORS[index % REF_COLORS.length])
+	};
+}
+/** Map a `colorHint` value to its color function, or `undefined` for no hint. */
+function resolveHintColor(hint, colors) {
+	if (hint === "applied") return colors.applied;
+	if (hint === "pending") return colors.pending;
+	if (hint === "unreachable") return colors.unreachable;
+}
+/**
+* Edge drawing priorities — higher priority wins when edges overlap on the
+* same grid cell. Backward edges are drawn on top so rollback paths remain
+* visible over spine and branch edges.
+*/
+const PRIORITY = {
+	branch: 1,
+	spine: 2,
+	backward: 3
+};
+const DIR = {
+	up: 1,
+	down: 2,
+	left: 4,
+	right: 8
+};
+/** Arrow characters for edge termination (one cell before the target node). */
+const ARROW = {
+	up: "▴",
+	down: "▾",
+	left: "◂",
+	right: "▸"
+};
+/** Maps a direction bitmask to its box-drawing character. */
+const BOX_CHAR = {
+	0: " ",
+	[DIR.up]: "│",
+	[DIR.down]: "│",
+	[DIR.up | DIR.down]: "│",
+	[DIR.left]: "─",
+	[DIR.right]: "─",
+	[DIR.left | DIR.right]: "─",
+	[DIR.down | DIR.right]: "┌",
+	[DIR.down | DIR.left]: "┐",
+	[DIR.up | DIR.right]: "└",
+	[DIR.up | DIR.left]: "┘",
+	[DIR.up | DIR.down | DIR.right]: "├",
+	[DIR.up | DIR.down | DIR.left]: "┤",
+	[DIR.left | DIR.right | DIR.down]: "┬",
+	[DIR.left | DIR.right | DIR.up]: "┴",
+	[DIR.up | DIR.down | DIR.left | DIR.right]: "┼"
+};
+/**
+* Convert a node's markers into renderable inline tags.
+*
+* - `db` → `◆ db`
+* - `contract` → `◆ contract` (applied) or `◇ contract` (planned)
+* - `ref` → the ref name, colored from the rotating {@link REF_COLORS} palette
+* - `custom` → the custom label
+*/
+function buildInlineTags(markers, colors) {
+	const tags = [];
+	const refNames = markers.filter((m) => m.kind === "ref").map((m) => m.name);
+	for (const m of markers) if (m.kind === "db") tags.push({
+		text: "◆ db",
+		color: colors.marker
+	});
+	else if (m.kind === "contract") tags.push({
+		text: m.planned ? "◆ contract" : "◇ contract",
+		color: colors.marker
+	});
+	else if (m.kind === "ref") tags.push({
+		text: m.name,
+		color: colors.ref(refNames.indexOf(m.name))
+	});
+	else if (m.kind === "custom") tags.push({
+		text: m.label,
+		color: colors.marker
+	});
+	return tags;
+}
+/** Total character width of inline tags including leading spaces (0 if no tags). */
+function inlineTagsWidth(tags) {
+	if (tags.length === 0) return 0;
+	return tags.reduce((w, t) => w + 1 + t.text.length, 0);
+}
+/**
+* Sparse character canvas for terminal graph rendering.
+*
+* Coordinates are unbounded integers — the grid auto-expands as content is
+* added and trims to the bounding box on {@link render}.
+*/
+var CharGrid = class {
+	connections = /* @__PURE__ */ new Map();
+	cellColors = /* @__PURE__ */ new Map();
+	chars = /* @__PURE__ */ new Map();
+	reserved = /* @__PURE__ */ new Set();
+	minX = Number.POSITIVE_INFINITY;
+	maxX = Number.NEGATIVE_INFINITY;
+	minY = Number.POSITIVE_INFINITY;
+	maxY = Number.NEGATIVE_INFINITY;
+	key(x, y) {
+		return `${x},${y}`;
+	}
+	/** Expand the bounding box to include (x, y). */
+	touch(x, y) {
+		if (x < this.minX) this.minX = x;
+		if (x > this.maxX) this.maxX = x;
+		if (y < this.minY) this.minY = y;
+		if (y > this.maxY) this.maxY = y;
+	}
+	/**
+	* Add a directional connection at (x, y). Multiple calls at the same cell
+	* are OR'd together — e.g. `addConnection(x, y, UP)` then
+	* `addConnection(x, y, RIGHT)` produces a └ corner. Color follows
+	* priority: higher-priority edges win at shared cells.
+	*/
+	addConnection(x, y, dir, color, priority = PRIORITY.branch) {
+		this.touch(x, y);
+		const k = this.key(x, y);
+		this.connections.set(k, (this.connections.get(k) ?? 0) | dir);
+		const existing = this.cellColors.get(k);
+		if (!existing || priority >= existing.priority) this.cellColors.set(k, {
+			color,
+			priority
+		});
+	}
+	/** Stamp a horizontal edge segment from x1 to x2 at row y. */
+	markHorizontal(y, x1, x2, color, priority) {
+		const lo = Math.min(x1, x2);
+		const hi = Math.max(x1, x2);
+		if (lo === hi) return;
+		this.addConnection(lo, y, DIR.right, color, priority);
+		for (let x = lo + 1; x < hi; x++) this.addConnection(x, y, DIR.left | DIR.right, color, priority);
+		this.addConnection(hi, y, DIR.left, color, priority);
+	}
+	/** Stamp a vertical edge segment from y1 to y2 at column x. */
+	markVertical(x, y1, y2, color, priority) {
+		const lo = Math.min(y1, y2);
+		const hi = Math.max(y1, y2);
+		if (lo === hi) return;
+		this.addConnection(x, lo, DIR.down, color, priority);
+		for (let y = lo + 1; y < hi; y++) this.addConnection(x, y, DIR.up | DIR.down, color, priority);
+		this.addConnection(x, hi, DIR.up, color, priority);
+	}
+	/** Place literal text at (x, y). Each character occupies one cell. Text stamps override connections. */
+	stampText(x, y, text, color) {
+		for (let i = 0; i < text.length; i++) {
+			const cx = x + i;
+			this.touch(cx, y);
+			this.chars.set(this.key(cx, y), {
+				ch: text[i],
+				color
+			});
+		}
+	}
+	/** True if (x, y) has stamped text or is in a reserved area (node labels). */
+	hasLabel(x, y) {
+		return this.chars.has(this.key(x, y)) || this.reserved.has(this.key(x, y));
+	}
+	/** True if (x, y) has any directional connection (an edge passes through). */
+	hasConnection(x, y) {
+		return (this.connections.get(this.key(x, y)) ?? 0) !== 0;
+	}
+	/** True if (x, y) has stamped text (not just a reserved area). */
+	hasText(x, y) {
+		return this.chars.has(this.key(x, y));
+	}
+	/** Reserve a horizontal span so label placement avoids it. Used for node id + marker regions. */
+	reserveArea(x, y, width) {
+		for (let i = 0; i < width; i++) this.reserved.add(this.key(x + i, y));
+	}
+	/** The largest y coordinate with content — used for positioning detached nodes below the graph. */
+	getMaxY() {
+		return this.maxY;
+	}
+	/**
+	* Render the grid to a multi-line string.
+	*
+	* Iterates row by row over the bounding box, resolving each cell to either
+	* its stamped text character or the box-drawing character for its
+	* connection bitmask. Consecutive characters with the same color are
+	* batched into a single ANSI-wrapped run for efficiency.
+	*/
+	render() {
+		if (this.minX === Number.POSITIVE_INFINITY) return "(empty)";
+		const rows = [];
+		for (let y = this.minY; y <= this.maxY; y++) {
+			let row = "";
+			let runChars = "";
+			let runColor;
+			const flush = () => {
+				if (runChars.length === 0) return;
+				row += runColor ? runColor(runChars) : runChars;
+				runChars = "";
+			};
+			for (let x = this.minX; x <= this.maxX; x++) {
+				const k = this.key(x, y);
+				let ch;
+				let color;
+				const label = this.chars.get(k);
+				if (label) {
+					ch = label.ch;
+					color = label.color;
+				} else {
+					const conn = this.connections.get(k) ?? 0;
+					ch = BOX_CHAR[conn] ?? " ";
+					color = conn === 0 ? void 0 : this.cellColors.get(k)?.color;
+				}
+				if (color !== runColor) {
+					flush();
+					runColor = color;
+				}
+				runChars += ch;
+			}
+			flush();
+			rows.push(row.trimEnd());
+		}
+		while (rows.length > 0 && rows[rows.length - 1] === "") rows.pop();
+		return rows.join("\n");
+	}
+};
+/**
+* Find the set of edge keys (`"from→to"`) on the shortest path from
+* `rootId` to `targetId`. Used to color spine edges distinctly from
+* branch edges in the rendered output.
+*
+* Returns an empty set if no path exists.
+*/
+function findSpineEdges(graph, rootId, targetId) {
+	const visited = new Set([rootId]);
+	const parent = /* @__PURE__ */ new Map();
+	const queue = [rootId];
+	while (queue.length > 0) {
+		const current = queue.shift();
+		if (current === targetId) {
+			const spineEdges = /* @__PURE__ */ new Set();
+			let node = targetId;
+			while (parent.has(node)) {
+				const edge = parent.get(node);
+				spineEdges.add(`${edge.from}→${edge.to}`);
+				node = edge.from;
+			}
+			return spineEdges;
+		}
+		for (const edge of graph.outgoing(current)) if (!visited.has(edge.to)) {
+			visited.add(edge.to);
+			parent.set(edge.to, edge);
+			queue.push(edge.to);
+		}
+	}
+	return /* @__PURE__ */ new Set();
+}
+/**
+* Prepend `src` and append `tgt` to dagre's control points, round to
+* integers, and deduplicate consecutive identical points.
+*/
+function prepareRawPoints(src, dagrePoints, tgt) {
+	const rounded = [
+		src,
+		...dagrePoints,
+		tgt
+	].map((p) => ({
+		x: Math.round(p.x),
+		y: Math.round(p.y)
+	}));
+	const deduped = [rounded[0]];
+	for (let i = 1; i < rounded.length; i++) {
+		const prev = deduped[deduped.length - 1];
+		const curr = rounded[i];
+		if (curr.x !== prev.x || curr.y !== prev.y) deduped.push(curr);
+	}
+	return deduped;
+}
+function countDiagonals(points) {
+	let count = 0;
+	for (let i = 1; i < points.length; i++) {
+		const prev = points[i - 1];
+		const curr = points[i];
+		if (prev.x !== curr.x && prev.y !== curr.y) count++;
+	}
+	return count;
+}
+/**
+* Decode a bitmask into an array of bend directions.
+*
+* Each bit selects how one diagonal is converted to an orthogonal corner:
+* 0 → horizontal-first, 1 → vertical-first. Used by {@link selectBestVariant}
+* to enumerate all 2^N combinations.
+*/
+function bitsToBends(bits, count) {
+	const bends = [];
+	for (let k = 0; k < count; k++) bends.push(bits >> k & 1 ? "vertical-first" : "horizontal-first");
+	return bends;
+}
+/**
+* Build one polyline variant by resolving each diagonal with the given bend direction.
+*
+* Diagonals are detected inline: when the last emitted point and the next
+* input point differ in both x and y, the segment is diagonal and is
+* resolved using the next value from `bends`. The result is deduplicated
+* to remove zero-length segments created when a bend coincides with an
+* adjacent point.
+*/
+function buildVariant(points, bends) {
+	if (points.length < 2) return points;
+	let bendIdx = 0;
+	const result = [points[0]];
+	for (let i = 1; i < points.length; i++) {
+		const prev = result[result.length - 1];
+		const curr = points[i];
+		if (prev.x === curr.x || prev.y === curr.y) result.push(curr);
+		else {
+			if ((bends[bendIdx++] ?? "horizontal-first") === "horizontal-first") result.push({
+				x: curr.x,
+				y: prev.y
+			});
+			else result.push({
+				x: prev.x,
+				y: curr.y
+			});
+			result.push(curr);
+		}
+	}
+	const final = [result[0]];
+	for (let i = 1; i < result.length; i++) {
+		const prev = final[final.length - 1];
+		const curr = result[i];
+		if (curr.x !== prev.x || curr.y !== prev.y) final.push(curr);
+	}
+	return final;
+}
+/** Count the number of direction changes (corners) in an orthogonal polyline. */
+function countCorners(poly) {
+	let corners = 0;
+	for (let i = 1; i < poly.length - 1; i++) {
+		const a = poly[i - 1];
+		const b = poly[i];
+		const c = poly[i + 1];
+		if (a.x === b.x !== (b.x === c.x)) corners++;
+	}
+	return corners;
+}
+/** Manhattan length of a polyline (sum of absolute x and y deltas). */
+function polyLength(poly) {
+	let len = 0;
+	for (let i = 0; i < poly.length - 1; i++) len += Math.abs(poly[i + 1].x - poly[i].x) + Math.abs(poly[i + 1].y - poly[i].y);
+	return len;
+}
+/**
+* Find the best (x, y) position to place an edge label adjacent to its
+* polyline. Returns null if no collision-free position exists.
+*
+* @param poly - The orthogonalized polyline for the edge.
+* @param label - The label text to place.
+* @param grid - The character grid (used for collision checks).
+* @param srcY - Y coordinate of the source node (for adjacency penalty).
+*/
+function findLabelPlacement(poly, label, grid, srcY) {
+	const segments = polyToSegments(poly);
+	let best;
+	for (const seg of segments) {
+		const candidates = segmentLabelCandidates(seg, label.length);
+		for (const pos of candidates) {
+			if (labelCollides(grid, pos.x, pos.y, label)) continue;
+			const score = scoreLabelCandidate(pos, seg, segments, label, grid, srcY);
+			if (!best || score > best.score) best = {
+				x: pos.x,
+				y: pos.y,
+				score
+			};
+		}
+	}
+	return best;
+}
+/** Convert a polyline into non-zero-length segments. */
+function polyToSegments(poly) {
+	const segments = [];
+	for (let i = 0; i < poly.length - 1; i++) {
+		const seg = segment(poly[i], poly[i + 1]);
+		if (manhattanLength(seg) > 0) segments.push(seg);
+	}
+	return segments;
+}
+/**
+* Generate all candidate (x, y) positions for placing a label adjacent
+* to a single segment. Positions are perpendicular to the segment:
+*
+* - Vertical segments: left and right, at every y along the segment.
+* - Horizontal segments: above and below, at every x where the label fits.
+*/
+function segmentLabelCandidates(seg, labelLen) {
+	const candidates = [];
+	if (isVertical(seg)) {
+		const minY = Math.min(seg.from.y, seg.to.y);
+		const maxY = Math.max(seg.from.y, seg.to.y);
+		for (const x of [seg.from.x + 2, seg.from.x - labelLen - 1]) for (let y = minY; y <= maxY; y++) candidates.push({
+			x,
+			y
+		});
+	} else {
+		const minX = Math.min(seg.from.x, seg.to.x);
+		const maxX = Math.max(seg.from.x, seg.to.x);
+		for (const dy of [-1, 1]) {
+			const y = seg.from.y + dy;
+			for (let x = minX; x <= maxX - labelLen + 1; x++) candidates.push({
+				x,
+				y
+			});
+		}
+	}
+	return candidates;
+}
+/**
+* Score a candidate label position. Higher is better.
+*
+* Combines: segment length, surrounding whitespace, distance from
+* segment midpoint, source-node proximity penalty, and segment-position
+* bonus (horizontal/later segments preferred when the edge has bends).
+*
+* @param pos - Candidate position (top-left corner of the label text).
+* @param seg - The segment this candidate is adjacent to.
+* @param allSegments - All segments of the edge polyline (for segment-position bonus).
+* @param label - The label text (used for width and whitespace probing).
+* @param grid - The character grid (used for whitespace checks).
+* @param srcY - Y coordinate of the edge's source node (penalizes labels
+*   that would appear to belong to the node rather than the edge).
+*/
+function scoreLabelCandidate(pos, seg, allSegments, label, grid, srcY) {
+	const len = manhattanLength(seg);
+	const midX = Math.round((seg.from.x + seg.to.x) / 2);
+	const midY = Math.round((seg.from.y + seg.to.y) / 2);
+	let score = len;
+	for (let dy = 1; dy <= 2; dy++) {
+		if (!rowHasContent(grid, pos.x, pos.y - dy, label.length)) score += 3;
+		if (!rowHasContent(grid, pos.x, pos.y + dy, label.length)) score += 3;
+	}
+	const labelCenterX = pos.x + Math.floor(label.length / 2);
+	score -= (Math.abs(labelCenterX - midX) + Math.abs(pos.y - midY)) * 2;
+	const labelCenterY = pos.y + Math.floor(label.length / 2);
+	score -= (Math.abs(labelCenterY - midY) + Math.abs(pos.x - midX)) * 2;
+	if (isVertical(seg) && pos.x > seg.from.x) score += 10;
+	if (srcY !== void 0 && Math.abs(pos.y - srcY) <= 1) score -= 20;
+	if (allSegments.some((s) => !isVertical(s))) {
+		if (!isVertical(seg)) score += 15;
+		const segIndex = allSegments.indexOf(seg);
+		score += segIndex / allSegments.length * 5;
+	}
+	return score;
+}
+/** True if any cell in the horizontal span [x, x+width) at row y has content. */
+function rowHasContent(grid, x, y, width) {
+	for (let i = 0; i < width; i++) if (grid.hasLabel(x + i, y) || grid.hasConnection(x + i, y)) return true;
+	return false;
+}
+/**
+* Check if placing `text` at (x, y) would collide with existing content.
+* Checks one cell of padding on each side to keep labels visually separated.
+*/
+function labelCollides(grid, x, y, text) {
+	for (let i = -1; i <= text.length; i++) {
+		const cx = x + i;
+		if (grid.hasLabel(cx, y)) return true;
+		if (i >= 0 && i < text.length && grid.hasConnection(cx, y)) return true;
+	}
+	return false;
+}
+/**
+* Resolve dagre's polyline into the best orthogonal variant and find the
+* optimal label position in a single pass.
+*
+* Enumerates all 2^N diagonal resolutions, scores each by:
+* - `corners * 10` — fewer corners preferred
+* - `+ manhattan length` — shorter paths preferred
+* - `+ 100` penalty if the label couldn't be placed
+*
+* For edges with no diagonals, the polyline is used as-is.
+*/
+function selectBestVariant(src, dagrePoints, tgt, label, grid) {
+	const rawPoints = prepareRawPoints(src, dagrePoints, tgt);
+	const diagCount = countDiagonals(rawPoints);
+	if (diagCount === 0) {
+		const poly = buildVariant(rawPoints, []);
+		return {
+			poly,
+			labelPos: label ? findLabelPlacement(poly, label, grid, src.y) : void 0
+		};
+	}
+	const numVariants = 1 << diagCount;
+	let bestPoly = null;
+	let bestLabel;
+	let bestScore = Number.POSITIVE_INFINITY;
+	for (let bits = 0; bits < numVariants; bits++) {
+		const poly = buildVariant(rawPoints, bitsToBends(bits, diagCount));
+		const corners = countCorners(poly);
+		const len = polyLength(poly);
+		const labelPos = label ? findLabelPlacement(poly, label, grid, src.y) : void 0;
+		const labelPenalty = label && !labelPos ? 100 : 0;
+		const score = corners * 10 + len + labelPenalty;
+		if (score < bestScore) {
+			bestScore = score;
+			bestPoly = poly;
+			bestLabel = labelPos;
+		}
+	}
+	return {
+		poly: bestPoly ?? buildVariant(rawPoints, bitsToBends(0, diagCount)),
+		labelPos: bestLabel
+	};
+}
+/**
+* Extract the subgraph covering the union of multiple paths.
+*
+* Each path is an ordered list of node ids (root → target). The result
+* contains every node on any path plus every forward edge between
+* consecutive nodes on any path. Detached nodes are always included.
+*
+* When all paths overlap (the common case), the result is identical to
+* a single-path extract. When paths diverge (e.g. DB marker on a
+* different branch than the contract), the result naturally includes the
+* fork and both branches — exactly the minimal information needed.
+*/
+function extractRelevantSubgraph(graph, paths) {
+	const nodeSet = /* @__PURE__ */ new Set();
+	const edgePairs = /* @__PURE__ */ new Set();
+	for (const path of paths) for (let i = 0; i < path.length; i++) {
+		nodeSet.add(path[i]);
+		if (i > 0) edgePairs.add(`${path[i - 1]}\0${path[i]}`);
+	}
+	return new RenderGraph(graph.nodes.filter((n) => nodeSet.has(n.id) || n.style === "detached"), graph.edges.filter((e) => edgePairs.has(`${e.from}\0${e.to}`)));
+}
+/**
+* Truncate a graph to the last `limit` spine edges from the spine target.
+* The window expands to include any node carrying a db or contract marker
+* so those are never truncated away.
+*
+* For the full graph: keeps all branches that fork from the visible spine window.
+* For the spine view: caller should call extractSubgraph first, then truncate.
+*/
+function truncateGraph(graph, spine, limit) {
+	if (spine.length <= 1 || limit >= spine.length - 1) return {
+		graph,
+		elidedCount: 0,
+		spine
+	};
+	let earliestMarkerIdx = spine.length;
+	for (let i = 0; i < spine.length; i++) if (graph.nodeById.get(spine[i])?.markers?.some((m) => m.kind === "db" || m.kind === "contract")) {
+		earliestMarkerIdx = i;
+		break;
+	}
+	const markerDistance = spine.length - 1 - earliestMarkerIdx;
+	const effectiveEdges = Math.max(limit, markerDistance);
+	if (effectiveEdges >= spine.length - 1) return {
+		graph,
+		elidedCount: 0,
+		spine
+	};
+	const keepFromIdx = spine.length - 1 - effectiveEdges;
+	const truncatedSpine = spine.slice(keepFromIdx);
+	const visibleSpineSet = new Set(truncatedSpine);
+	const reachable = new Set(visibleSpineSet);
+	const queue = [...truncatedSpine];
+	while (queue.length > 0) {
+		const current = queue.shift();
+		for (const edge of graph.outgoing(current)) if (!reachable.has(edge.to)) {
+			reachable.add(edge.to);
+			queue.push(edge.to);
+		}
+	}
+	for (const n of graph.nodes) if (n.style === "detached") reachable.add(n.id);
+	const truncatedNodes = graph.nodes.filter((n) => reachable.has(n.id));
+	const truncatedEdges = graph.edges.filter((e) => reachable.has(e.from) && reachable.has(e.to));
+	const elidedCount = spine.length - 1 - effectiveEdges;
+	return {
+		graph: new RenderGraph(truncatedNodes, truncatedEdges),
+		elidedCount,
+		spine: truncatedSpine
+	};
+}
+/**
+* After truncation the original root may not be in the visible graph.
+* Find the first node with no incoming edges as a fallback root.
+*/
+function findVisibleRoot(graph, layoutNodes) {
+	return layoutNodes.find((n) => !graph.incomingNodes.has(n.id))?.id ?? layoutNodes[0]?.id ?? "∅";
+}
+/**
+* The main rendering pipeline: dagre layout → edge stamping → label
+* placement → arrowheads → nodes → elided indicator → detached nodes.
+*
+* Called by {@link render} after optional truncation. Receives nodes/edges
+* and produces the final multi-line string.
+*
+* @param graph - The graph to render (may include detached nodes, which are
+*   rendered below the main graph rather than laid out by dagre).
+* @param options - Render options (rootId, spineTarget, colorize).
+* @param elidedCount - If > 0, a `┊ (N earlier migrations)` indicator
+*   is stamped above the visible root node.
+*/
+function layoutAndRender(graph, options, elidedCount = 0) {
+	const colors = buildColors(options.colorize ?? true);
+	const layoutNodes = graph.nodes.filter((n) => n.style !== "detached");
+	const layoutNodeIds = new Set(layoutNodes.map((n) => n.id));
+	const requestedRoot = options.rootId ?? layoutNodes[0]?.id ?? "∅";
+	const spineEdgeKeys = findSpineEdges(graph, layoutNodeIds.has(requestedRoot) ? requestedRoot : findVisibleRoot(graph, layoutNodes), options.spineTarget);
+	const g = new dagre.graphlib.Graph({ multigraph: true });
+	g.setGraph({
+		rankdir: "TB",
+		ranksep: 4,
+		nodesep: 6,
+		marginx: 2,
+		marginy: 1,
+		...options.dagreOptions
+	});
+	g.setDefaultEdgeLabel(() => ({}));
+	for (const node of layoutNodes) {
+		const tagWidth = inlineTagsWidth(buildInlineTags(node.markers ?? [], colors));
+		g.setNode(node.id, {
+			width: node.id.length + 6 + tagWidth,
+			height: 1
+		});
+	}
+	const edgeNames = [];
+	for (let i = 0; i < graph.edges.length; i++) {
+		const edge = graph.edges[i];
+		const fromDetached = graph.nodeById.get(edge.from)?.style === "detached";
+		const toDetached = graph.nodeById.get(edge.to)?.style === "detached";
+		if (fromDetached || toDetached) {
+			edgeNames.push("");
+			continue;
+		}
+		const name = `e${i}`;
+		edgeNames.push(name);
+		g.setEdge(edge.from, edge.to, { label: edge.label ?? "" }, name);
+	}
+	dagre.layout(g);
+	const nodePos = /* @__PURE__ */ new Map();
+	for (const id of g.nodes()) {
+		const n = g.node(id);
+		nodePos.set(id, {
+			x: Math.round(n.x),
+			y: Math.round(n.y)
+		});
+	}
+	const grid = new CharGrid();
+	for (const node of layoutNodes) {
+		const pos = nodePos.get(node.id);
+		if (!pos) continue;
+		const tagWidth = inlineTagsWidth(buildInlineTags(node.markers ?? [], colors));
+		grid.reserveArea(pos.x - 1, pos.y, node.id.length + 4 + tagWidth);
+	}
+	const edgeEntries = [];
+	for (let i = 0; i < graph.edges.length; i++) {
+		const edge = graph.edges[i];
+		const name = edgeNames[i];
+		if (!name || !nodePos.has(edge.from) || !nodePos.has(edge.to)) continue;
+		const src = nodePos.get(edge.from);
+		const tgt = nodePos.get(edge.to);
+		const dagrePoints = g.edge({
+			v: edge.from,
+			w: edge.to,
+			name
+		})?.points ?? [];
+		const isBackward = tgt.y < src.y;
+		const isSpine = spineEdgeKeys.has(`${edge.from}→${edge.to}`);
+		const role = isBackward ? "backward" : isSpine ? "spine" : "branch";
+		const edgeColor = resolveHintColor(edge.colorHint, colors) ?? (role === "backward" ? colors.backward : role === "spine" ? colors.spine : colors.branch);
+		const priority = role === "backward" ? PRIORITY.backward : role === "spine" ? PRIORITY.spine : PRIORITY.branch;
+		edgeEntries.push({
+			idx: i,
+			edge,
+			dagrePoints,
+			src,
+			tgt,
+			role,
+			edgeColor,
+			priority
+		});
+	}
+	const drawnEdges = [];
+	for (const entry of edgeEntries) {
+		const { edge, dagrePoints, src, tgt, edgeColor, priority } = entry;
+		const { poly } = selectBestVariant(src, dagrePoints, tgt, edge.label, grid);
+		for (let j = 0; j < poly.length - 1; j++) {
+			const a = poly[j];
+			const b = poly[j + 1];
+			if (a.y === b.y) grid.markHorizontal(a.y, a.x, b.x, edgeColor, priority);
+			else if (a.x === b.x) grid.markVertical(a.x, a.y, b.y, edgeColor, priority);
+		}
+		drawnEdges.push({
+			edge,
+			poly,
+			role: entry.role,
+			srcY: src.y
+		});
+	}
+	const labelOrder = [...drawnEdges].map((de, i) => ({
+		...de,
+		i
+	})).filter((de) => de.edge.label).sort((a, b) => (b.edge.label?.length ?? 0) - (a.edge.label?.length ?? 0));
+	for (const { edge, poly, role, srcY } of labelOrder) {
+		if (!edge.label) continue;
+		const labelPos = findLabelPlacement(poly, edge.label, grid, srcY);
+		if (labelPos) {
+			const labelColor = resolveHintColor(edge.colorHint, colors) ?? (role === "backward" ? colors.backward : role === "spine" ? colors.spine : colors.label);
+			grid.stampText(labelPos.x, labelPos.y, edge.label, labelColor);
+		}
+	}
+	for (const { edge, poly, role } of drawnEdges) {
+		if (poly.length < 2) continue;
+		const last = poly[poly.length - 1];
+		const prev = poly[poly.length - 2];
+		const edgeColor = resolveHintColor(edge.colorHint, colors) ?? (role === "backward" ? colors.backward : role === "spine" ? colors.spine : colors.branch);
+		let ax;
+		let ay;
+		let arrow;
+		if (prev.x === last.x) if (last.y > prev.y) {
+			ax = last.x;
+			ay = last.y - 1;
+			arrow = ARROW.down;
+		} else {
+			ax = last.x;
+			ay = last.y + 1;
+			arrow = ARROW.up;
+		}
+		else if (last.x > prev.x) {
+			ax = last.x - 1;
+			ay = last.y;
+			arrow = ARROW.right;
+		} else {
+			ax = last.x + 1;
+			ay = last.y;
+			arrow = ARROW.left;
+		}
+		if (ax !== void 0 && ay !== void 0 && arrow && !grid.hasText(ax, ay)) grid.stampText(ax, ay, arrow, edgeColor);
+	}
+	const spineNodeIds = /* @__PURE__ */ new Set();
+	for (const key of spineEdgeKeys) {
+		const [from, to] = key.split("→");
+		if (from) spineNodeIds.add(from);
+		if (to) spineNodeIds.add(to);
+	}
+	for (const node of layoutNodes) {
+		const pos = nodePos.get(node.id);
+		if (!pos) continue;
+		const isSpineNode = spineNodeIds.has(node.id);
+		const nodeColor = isSpineNode ? colors.spine : colors.branch;
+		grid.stampText(pos.x, pos.y, "○", nodeColor);
+		grid.stampText(pos.x + 1, pos.y, " ");
+		const hasMarkers = node.markers && node.markers.length > 0;
+		grid.stampText(pos.x + 2, pos.y, node.id, isSpineNode || hasMarkers ? bold : dim);
+		const tags = buildInlineTags(node.markers ?? [], colors);
+		if (tags.length > 0) {
+			let bx = pos.x + 2 + node.id.length;
+			for (const tag of tags) {
+				grid.stampText(bx, pos.y, " ");
+				bx++;
+				grid.stampText(bx, pos.y, tag.text, tag.color);
+				bx += tag.text.length;
+			}
+		}
+	}
+	if (elidedCount > 0) {
+		const topNodeId = layoutNodes.find((n) => !graph.incomingNodes.has(n.id))?.id ?? layoutNodes[0]?.id;
+		const rootPos = topNodeId ? nodePos.get(topNodeId) : void 0;
+		if (rootPos) {
+			const label = elidedCount === 1 ? "1 earlier migration" : `${elidedCount} earlier migrations`;
+			const topY = rootPos.y - 3;
+			grid.stampText(rootPos.x, topY, "┊", colors.label);
+			grid.stampText(rootPos.x, topY + 1, "┊", colors.label);
+			grid.stampText(rootPos.x + 2, topY + 1, `(${label})`, colors.label);
+			grid.stampText(rootPos.x, topY + 2, "┊", colors.label);
+		}
+	}
+	const detachedNodes = graph.nodes.filter((n) => n.style === "detached");
+	if (detachedNodes.length > 0) {
+		let bottomNodeX = nodePos.values().next().value?.x ?? 0;
+		let bottomNodeY = -1;
+		for (const [, pos] of nodePos) if (pos.y > bottomNodeY) {
+			bottomNodeY = pos.y;
+			bottomNodeX = pos.x;
+		}
+		const spineX = bottomNodeX;
+		let bottomY = grid.getMaxY() + 1;
+		for (const node of detachedNodes) {
+			grid.stampText(spineX, bottomY, "┊", colors.branch);
+			bottomY++;
+			grid.stampText(spineX, bottomY, "◇", colors.branch);
+			grid.stampText(spineX + 2, bottomY, node.id, dim);
+			const tags = buildInlineTags(node.markers ?? [], colors);
+			if (tags.length > 0) {
+				let bx = spineX + 2 + node.id.length;
+				for (const tag of tags) {
+					grid.stampText(bx, bottomY, " ");
+					bx++;
+					grid.stampText(bx, bottomY, tag.text, tag.color);
+					bx += tag.text.length;
+				}
+			}
+			bottomY++;
+		}
+	}
+	return grid.render();
+}
+/**
+* BFS to find the ordered node path from `rootId` to `targetId`.
+* Used for truncation — the spine path determines which edges to keep.
+*
+* Returns `[rootId]` if no path exists.
+*/
+function findSpinePath(graph, rootId, targetId) {
+	const visited = new Set([rootId]);
+	const parent = /* @__PURE__ */ new Map();
+	const queue = [rootId];
+	while (queue.length > 0) {
+		const current = queue.shift();
+		if (current === targetId) {
+			const path = [];
+			let node = targetId;
+			while (node !== rootId) {
+				path.unshift(node);
+				node = parent.get(node);
+			}
+			path.unshift(rootId);
+			return path;
+		}
+		for (const edge of graph.outgoing(current)) if (!visited.has(edge.to)) {
+			visited.add(edge.to);
+			parent.set(edge.to, current);
+			queue.push(edge.to);
+		}
+	}
+	return [rootId];
+}
+/**
+* Render a graph with optional truncation.
+*
+* The caller decides what to pass in: the full graph for `--graph`, or a
+* subgraph extracted via {@link extractRelevantSubgraph} for the default view.
+*/
+function render(graph, options) {
+	if (options.limit !== void 0) {
+		const { graph: truncated, elidedCount } = truncateGraph(graph, findSpinePath(graph, options.rootId ?? graph.nodes[0]?.id ?? "∅", options.spineTarget), options.limit);
+		return layoutAndRender(truncated, options, elidedCount);
+	}
+	return layoutAndRender(graph, options);
+}
+const graphRenderer = { render };
+/** True if the graph is a single linear chain (no branching), ignoring detached nodes. */
+function isLinearGraph(graph) {
+	for (const node of graph.nodes) {
+		if (node.style === "detached") continue;
+		if (graph.outgoing(node.id).length > 1) return false;
+	}
+	return true;
+}
+
+//#endregion
+//#region src/commands/migration-status.ts
+function summarizeOps(ops) {
+	if (ops.length === 0) return {
+		summary: "0 ops",
+		hasDestructive: false
+	};
+	const classes = /* @__PURE__ */ new Map();
+	for (const op of ops) classes.set(op.operationClass, (classes.get(op.operationClass) ?? 0) + 1);
+	const hasDestructive = classes.has("destructive");
+	const count = ops.length;
+	const noun = count === 1 ? "op" : "ops";
+	if (classes.size === 1) return {
+		summary: `${count} ${noun} (all ${[...classes.keys()][0]})`,
+		hasDestructive
+	};
+	const destructiveCount = classes.get("destructive");
+	if (destructiveCount) return {
+		summary: `${count} ${noun} (${destructiveCount} destructive)`,
+		hasDestructive
+	};
+	return {
+		summary: `${count} ${noun} (${[...classes.entries()].map(([cls, n]) => `${n} ${cls}`).join(", ")})`,
+		hasDestructive
+	};
+}
+/**
+* Derive per-edge status across the full graph using path analysis.
+*
+* - **applied**: edge is on the path from root to the DB marker
+* - **pending**: edge is on the path from the DB marker to the target
+*   (and the marker is reachable from root, i.e. it's on the same branch)
+* - **unreachable**: edge is on the path from root to the target but the DB
+*   marker is on a different branch — `apply` can't reach these edges
+*   without the DB first moving to this branch
+*
+* Returns statuses only for edges that have a known status (skips offline
+* and edges not on any relevant path).
+*
+* @internal Exported for testing only.
+*/
+function deriveEdgeStatuses(graph, targetHash, contractHash, markerHash, mode) {
+	if (mode === "offline") return [];
+	const edgeKey = (e) => `${e.from}\0${e.to}`;
+	const effectiveMarker = markerHash ?? EMPTY_CONTRACT_HASH;
+	const appliedPath = markerHash !== void 0 ? findPath(graph, EMPTY_CONTRACT_HASH, markerHash) : null;
+	const pendingPath = findPath(graph, effectiveMarker, targetHash);
+	const targetPath = findPath(graph, EMPTY_CONTRACT_HASH, targetHash);
+	const statuses = [];
+	const assignedKeys = /* @__PURE__ */ new Set();
+	if (appliedPath) for (const e of appliedPath) {
+		assignedKeys.add(edgeKey(e));
+		statuses.push({
+			dirName: e.dirName,
+			status: "applied"
+		});
+	}
+	if (pendingPath) for (const e of pendingPath) {
+		assignedKeys.add(edgeKey(e));
+		statuses.push({
+			dirName: e.dirName,
+			status: "pending"
+		});
+	}
+	if (contractHash !== EMPTY_CONTRACT_HASH && contractHash !== targetHash && graph.nodes.has(contractHash)) {
+		const beyondTarget = findPath(graph, targetHash, contractHash);
+		if (beyondTarget) {
+			for (const e of beyondTarget) if (!assignedKeys.has(edgeKey(e))) {
+				assignedKeys.add(edgeKey(e));
+				statuses.push({
+					dirName: e.dirName,
+					status: "pending"
+				});
+			}
+		}
+	}
+	if (targetPath) {
+		for (const e of targetPath) if (!assignedKeys.has(edgeKey(e))) statuses.push({
+			dirName: e.dirName,
+			status: "unreachable"
+		});
+	}
+	return statuses;
+}
+/**
+* @param mode    — 'online' if we connected to the database, 'offline' otherwise
+* @param markerHash — the marker hash from the database, or undefined if no marker row / offline
+*/
+function buildMigrationEntries(chain, packages, mode, markerHash, edgeStatuses) {
+	const pkgByDirName = new Map(packages.map((p) => [p.dirName, p]));
+	const statusByDirName = edgeStatuses ? new Map(edgeStatuses.map((e) => [e.dirName, e.status])) : void 0;
+	const markerInChain = markerHash === void 0 || chain.some((e) => e.to === markerHash);
+	const entries = [];
+	let reachedMarker = mode === "online" && markerHash === void 0;
+	for (const migration of chain) {
+		const ops = pkgByDirName.get(migration.dirName)?.ops ?? [];
+		const { summary, hasDestructive } = summarizeOps(ops);
+		let status;
+		const edgeStatus = statusByDirName?.get(migration.dirName);
+		if (edgeStatus) status = edgeStatus;
+		else if (mode === "offline" || !markerInChain) status = "unknown";
+		else if (reachedMarker) status = "pending";
+		else status = "applied";
+		entries.push({
+			dirName: migration.dirName,
+			from: migration.from,
+			to: migration.to,
+			migrationId: migration.migrationId,
+			operationCount: ops.length,
+			operationSummary: summary,
+			hasDestructive,
+			status
+		});
+		if (!reachedMarker && migration.to === markerHash) reachedMarker = true;
+	}
+	return entries;
+}
+/**
+* Resolve the migration chain to display in status output.
+*
+* When offline or the marker is at EMPTY, the chain is simply the shortest
+* path from EMPTY to the target — all structural paths are equivalent per
+* the spec, so the deterministic shortest path is the canonical display.
+*
+* When online with a non-empty marker, the chain routes *through* the marker:
+* EMPTY→marker (applied history) + marker→target (pending edges). This ensures
+* the displayed chain includes the marker node so applied/pending status is
+* correct. Without this, BFS from EMPTY to target could pick a shortest path
+* that bypasses the marker entirely (e.g. in a diamond graph), causing the
+* marker to appear "diverged" when it isn't.
+*/
+function resolveDisplayChain(graph, targetHash, markerHash) {
+	if (markerHash === void 0) return findPath(graph, EMPTY_CONTRACT_HASH, targetHash);
+	const toMarker = findPath(graph, EMPTY_CONTRACT_HASH, markerHash);
+	if (!toMarker) return findPath(graph, EMPTY_CONTRACT_HASH, targetHash);
+	if (markerHash === targetHash) return toMarker;
+	const fromMarker = findPath(graph, markerHash, targetHash);
+	if (fromMarker) return [...toMarker, ...fromMarker];
+	const toTarget = findPath(graph, EMPTY_CONTRACT_HASH, targetHash);
+	if (!toTarget) return null;
+	const targetToMarker = findPath(graph, targetHash, markerHash);
+	if (targetToMarker) return [...toTarget, ...targetToMarker];
+	return toTarget;
+}
+const DEFAULT_LIMIT = 10;
+function determineLimit(opts) {
+	if (opts.all) return;
+	if (!opts.limit) return DEFAULT_LIMIT;
+	const parsed = Number.parseInt(opts.limit, 10);
+	if (Number.isNaN(parsed)) return DEFAULT_LIMIT;
+	return parsed;
+}
+async function executeMigrationStatusCommand(options, flags, ui) {
+	const config = await loadConfig(options.config);
+	const { configPath, migrationsDir, migrationsRelative, refsPath } = resolveMigrationPaths(options.config, config);
+	const dbConnection = options.db ?? config.db?.connection;
+	const hasDriver = !!config.driver;
+	let activeRefName;
+	let activeRefHash;
+	let allRefs = {};
+	try {
+		allRefs = await readRefs(refsPath);
+	} catch (error) {
+		if (MigrationToolsError.is(error)) return notOk(errorRuntime(error.message, {
+			why: error.why,
+			fix: error.fix,
+			meta: { code: error.code }
+		}));
+		throw error;
+	}
+	if (options.ref) {
+		activeRefName = options.ref;
+		try {
+			activeRefHash = resolveRef(allRefs, activeRefName);
+		} catch (error) {
+			if (MigrationToolsError.is(error)) return notOk(errorRuntime(error.message, {
+				why: error.why,
+				fix: error.fix,
+				meta: { code: error.code }
+			}));
+			throw error;
+		}
+	}
+	const statusRefs = Object.entries(allRefs).map(([name, hash]) => ({
+		name,
+		hash,
+		active: name === activeRefName
+	}));
+	if (!flags.json && !flags.quiet) {
+		const details = [{
+			label: "config",
+			value: configPath
+		}, {
+			label: "migrations",
+			value: migrationsRelative
+		}];
+		if (dbConnection && hasDriver) details.push({
+			label: "database",
+			value: maskConnectionUrl(String(dbConnection))
+		});
+		if (activeRefName) details.push({
+			label: "ref",
+			value: activeRefName
+		});
+		const header = formatStyledHeader({
+			command: "migration status",
+			description: "Show migration history and applied status",
+			details,
+			flags
+		});
+		ui.stderr(header);
+	}
+	const diagnostics = [];
+	let contractHash = EMPTY_CONTRACT_HASH;
+	try {
+		contractHash = (await readContractEnvelope(config)).storageHash;
+	} catch (error) {
+		diagnostics.push({
+			code: "CONTRACT.UNREADABLE",
+			severity: "warn",
+			message: `Could not read contract: ${error instanceof Error ? error.message : "unknown error"}`,
+			hints: ["Run 'prisma-next contract emit' to generate a valid contract"]
+		});
+	}
+	let attested;
+	let graph;
+	try {
+		({bundles: attested, graph} = await loadMigrationBundles(migrationsDir));
+	} catch (error) {
+		if (MigrationToolsError.is(error)) return notOk(errorRuntime(error.message, {
+			why: error.why,
+			fix: error.fix,
+			meta: { code: error.code }
+		}));
+		return notOk(errorUnexpected(error instanceof Error ? error.message : String(error), { why: `Failed to read migrations directory: ${error instanceof Error ? error.message : String(error)}` }));
+	}
+	if (attested.length === 0) {
+		if (contractHash !== EMPTY_CONTRACT_HASH) diagnostics.push({
+			code: "CONTRACT.AHEAD",
+			severity: "warn",
+			message: "No migration exists for the current contract",
+			hints: ["Run 'prisma-next migration plan' to generate a migration for the current contract"]
+		});
+		return ok({
+			ok: true,
+			mode: dbConnection && hasDriver ? "online" : "offline",
+			migrations: [],
+			targetHash: EMPTY_CONTRACT_HASH,
+			contractHash,
+			summary: "No migrations found",
+			diagnostics
+		});
+	}
+	let targetHash;
+	if (activeRefHash) targetHash = activeRefHash;
+	else if (graph.nodes.has(contractHash)) targetHash = contractHash;
+	else {
+		const leaves = findReachableLeaves(graph, EMPTY_CONTRACT_HASH);
+		if (leaves.length === 1) targetHash = leaves[0];
+		else diagnostics.push({
+			code: "MIGRATION.DIVERGED",
+			severity: "warn",
+			message: "There are multiple valid migration paths — you must select a target",
+			hints: ["Use '--ref <name>' to select a target", "Or 'prisma-next migration ref set <name> <hash>' to create one"]
+		});
+	}
+	let markerHash;
+	let mode = "offline";
+	if (dbConnection && hasDriver) {
+		const client = createControlClient({
+			family: config.family,
+			target: config.target,
+			adapter: config.adapter,
+			driver: config.driver,
+			extensionPacks: config.extensionPacks ?? []
+		});
+		try {
+			await client.connect(dbConnection);
+			markerHash = (await client.readMarker())?.storageHash;
+			mode = "online";
+		} catch {
+			if (!flags.json && !flags.quiet) ui.warn("Could not connect to database — showing offline status");
+		} finally {
+			await client.close();
+		}
+	}
+	if (mode === "online" && markerHash !== void 0 && !graph.nodes.has(markerHash) && markerHash !== contractHash) {
+		const hints = [];
+		if (graph.nodes.has(contractHash)) hints.push("Run 'prisma-next db sign' to overwrite the marker if the database already matches the contract", "Run 'prisma-next db update' to push the current contract to the database", "Run 'prisma-next contract infer' to make your contract match the database", "Run 'prisma-next db verify' to inspect the database state");
+		else hints.push("Run 'prisma-next db update' to push the current contract to the database", "Run 'prisma-next contract infer' to make your contract match the database", "Run 'prisma-next db verify' to inspect the database state");
+		diagnostics.push({
+			code: "MIGRATION.MARKER_NOT_IN_HISTORY",
+			severity: "warn",
+			message: "Database was updated outside the migration system (marker does not match any migration)",
+			hints
+		});
+		return ok({
+			ok: true,
+			mode,
+			migrations: [],
+			targetHash: EMPTY_CONTRACT_HASH,
+			contractHash,
+			summary: `${attested.length} migration(s) on disk`,
+			diagnostics,
+			markerHash,
+			...statusRefs.length > 0 ? { refs: statusRefs } : {}
+		});
+	}
+	if (mode === "online" && markerHash === void 0) diagnostics.push({
+		code: "MIGRATION.NO_MARKER",
+		severity: "warn",
+		message: "Database has not been initialized — no migration marker found",
+		hints: ["Run 'prisma-next migration apply' to apply pending migrations"]
+	});
+	if (targetHash && contractHash !== EMPTY_CONTRACT_HASH && !graph.nodes.has(contractHash) && markerHash !== contractHash) diagnostics.push({
+		code: "CONTRACT.AHEAD",
+		severity: "warn",
+		message: "Contract has changed since the last migration was planned",
+		hints: ["Run 'prisma-next migration plan' to generate a migration for the current contract"]
+	});
+	if (!targetHash) return ok({
+		ok: true,
+		mode,
+		migrations: [],
+		targetHash: EMPTY_CONTRACT_HASH,
+		contractHash,
+		summary: `${attested.length} migration(s) on disk`,
+		diagnostics,
+		...ifDefined("markerHash", markerHash),
+		...statusRefs.length > 0 ? { refs: statusRefs } : {},
+		graph,
+		bundles: attested,
+		diverged: true
+	});
+	const chain = resolveDisplayChain(graph, targetHash, markerHash);
+	if (!chain) return notOk(errorRuntime("Cannot reconstruct migration history", {
+		why: `No path from ${EMPTY_CONTRACT_HASH} to target ${targetHash}`,
+		fix: "The migration history may have gaps. Check the migrations directory for missing or corrupted packages."
+	}));
+	const edgeStatuses = deriveEdgeStatuses(graph, targetHash, contractHash, markerHash, mode);
+	const entries = buildMigrationEntries(chain, attested, mode, markerHash, edgeStatuses);
+	const pendingCount = edgeStatuses.filter((e) => e.status === "pending").length;
+	const appliedCount = edgeStatuses.filter((e) => e.status === "applied").length;
+	let summary;
+	if (mode === "online") if (markerHash !== void 0 && !graph.nodes.has(markerHash) && markerHash === contractHash) summary = `${attested.length} migration(s) on disk`;
+	else if (activeRefHash && markerHash !== void 0) summary = summarizeRefDistance(graph, markerHash, activeRefHash, activeRefName);
+	else if (pendingCount === 0) summary = `Database is up to date (${appliedCount} migration${appliedCount !== 1 ? "s" : ""} applied)`;
+	else if (markerHash === void 0) summary = `${pendingCount} pending migration(s) — database has no marker`;
+	else summary = `${pendingCount} pending migration(s) — run 'prisma-next migration apply' to apply`;
+	else summary = `${entries.length} migration(s) on disk`;
+	if (mode === "online") if (markerHash !== void 0 && !graph.nodes.has(markerHash) && markerHash === contractHash) diagnostics.push({
+		code: "MIGRATION.MARKER_NOT_IN_HISTORY",
+		severity: "warn",
+		message: "Database matches the current contract but was updated directly (not via migration apply)",
+		hints: ["Run 'prisma-next migration plan' to plan a migration to your current contract"]
+	});
+	else if (pendingCount > 0) diagnostics.push({
+		code: "MIGRATION.DATABASE_BEHIND",
+		severity: "info",
+		message: `${pendingCount} migration(s) pending`,
+		hints: ["Run 'prisma-next migration apply' to apply pending migrations"]
+	});
+	else diagnostics.push({
+		code: "MIGRATION.UP_TO_DATE",
+		severity: "info",
+		message: "Database is up to date",
+		hints: []
+	});
+	let pathDecision;
+	if (mode === "online" && markerHash !== void 0) {
+		const decision = findPathWithDecision(graph, markerHash, targetHash, activeRefName);
+		if (decision) pathDecision = toPathDecisionResult(decision);
+	}
+	return ok({
+		ok: true,
+		mode,
+		migrations: entries,
+		targetHash,
+		contractHash,
+		summary,
+		diagnostics,
+		...ifDefined("markerHash", markerHash),
+		...statusRefs.length > 0 ? { refs: statusRefs } : {},
+		...ifDefined("pathDecision", pathDecision),
+		graph,
+		bundles: attested,
+		edgeStatuses,
+		...ifDefined("activeRefHash", activeRefHash),
+		...ifDefined("activeRefName", activeRefName)
+	});
+}
+function createMigrationStatusCommand() {
+	const command = new Command("status");
+	setCommandDescriptions(command, "Show migration history and applied status", "Displays the migration history in order. When a database connection\nis available, shows which migrations are applied and which are pending.\nWithout a database connection, shows the history from disk only.");
+	setCommandExamples(command, ["prisma-next migration status", "prisma-next migration status --db $DATABASE_URL"]);
+	addGlobalOptions(command).option("--db <url>", "Database connection string").option("--config <path>", "Path to prisma-next.config.ts").option("--ref <name>", "Target ref name from migrations/refs.json").option("--graph", "Show the full migration graph with all branches").option("--limit <n>", "Maximum number of migrations to display (default: 10)").option("--all", "Show full history (disables truncation)").action(async (options) => {
+		const flags = parseGlobalFlags(options);
+		const ui = new TerminalUI({
+			color: flags.color,
+			interactive: flags.interactive
+		});
+		const exitCode = handleResult(await executeMigrationStatusCommand(options, flags, ui), flags, ui, (statusResult) => {
+			if (flags.json) {
+				const { graph: _g, bundles: _b, edgeStatuses: _es, activeRefHash: _arh, activeRefName: _arn, diverged: _d, ...jsonResult } = statusResult;
+				ui.output(JSON.stringify(jsonResult, null, 2));
+			} else if (!flags.quiet) {
+				const colorize = flags.color !== false;
+				if (statusResult.graph) {
+					const limit = determineLimit(options);
+					const renderInput = migrationGraphToRenderInput({
+						graph: statusResult.graph,
+						mode: statusResult.mode,
+						markerHash: statusResult.markerHash,
+						contractHash: statusResult.contractHash,
+						refs: statusResult.refs,
+						activeRefHash: statusResult.activeRefHash,
+						activeRefName: statusResult.activeRefName,
+						edgeStatuses: statusResult.edgeStatuses
+					});
+					const graphToRender = options.graph || statusResult.diverged ? renderInput.graph : extractRelevantSubgraph(renderInput.graph, renderInput.relevantPaths);
+					const renderOptions = {
+						...renderInput.options,
+						colorize,
+						...ifDefined("limit", limit),
+						...isLinearGraph(graphToRender) ? { dagreOptions: { ranksep: 1 } } : {}
+					};
+					const graphOutput = graphRenderer.render(graphToRender, renderOptions);
+					ui.log(graphOutput);
+					if (statusResult.mode === "online") ui.log(formatLegend(colorize));
+				}
+				ui.log("");
+				ui.log(formatStatusSummary(statusResult, colorize));
+			}
+		});
+		process.exit(exitCode);
+	});
+	return command;
+}
+function formatLegend(colorize) {
+	const c = (fn, s) => colorize ? fn(s) : s;
+	return c(dim, [
+		`${c(cyan, "✓")} applied`,
+		`${c(yellow, "⧗")} pending`,
+		`${c(magenta, "✗")} unreachable`
+	].join("  "));
+}
+function formatStatusSummary(result, colorize) {
+	const c = (fn, s) => colorize ? fn(s) : s;
+	const lines = [];
+	const hasUnknown = result.migrations.some((e) => e.status === "unknown");
+	const pendingCount = result.migrations.filter((e) => e.status === "pending").length;
+	const hasWarnings = result.diagnostics?.some((d) => d.severity === "warn") ?? false;
+	if (result.mode === "online") if (hasUnknown || hasWarnings) lines.push(`${c(yellow, "⚠")} ${result.summary}`);
+	else if (pendingCount === 0) lines.push(`${c(cyan, "✔")} ${result.summary}`);
+	else lines.push(`${c(yellow, "⧗")} ${result.summary}`);
+	else lines.push(result.summary);
+	const warnings = result.diagnostics?.filter((d) => d.severity === "warn") ?? [];
+	for (const diag of warnings) {
+		lines.push(`${c(yellow, "⚠")} ${diag.message}`);
+		for (const hint of diag.hints) lines.push(`  ${c(dim, hint)}`);
+	}
+	return lines.join("\n");
+}
+function summarizeRefDistance(graph, markerHash, refHash, refName) {
+	if (markerHash === refHash) return `At ref "${refName}" target`;
+	const pathToRef = findPath(graph, markerHash, refHash);
+	if (pathToRef) return `${pathToRef.length} migration(s) behind ref "${refName}"`;
+	const pathFromRef = findPath(graph, refHash, markerHash);
+	if (pathFromRef) return `${pathFromRef.length} migration(s) ahead of ref "${refName}"`;
+	return `No path between database marker and ref "${refName}" target`;
+}
+
+//#endregion
+export { deriveEdgeStatuses as n, createMigrationStatusCommand as t };
+//# sourceMappingURL=migration-status-B7OVZ-Ka.mjs.map