prisma-next 0.12.0-dev.22 → 0.12.0-dev.24

package/dist/{migration-graph-CeBB07Cc.mjs → migration-graph-tree-render-BQdhKBO8.mjs}

@@ -1,11 +1,4 @@
-import { t as loadConfig } from "./config-loader-B6sJjXTv.mjs";
-import { E as formatStyledHeader, _ as parseGlobalFlagsOrExit, b as handleResult, d as setCommandSeeAlso, l as setCommandDescriptions, s as resolveMigrationPaths, t as addGlobalOptions, u as setCommandExamples, v as createTerminalUI } from "./command-helpers-Cmdqyhz9.mjs";
-import { r as buildReadAggregate } from "./contract-space-aggregate-loader-CirAEsM8.mjs";
-import { i as migrationGraphToRenderInput, n as graphRenderer } from "./graph-render-rFAqZujX.mjs";
-import { c as migrationListForwardArrow, l as classifyMigrationGraphTopology, n as createAnsiMigrationListStyler, s as migrationListEmptySource, t as CONTRACT_MARKER_NAME } from "./migration-list-styler-CsMECsY4.mjs";
-import { Command } from "commander";
-import { ok } from "@prisma-next/utils/result";
-import { bold, createColors } from "colorette";
+import { bold, createColors, cyan, cyanBright, dim, green, yellow } from "colorette";
 import stringWidth from "string-width";
 import { EMPTY_CONTRACT_HASH } from "@prisma-next/migration-tools/constants";
 //#region src/utils/formatters/migration-graph-layout.ts
@@ -655,6 +648,224 @@ function buildMigrationGraphLayout(rowModel) {
 	};
 }
 //#endregion
+//#region src/utils/formatters/migration-list-graph-topology.ts
+function compareDirNameDesc(a, b) {
+	return b.dirName.localeCompare(a.dirName);
+}
+function bumpDegree(map, key) {
+	map.set(key, (map.get(key) ?? 0) + 1);
+}
+function compareNodesRootFirst(a, b) {
+	if (a === EMPTY_CONTRACT_HASH) return -1;
+	if (b === EMPTY_CONTRACT_HASH) return 1;
+	return a.localeCompare(b);
+}
+/**
+* Shortest-path distance of each node from the forward roots, over the given
+* candidate edges. Roots are the in-degree-0 nodes (baseline first, then lex);
+* a rooted component therefore distances every node by how many forward steps
+* it sits from a root. A component with no root (a pure cycle) is seeded from
+* its single lexically-smallest node so the cycle still gets a stable layering.
+*
+* Crucially this is *shortest* path, not longest: a backward (rollback) edge
+* `deep → shallow` never offers a shorter route to the already-shallower
+* target, so it is inert here. Distances are thus stable whether or not the
+* rollbacks are still in the candidate set — which is what lets the peel below
+* tell a genuine back-edge (target strictly shallower than source) apart from a
+* forward edge that merely happens to share the back-edge's cycle.
+*/
+function forwardDistances(nodes, candidates) {
+	const inDegree = /* @__PURE__ */ new Map();
+	for (const node of nodes) inDegree.set(node, 0);
+	for (const edge of candidates) bumpDegree(inDegree, edge.to);
+	const roots = [...nodes].filter((node) => (inDegree.get(node) ?? 0) === 0);
+	roots.sort(compareNodesRootFirst);
+	const seeds = roots.length > 0 ? roots : [...nodes].sort(compareNodesRootFirst).slice(0, 1);
+	const dist = /* @__PURE__ */ new Map();
+	for (const seed of seeds) dist.set(seed, 0);
+	const maxPasses = nodes.size;
+	for (let pass = 0; pass < maxPasses; pass++) {
+		let changed = false;
+		for (const edge of candidates) {
+			const base = dist.get(edge.from);
+			if (base === void 0) continue;
+			const next = base + 1;
+			if (next < (dist.get(edge.to) ?? Number.POSITIVE_INFINITY)) {
+				dist.set(edge.to, next);
+				changed = true;
+			}
+		}
+		if (!changed) break;
+	}
+	for (const node of nodes) if (!dist.has(node)) dist.set(node, 0);
+	return dist;
+}
+function canReachForward(start, goal, candidates) {
+	if (start === goal) return true;
+	const outgoing = /* @__PURE__ */ new Map();
+	for (const edge of candidates) {
+		const bucket = outgoing.get(edge.from);
+		if (bucket) bucket.push(edge.to);
+		else outgoing.set(edge.from, [edge.to]);
+	}
+	const visited = new Set([start]);
+	const queue = [start];
+	while (queue.length > 0) {
+		const node = queue.shift();
+		if (node === void 0) continue;
+		for (const next of outgoing.get(node) ?? []) {
+			if (next === goal) return true;
+			if (!visited.has(next)) {
+				visited.add(next);
+				queue.push(next);
+			}
+		}
+	}
+	return false;
+}
+/**
+* Demote node-skipping rollbacks left forward by the DFS. An edge `from → to`
+* is a rollback exactly when both hold:
+*   1. `to` is a forward-ancestor of `from` — `to` can still reach `from` over
+*      the other forward edges, so the edge closes a cycle; and
+*   2. `to` is strictly shallower than `from` (smaller forward distance) — the
+*      edge points back toward the root rather than advancing history.
+*
+* Condition 2 is the discriminator: in a cycle created by a rollback every edge
+* satisfies condition 1, but only the rollback itself runs deep → shallow. The
+* forward chain edges run shallow → deep and are never peeled, however many
+* rollbacks converge on the same target. Tight back-edges whose source and
+* target sit at the same distance (mutual two-node cycles) are already resolved
+* by the DFS immediate-parent rule, so they never reach this pass. One edge is
+* peeled per iteration (dirName-descending tie-break) and distances/reachability
+* are recomputed, making the outcome independent of edge input order.
+*/
+function peelNodeSkippingRollbacks(nodes, kindByMigrationHash, nonSelf) {
+	let candidates = nonSelf.filter((edge) => kindByMigrationHash.get(edge.hash) === "forward");
+	while (candidates.length > 0) {
+		const dist = forwardDistances(nodes, candidates);
+		const backEdges = candidates.filter((edge) => {
+			if ((dist.get(edge.to) ?? 0) >= (dist.get(edge.from) ?? 0)) return false;
+			const without = candidates.filter((candidate) => candidate !== edge);
+			return canReachForward(edge.to, edge.from, without);
+		});
+		if (backEdges.length === 0) break;
+		backEdges.sort(compareDirNameDesc);
+		const rollback = backEdges[0];
+		if (rollback === void 0) break;
+		kindByMigrationHash.set(rollback.hash, "rollback");
+		candidates = candidates.filter((edge) => edge !== rollback);
+	}
+}
+/**
+* DFS with dirName-descending traversal. A GRAY target is a rollback only when it
+* is the immediate DFS parent of the source — cross-links to other GRAY nodes
+* stay forward. A follow-up peel pass demotes node-skipping rollbacks (target is
+* a forward-ancestor of the source and sits strictly shallower than it).
+*/
+function classifyNormalizedEdges(edges) {
+	const nodes = /* @__PURE__ */ new Set();
+	const kindByMigrationHash = /* @__PURE__ */ new Map();
+	const outgoingByFrom = /* @__PURE__ */ new Map();
+	const nonSelf = [];
+	for (const edge of edges) {
+		nodes.add(edge.from);
+		nodes.add(edge.to);
+		if (edge.from === edge.to) {
+			kindByMigrationHash.set(edge.hash, "self");
+			continue;
+		}
+		nonSelf.push(edge);
+		const bucket = outgoingByFrom.get(edge.from);
+		if (bucket) bucket.push(edge);
+		else outgoingByFrom.set(edge.from, [edge]);
+	}
+	for (const bucket of outgoingByFrom.values()) bucket.sort(compareDirNameDesc);
+	const nonSelfInDegree = /* @__PURE__ */ new Map();
+	for (const node of nodes) nonSelfInDegree.set(node, 0);
+	for (const bucket of outgoingByFrom.values()) for (const edge of bucket) bumpDegree(nonSelfInDegree, edge.to);
+	const dfsRoots = [];
+	for (const node of nodes) if ((nonSelfInDegree.get(node) ?? 0) === 0) dfsRoots.push(node);
+	dfsRoots.sort((a, b) => {
+		if (a === EMPTY_CONTRACT_HASH) return -1;
+		if (b === EMPTY_CONTRACT_HASH) return 1;
+		return a.localeCompare(b);
+	});
+	if (dfsRoots.length === 0) dfsRoots.push(...[...nodes].sort((a, b) => a.localeCompare(b)));
+	const WHITE = 0;
+	const GRAY = 1;
+	const BLACK = 2;
+	const color = /* @__PURE__ */ new Map();
+	const dfsParent = /* @__PURE__ */ new Map();
+	for (const node of nodes) color.set(node, WHITE);
+	const stack = [];
+	function isImmediateDfsParent(ancestor, node) {
+		return dfsParent.get(node) === ancestor;
+	}
+	function pushFrame(node, parent) {
+		color.set(node, GRAY);
+		dfsParent.set(node, parent);
+		stack.push({
+			node,
+			outgoing: outgoingByFrom.get(node) ?? [],
+			index: 0
+		});
+	}
+	function runDfsFrom(root) {
+		if (color.get(root) !== WHITE) return;
+		pushFrame(root, void 0);
+		while (stack.length > 0) {
+			const frame = stack[stack.length - 1];
+			if (frame === void 0) break;
+			if (frame.index >= frame.outgoing.length) {
+				color.set(frame.node, BLACK);
+				stack.pop();
+				continue;
+			}
+			const edge = frame.outgoing[frame.index];
+			frame.index += 1;
+			if (edge === void 0) continue;
+			const v = edge.to;
+			const vColor = color.get(v);
+			if (vColor === GRAY && isImmediateDfsParent(v, frame.node)) kindByMigrationHash.set(edge.hash, "rollback");
+			else {
+				kindByMigrationHash.set(edge.hash, "forward");
+				if (vColor === WHITE) pushFrame(v, frame.node);
+			}
+		}
+	}
+	for (const root of dfsRoots) runDfsFrom(root);
+	const remainingWhite = [...nodes].filter((node) => color.get(node) === WHITE);
+	remainingWhite.sort((a, b) => a.localeCompare(b));
+	for (const root of remainingWhite) runDfsFrom(root);
+	peelNodeSkippingRollbacks(nodes, kindByMigrationHash, nonSelf);
+	const forwardInDegree = /* @__PURE__ */ new Map();
+	const forwardOutDegree = /* @__PURE__ */ new Map();
+	for (const edge of edges) {
+		if (kindByMigrationHash.get(edge.hash) !== "forward") continue;
+		bumpDegree(forwardOutDegree, edge.from);
+		bumpDegree(forwardInDegree, edge.to);
+	}
+	return {
+		kindByMigrationHash,
+		forwardInDegree,
+		forwardOutDegree
+	};
+}
+/**
+* Classify forward/rollback/self for a `MigrationGraph` edge set (Tier-3).
+*/
+function classifyMigrationGraphTopology(graph) {
+	const normalized = [];
+	for (const edges of graph.forwardChain.values()) for (const edge of edges) normalized.push({
+		hash: edge.migrationHash,
+		from: edge.from,
+		to: edge.to,
+		dirName: edge.dirName
+	});
+	return classifyNormalizedEdges(normalized);
+}
+//#endregion
 //#region src/utils/formatters/migration-graph-rows.ts
 /**
 * Return the weakly-connected components of `graph` as an array of node sets,
@@ -869,6 +1080,179 @@ function laneColorForColumn(column) {
 	if (column <= 0) return (text) => text;
 	return LANE_COLOR_CYCLE[(column - 1) % LANE_COLOR_CYCLE.length] ?? ((text) => text);
 }
+function migrationListForwardArrow(glyphMode) {
+	return glyphMode === "ascii" ? "->" : "→";
+}
+function migrationListEmptySource(glyphMode) {
+	return glyphMode === "ascii" ? "-" : "∅";
+}
+function abbreviateContractHash(hash) {
+	return (hash.startsWith("sha256:") ? hash.slice(7) : hash).slice(0, 7);
+}
+//#endregion
+//#region src/utils/formatters/migration-list-render.ts
+const IDENTITY_MIGRATION_LIST_STYLER = {
+	kind: (text) => text,
+	dirName: (text) => text,
+	sourceHash: (text) => text,
+	destHash: (text) => text,
+	glyph: (text) => text,
+	lane: (text) => text,
+	invariants: (ids) => `{${ids.join(", ")}}`,
+	refs: (names) => `(${names.join(", ")})`,
+	spaceHeading: (text) => text,
+	summary: (text) => text,
+	emptyState: (text) => text
+};
+function canonicalFrom(from) {
+	return from ?? EMPTY_CONTRACT_HASH;
+}
+function migrationGraphFromListEntries(entries) {
+	const nodes = /* @__PURE__ */ new Set();
+	const forwardChain = /* @__PURE__ */ new Map();
+	const reverseChain = /* @__PURE__ */ new Map();
+	const migrationByHash = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		const from = canonicalFrom(entry.from);
+		const edge = {
+			from,
+			to: entry.to,
+			migrationHash: entry.migrationHash,
+			dirName: entry.dirName,
+			createdAt: entry.createdAt,
+			invariants: entry.providedInvariants
+		};
+		nodes.add(from);
+		nodes.add(entry.to);
+		const forward = forwardChain.get(from);
+		if (forward) forward.push(edge);
+		else forwardChain.set(from, [edge]);
+		const reverse = reverseChain.get(entry.to);
+		if (reverse) reverse.push(edge);
+		else reverseChain.set(entry.to, [edge]);
+		migrationByHash.set(entry.migrationHash, edge);
+	}
+	return {
+		nodes,
+		forwardChain,
+		reverseChain,
+		migrationByHash
+	};
+}
+function buildEdgeAnnotationsByHashFromListEntries(entries) {
+	const annotations = /* @__PURE__ */ new Map();
+	for (const entry of entries) annotations.set(entry.migrationHash, {
+		operationCount: entry.operationCount,
+		invariants: entry.providedInvariants
+	});
+	return annotations;
+}
+function buildRefsByHashFromListEntries(entries) {
+	const refsByHash = /* @__PURE__ */ new Map();
+	for (const entry of entries) if (entry.refs.length > 0) refsByHash.set(entry.to, entry.refs);
+	return refsByHash;
+}
+function formatEmptyStateLine(spaceId, style) {
+	return style.emptyState(`There are no migrations in migrations/${spaceId}/ yet`);
+}
+function indentTreeBlock(treeOutput, indent) {
+	if (treeOutput.length === 0) return treeOutput;
+	return treeOutput.split("\n").map((line) => line.length === 0 ? line : `${indent}${line}`).join("\n");
+}
+function renderSpaceTreeBlock(spaceId, migrations, multiSpace, glyphMode, style, colorize) {
+	if (migrations.length === 0) {
+		const emptyLine = formatEmptyStateLine(spaceId, style);
+		if (!multiSpace) return [emptyLine];
+		return [style.spaceHeading(`${spaceId}:`), `  ${emptyLine}`];
+	}
+	const treeOutput = renderMigrationGraphTree(buildMigrationGraphLayout(buildMigrationGraphRows(migrationGraphFromListEntries(migrations))), {
+		refsByHash: buildRefsByHashFromListEntries(migrations),
+		edgeAnnotationsByHash: buildEdgeAnnotationsByHashFromListEntries(migrations),
+		colorize,
+		glyphMode
+	});
+	if (!multiSpace) return treeOutput.length === 0 ? [] : [treeOutput];
+	const indented = indentTreeBlock(treeOutput, "  ");
+	return [style.spaceHeading(`${spaceId}:`), indented];
+}
+/**
+* Compose the styled `migration list` human output via the shared tree
+* renderer. Each on-disk migration is one edge row with package-fact
+* annotations; refs decorate destination contract nodes.
+*
+* `options.colorize` must match whether `style` emits ANSI (e.g. both true for
+* `createAnsiMigrationListStyler({ useColor: true })`).
+*/
+function renderMigrationListWithStyle(result, style, glyphMode = "unicode", options = {}) {
+	const multiSpace = result.spaces.length > 1;
+	const colorize = options.colorize ?? false;
+	const lines = [];
+	for (let index = 0; index < result.spaces.length; index++) {
+		const space = result.spaces[index];
+		if (index > 0) lines.push("");
+		lines.push(...renderSpaceTreeBlock(space.spaceId, space.migrations, multiSpace, glyphMode, style, colorize));
+	}
+	if (result.spaces.reduce((count, space) => count + space.migrations.length, 0) > 0) {
+		lines.push("");
+		lines.push(style.summary(result.summary));
+	}
+	return lines.join("\n");
+}
+//#endregion
+//#region src/utils/formatters/migration-list-styler.ts
+/**
+* The current contract overlay marker. Unlike user refs, this names the user's
+* declared desired state — the implicit base/target for `plan` / `migrate` —
+* not a stored label. It is emphasized (bold) so it stands out from plain refs
+* (including the live-database `db` marker, which is just another ref).
+*/
+const CONTRACT_MARKER_NAME = "contract";
+function styleRefName(name) {
+	return name === "contract" ? bold(green(name)) : green(name);
+}
+/**
+* Build a {@link MigrationListStyler} that decorates `migration list`
+* tokens with ANSI SGR codes. When `useColor` is `false` (non-TTY,
+* `--no-color`, `NO_COLOR=1`, piped output) the function returns the
+* shared identity styler so callers get plain text with zero ANSI
+* bytes — pipe-friendly by construction.
+*
+* Palette:
+*
+* - `dirName`: bold
+* - `sourceHash`: dim cyan
+* - `destHash`: bright cyan
+* - `kind` (`*` / `↩` / `⟲`): bright — the signal; lanes and arrows dim
+* - `glyph` (`→` / `⟲` / `∅`): dim
+* - `lane` (graph gutter lines `│` and fan/join connectors `├─┐` / `├─┘`): dim
+* - `invariants` (`{...}`): yellow
+* - `refs` (`(...)`): green; the `contract` desired-state marker inside is
+*   green-bold (the active ref is bolded separately by the tree styler)
+* - `spaceHeading` (`<spaceId>:`): bold
+* - `summary`: dim
+* - `emptyState`: dim
+*/
+function createAnsiMigrationListStyler(opts) {
+	if (!opts.useColor) return IDENTITY_MIGRATION_LIST_STYLER;
+	return {
+		kind: (text) => text,
+		dirName: (text) => bold(text),
+		sourceHash: (text) => dim(cyan(text)),
+		destHash: (text) => cyanBright(text),
+		glyph: (text) => dim(text),
+		lane: (text) => dim(text),
+		invariants: (ids) => yellow(`{${ids.join(", ")}}`),
+		refs: (names) => {
+			const open = green("(");
+			const close = green(")");
+			const separator = green(", ");
+			return open + names.map(styleRefName).join(separator) + close;
+		},
+		spaceHeading: (text) => bold(text),
+		summary: (text) => dim(text),
+		emptyState: (text) => dim(text)
+	};
+}
 //#endregion
 //#region src/utils/formatters/migration-graph-tree-render.ts
 const LABEL_GAP = 2;
@@ -1231,6 +1615,15 @@ function createTreeStyler(opts) {
 		}
 	};
 }
+function formatEdgeAnnotationSuffix(migrationHash, opts, style) {
+	const annotation = opts.edgeAnnotationsByHash?.get(migrationHash);
+	if (annotation === void 0) return "";
+	const segments = [];
+	if (annotation.operationCount !== void 0) segments.push(`${annotation.operationCount} ops`);
+	if (annotation.invariants !== void 0 && annotation.invariants.length > 0) segments.push(style.invariants(annotation.invariants));
+	if (segments.length === 0) return "";
+	return `  ${segments.join("  ")}`;
+}
 function formatEdgeHashColumn(edge, style, hashLength, palette) {
 	if (edge.kind === "self") {
 		const hash = abbreviateHash(edge.from, hashLength, palette.emptySource);
@@ -1335,7 +1728,8 @@ function renderMigrationGraphTree(model, opts) {
 		const laneIndex = row.laneIndex ?? 0;
 		const dirName = `${(opts.colorize && laneIndex > NEUTRAL_LANE ? (text) => forcedBold(laneColorForColumn(laneIndex)(text)) : style.dirName)(edge.dirName)}${dirNamePadding}`;
 		const hashColumn = formatEdgeHashColumn(edge, style, hashLength, palette);
-		lines.push(trimTrailingWhitespace(`${gutterPad}${dirName}${hashColumn}`));
+		const annotationSuffix = formatEdgeAnnotationSuffix(edge.migrationHash, opts, style);
+		lines.push(trimTrailingWhitespace(`${gutterPad}${dirName}${hashColumn}${annotationSuffix}`));
 	}
 	return lines.join("\n");
 }
@@ -1365,160 +1759,6 @@ function renderMigrationGraphLegend(opts) {
 	].join("\n");
 }
 //#endregion
-//#region src/commands/migration-graph.ts
-/**
-* `--legend` describes the `--tree` visual language, so passing it auto-enables
-* the tree path (it has nothing to say about the legacy dagre default).
-*/
-function migrationGraphUsesTree(options) {
-	return options.tree === true || options.legend === true;
-}
-/**
-* The legend is decoration printed alongside the command header on stderr, so
-* it is suppressed for the machine-readable / silent paths (`--json`, `--dot`,
-* `--quiet`) exactly as the header is.
-*/
-function migrationGraphShowsLegend(options, flags) {
-	return options.legend === true && options.dot !== true && flags.json !== true && flags.quiet !== true;
-}
-async function executeMigrationGraphCommand(options, flags, ui) {
-	const config = await loadConfig(options.config);
-	const { configPath, appMigrationsRelative, migrationsDir } = resolveMigrationPaths(options.config, config);
-	if (!flags.json && !flags.quiet) {
-		const header = formatStyledHeader({
-			command: "migration graph",
-			description: "Show the migration graph topology",
-			details: [{
-				label: "config",
-				value: configPath
-			}, {
-				label: "migrations",
-				value: appMigrationsRelative
-			}],
-			flags
-		});
-		ui.stderr(header);
-		if (migrationGraphShowsLegend(options, flags)) {
-			ui.stderr(renderMigrationGraphLegend({
-				colorize: flags.color !== false,
-				glyphMode: ui.resolveGlyphMode(options.ascii === true)
-			}));
-			ui.stderr("");
-		}
-	}
-	const loaded = await buildReadAggregate(config, { migrationsDir });
-	if (!loaded.ok) return loaded;
-	const { aggregate, contractHash } = loaded.value;
-	const graph = aggregate.app.graph();
-	return ok({
-		ok: true,
-		graph,
-		contractHash,
-		refs: Object.entries(aggregate.app.refs).map(([name, entry]) => ({
-			name,
-			hash: entry.hash,
-			active: false
-		})),
-		summary: `${graph.nodes.size} node(s), ${graph.migrationByHash.size} edge(s)`
-	});
-}
-function createMigrationGraphCommand() {
-	const command = new Command("graph");
-	setCommandDescriptions(command, "Show the migration graph topology", "Renders the migration graph topology. Offline — does not consult\nthe database. Use --tree for the condensed annotated tree\n(--ascii swaps box-drawing for pipe-friendly ASCII glyphs),\n--json for machine-readable output, or --dot for Graphviz DOT\nformat.");
-	setCommandExamples(command, [
-		"prisma-next migration graph",
-		"prisma-next migration graph --json",
-		"prisma-next migration graph --dot",
-		"prisma-next migration graph --tree",
-		"prisma-next migration graph --tree --ascii",
-		"prisma-next migration graph --legend"
-	]);
-	setCommandSeeAlso(command, [
-		{
-			verb: "migration status",
-			oneLiner: "Show migration path and pending status"
-		},
-		{
-			verb: "migration log",
-			oneLiner: "Show executed migration history"
-		},
-		{
-			verb: "migration list",
-			oneLiner: "List on-disk migrations"
-		},
-		{
-			verb: "migration show",
-			oneLiner: "Display migration package contents"
-		}
-	]);
-	addGlobalOptions(command).option("--config <path>", "Path to prisma-next.config.ts").option("--dot", "Output in Graphviz DOT format").option("--tree", "Experimental condensed annotated tree renderer").option("--ascii", "Use ASCII glyphs for --tree (pipe-friendly)").option("--legend", "Print a key for the --tree glyphs and lane colors (implies --tree)").action(async (options) => {
-		const flags = parseGlobalFlagsOrExit(options);
-		const ui = createTerminalUI(flags);
-		const exitCode = handleResult(await executeMigrationGraphCommand(options, flags, ui), flags, ui, (graphResult) => {
-			if (options.dot) {
-				const lines = ["digraph migrations {"];
-				for (const edge of graphResult.graph.migrationByHash.values()) {
-					const from = edge.from.slice(0, 12);
-					const to = edge.to.slice(0, 12);
-					lines.push(`  "${from}" -> "${to}" [label="${edge.dirName}"];`);
-				}
-				lines.push("}");
-				ui.output(lines.join("\n"));
-			} else if (flags.json) {
-				const nodes = [...graphResult.graph.nodes];
-				const edges = [...graphResult.graph.migrationByHash.values()].map((e) => ({
-					dirName: e.dirName,
-					from: e.from,
-					to: e.to,
-					migrationHash: e.migrationHash
-				}));
-				ui.output(JSON.stringify({
-					ok: true,
-					nodes,
-					edges,
-					summary: graphResult.summary
-				}, null, 2));
-			} else if (!flags.quiet) if (migrationGraphUsesTree(options)) {
-				const refsByHash = /* @__PURE__ */ new Map();
-				for (const ref of graphResult.refs) {
-					const existing = refsByHash.get(ref.hash);
-					refsByHash.set(ref.hash, existing ? [...existing, ref.name] : [ref.name]);
-				}
-				const layout = buildMigrationGraphLayout(buildMigrationGraphRows(graphResult.graph, { ...graphResult.contractHash !== null ? { contractHash: graphResult.contractHash } : {} }));
-				const activeRef = graphResult.refs.find((ref) => ref.active);
-				const treeOutput = renderMigrationGraphTree(layout, {
-					refsByHash,
-					...graphResult.contractHash !== null ? { contractHash: graphResult.contractHash } : {},
-					...activeRef !== void 0 ? { activeRefName: activeRef.name } : {},
-					colorize: flags.color !== false,
-					glyphMode: ui.resolveGlyphMode(options.ascii === true)
-				});
-				ui.output(treeOutput);
-				ui.output(`\n${graphResult.summary}`);
-			} else {
-				const renderInput = migrationGraphToRenderInput({
-					graph: graphResult.graph,
-					mode: "offline",
-					markerHash: void 0,
-					contractHash: graphResult.contractHash ?? EMPTY_CONTRACT_HASH,
-					refs: graphResult.refs,
-					activeRefHash: void 0,
-					activeRefName: void 0,
-					edgeStatuses: []
-				});
-				const graphOutput = graphRenderer.render(renderInput.graph, {
-					...renderInput.options,
-					colorize: flags.color !== false
-				});
-				ui.log(graphOutput);
-				ui.log(`\n${graphResult.summary}`);
-			}
-		});
-		process.exit(exitCode);
-	});
-	return command;
-}
-//#endregion
-export { migrationGraphUsesTree as i, executeMigrationGraphCommand as n, migrationGraphShowsLegend as r, createMigrationGraphCommand as t };
+export { renderMigrationListWithStyle as a, buildMigrationGraphLayout as c, IDENTITY_MIGRATION_LIST_STYLER as i, renderMigrationGraphTree as n, abbreviateContractHash as o, createAnsiMigrationListStyler as r, buildMigrationGraphRows as s, renderMigrationGraphLegend as t };
 
-//# sourceMappingURL=migration-graph-CeBB07Cc.mjs.map
+//# sourceMappingURL=migration-graph-tree-render-BQdhKBO8.mjs.map