@prisma-next/cli 0.11.0-dev.59 → 0.11.0-dev.60

package/src/utils/command-helpers.ts

@@ -3,10 +3,7 @@ import type { ControlTargetDescriptor } from '@prisma-next/framework-components/
 import { hasMigrations } from '@prisma-next/framework-components/control';
 import type { NoInvariantPathStructuralEdge } from '@prisma-next/migration-tools/errors';
 import type { MigrationEdge, MigrationGraph } from '@prisma-next/migration-tools/graph';
-import { readMigrationsDir } from '@prisma-next/migration-tools/io';
 import type { PathDecision } from '@prisma-next/migration-tools/migration-graph';
-import { reconstructGraph } from '@prisma-next/migration-tools/migration-graph';
-import type { OnDiskMigrationPackage } from '@prisma-next/migration-tools/package';
 import { APP_SPACE_ID, spaceMigrationDirectory } from '@prisma-next/migration-tools/spaces';
 import { ifDefined } from '@prisma-next/utils/defined';
 import type { Command } from 'commander';
@@ -231,27 +228,6 @@ export function getTargetMigrations(target: ControlTargetDescriptor<string, stri
   return hasMigrations(target) ? target.migrations : undefined;
 }
 
-/**
- * Reads the migrations directory and builds the migration graph from all
- * packages. Throws on I/O or graph errors — callers handle error mapping.
- *
- * Every on-disk package is content-addressed (`migrationHash` is always a
- * string); there is no draft state to filter out.
- */
-export async function loadMigrationPackages(migrationsDir: string): Promise<{
-  bundles: readonly OnDiskMigrationPackage[];
-  graph: MigrationGraph;
-}> {
-  // `readMigrationsDir` is tolerant: it retains hash-/invariant-mismatched
-  // packages and omits unparseable ones, reporting both via `problems`.
-  // This helper preserves its historical `{ bundles, graph }` contract by
-  // exposing the retained packages; callers that need to surface load
-  // problems read them from the tolerant primitive directly.
-  const { packages } = await readMigrationsDir(migrationsDir);
-  const graph = reconstructGraph(packages);
-  return { bundles: packages, graph };
-}
-
 /**
  * The subset of the emitted contract.json that the framework layer can
  * safely type. The emitter adds these fields on top of the family-specific

package/src/utils/contract-space-aggregate-loader.ts

@@ -1,5 +1,8 @@
+import { readFile } from 'node:fs/promises';
+import type { PrismaNextConfig } from '@prisma-next/config/config-types';
 import type { Contract } from '@prisma-next/contract/types';
 import type { ControlExtensionDescriptor } from '@prisma-next/framework-components/control';
+import { createControlStack } from '@prisma-next/framework-components/control';
 import type {
   ContractSpaceAggregate,
   DeclaredExtensionEntry,
@@ -7,8 +10,12 @@ import type {
   IntegrityViolation,
 } from '@prisma-next/migration-tools/aggregate';
 import { loadContractSpaceAggregate } from '@prisma-next/migration-tools/aggregate';
+import { EMPTY_CONTRACT_HASH } from '@prisma-next/migration-tools/constants';
+import { MigrationToolsError } from '@prisma-next/migration-tools/errors';
+import { blindCast } from '@prisma-next/utils/casts';
 import { notOk, ok, type Result } from '@prisma-next/utils/result';
-import { CliStructuredError } from './cli-errors';
+import { CliStructuredError, errorUnexpected, mapMigrationToolsError } from './cli-errors';
+import { readContractEnvelope, resolveContractPath } from './command-helpers';
 import { toDeclaredExtensionsFromRaw } from './extension-pack-inputs';
 
 const CONTRACT_SPACES_DOCS_URL = 'https://pris.ly/contract-spaces';
@@ -279,3 +286,111 @@ export async function buildContractSpaceAggregate<
   }
   return ok(loaded.value);
 }
+
+/**
+ * Build a minimal app {@link Contract} carrying only the project's
+ * contract-identity (`storage.storageHash` + `target` / `targetFamily`)
+ * when the real `contract.json` is absent or undeserializable.
+ *
+ * `loadContractSpaceAggregate` requires an `appContract` to synthesise the
+ * app space's head ref from its storage hash. Read commands query only that
+ * hash and the target — never `models` — so an empty-`models` stand-in is
+ * sufficient for them. It is *not* a valid contract for any consumer that
+ * reads schema, which is why this is confined to the read-aggregate path.
+ */
+export function appContractStandInFromIdentity(args: {
+  readonly contractHash: string;
+  readonly targetId: string;
+  readonly targetFamily: string;
+}): Contract {
+  return blindCast<
+    Contract,
+    'read-aggregate consumers query only storage.storageHash and target; empty models stand in for an unreadable contract.json'
+  >({
+    storage: { storageHash: args.contractHash },
+    schemaVersion: '0.0.0',
+    target: args.targetId,
+    targetFamily: args.targetFamily,
+    models: {},
+    profileHash: EMPTY_CONTRACT_HASH,
+  });
+}
+
+export async function loadContractRawSafely(config: {
+  contract?: { output?: string };
+}): Promise<unknown | null> {
+  try {
+    const path = resolveContractPath(config);
+    const raw = await readFile(path, 'utf-8');
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Tolerant {@link ContractSpaceAggregate} assembly for read-only CLI
+ * commands. No integrity gate — callers query `aggregate.app` (or other
+ * facets) without re-reading `migrations/`. When `contract.json` is absent
+ * or undeserializable, the app contract falls back to an identity-only
+ * stand-in ({@link appContractStandInFromIdentity}), so these commands
+ * load without requiring a readable contract.
+ */
+export async function buildReadAggregate(
+  config: PrismaNextConfig,
+  options: { readonly migrationsDir: string },
+): Promise<
+  Result<
+    { readonly aggregate: ContractSpaceAggregate; readonly contractHash: string },
+    CliStructuredError
+  >
+> {
+  let contractHash: string = EMPTY_CONTRACT_HASH;
+  try {
+    const envelope = await readContractEnvelope(config);
+    contractHash = envelope.storageHash;
+  } catch {
+    // Contract unreadable — marker uses EMPTY_CONTRACT_HASH
+  }
+
+  try {
+    const contractRawForAggregate = await loadContractRawSafely(config);
+    const stack = createControlStack(config);
+    const familyInstance = config.family.create(stack);
+    const deserializeContract = (json: unknown): Contract =>
+      familyInstance.deserializeContract(json);
+    let appContractForLoad: Contract = appContractStandInFromIdentity({
+      contractHash,
+      targetId: config.target.id,
+      targetFamily: config.target.familyId,
+    });
+    if (contractRawForAggregate !== null) {
+      try {
+        appContractForLoad = deserializeContract(contractRawForAggregate);
+      } catch {
+        // Deserialization failed — identity-only stand-in fallback
+      }
+    }
+
+    const loaded = await loadContractSpaceAggregateForCli({
+      targetId: config.target.id,
+      migrationsDir: options.migrationsDir,
+      appContract: appContractForLoad,
+      extensionPacks: config.extensionPacks ?? [],
+      deserializeContract,
+    });
+    if (!loaded.ok) {
+      return loaded;
+    }
+    return ok({ aggregate: loaded.value, contractHash });
+  } 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 directory: ${error instanceof Error ? error.message : String(error)}`,
+      }),
+    );
+  }
+}

package/src/utils/formatters/migration-list-data-column.ts

@@ -1,7 +1,7 @@
-import type { MigrationEdgeKind } from '@prisma-next/migration-tools/migration-list-graph-topology';
-import type { MigrationListEntry } from '@prisma-next/migration-tools/migration-list-types';
 import type { GlyphMode } from '../glyph-mode';
+import type { MigrationEdgeKind } from './migration-list-graph-topology';
 import type { MigrationListStyler } from './migration-list-render';
+import type { MigrationListEntry } from './migration-list-types';
 
 export const MIGRATION_LIST_HASH_WIDTH = 7;
 export const MIGRATION_LIST_EMPTY_SOURCE = '∅';

package/src/utils/formatters/migration-list-graph-layout.ts

@@ -3,8 +3,8 @@ import {
   classifyMigrationListGraphTopology,
   type MigrationEdgeKind,
   type MigrationListGraphTopology,
-} from '@prisma-next/migration-tools/migration-list-graph-topology';
-import type { MigrationListEntry } from '@prisma-next/migration-tools/migration-list-types';
+} from './migration-list-graph-topology';
+import type { MigrationListEntry } from './migration-list-types';
 
 export type ConnectorKind = 'fanBelow' | 'joinAbove';
 

package/src/utils/formatters/migration-list-graph-render.ts

@@ -1,8 +1,3 @@
-import type { MigrationListGraphTopology } from '@prisma-next/migration-tools/migration-list-graph-topology';
-import type {
-  MigrationListEntry,
-  MigrationListResult,
-} from '@prisma-next/migration-tools/migration-list-types';
 import type { GlyphMode } from '../glyph-mode';
 import {
   abbreviateContractHash,
@@ -22,7 +17,9 @@ import type {
   NodeLineLayoutRow,
 } from './migration-list-graph-layout';
 import { computeMigrationListGraphLayout } from './migration-list-graph-layout';
+import type { MigrationListGraphTopology } from './migration-list-graph-topology';
 import type { MigrationListStyler } from './migration-list-render';
+import type { MigrationListEntry, MigrationListResult } from './migration-list-types';
 
 export type { GlyphMode } from '../glyph-mode';
 

package/src/utils/formatters/migration-list-graph-topology.ts

@@ -0,0 +1,158 @@
+import { EMPTY_CONTRACT_HASH } from '@prisma-next/migration-tools/constants';
+import type { MigrationListEntry } from './migration-list-types';
+
+export type MigrationEdgeKind = 'forward' | 'rollback' | 'self';
+
+export interface MigrationListGraphTopology {
+  readonly kindByMigrationHash: ReadonlyMap<string, MigrationEdgeKind>;
+  readonly forwardInDegree: ReadonlyMap<string, number>;
+  readonly forwardOutDegree: ReadonlyMap<string, number>;
+}
+
+interface NonSelfEdge {
+  readonly entry: MigrationListEntry;
+  readonly from: string;
+  readonly to: string;
+}
+
+function canonicalFrom(from: string | null): string {
+  return from ?? EMPTY_CONTRACT_HASH;
+}
+
+function compareDirNameDesc(a: MigrationListEntry, b: MigrationListEntry): number {
+  return b.dirName.localeCompare(a.dirName);
+}
+
+function bumpDegree(map: Map<string, number>, key: string): void {
+  map.set(key, (map.get(key) ?? 0) + 1);
+}
+
+export function classifyMigrationListGraphTopology(
+  entries: readonly MigrationListEntry[],
+): MigrationListGraphTopology {
+  const nodes = new Set<string>();
+  const kindByMigrationHash = new Map<string, MigrationEdgeKind>();
+  const outgoingByFrom = new Map<string, NonSelfEdge[]>();
+
+  for (const entry of entries) {
+    const from = canonicalFrom(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: NonSelfEdge = { 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 = new Map<string, number>();
+  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: string[] = [];
+  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 = new Map<string, number>();
+  for (const node of nodes) {
+    color.set(node, WHITE);
+  }
+
+  interface Frame {
+    node: string;
+    outgoing: readonly NonSelfEdge[];
+    index: number;
+  }
+  const stack: Frame[] = [];
+
+  function pushFrame(node: string): void {
+    color.set(node, GRAY);
+    stack.push({ node, outgoing: outgoingByFrom.get(node) ?? [], index: 0 });
+  }
+
+  function runDfsFrom(root: string): void {
+    if (color.get(root) !== WHITE) return;
+    pushFrame(root);
+
+    while (stack.length > 0) {
+      const frame = stack[stack.length - 1];
+      if (frame === undefined) 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 === undefined) 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 = new Map<string, number>();
+  const forwardOutDegree = new Map<string, number>();
+
+  for (const entry of entries) {
+    if (kindByMigrationHash.get(entry.migrationHash) !== 'forward') continue;
+    const from = canonicalFrom(entry.from);
+    const to = entry.to;
+    bumpDegree(forwardOutDegree, from);
+    bumpDegree(forwardInDegree, to);
+  }
+
+  return {
+    kindByMigrationHash,
+    forwardInDegree,
+    forwardOutDegree,
+  };
+}

package/src/utils/formatters/migration-list-render.ts

@@ -1,12 +1,3 @@
-import {
-  classifyMigrationListGraphTopology,
-  type MigrationEdgeKind,
-  type MigrationListGraphTopology,
-} from '@prisma-next/migration-tools/migration-list-graph-topology';
-import type {
-  MigrationListEntry,
-  MigrationListResult,
-} from '@prisma-next/migration-tools/migration-list-types';
 import type { GlyphMode } from '../glyph-mode';
 import {
   computeMigrationDirNameWidth,
@@ -15,14 +6,20 @@ import {
   migrationListForwardArrow,
   migrationListKindGlyph,
 } from './migration-list-data-column';
+import {
+  classifyMigrationListGraphTopology,
+  type MigrationEdgeKind,
+  type MigrationListGraphTopology,
+} from './migration-list-graph-topology';
+import type { MigrationListEntry, MigrationListResult } from './migration-list-types';
 
-export type { MigrationEdgeKind } from '@prisma-next/migration-tools/migration-list-graph-topology';
+export type { GlyphMode } from '../glyph-mode';
+export type { MigrationEdgeKind } from './migration-list-graph-topology';
 export type {
   MigrationListEntry,
   MigrationListResult,
   MigrationSpaceListEntry,
-} from '@prisma-next/migration-tools/migration-list-types';
-export type { GlyphMode } from '../glyph-mode';
+} from './migration-list-types';
 
 /**
  * Semantic styler for `migration list` output tokens. Token-typed so

package/src/utils/formatters/migration-list-types.ts

@@ -0,0 +1,21 @@
+export interface MigrationListEntry {
+  readonly dirName: 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[];
+}
+
+export interface MigrationSpaceListEntry {
+  readonly spaceId: string;
+  readonly migrations: readonly MigrationListEntry[];
+}
+
+export interface MigrationListResult {
+  readonly ok: true;
+  readonly spaces: readonly MigrationSpaceListEntry[];
+  readonly summary: string;
+}

package/dist/cli-errors-DQY629C7.mjs

@@ -1,220 +0,0 @@
-import { CliStructuredError as CliStructuredError$1, errorConfigValidation as errorConfigValidation$1, errorContractConfigMissing as errorContractConfigMissing$1, errorContractValidationFailed, errorDatabaseConnectionRequired, errorDriverRequired, errorFileNotFound, errorInvalidOutputFormat, errorMigrationPlanningFailed, errorOutputFormatMutex, errorTargetMigrationNotSupported, errorUnexpected as errorUnexpected$1 } from "@prisma-next/errors/control";
-import { ERROR_CODE_DESTRUCTIVE_CHANGES, errorDestructiveChanges, errorHashMismatch, errorMarkerMissing, errorRunnerFailed, errorRuntime, errorRuntime as errorRuntime$1, errorTargetMismatch } from "@prisma-next/errors/execution";
-import "@prisma-next/errors/migration";
-//#region src/utils/cli-errors.ts
-function errorRefSetHashNotInGraph(resolvedHash, reachableHashes, graphTipHash) {
-	const reachableList = reachableHashes.length > 0 ? reachableHashes.join(", ") : "(none — migration graph is empty)";
-	const fix = reachableHashes.length > 0 ? graphTipHash !== null ? `Set the ref to a graph-node hash such as ${graphTipHash}, or run \`prisma-next migration plan\` to extend the graph.` : "Set the ref to a hash that appears in the migration graph." : "Run `prisma-next migration plan` first.";
-	return errorRuntime(`Resolved contract hash is not in the migration graph: ${resolvedHash}`, {
-		why: reachableHashes.length > 0 ? `The migration graph reaches ${reachableList}; resolved ${resolvedHash} isn't a graph node.` : "The migration graph is empty — no hashes reachable.",
-		fix,
-		meta: {
-			code: "MIGRATION.HASH_NOT_IN_GRAPH",
-			resolvedHash,
-			reachableHashes: [...reachableHashes],
-			...graphTipHash !== null ? { graphTipHash } : {}
-		}
-	});
-}
-function errorRefSetEmptySentinel(hash) {
-	return errorRuntime(`Cannot set ref to the empty-database sentinel: ${hash}`, {
-		why: "The empty-database sentinel is a planner internal; it is not a valid ref target.",
-		fix: "Set the ref to a contract hash from the migration graph, or use another ref name.",
-		meta: {
-			code: "MIGRATION.REF_SET_EMPTY_SENTINEL",
-			hash
-		}
-	});
-}
-/**
-* `--space <id>` was given a value that doesn't satisfy the contract-space
-* naming rule (`[a-z][a-z0-9_-]{0,63}` per `isValidSpaceId`). Fires before
-* any fs work — the input is syntactically rejected the same way an on-disk
-* directory with that name would be skipped by the enumerator.
-*/
-function errorInvalidSpaceId(spaceId) {
-	return errorRuntime(`Invalid contract space id: ${spaceId}`, {
-		why: "Contract space ids must match [a-z][a-z0-9_-]{0,63} (lowercase, starts with a letter, max 64 characters — the rule applied to every on-disk space directory).",
-		fix: "Pass a space id that matches the directory naming rule, or omit --space to list every space.",
-		meta: {
-			code: "MIGRATION.INVALID_SPACE_ID",
-			spaceId
-		}
-	});
-}
-/**
-* `migration list --space <id>` was given a contract-space id that has no
-* directory under `migrations/`. Distinct from "the space exists but is
-* empty" — that path renders the empty-state line and exits 0 per the
-* slice spec § Empty-state. This error fires only when `<projectMigrationsDir>/<spaceId>`
-* does not exist on disk.
-*
-* `availableSpaces` lists the contract-space directory names actually
-* present, sorted lex-asc, so the diagnostic can suggest a near match
-* without making the user reach for `ls`.
-*/
-function errorSpaceNotFound(spaceId, availableSpaces) {
-	const availableList = availableSpaces.length > 0 ? availableSpaces.join(", ") : "(none — no contract spaces on disk yet)";
-	const fix = availableSpaces.length > 0 ? `Pick one of: ${availableList}. Run \`prisma-next migration list\` (no --space) to see every space's migrations.` : "Author a migration with `prisma-next migration new` to create the first contract-space directory.";
-	return errorRuntime(`Unknown contract space: ${spaceId}`, {
-		why: `No directory named "${spaceId}" exists under the migrations root.`,
-		fix,
-		meta: {
-			code: "MIGRATION.SPACE_NOT_FOUND",
-			spaceId,
-			availableSpaces: [...availableSpaces]
-		}
-	});
-}
-function errorRefSetBundleNotFound(hash) {
-	return errorRuntime(`No migration bundle matches graph-node hash ${hash}`, {
-		why: `The hash is a graph node but no on-disk bundle has metadata.to = ${hash}.`,
-		fix: "Run `pnpm fixtures:check`, or re-emit the migration that produces this hash so its bundle is restored.",
-		meta: {
-			code: "MIGRATION.REF_SET_BUNDLE_NOT_FOUND",
-			hash
-		}
-	});
-}
-function errorPlanForgotTheFlag(resolvedHash, reachableRefs, graphTipHash) {
-	const reachableList = reachableRefs.length > 0 ? reachableRefs.map((r) => `${r.name} (${r.hash})`).join(", ") : "(none)";
-	const refFix = reachableRefs.length > 0 ? `Run migration plan with ${reachableRefs.map((r) => `--from ${r.name}`).join(" or ")}.` : graphTipHash !== null ? `Run migration plan --from ${graphTipHash}.` : "Commit pending migrations first, then run migration plan.";
-	return errorRuntime(`Resolved from-hash is not in the migration graph: ${resolvedHash}`, {
-		why: `The migration graph reaches ${reachableList}; resolved ${resolvedHash} isn't a graph node.`,
-		fix: refFix,
-		meta: {
-			code: "MIGRATION.HASH_NOT_IN_GRAPH",
-			resolvedHash,
-			reachableRefs: reachableRefs.map((r) => r.name),
-			...graphTipHash !== null ? { graphTipHash } : {}
-		}
-	});
-}
-function errorSnapshotMissing(identifier, options) {
-	const viaRef = options?.viaRef !== false;
-	const fix = viaRef ? `Run "prisma-next db update --advance-ref ${identifier}" to repopulate the snapshot, or "prisma-next ref delete ${identifier}" to clear the orphan pointer.` : `No contract source exists for hash "${identifier}" on an empty migration graph. Use --from with a ref name that has a paired snapshot, or run db update first.`;
-	return errorRuntime(viaRef ? `Ref "${identifier}" has no paired contract snapshot` : `No contract source for from-hash "${identifier}"`, {
-		why: viaRef ? `Ref "${identifier}" exists but its paired snapshot files are missing.` : `Hash "${identifier}" is not a graph node and no paired ref snapshot supplies a contract.`,
-		fix,
-		meta: {
-			code: "MIGRATION.SNAPSHOT_MISSING",
-			identifier,
-			viaRef
-		}
-	});
-}
-function errorMarkerMismatch(markerHash, reachableHashes, graphTip) {
-	const reachableList = reachableHashes.length > 0 ? reachableHashes.join(", ") : "(none — migration graph is empty)";
-	const planFromFix = graphTip !== null ? `Run \`prisma-next migration plan --from ${graphTip}\` if the live marker is canonical and the on-disk graph needs catching up.` : "Run `prisma-next migration plan` if the live marker is canonical and the on-disk graph needs catching up.";
-	return errorRuntime("Database marker is not reachable in the on-disk migration graph", {
-		why: `DB marker is ${markerHash}, but the on-disk migration graph reaches: ${reachableList}.`,
-		fix: [
-			planFromFix,
-			`Run \`prisma-next ref set db ${markerHash}\` if the on-disk graph is canonical and the local \`db\` ref drifted.`,
-			"Investigate whether the database was migrated by an out-of-band process."
-		].join("\n"),
-		meta: {
-			code: "MIGRATION.MARKER_MISMATCH",
-			markerHash,
-			reachableHashes: [...reachableHashes],
-			...graphTip !== null ? { graphTip } : {}
-		}
-	});
-}
-function errorPathUnreachable(failure) {
-	const meta = failure.meta ?? {};
-	const fromHashMeta = typeof meta["fromHash"] === "string" ? meta["fromHash"] : null;
-	const planFromHash = fromHashMeta === "<empty>" ? null : fromHashMeta;
-	const targetHash = typeof meta["targetHash"] === "string" ? meta["targetHash"] : typeof meta["target"] === "string" ? meta["target"] : null;
-	const deadEnds = meta["deadEnds"];
-	const deadEndsSuffix = Array.isArray(deadEnds) && deadEnds.length > 0 ? ` Dead-ends: ${deadEnds.map(String).join(", ")}.` : "";
-	const planCommand = (() => {
-		if (planFromHash !== null && targetHash !== null) return `prisma-next migration plan --from ${planFromHash} --to ${targetHash} --name <slug>`;
-		if (targetHash !== null) return `prisma-next migration plan --to ${targetHash} --name <slug>`;
-		if (planFromHash !== null) return `prisma-next migration plan --from ${planFromHash} --name <slug>`;
-		return "prisma-next migration plan";
-	})();
-	const applyCommand = targetHash !== null ? `prisma-next migrate --to ${targetHash}` : "prisma-next migrate";
-	return errorRuntime(failure.summary, {
-		why: failure.why ?? `Cannot reach target "${targetHash ?? "<unknown>"}" from current marker "${fromHashMeta ?? "<unknown>"}".${deadEndsSuffix}`,
-		fix: [
-			"Plan the missing edge, then apply it:",
-			`  1. ${planCommand}`,
-			`  2. ${applyCommand}`,
-			"A rollback (reverse) plan is expected to contain destructive (DROP) operations — review them before applying.",
-			"Narrower cases (rename inference, re-adding a NOT NULL column without a safe default, or a type change that needs data) may additionally need a hint in the planned migration.",
-			"Inspect the on-disk graph with `prisma-next migration list`, or `prisma-next migration show <bundle>` for any bundle in the path you expected."
-		].join("\n"),
-		meta: {
-			...meta,
-			code: "MIGRATION.PATH_UNREACHABLE"
-		}
-	});
-}
-/**
-* Maps a `MigrationToolsError` raised by the migration-tools loader/graph
-* surface (`readMigrationPackage`, `readMigrationsDir`, `readRefs`,
-* `resolveRef`, `reconstructGraph`, ...) into a CLI `errorRuntime` envelope.
-*
-* The full `error.details` payload is forwarded into `meta` so machine
-* consumers (`--json`) see structural fields like `dir`, `storedHash`,
-* `computedHash` (for `MIGRATION.HASH_MISMATCH`) alongside the stable
-* `code`. The user-visible `summary`/`why`/`fix` text is unchanged.
-*
-* Callers are expected to gate on `MigrationToolsError.is(error)` first
-* (mirroring the original inline pattern); non-`MigrationToolsError`
-* values are caller-classified (rethrow, wrap with command-specific
-* `errorUnexpected`, etc.).
-*/
-function mapMigrationToolsError(error) {
-	return errorRuntime(error.message, {
-		why: error.why,
-		fix: error.fix,
-		meta: {
-			code: error.code,
-			...error.details ?? {}
-		}
-	});
-}
-/**
-* Maps a `RefResolutionError` from the contract/migration reference
-* resolver into a CLI structured error envelope.
-*/
-function mapRefResolutionError(error) {
-	switch (error.kind) {
-		case "not-found": return errorRuntime(`Not a known ${error.grammar} reference: "${error.input}"`, {
-			why: `No ${error.grammar} matching "${error.input}" exists in the migration graph or refs index.`,
-			fix: error.grammar === "contract" ? "Provide a valid contract hash, ref name, or migration directory name." : "Provide a valid migration directory name or migration hash.",
-			meta: {
-				input: error.input,
-				grammar: error.grammar
-			}
-		});
-		case "ambiguous": return errorRuntime(`Ambiguous ${error.grammar} reference: "${error.input}"`, {
-			why: `"${error.input}" matches multiple ${error.grammar}s: ${error.candidates.join(", ")}`,
-			fix: "Provide a longer prefix or use the full hash to disambiguate.",
-			meta: {
-				input: error.input,
-				candidates: error.candidates,
-				grammar: error.grammar
-			}
-		});
-		case "wrong-grammar": return errorRuntime(error.message, {
-			why: error.message,
-			fix: error.fix,
-			meta: {
-				input: error.input,
-				expectedGrammar: error.expectedGrammar
-			}
-		});
-		case "invalid-format": return errorRuntime(`Invalid reference format: "${error.input}"`, {
-			why: error.reason,
-			fix: "Provide a valid contract hash, ref name, or migration directory name.",
-			meta: { input: error.input }
-		});
-	}
-}
-//#endregion
-export { mapRefResolutionError as A, errorRuntime$1 as C, errorTargetMismatch as D, errorTargetMigrationNotSupported as E, errorUnexpected$1 as O, errorRunnerFailed as S, errorSpaceNotFound as T, errorPathUnreachable as _, errorContractValidationFailed as a, errorRefSetEmptySentinel as b, errorDriverRequired as c, errorInvalidOutputFormat as d, errorInvalidSpaceId as f, errorOutputFormatMutex as g, errorMigrationPlanningFailed as h, errorContractConfigMissing$1 as i, mapMigrationToolsError as k, errorFileNotFound as l, errorMarkerMissing as m, ERROR_CODE_DESTRUCTIVE_CHANGES as n, errorDatabaseConnectionRequired as o, errorMarkerMismatch as p, errorConfigValidation$1 as r, errorDestructiveChanges as s, CliStructuredError$1 as t, errorHashMismatch as u, errorPlanForgotTheFlag as v, errorSnapshotMissing as w, errorRefSetHashNotInGraph as x, errorRefSetBundleNotFound as y };
-
-//# sourceMappingURL=cli-errors-DQY629C7.mjs.map