prisma-next 0.11.0-dev.6 → 0.11.0-dev.61

package/dist/migration-list-A3bJ4j5e.mjs

@@ -0,0 +1,780 @@
+import { t as loadConfig } from "./config-loader-B6sJjXTv.mjs";
+import { B as errorInvalidSpaceId, Q as errorSpaceNotFound, T as formatStyledHeader, _ as createTerminalUI, d as setCommandSeeAlso, g as parseGlobalFlagsOrExit, l as setCommandDescriptions, s as resolveMigrationPaths, t as addGlobalOptions, u as setCommandExamples, y as handleResult } from "./command-helpers-CoceqqMl.mjs";
+import { r as buildReadAggregate } from "./contract-space-aggregate-loader-lafgkTwG.mjs";
+import { Command } from "commander";
+import { ifDefined } from "@prisma-next/utils/defined";
+import { notOk, ok } from "@prisma-next/utils/result";
+import { APP_SPACE_ID, RESERVED_SPACE_SUBDIR_NAMES, isValidSpaceId, listContractSpaceDirectories } from "@prisma-next/migration-tools/spaces";
+import { bold, cyan, cyanBright, dim, green, greenBright, yellow } from "colorette";
+import { EMPTY_CONTRACT_HASH } from "@prisma-next/migration-tools/constants";
+import { HEAD_REF_NAME, refsByContractHash } from "@prisma-next/migration-tools/refs";
+const MIGRATION_LIST_UNICODE_KIND_GLYPH = {
+	forward: "*",
+	rollback: "↩",
+	self: "⟲"
+};
+const MIGRATION_LIST_ASCII_KIND_GLYPH = {
+	forward: "*",
+	rollback: "<",
+	self: "~"
+};
+function migrationListKindGlyph(glyphMode, edgeKind) {
+	return glyphMode === "ascii" ? MIGRATION_LIST_ASCII_KIND_GLYPH[edgeKind] : MIGRATION_LIST_UNICODE_KIND_GLYPH[edgeKind];
+}
+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);
+}
+function computeMigrationDirNameWidth(migrations) {
+	if (migrations.length === 0) return 0;
+	return Math.max(...migrations.map((entry) => entry.dirName.length)) + 2;
+}
+function formatSourceColumn(from, style, emptySource) {
+	if (from === null) return style.glyph(emptySource) + " ".repeat(7 - emptySource.length);
+	return style.sourceHash(abbreviateContractHash(from));
+}
+function formatDecorations(providedInvariants, refs, style) {
+	const blocks = [];
+	if (providedInvariants.length > 0) blocks.push(style.invariants(providedInvariants));
+	if (refs.length > 0) blocks.push(style.refs(refs));
+	if (blocks.length === 0) return "";
+	return `  ${blocks.join(" ")}`;
+}
+function formatMigrationDataColumn(migration, options) {
+	const { dirNameWidth, edgeKind, style, forwardArrow = "→", emptySource = "∅" } = options;
+	const dirNamePadding = " ".repeat(Math.max(0, dirNameWidth - migration.dirName.length));
+	const dirName = `${style.dirName(migration.dirName)}${dirNamePadding}`;
+	const decorations = formatDecorations(migration.providedInvariants, migration.refs, style);
+	if (edgeKind === "self") {
+		const contractHash = migration.from ?? migration.to;
+		return `${dirName}${style.sourceHash(abbreviateContractHash(contractHash))}${decorations}`;
+	}
+	return `${dirName}${formatSourceColumn(migration.from, style, emptySource)} ${style.glyph(forwardArrow)} ${style.destHash(abbreviateContractHash(migration.to))}${decorations}`;
+}
+function formatNodeLineDataColumn(contractHash, style) {
+	return style.sourceHash(abbreviateContractHash(contractHash));
+}
+//#endregion
+//#region src/utils/formatters/migration-list-graph-topology.ts
+function canonicalFrom$1(from) {
+	return from ?? EMPTY_CONTRACT_HASH;
+}
+function compareDirNameDesc(a, b) {
+	return b.dirName.localeCompare(a.dirName);
+}
+function bumpDegree(map, key) {
+	map.set(key, (map.get(key) ?? 0) + 1);
+}
+function classifyMigrationListGraphTopology(entries) {
+	const nodes = /* @__PURE__ */ new Set();
+	const kindByMigrationHash = /* @__PURE__ */ new Map();
+	const outgoingByFrom = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		const from = canonicalFrom$1(entry.from);
+		const to = entry.to;
+		nodes.add(from);
+		nodes.add(to);
+		if (from === to) {
+			kindByMigrationHash.set(entry.migrationHash, "self");
+			continue;
+		}
+		const bucket = outgoingByFrom.get(from);
+		const edge = {
+			entry,
+			from,
+			to
+		};
+		if (bucket) bucket.push(edge);
+		else outgoingByFrom.set(from, [edge]);
+	}
+	for (const bucket of outgoingByFrom.values()) bucket.sort((a, b) => compareDirNameDesc(a.entry, b.entry));
+	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();
+	for (const node of nodes) color.set(node, WHITE);
+	const stack = [];
+	function pushFrame(node) {
+		color.set(node, GRAY);
+		stack.push({
+			node,
+			outgoing: outgoingByFrom.get(node) ?? [],
+			index: 0
+		});
+	}
+	function runDfsFrom(root) {
+		if (color.get(root) !== WHITE) return;
+		pushFrame(root);
+		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) kindByMigrationHash.set(edge.entry.migrationHash, "rollback");
+			else {
+				kindByMigrationHash.set(edge.entry.migrationHash, "forward");
+				if (vColor === WHITE) pushFrame(v);
+			}
+		}
+	}
+	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);
+	const forwardInDegree = /* @__PURE__ */ new Map();
+	const forwardOutDegree = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		if (kindByMigrationHash.get(entry.migrationHash) !== "forward") continue;
+		const from = canonicalFrom$1(entry.from);
+		const to = entry.to;
+		bumpDegree(forwardOutDegree, from);
+		bumpDegree(forwardInDegree, to);
+	}
+	return {
+		kindByMigrationHash,
+		forwardInDegree,
+		forwardOutDegree
+	};
+}
+//#endregion
+//#region src/utils/formatters/migration-list-graph-layout.ts
+function canonicalFrom(from) {
+	return from ?? EMPTY_CONTRACT_HASH;
+}
+function forwardInDegree(topology, hash) {
+	return topology.forwardInDegree.get(hash) ?? 0;
+}
+function forwardOutDegree(topology, hash) {
+	return topology.forwardOutDegree.get(hash) ?? 0;
+}
+function buildForwardProducersByTo(entries, kindByMigrationHash) {
+	const byTo = /* @__PURE__ */ new Map();
+	for (const entry of entries) {
+		if (kindByMigrationHash.get(entry.migrationHash) !== "forward") continue;
+		const bucket = byTo.get(entry.to);
+		if (bucket) bucket.push(entry);
+		else byTo.set(entry.to, [entry]);
+	}
+	return byTo;
+}
+function countForwardProducersTo(forwardProducersByTo, contract) {
+	return forwardProducersByTo.get(contract)?.length ?? 0;
+}
+function hasLaterForwardDepartingFrom(entries, startIndex, contract, kindByMigrationHash) {
+	for (let index = startIndex + 1; index < entries.length; index++) {
+		const later = entries[index];
+		if (later === void 0) continue;
+		if (kindByMigrationHash.get(later.migrationHash) !== "forward") continue;
+		if (canonicalFrom(later.from) === contract) return true;
+	}
+	return false;
+}
+function computeMigrationListGraphLayout(entries, topology = classifyMigrationListGraphTopology(entries)) {
+	const { kindByMigrationHash } = topology;
+	const forwardProducersByTo = buildForwardProducersByTo(entries, kindByMigrationHash);
+	const convergencesEmitted = /* @__PURE__ */ new Set();
+	const producerLaneByHash = /* @__PURE__ */ new Map();
+	const lanes = [];
+	const rows = [];
+	function emitNodeLine(contractHash) {
+		rows.push({
+			kind: "nodeLine",
+			contractHash,
+			laneIndex: 0
+		});
+	}
+	function emitConnector(connectorKind, contractHash, startLane, endLane, branchCount) {
+		rows.push({
+			kind: "connector",
+			connectorKind,
+			contractHash,
+			startLane,
+			endLane,
+			branchCount
+		});
+	}
+	function activeLaneIndices() {
+		const indices = [];
+		for (let index = 0; index < lanes.length; index++) if (lanes[index]?.active) indices.push(index);
+		return indices;
+	}
+	function lanesWanting(contract) {
+		const indices = [];
+		for (let index = 0; index < lanes.length; index++) {
+			const lane = lanes[index];
+			if (lane?.active && lane.want === contract) indices.push(index);
+		}
+		return indices;
+	}
+	function ensureLane(index) {
+		while (lanes.length <= index) lanes.push({
+			want: "",
+			active: false
+		});
+	}
+	function openLaneAtRight(want) {
+		const index = lanes.length;
+		lanes.push({
+			want,
+			active: true
+		});
+		return index;
+	}
+	function closeLane(index) {
+		ensureLane(index);
+		const lane = lanes[index];
+		if (lane) lane.active = false;
+	}
+	function emitJoinAbove(contractHash, laneIndices) {
+		if (laneIndices.length < 2) return;
+		const startLane = Math.min(...laneIndices);
+		emitConnector("joinAbove", contractHash, startLane, Math.max(...laneIndices), laneIndices.length);
+		for (const index of laneIndices) if (index !== startLane) closeLane(index);
+	}
+	function emitConvergencePreamble(contract) {
+		if (convergencesEmitted.has(contract)) return;
+		if (forwardInDegree(topology, contract) < 2) return;
+		const consumersWanting = lanesWanting(contract);
+		if (forwardOutDegree(topology, contract) >= 2 && consumersWanting.length >= 2) emitJoinAbove(contract, consumersWanting);
+		emitNodeLine(contract);
+		const producers = forwardProducersByTo.get(contract) ?? [];
+		if (producers.length >= 2) emitConnector("fanBelow", contract, 0, producers.length - 1, producers.length);
+		for (const [producerIndex, producer] of producers.entries()) {
+			ensureLane(producerIndex);
+			lanes[producerIndex] = {
+				want: canonicalFrom(producer.from),
+				active: true
+			};
+			producerLaneByHash.set(producer.migrationHash, producerIndex);
+		}
+		convergencesEmitted.add(contract);
+	}
+	function placeWoven(entry, edgeKind, laneIndex) {
+		const passThroughLanes = activeLaneIndices().filter((index) => index !== laneIndex);
+		rows.push({
+			kind: "migration",
+			entry,
+			edgeKind,
+			laneIndex,
+			passThroughLanes,
+			woven: true
+		});
+		ensureLane(laneIndex);
+		lanes[laneIndex] = {
+			want: canonicalFrom(entry.from),
+			active: true
+		};
+	}
+	function placeUnwoven(entry, edgeKind) {
+		const passThroughLanes = activeLaneIndices();
+		const laneIndex = passThroughLanes.length === 0 ? 0 : Math.max(...passThroughLanes) + 1;
+		rows.push({
+			kind: "migration",
+			entry,
+			edgeKind,
+			laneIndex,
+			passThroughLanes,
+			woven: false
+		});
+	}
+	for (let entryIndex = 0; entryIndex < entries.length; entryIndex++) {
+		const entry = entries[entryIndex];
+		const edgeKind = kindByMigrationHash.get(entry.migrationHash) ?? "forward";
+		const to = entry.to;
+		if (edgeKind !== "forward") {
+			placeUnwoven(entry, edgeKind);
+			continue;
+		}
+		if (forwardInDegree(topology, to) >= 2 && !convergencesEmitted.has(to)) emitConvergencePreamble(to);
+		const presetLane = producerLaneByHash.get(entry.migrationHash);
+		const wantingTo = lanesWanting(to);
+		if (wantingTo.length >= 2 && countForwardProducersTo(forwardProducersByTo, to) === 1) emitJoinAbove(to, wantingTo);
+		if (presetLane !== void 0) {
+			placeWoven(entry, edgeKind, presetLane);
+			continue;
+		}
+		const firstWanting = wantingTo[0];
+		if (firstWanting !== void 0) {
+			placeWoven(entry, edgeKind, firstWanting);
+			continue;
+		}
+		if (hasLaterForwardDepartingFrom(entries, entryIndex, to, kindByMigrationHash)) {
+			placeUnwoven(entry, edgeKind);
+			continue;
+		}
+		placeWoven(entry, edgeKind, openLaneAtRight(canonicalFrom(entry.from)));
+	}
+	return { rows };
+}
+//#endregion
+//#region src/utils/formatters/migration-list-graph-render.ts
+const UNICODE_PALETTE = {
+	lane: "│",
+	node: "o",
+	forwardArrow: migrationListForwardArrow("unicode"),
+	emptySource: migrationListEmptySource("unicode"),
+	kind: MIGRATION_LIST_UNICODE_KIND_GLYPH,
+	fanBelow: (branchCount) => branchCount === 2 ? "├─┐" : "├─┬─┐",
+	joinAbove: (branchCount) => branchCount === 2 ? "├─┘" : "└─┴─┘"
+};
+const ASCII_PALETTE = {
+	lane: "|",
+	node: "o",
+	forwardArrow: migrationListForwardArrow("ascii"),
+	emptySource: migrationListEmptySource("ascii"),
+	kind: MIGRATION_LIST_ASCII_KIND_GLYPH,
+	fanBelow: (branchCount) => branchCount === 2 ? "+-\\" : "+-|-\\",
+	joinAbove: (branchCount) => branchCount === 2 ? "+-/" : "/-+-/"
+};
+function paletteFor(mode) {
+	return mode === "ascii" ? ASCII_PALETTE : UNICODE_PALETTE;
+}
+function migrationEntries(layout) {
+	const entries = [];
+	for (const row of layout.rows) if (row.kind === "migration") entries.push(row.entry);
+	return entries;
+}
+function layoutMaxLaneIndex(layout) {
+	let max = 0;
+	for (const row of layout.rows) if (row.kind === "migration") max = Math.max(max, row.laneIndex, ...row.passThroughLanes);
+	else if (row.kind === "connector") max = Math.max(max, row.endLane);
+	else max = Math.max(max, row.laneIndex);
+	return max;
+}
+function laneCell(glyph) {
+	return `${glyph} `;
+}
+function emptyLaneCell() {
+	return "  ";
+}
+function renderMigrationGutter(row, maxLane, palette, style) {
+	const cells = [];
+	for (let lane = 0; lane <= maxLane; lane++) if (lane === row.laneIndex) cells.push(laneCell(style.kind(palette.kind[row.edgeKind])));
+	else if (row.passThroughLanes.includes(lane)) cells.push(laneCell(style.lane(palette.lane)));
+	else cells.push(emptyLaneCell());
+	return cells.join("");
+}
+function renderNodeLineGutter(row, openLanes, maxLane, palette, style) {
+	const cells = [];
+	for (let lane = 0; lane <= maxLane; lane++) if (lane === row.laneIndex) cells.push(laneCell(palette.node));
+	else if (openLanes.has(lane)) cells.push(laneCell(style.lane(palette.lane)));
+	else cells.push(emptyLaneCell());
+	return cells.join("");
+}
+function renderConnectorGutter(row, openLanes, maxLane, palette, style) {
+	const spanWidth = (row.endLane - row.startLane + 1) * 2;
+	let spanGlyph = (row.connectorKind === "fanBelow" ? palette.fanBelow(row.branchCount) : palette.joinAbove(row.branchCount)).padEnd(spanWidth, " ").slice(0, spanWidth);
+	if (![...openLanes].some((lane) => lane < row.startLane || lane > row.endLane) && spanGlyph.endsWith(" ")) spanGlyph = spanGlyph.slice(0, -1);
+	let gutter = "";
+	for (let lane = 0; lane < row.startLane; lane++) gutter += openLanes.has(lane) ? laneCell(style.lane(palette.lane)) : emptyLaneCell();
+	gutter += style.lane(spanGlyph);
+	for (let lane = row.endLane + 1; lane <= maxLane; lane++) gutter += openLanes.has(lane) ? laneCell(style.lane(palette.lane)) : emptyLaneCell();
+	return gutter;
+}
+function advanceOpenLanes(row, openLanes) {
+	if (row.kind === "migration") return new Set([row.laneIndex, ...row.passThroughLanes]);
+	if (row.kind === "connector") {
+		if (row.connectorKind === "fanBelow") {
+			const next = new Set(openLanes);
+			for (let lane = row.startLane; lane <= row.endLane; lane++) next.add(lane);
+			return next;
+		}
+		const next = new Set(openLanes);
+		for (let lane = row.startLane + 1; lane <= row.endLane; lane++) next.delete(lane);
+		return next;
+	}
+	return openLanes;
+}
+function renderMigrationListGraphWithStyle(layout, style, glyphMode) {
+	const palette = paletteFor(glyphMode);
+	const migrations = migrationEntries(layout);
+	const layoutMaxLane = layoutMaxLaneIndex(layout);
+	const dirNameWidth = computeMigrationDirNameWidth(migrations);
+	const gutterMaxLane = layoutMaxLane;
+	const blockDataStart = (layoutMaxLane + 1) * 2;
+	const gutterVisibleWidth = (gutterMaxLane + 1) * 2;
+	const lines = [];
+	let openLanes = /* @__PURE__ */ new Set();
+	function padToDataColumn(gutter, dataStart) {
+		return gutter + " ".repeat(Math.max(0, dataStart - gutterVisibleWidth));
+	}
+	for (const row of layout.rows) {
+		if (row.kind === "migration") {
+			const gutter = renderMigrationGutter(row, gutterMaxLane, palette, style);
+			const data = formatMigrationDataColumn(row.entry, {
+				dirNameWidth,
+				edgeKind: row.edgeKind,
+				style,
+				forwardArrow: palette.forwardArrow,
+				emptySource: palette.emptySource
+			});
+			lines.push(`${padToDataColumn(gutter, blockDataStart)}${data}`);
+		} else if (row.kind === "nodeLine") {
+			const gutter = renderNodeLineGutter(row, openLanes, gutterMaxLane, palette, style);
+			const data = formatNodeLineDataColumn(row.contractHash, style);
+			lines.push(`${padToDataColumn(gutter, blockDataStart)}${data}`);
+		} else lines.push(renderConnectorGutter(row, openLanes, gutterMaxLane, palette, style));
+		openLanes = advanceOpenLanes(row, openLanes);
+	}
+	return lines.map((line) => line.trimEnd()).join("\n");
+}
+function formatGraphEmptyStateLine(spaceId, style) {
+	return style.emptyState(`There are no migrations in migrations/${spaceId}/ yet`);
+}
+function renderGraphSpaceBlock(spaceId, migrations, multiSpace, style, glyphMode, topology) {
+	if (migrations.length === 0) {
+		const emptyLine = formatGraphEmptyStateLine(spaceId, style);
+		if (!multiSpace) return [emptyLine];
+		return [style.spaceHeading(`${spaceId}:`), `  ${emptyLine}`];
+	}
+	const rows = renderMigrationListGraphWithStyle(computeMigrationListGraphLayout(migrations, topology), style, glyphMode).split("\n");
+	if (!multiSpace) return rows;
+	return [style.spaceHeading(`${spaceId}:`), ...rows.map((row) => `  ${row}`)];
+}
+function renderMigrationListGraphResult(result, style, glyphMode, topologyBySpaceId) {
+	const multiSpace = result.spaces.length > 1;
+	const lines = [];
+	for (let index = 0; index < result.spaces.length; index++) {
+		const space = result.spaces[index];
+		if (index > 0) lines.push("");
+		const topology = topologyBySpaceId.get(space.spaceId);
+		if (topology === void 0) throw new Error(`missing topology for space ${space.spaceId}`);
+		lines.push(...renderGraphSpaceBlock(space.spaceId, space.migrations, multiSpace, style, glyphMode, topology));
+	}
+	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-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 resolveEdgeKind(migrationHash, kindByMigrationHash) {
+	return kindByMigrationHash.get(migrationHash) ?? "forward";
+}
+function formatMigrationRow(migration, dirNameWidth, edgeKind, glyphMode, style) {
+	return `${`${style.kind(migrationListKindGlyph(glyphMode, edgeKind))} `}${formatMigrationDataColumn(migration, {
+		dirNameWidth,
+		edgeKind,
+		style,
+		forwardArrow: migrationListForwardArrow(glyphMode),
+		emptySource: migrationListEmptySource(glyphMode)
+	})}`;
+}
+function formatEmptyStateLine(spaceId, style) {
+	return style.emptyState(`There are no migrations in migrations/${spaceId}/ yet`);
+}
+function renderSpaceBlock(spaceId, migrations, multiSpace, glyphMode, kindByMigrationHash, style) {
+	if (migrations.length === 0) {
+		const emptyLine = formatEmptyStateLine(spaceId, style);
+		if (!multiSpace) return [emptyLine];
+		return [style.spaceHeading(`${spaceId}:`), `  ${emptyLine}`];
+	}
+	const dirNameWidth = computeMigrationDirNameWidth(migrations);
+	const rows = migrations.map((entry) => formatMigrationRow(entry, dirNameWidth, resolveEdgeKind(entry.migrationHash, kindByMigrationHash), glyphMode, style));
+	if (!multiSpace) return rows;
+	return [style.spaceHeading(`${spaceId}:`), ...rows.map((row) => `  ${row}`)];
+}
+function buildMigrationListTopologyBySpace(result) {
+	const topologyBySpaceId = /* @__PURE__ */ new Map();
+	for (const space of result.spaces) topologyBySpaceId.set(space.spaceId, classifyMigrationListGraphTopology(space.migrations));
+	return topologyBySpaceId;
+}
+/**
+* Compose the styled `migration list` output. The renderer is
+* presentation-neutral — every token passes through `style` before
+* landing in the output, so the same composition serves the pure-text
+* path ({@link renderMigrationList} via
+* {@link IDENTITY_MIGRATION_LIST_STYLER}) and the ANSI-styled CLI path
+* (via the ANSI styler the CLI shell wires up).
+*/
+function renderMigrationListWithStyle(result, style, glyphMode = "unicode", topologyBySpaceId = buildMigrationListTopologyBySpace(result)) {
+	const multiSpace = result.spaces.length > 1;
+	const lines = [];
+	for (let index = 0; index < result.spaces.length; index++) {
+		const space = result.spaces[index];
+		if (index > 0) lines.push("");
+		const kindByMigrationHash = topologyBySpaceId.get(space.spaceId)?.kindByMigrationHash ?? classifyMigrationListGraphTopology(space.migrations).kindByMigrationHash;
+		lines.push(...renderSpaceBlock(space.spaceId, space.migrations, multiSpace, glyphMode, kindByMigrationHash, style));
+	}
+	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 reserved ref name for the live-database marker. Treated as a
+* structurally distinct token from user-named refs so the styler can
+* make it visually pop in `(refs)` decorations.
+*/
+const DB_REF_NAME = "db";
+function styleRefName(name) {
+	return name === DB_REF_NAME ? bold(greenBright(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 live-DB `db` marker inside is green-bold
+* - `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/commands/migration-list.ts
+function compareSpaceIds(a, b) {
+	if (a === APP_SPACE_ID) return b === APP_SPACE_ID ? 0 : -1;
+	if (b === APP_SPACE_ID) return 1;
+	if (a < b) return -1;
+	if (a > b) return 1;
+	return 0;
+}
+function compareDirNamesDescending(a, b) {
+	if (a.dirName < b.dirName) return 1;
+	if (a.dirName > b.dirName) return -1;
+	return 0;
+}
+/**
+* Ref names decorating a space's destination contract hashes. The
+* tolerant `member.refs` deliberately omits the structural `head.json`;
+* for extension spaces the old enumerator surfaced it as a `head`
+* decoration on the tip migration, so fold `member.headRef` back in to
+* keep that output. The app space synthesises its head, so it carries
+* no on-disk `head` ref to restore.
+*/
+function listRefsByContractHash(member) {
+	const byHash = new Map(refsByContractHash(member.refs));
+	if (member.spaceId !== APP_SPACE_ID && member.headRef !== null) {
+		const hash = member.headRef.hash;
+		const bucket = byHash.get(hash) ?? [];
+		if (!bucket.includes(HEAD_REF_NAME)) byHash.set(hash, [...bucket, HEAD_REF_NAME].sort());
+	}
+	return byHash;
+}
+async function orderedOnDiskSpaceIds(projectMigrationsDir) {
+	return (await listContractSpaceDirectories(projectMigrationsDir)).filter((name) => !RESERVED_SPACE_SUBDIR_NAMES.has(name)).filter(isValidSpaceId).sort(compareSpaceIds);
+}
+/**
+* Project the loaded {@link ContractSpaceAggregate} into the render-ready
+* {@link MigrationSpaceListEntry} rows `migration list` displays.
+*
+* Space membership matches the on-disk contract-space directories (not the
+* aggregate's always-present synthesized app member when `migrations/app/`
+* is absent); package and ref data come from `aggregate.space(id)`.
+*/
+async function migrationSpaceListEntriesFromAggregate(aggregate, projectMigrationsDir) {
+	const spaceIds = await orderedOnDiskSpaceIds(projectMigrationsDir);
+	const spaces = [];
+	for (const spaceId of spaceIds) {
+		const member = aggregate.space(spaceId);
+		if (member === void 0) continue;
+		const refsByHash = listRefsByContractHash(member);
+		const migrations = member.packages.map((pkg) => ({
+			dirName: pkg.dirName,
+			from: pkg.metadata.from,
+			to: pkg.metadata.to,
+			migrationHash: pkg.metadata.migrationHash,
+			operationCount: pkg.ops.length,
+			createdAt: pkg.metadata.createdAt,
+			refs: refsByHash.get(pkg.metadata.to) ?? [],
+			providedInvariants: pkg.metadata.providedInvariants
+		})).sort(compareDirNamesDescending);
+		spaces.push({
+			spaceId,
+			migrations
+		});
+	}
+	return spaces;
+}
+function renderMigrationListHumanOutput(result, options) {
+	const styler = createAnsiMigrationListStyler({ useColor: options.useColor });
+	const topologyBySpaceId = buildMigrationListTopologyBySpace(result);
+	if (options.graph) return renderMigrationListGraphResult(result, styler, options.glyphMode, topologyBySpaceId);
+	return renderMigrationListWithStyle(result, styler, options.glyphMode, topologyBySpaceId);
+}
+function computeSummary(spaces) {
+	const totalMigrations = spaces.reduce((count, space) => count + space.migrations.length, 0);
+	if (spaces.length <= 1) return `${totalMigrations} migration(s) on disk`;
+	return `${totalMigrations} migration(s) across ${spaces.length} contract space(s)`;
+}
+/**
+* Policy core of `migration list`: validates `--space`, narrows the
+* pre-enumerated spaces, and assembles a {@link MigrationListResult}.
+*
+* - `migrations/` missing or contains no valid space directories →
+*   caller passes `spaces: []`; this synthesizes `[{ spaceId: APP_SPACE_ID, migrations: [] }]`.
+* - `--space <id>` on an existing-but-empty space → `{ spaceId, migrations: [] }` in the input.
+* - `--space <id>` on a non-existent (or reserved) space → `SPACE_NOT_FOUND`.
+*/
+function runMigrationList(inputs) {
+	const { spaces, spaceFilter } = inputs;
+	if (spaceFilter !== void 0 && !isValidSpaceId(spaceFilter)) return notOk(errorInvalidSpaceId(spaceFilter));
+	if (spaceFilter !== void 0 && !spaces.some((s) => s.spaceId === spaceFilter)) return notOk(errorSpaceNotFound(spaceFilter, spaces.map((s) => s.spaceId).sort()));
+	const scopedSpaces = spaceFilter !== void 0 ? spaces.filter((s) => s.spaceId === spaceFilter) : spaces;
+	const resultSpaces = scopedSpaces.length === 0 ? [{
+		spaceId: APP_SPACE_ID,
+		migrations: []
+	}] : scopedSpaces;
+	return ok({
+		ok: true,
+		spaces: resultSpaces,
+		summary: computeSummary(resultSpaces)
+	});
+}
+/**
+* CLI shell: loads config, resolves paths, prints the styled header on
+* stderr (interactive mode only), and delegates to {@link runMigrationList}.
+* Kept intentionally thin so the unit-testable surface lives in the core.
+*/
+async function executeMigrationListCommand(options, flags, ui) {
+	const config = await loadConfig(options.config);
+	const { configPath, migrationsDir, migrationsRelative } = resolveMigrationPaths(options.config, config);
+	if (!flags.json && !flags.quiet) {
+		const header = formatStyledHeader({
+			command: "migration list",
+			description: "List on-disk migrations, latest first, per contract space",
+			details: [
+				{
+					label: "config",
+					value: configPath
+				},
+				{
+					label: "migrations",
+					value: migrationsRelative
+				},
+				...options.space !== void 0 ? [{
+					label: "space",
+					value: options.space
+				}] : []
+			],
+			flags
+		});
+		ui.stderr(header);
+	}
+	const loaded = await buildReadAggregate(config, { migrationsDir });
+	if (!loaded.ok) return notOk(loaded.failure);
+	return runMigrationList({
+		spaces: await migrationSpaceListEntriesFromAggregate(loaded.value.aggregate, migrationsDir),
+		...ifDefined("spaceFilter", options.space)
+	});
+}
+function createMigrationListCommand() {
+	const command = new Command("list");
+	setCommandDescriptions(command, "List on-disk migrations, latest first, per contract space", "Enumerates every on-disk migration under migrations/<space>/ for every\ncontract space found on disk, latest first. Offline — does not consult\nthe database. Each row leads with a kind glyph (* forward, ↩ rollback,\n⟲ self), then dirName, then source → destination contract hashes\n(7-char git-style). Self-edges show a single hash. Invariants render as\n{...}; refs on the destination as (production, db). Pass --space <id>\nto narrow to one contract space. --graph draws the forward spine with\nlane gutters; --ascii forces ASCII glyphs (orthogonal to --no-color).");
+	setCommandExamples(command, [
+		"prisma-next migration list",
+		"prisma-next migration list --graph",
+		"prisma-next migration list --space app",
+		"prisma-next migration list --graph --ascii",
+		"prisma-next migration list --json"
+	]);
+	setCommandSeeAlso(command, [
+		{
+			verb: "migration status",
+			oneLiner: "Show migration path and pending status"
+		},
+		{
+			verb: "migration log",
+			oneLiner: "Show executed migration history"
+		},
+		{
+			verb: "migration graph",
+			oneLiner: "Show the migration graph topology"
+		},
+		{
+			verb: "migration show",
+			oneLiner: "Display migration package contents"
+		}
+	]);
+	addGlobalOptions(command).option("--config <path>", "Path to prisma-next.config.ts").option("--space <id>", "Narrow output to a single contract space").option("--graph", "Draw migration relationships as an annotated tree").option("--ascii", "Use ASCII glyphs for --graph (pipe-friendly)").action(async (options) => {
+		const flags = parseGlobalFlagsOrExit(options);
+		const ui = createTerminalUI(flags);
+		const exitCode = handleResult(await executeMigrationListCommand(options, flags, ui), flags, ui, (listResult) => {
+			if (flags.json) ui.output(JSON.stringify(listResult, null, 2));
+			else if (!flags.quiet) ui.output(renderMigrationListHumanOutput(listResult, {
+				graph: options.graph === true,
+				glyphMode: ui.resolveGlyphMode(options.ascii === true),
+				useColor: ui.useColor
+			}));
+		});
+		process.exit(exitCode);
+	});
+	return command;
+}
+//#endregion
+export { runMigrationList as a, renderMigrationListHumanOutput as i, executeMigrationListCommand as n, migrationSpaceListEntriesFromAggregate as r, createMigrationListCommand as t };
+
+//# sourceMappingURL=migration-list-A3bJ4j5e.mjs.map