prisma-next 0.11.0 → 0.12.0-dev.10

package/dist/commands/migration-check.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"migration-check.d.mts","names":[],"sources":["../../src/commands/migration-check.ts"],"mappings":";;;UA2BiB,YAAA;EAAA,SACN,MAAA;EAAA,SACA,KAAA;EAAA,SACA,GAAA;EAAA,SACA,GAAA;AAAA;AAAA,UAGM,oBAAA;EAAA,SACN,EAAA;EAAA,SACA,QAAA,WAAmB,YAAA;EAAA,SACnB,OAAA;AAAA;AAAA,iBAmRK,2BAAA,CAAA,GAA+B,OAAA"}
+{"version":3,"file":"migration-check.d.mts","names":[],"sources":["../../src/utils/integrity-violation-to-check-failure.ts","../../src/commands/migration-check.ts"],"mappings":";;UAGiB,YAAA;EAAA,SACN,MAAA;EAAA,SACA,KAAA;EAAA,SACA,GAAA;EAAA,SACA,GAAA;AAAA;;;UCgCM,oBAAA;EAAA,SACN,EAAA;EAAA,SACA,QAAA,WAAmB,YAAY;EAAA,SAC/B,OAAA;AAAA;AAAA,iBAsOK,2BAAA,CAAA,GAA+B,OAAO"}

package/dist/commands/migration-check.mjs

@@ -1,281 +1,2 @@
-import { t as loadConfig } from "../config-loader-B6sJjXTv.mjs";
-import { t as createTerminalUI } from "../terminal-ui-BiB_8KNo.mjs";
-import { S as formatStyledHeader, a as loadMigrationPackages, d as setCommandDescriptions, f as setCommandExamples, l as resolveMigrationPaths, p as setCommandSeeAlso, t as addGlobalOptions, v as parseGlobalFlagsOrExit } from "../command-helpers-BSb0tRC8.mjs";
-import { Command } from "commander";
-import { join, relative } from "pathe";
-import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
-import { MigrationToolsError } from "@prisma-next/migration-tools/errors";
-import { parseMigrationRef } from "@prisma-next/migration-tools/ref-resolution";
-import { readRefs } from "@prisma-next/migration-tools/refs";
-import { verifyMigrationHash } from "@prisma-next/migration-tools/hash";
-//#region src/commands/migration-check.ts
-/**
-* Canonical user-facing locator for a check failure: the cwd-relative path
-* to the migration package directory. Surfacing the same shape across every
-* PN code means `--json` consumers can branch uniformly on `where`.
-*/
-function migrationPathRelative(dirPath) {
-	return relative(process.cwd(), dirPath);
-}
-function migrationFileRelative(dirPath, fileName) {
-	return join(migrationPathRelative(dirPath), fileName);
-}
-function checkFileExists(dirPath, dirName, fileName) {
-	if (!existsSync(join(dirPath, fileName))) return {
-		pnCode: "PN-MIG-CHECK-002",
-		where: migrationFileRelative(dirPath, fileName),
-		why: `${fileName} is missing from ${dirName}`,
-		fix: "Re-emit the migration package or restore from version control."
-	};
-	return null;
-}
-/**
-* Within-migration snapshot-consistency check (PN-MIG-CHECK-005).
-*
-* Compares the migration's stored `metadata.to` against the `storageHash`
-* recorded in its on-disk `end-contract.json` snapshot. The two values are
-* independent on-disk records of the same fact (the migration's destination
-* contract); drift between them indicates the package is internally
-* corrupt. Cross-migration consistency (one migration's end-contract.json
-* agreeing with the next migration's start-contract.json) is a separate
-* check that requires shadow execution and is deferred to
-* `migration preflight`.
-*
-* Shared between the graph-wide and per-migration code paths so both report
-* the same failure for the same on-disk state.
-*/
-function checkSnapshotConsistency(pkg) {
-	const endContractPath = join(pkg.dirPath, "end-contract.json");
-	if (!existsSync(endContractPath)) return null;
-	try {
-		const snapshotHash = JSON.parse(readFileSync(endContractPath, "utf-8"))["storage"]?.["storageHash"];
-		if (typeof snapshotHash === "string" && snapshotHash !== pkg.metadata.to) return {
-			pnCode: "PN-MIG-CHECK-005",
-			where: migrationPathRelative(pkg.dirPath),
-			why: `Migration "${pkg.dirName}" declares to=${pkg.metadata.to} but end-contract.json has storageHash=${snapshotHash}`,
-			fix: "Re-emit the migration package so migration.json and end-contract.json agree."
-		};
-	} catch {
-		return {
-			pnCode: "PN-MIG-CHECK-006",
-			where: migrationPathRelative(pkg.dirPath),
-			why: `Migration "${pkg.dirName}" has an unparseable end-contract.json.`,
-			fix: "Re-emit the migration package to repair the snapshot file."
-		};
-	}
-	return null;
-}
-async function executeMigrationCheckCommand(target, options, flags, ui) {
-	const config = await loadConfig(options.config);
-	const { configPath, appMigrationsDir, appMigrationsRelative, refsDir } = resolveMigrationPaths(options.config, config);
-	if (!flags.json && !flags.quiet) {
-		const details = [{
-			label: "config",
-			value: configPath
-		}, {
-			label: "migrations",
-			value: appMigrationsRelative
-		}];
-		if (target) details.push({
-			label: "target",
-			value: target
-		});
-		const header = formatStyledHeader({
-			command: "migration check",
-			description: "Verify artifact and graph integrity",
-			details,
-			flags
-		});
-		ui.stderr(header);
-	}
-	const failures = [];
-	let bundles;
-	let graph;
-	try {
-		const loaded = await loadMigrationPackages(appMigrationsDir);
-		bundles = loaded.bundles;
-		graph = loaded.graph;
-	} catch (error) {
-		if (MigrationToolsError.is(error)) {
-			const pnCode = error.code === "MIGRATION.HASH_MISMATCH" ? "PN-MIG-CHECK-001" : "PN-MIG-CHECK-002";
-			const rawWhere = error.details?.["dir"] ?? error.details?.["filePath"] ?? null;
-			const where = rawWhere ? relative(process.cwd(), rawWhere) : "unknown";
-			failures.push({
-				pnCode,
-				where,
-				why: error.why,
-				fix: error.fix
-			});
-			return {
-				result: {
-					ok: false,
-					failures,
-					summary: `${failures.length} integrity failure(s)`
-				},
-				exitCode: 4
-			};
-		}
-		throw error;
-	}
-	if (existsSync(appMigrationsDir)) {
-		const loadedDirNames = new Set(bundles.map((p) => p.dirName));
-		try {
-			const entries = readdirSync(appMigrationsDir);
-			for (const entry of entries) {
-				if (entry.startsWith(".") || entry.startsWith("_") || entry === "refs") continue;
-				const entryPath = join(appMigrationsDir, entry);
-				try {
-					if (!statSync(entryPath).isDirectory()) continue;
-				} catch {
-					continue;
-				}
-				if (!loadedDirNames.has(entry)) for (const f of ["migration.json", "ops.json"]) {
-					const fail = checkFileExists(entryPath, entry, f);
-					if (fail) failures.push(fail);
-				}
-			}
-		} catch {}
-	}
-	if (target) {
-		const refs = await readRefs(refsDir);
-		const migResult = parseMigrationRef(target, {
-			graph,
-			refs
-		});
-		if (!migResult.ok) return {
-			result: {
-				ok: false,
-				failures: [],
-				summary: migResult.failure.kind === "not-found" ? `Migration "${target}" does not exist` : migResult.failure.kind === "wrong-grammar" ? migResult.failure.message : `Invalid migration reference: "${target}"`
-			},
-			exitCode: 2
-		};
-		const matchedPkg = bundles.find((p) => p.metadata.migrationHash === migResult.value.migrationHash);
-		if (!matchedPkg) return {
-			result: {
-				ok: false,
-				failures: [],
-				summary: `Migration package for "${target}" not found on disk`
-			},
-			exitCode: 2
-		};
-		for (const f of ["migration.json", "ops.json"]) {
-			const fail = checkFileExists(matchedPkg.dirPath, matchedPkg.dirName, f);
-			if (fail) failures.push(fail);
-		}
-		const verification = verifyMigrationHash(matchedPkg);
-		if (!verification.ok) failures.push({
-			pnCode: "PN-MIG-CHECK-001",
-			where: migrationFileRelative(matchedPkg.dirPath, "migration.json"),
-			why: `Stored hash ${verification.storedHash} does not match recomputed hash ${verification.computedHash}`,
-			fix: "Re-emit the migration package or restore from version control."
-		});
-		const snapshotFailure = checkSnapshotConsistency(matchedPkg);
-		if (snapshotFailure) failures.push(snapshotFailure);
-	} else {
-		for (const pkg of bundles) {
-			for (const f of ["migration.json", "ops.json"]) {
-				const fail = checkFileExists(pkg.dirPath, pkg.dirName, f);
-				if (fail) failures.push(fail);
-			}
-			const verification = verifyMigrationHash(pkg);
-			if (!verification.ok) failures.push({
-				pnCode: "PN-MIG-CHECK-001",
-				where: migrationFileRelative(pkg.dirPath, "migration.json"),
-				why: `Stored hash ${verification.storedHash} does not match recomputed hash ${verification.computedHash}`,
-				fix: "Re-emit the migration package or restore from version control."
-			});
-		}
-		for (const pkg of bundles) {
-			const snapshotFailure = checkSnapshotConsistency(pkg);
-			if (snapshotFailure) failures.push(snapshotFailure);
-		}
-		const allToHashes = new Set(bundles.map((p) => p.metadata.to));
-		for (const pkg of bundles) if (!(pkg.metadata.from === null || allToHashes.has(pkg.metadata.from) || pkg.metadata.from === "sha256:empty")) failures.push({
-			pnCode: "PN-MIG-CHECK-003",
-			where: migrationPathRelative(pkg.dirPath),
-			why: `Migration "${pkg.dirName}" starts from ${pkg.metadata.from} which no other migration produces`,
-			fix: "This migration is unreachable in the graph. Delete it or re-emit a connecting migration."
-		});
-		try {
-			const refs = await readRefs(refsDir);
-			for (const [name, entry] of Object.entries(refs)) if (!graph.nodes.has(entry.hash)) failures.push({
-				pnCode: "PN-MIG-CHECK-004",
-				where: relative(process.cwd(), join(refsDir, `${name}.json`)),
-				why: `Ref "${name}" points at ${entry.hash} which does not exist in the migration graph`,
-				fix: `Update the ref with \`prisma-next ref set ${name} <valid-hash>\` or delete it.`
-			});
-		} catch {}
-	}
-	if (failures.length === 0) return {
-		result: {
-			ok: true,
-			failures: [],
-			summary: "All checks passed"
-		},
-		exitCode: 0
-	};
-	return {
-		result: {
-			ok: false,
-			failures,
-			summary: `${failures.length} integrity failure(s)`
-		},
-		exitCode: 4
-	};
-}
-function createMigrationCheckCommand() {
-	const command = new Command("check");
-	setCommandDescriptions(command, "Verify artifact and graph integrity", "Validates that on-disk migration packages are internally consistent\n(hashes match, manifests are complete) and that the graph is well-formed\n(edges connect, refs point at valid nodes). Offline — does not consult\nthe database.");
-	setCommandExamples(command, [
-		"prisma-next migration check",
-		"prisma-next migration check 20260101-add-users",
-		"prisma-next migration check --json"
-	]);
-	setCommandSeeAlso(command, [
-		{
-			verb: "migration status",
-			oneLiner: "Show migration path and pending status"
-		},
-		{
-			verb: "migration list",
-			oneLiner: "List on-disk migrations"
-		},
-		{
-			verb: "migration graph",
-			oneLiner: "Show the migration graph topology"
-		}
-	]);
-	command.exitOverride();
-	addGlobalOptions(command).argument("[migration]", "Migration reference (directory name or hash) to check").option("--config <path>", "Path to prisma-next.config.ts").action(async (target, options) => {
-		const flags = parseGlobalFlagsOrExit(options);
-		const ui = createTerminalUI(flags);
-		let result;
-		let exitCode;
-		try {
-			({result, exitCode} = await executeMigrationCheckCommand(target, options, flags, ui));
-		} catch (error) {
-			result = {
-				ok: false,
-				failures: [],
-				summary: error instanceof Error ? error.message : String(error)
-			};
-			exitCode = 2;
-		}
-		if (flags.json) ui.output(JSON.stringify(result, null, 2));
-		else if (!flags.quiet) if (result.ok) ui.log(`✔ ${result.summary}`);
-		else {
-			for (const f of result.failures) {
-				ui.log(`✗ [${f.pnCode}] ${f.where}: ${f.why}`);
-				ui.log(`  fix: ${f.fix}`);
-			}
-			ui.log(`\n${result.summary}`);
-		}
-		process.exit(exitCode);
-	});
-	return command;
-}
-//#endregion
+import { t as createMigrationCheckCommand } from "../migration-check-BiBJoYYW.mjs";
 export { createMigrationCheckCommand };
-
-//# sourceMappingURL=migration-check.mjs.map

package/dist/commands/migration-graph.d.mts

@@ -1,8 +1,36 @@
-import { n as StatusRef } from "../migration-types-BXWvz12q.mjs";
+import { N as CliStructuredError } from "../types-CeC5ec2Y.mjs";
+import { n as GlobalFlags, t as CommonCommandOptions } from "../global-flags-DEHjV8_s.mjs";
+import { n as StatusRef } from "../migration-types-D2FW63pr.mjs";
+import { t as TerminalUI } from "../terminal-ui-5Y6mrg93.mjs";
 import { Command } from "commander";
+import { Result } from "@prisma-next/utils/result";
 import { MigrationGraph } from "@prisma-next/migration-tools/graph";
 
 //#region src/commands/migration-graph.d.ts
+interface MigrationGraphOptions extends CommonCommandOptions {
+  readonly config?: string;
+  readonly dot?: boolean;
+  readonly tree?: boolean;
+  readonly ascii?: boolean;
+  readonly legend?: boolean;
+}
+/**
+ * `--legend` describes the `--tree` visual language, so passing it auto-enables
+ * the tree path (it has nothing to say about the legacy dagre default).
+ */
+declare function migrationGraphUsesTree(options: {
+  readonly tree?: boolean;
+  readonly legend?: boolean;
+}): boolean;
+/**
+ * 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.
+ */
+declare function migrationGraphShowsLegend(options: {
+  readonly legend?: boolean;
+  readonly dot?: boolean;
+}, flags: GlobalFlags): boolean;
 interface MigrationGraphResult {
   readonly ok: true;
   readonly graph: MigrationGraph;
@@ -10,7 +38,8 @@ interface MigrationGraphResult {
   readonly refs: readonly StatusRef[];
   readonly summary: string;
 }
+declare function executeMigrationGraphCommand(options: MigrationGraphOptions, flags: GlobalFlags, ui: TerminalUI): Promise<Result<MigrationGraphResult, CliStructuredError>>;
 declare function createMigrationGraphCommand(): Command;
 //#endregion
-export { MigrationGraphResult, createMigrationGraphCommand };
+export { MigrationGraphResult, createMigrationGraphCommand, executeMigrationGraphCommand, migrationGraphShowsLegend, migrationGraphUsesTree };
 //# sourceMappingURL=migration-graph.d.mts.map

package/dist/commands/migration-graph.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"migration-graph.d.mts","names":[],"sources":["../../src/commands/migration-graph.ts"],"mappings":";;;;;UAmCiB,oBAAA;EAAA,SACN,EAAA;EAAA,SACA,KAAA,EAAO,cAAA;EAAA,SACP,YAAA;EAAA,SACA,IAAA,WAAe,SAAA;EAAA,SACf,OAAA;AAAA;AAAA,iBAoEK,2BAAA,CAAA,GAA+B,OAAA"}
+{"version":3,"file":"migration-graph.d.mts","names":[],"sources":["../../src/commands/migration-graph.ts"],"mappings":";;;;;;;;;UA6BU,qBAAA,SAA8B,oBAAoB;EAAA,SACjD,MAAA;EAAA,SACA,GAAA;EAAA,SACA,IAAA;EAAA,SACA,KAAA;EAAA,SACA,MAAA;AAAA;;;;;iBAOK,sBAAA,CAAuB,OAAA;EAAA,SAC5B,IAAA;EAAA,SACA,MAAA;AAAA;;;;;;iBAUK,yBAAA,CACd,OAAA;EAAA,SAAoB,MAAA;EAAA,SAA2B,GAAA;AAAA,GAC/C,KAAA,EAAO,WAAW;AAAA,UAOH,oBAAA;EAAA,SACN,EAAA;EAAA,SACA,KAAA,EAAO,cAAA;EAAA,SACP,YAAA;EAAA,SACA,IAAA,WAAe,SAAS;EAAA,SACxB,OAAA;AAAA;AAAA,iBAGW,4BAAA,CACpB,OAAA,EAAS,qBAAA,EACT,KAAA,EAAO,WAAA,EACP,EAAA,EAAI,UAAA,GACH,OAAA,CAAQ,MAAA,CAAO,oBAAA,EAAsB,kBAAA;AAAA,iBAoDxB,2BAAA,CAAA,GAA+B,OAAO"}

package/dist/commands/migration-graph.mjs

@@ -1,137 +1,2 @@
-import { t as loadConfig } from "../config-loader-B6sJjXTv.mjs";
-import { b as mapMigrationToolsError, y as errorUnexpected } from "../cli-errors-Djtz98Vm.mjs";
-import { t as createTerminalUI } from "../terminal-ui-BiB_8KNo.mjs";
-import { S as formatStyledHeader, a as loadMigrationPackages, d as setCommandDescriptions, f as setCommandExamples, l as resolveMigrationPaths, p as setCommandSeeAlso, s as readContractEnvelope, t as addGlobalOptions, v as parseGlobalFlagsOrExit, y as handleResult } from "../command-helpers-BSb0tRC8.mjs";
-import { i as migrationGraphToRenderInput, n as graphRenderer } from "../graph-render-DJVv0_uf.mjs";
-import { Command } from "commander";
-import { notOk, ok } from "@prisma-next/utils/result";
-import { EMPTY_CONTRACT_HASH } from "@prisma-next/migration-tools/constants";
-import { MigrationToolsError } from "@prisma-next/migration-tools/errors";
-import { readRefs } from "@prisma-next/migration-tools/refs";
-//#region src/commands/migration-graph.ts
-async function executeMigrationGraphCommand(options, flags, ui) {
-	const config = await loadConfig(options.config);
-	const { configPath, appMigrationsDir, appMigrationsRelative, refsDir } = 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);
-	}
-	let graph;
-	try {
-		({graph} = await loadMigrationPackages(appMigrationsDir));
-	} catch (error) {
-		if (MigrationToolsError.is(error)) return notOk(mapMigrationToolsError(error));
-		return notOk(errorUnexpected(error instanceof Error ? error.message : String(error), { why: `Failed to read migrations: ${error instanceof Error ? error.message : String(error)}` }));
-	}
-	let contractHash = null;
-	try {
-		contractHash = (await readContractEnvelope(config)).storageHash;
-	} catch {}
-	let refs = [];
-	try {
-		const allRefs = await readRefs(refsDir);
-		refs = Object.entries(allRefs).map(([name, entry]) => ({
-			name,
-			hash: entry.hash,
-			active: false
-		}));
-	} catch {}
-	return ok({
-		ok: true,
-		graph,
-		contractHash,
-		refs,
-		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 as an ASCII tree. Offline — does not\nconsult the database. Use --json for machine-readable output or\n--dot for Graphviz DOT format.");
-	setCommandExamples(command, [
-		"prisma-next migration graph",
-		"prisma-next migration graph --json",
-		"prisma-next migration graph --dot"
-	]);
-	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").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) {
-				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 { createMigrationGraphCommand };
-
-//# sourceMappingURL=migration-graph.mjs.map
+import { i as migrationGraphUsesTree, n as executeMigrationGraphCommand, r as migrationGraphShowsLegend, t as createMigrationGraphCommand } from "../migration-graph-C9WC-7eO.mjs";
+export { createMigrationGraphCommand, executeMigrationGraphCommand, migrationGraphShowsLegend, migrationGraphUsesTree };

package/dist/commands/migration-list.d.mts

@@ -1,20 +1,80 @@
+import { N as CliStructuredError } from "../types-CeC5ec2Y.mjs";
+import { n as GlobalFlags, t as CommonCommandOptions } from "../global-flags-DEHjV8_s.mjs";
+import { n as GlyphMode, t as TerminalUI } from "../terminal-ui-5Y6mrg93.mjs";
 import { Command } from "commander";
+import { Result } from "@prisma-next/utils/result";
+import { ContractSpaceAggregate } from "@prisma-next/migration-tools/aggregate";
 
-//#region src/commands/migration-list.d.ts
+//#region src/utils/formatters/migration-list-types.d.ts
 interface MigrationListEntry {
   readonly dirName: string;
-  readonly from: string;
+  readonly from: string | null;
   readonly to: string;
   readonly migrationHash: string;
   readonly operationCount: number;
   readonly createdAt: string;
+  readonly refs: readonly string[];
+  readonly providedInvariants: readonly string[];
+}
+interface MigrationSpaceListEntry {
+  readonly spaceId: string;
+  readonly migrations: readonly MigrationListEntry[];
 }
 interface MigrationListResult {
   readonly ok: true;
-  readonly migrations: readonly MigrationListEntry[];
+  readonly spaces: readonly MigrationSpaceListEntry[];
   readonly summary: string;
 }
+//#endregion
+//#region src/commands/migration-list.d.ts
+/**
+ * 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)`.
+ */
+declare function migrationSpaceListEntriesFromAggregate(aggregate: ContractSpaceAggregate, projectMigrationsDir: string): Promise<readonly MigrationSpaceListEntry[]>;
+interface MigrationListOptions extends CommonCommandOptions {
+  readonly config?: string;
+  readonly space?: string;
+  readonly ascii?: boolean;
+}
+interface MigrationListHumanRenderOptions {
+  readonly glyphMode: GlyphMode;
+  readonly useColor: boolean;
+}
+declare function renderMigrationListHumanOutput(result: MigrationListResult, options: MigrationListHumanRenderOptions): string;
+/**
+ * Inputs for {@link runMigrationList} — the policy core of `migration list`
+ * that tests exercise directly.
+ *
+ * The core does not call `loadConfig`, parse CLI flags, render a styled
+ * header, or write to any stream. Enumeration is supplied by the caller
+ * (the CLI shell builds it from {@link migrationSpaceListEntriesFromAggregate}).
+ */
+interface RunMigrationListInputs {
+  readonly spaces: readonly MigrationSpaceListEntry[];
+  readonly spaceFilter?: string;
+}
+/**
+ * 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`.
+ */
+declare function runMigrationList(inputs: RunMigrationListInputs): Result<MigrationListResult, CliStructuredError>;
+/**
+ * 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.
+ */
+declare function executeMigrationListCommand(options: MigrationListOptions, flags: GlobalFlags, ui: TerminalUI): Promise<Result<MigrationListResult, CliStructuredError>>;
 declare function createMigrationListCommand(): Command;
 //#endregion
-export { MigrationListEntry, MigrationListResult, createMigrationListCommand };
+export { MigrationListHumanRenderOptions, RunMigrationListInputs, createMigrationListCommand, executeMigrationListCommand, migrationSpaceListEntriesFromAggregate, renderMigrationListHumanOutput, runMigrationList };
 //# sourceMappingURL=migration-list.d.mts.map

package/dist/commands/migration-list.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"migration-list.d.mts","names":[],"sources":["../../src/commands/migration-list.ts"],"mappings":";;;UA8BiB,kBAAA;EAAA,SACN,OAAA;EAAA,SACA,IAAA;EAAA,SACA,EAAA;EAAA,SACA,aAAA;EAAA,SACA,cAAA;EAAA,SACA,SAAA;AAAA;AAAA,UAGM,mBAAA;EAAA,SACN,EAAA;EAAA,SACA,UAAA,WAAqB,kBAAA;EAAA,SACrB,OAAA;AAAA;AAAA,iBAwEK,0BAAA,CAAA,GAA8B,OAAA"}
+{"version":3,"file":"migration-list.d.mts","names":[],"sources":["../../src/utils/formatters/migration-list-types.ts","../../src/commands/migration-list.ts"],"mappings":";;;;;;;;UAAiB,kBAAA;EAAA,SACN,OAAA;EAAA,SACA,IAAA;EAAA,SACA,EAAA;EAAA,SACA,aAAA;EAAA,SACA,cAAA;EAAA,SACA,SAAA;EAAA,SACA,IAAA;EAAA,SACA,kBAAA;AAAA;AAAA,UAGM,uBAAA;EAAA,SACN,OAAA;EAAA,SACA,UAAA,WAAqB,kBAAkB;AAAA;AAAA,UAGjC,mBAAA;EAAA,SACN,EAAA;EAAA,SACA,MAAA,WAAiB,uBAAuB;EAAA,SACxC,OAAA;AAAA;;;;;;;;;;;iBC8EW,sCAAA,CACpB,SAAA,EAAW,sBAAA,EACX,oBAAA,WACC,OAAA,UAAiB,uBAAA;AAAA,UA6BV,oBAAA,SAA6B,oBAAoB;EAAA,SAChD,MAAA;EAAA,SACA,KAAA;EAAA,SACA,KAAA;AAAA;AAAA,UAGM,+BAAA;EAAA,SACN,SAAA,EAAW,SAAS;EAAA,SACpB,QAAA;AAAA;AAAA,iBAGK,8BAAA,CACd,MAAA,EAAQ,mBAAA,EACR,OAAA,EAAS,+BAA+B;;;ADjIQ;AAGlD;;;;;UC6IiB,sBAAA;EAAA,SACN,MAAA,WAAiB,uBAAuB;EAAA,SACxC,WAAA;AAAA;AD5IO;;;;AC8ElB;;;;;AD9EkB,iBCgKF,gBAAA,CACd,MAAA,EAAQ,sBAAA,GACP,MAAA,CAAO,mBAAA,EAAqB,kBAAA;;;;;;iBA6BT,2BAAA,CACpB,OAAA,EAAS,oBAAA,EACT,KAAA,EAAO,WAAA,EACP,EAAA,EAAI,UAAA,GACH,OAAA,CAAQ,MAAA,CAAO,mBAAA,EAAqB,kBAAA;AAAA,iBAqCvB,0BAAA,CAAA,GAA8B,OAAO"}