@prisma-next/migration-tools 0.8.0-dev.1 → 0.8.0-dev.10

package/src/errors.ts

@@ -111,27 +111,6 @@ export function errorInvalidOperationEntry(index: number, reason: string): Migra
   );
 }
 
-export function errorStaleContractBookends(args: {
-  readonly side: 'from' | 'to';
-  readonly metaHash: string | null;
-  readonly contractHash: string;
-}): MigrationToolsError {
-  const { side, metaHash, contractHash } = args;
-  // `meta.from` is `string | null` (null = baseline). Render `null` as a
-  // human-readable token in the diagnostic so the message stays clear when
-  // the mismatch is a baseline-vs-non-baseline disagreement.
-  const renderedMetaHash = metaHash === null ? 'null (baseline)' : `"${metaHash}"`;
-  return new MigrationToolsError(
-    'MIGRATION.STALE_CONTRACT_BOOKENDS',
-    'Migration manifest contract bookends disagree with describe()',
-    {
-      why: `migration.json stores ${side}Contract.storage.storageHash "${contractHash}", but describe() returned meta.${side} = ${renderedMetaHash}. The bookend is stale — most likely the migration's describe() was edited after the package was scaffolded by \`migration plan\`.`,
-      fix: 'Re-run `migration plan` to regenerate the package with fresh contract bookends, or restore the directory from version control.',
-      details: { side, metaHash, contractHash },
-    },
-  );
-}
-
 export function errorInvalidSlug(slug: string): MigrationToolsError {
   return new MigrationToolsError('MIGRATION.INVALID_NAME', 'Invalid migration name', {
     why: `The slug "${slug}" contains no valid characters after sanitization (only a-z, 0-9 are kept).`,
@@ -220,7 +199,7 @@ export function errorAmbiguousTarget(
     : '';
   return new MigrationToolsError('MIGRATION.AMBIGUOUS_TARGET', 'Ambiguous migration target', {
     why: `The migration history has diverged into multiple branches: ${branchTips.join(', ')}. This typically happens when two developers plan migrations from the same starting point.${divergenceInfo}`,
-    fix: 'Use `migration ref set <name> <hash>` to target a specific branch, delete one of the conflicting migration directories and re-run `migration plan`, or use --from <hash> to explicitly select a starting point.',
+    fix: 'Use `ref set <name> <hash>` to target a specific branch, delete one of the conflicting migration directories and re-run `migration plan`, or use --from <hash> to explicitly select a starting point.',
     details: {
       branchTips,
       ...(context ? { divergencePoint: context.divergencePoint, branches: context.branches } : {}),

package/src/exports/ref-resolution.ts

@@ -0,0 +1,15 @@
+export { parseContractRef } from '../refs/contract-ref';
+export { parseMigrationRef } from '../refs/migration-ref';
+export type {
+  ContractRef,
+  ContractRefProvenance,
+  MigrationRef,
+  MigrationRefProvenance,
+  RefResolutionAmbiguous,
+  RefResolutionContext,
+  RefResolutionError,
+  RefResolutionInvalidFormat,
+  RefResolutionNotFound,
+  RefResolutionWrongGrammar,
+} from '../refs/types';
+export { findEdgeByDirName } from '../refs/types';

package/src/hash.ts

@@ -15,11 +15,13 @@ function sha256Hex(input: string): string {
 }
 
 /**
- * Content-addressed migration hash over (metadata envelope sans
- * contracts/hints, ops). See ADR 199 — Storage-only migration identity
- * for the rationale: contracts are anchored separately by the
- * storage-hash bookends inside the envelope; planner hints are advisory
- * and must not affect identity.
+ * Content-addressed migration hash over (metadata envelope sans hints,
+ * ops). See ADR 199 — Storage-only migration identity for the
+ * rationale: the storage-hash bookends (`from`, `to`) inside the
+ * envelope anchor the contract identity by hash, and planner hints are
+ * advisory and must not affect identity. The full contract IRs are not
+ * part of the manifest — they live in sibling `*-contract.json` files
+ * authored alongside the migration, never inlined here.
  *
  * The integrity check is purely structural, not semantic. The function
  * canonicalizes its inputs via `sortKeys` (recursive) + `JSON.stringify`
@@ -44,13 +46,7 @@ export function computeMigrationHash(
   metadata: Omit<MigrationMetadata, 'migrationHash'> & { readonly migrationHash?: string },
   ops: MigrationOps,
 ): string {
-  const {
-    migrationHash: _migrationHash,
-    fromContract: _fromContract,
-    toContract: _toContract,
-    hints: _hints,
-    ...strippedMeta
-  } = metadata;
+  const { migrationHash: _migrationHash, hints: _hints, ...strippedMeta } = metadata;
 
   const canonicalMetadata = canonicalizeJson(strippedMeta);
   const canonicalOps = canonicalizeJson(ops);

package/src/io.ts

@@ -3,7 +3,6 @@ import type {
   MigrationMetadata,
   MigrationPackage,
 } from '@prisma-next/framework-components/control';
-import { canonicalizeJson } from '@prisma-next/framework-components/utils';
 import { type } from 'arktype';
 import { basename, dirname, join, resolve } from 'pathe';
 import {
@@ -40,8 +39,6 @@ const MigrationMetadataSchema = type({
   from: 'string > 0 | null',
   to: 'string',
   migrationHash: 'string',
-  fromContract: 'object | null',
-  toContract: 'object',
   hints: MigrationHintsSchema,
   labels: 'string[]',
   providedInvariants: 'string[]',
@@ -74,35 +71,31 @@ export async function writeMigrationPackage(
  * Materialise an in-memory {@link MigrationPackage} to a per-space
  * directory on disk.
  *
- * Writes three files under `<targetDir>/<pkg.dirName>/`:
+ * Writes two files under `<targetDir>/<pkg.dirName>/`:
  *
  * - `migration.json` — the manifest (pretty-printed, matches
  *   {@link writeMigrationPackage}'s output for byte-for-byte parity with
  *   app-space migrations).
  * - `ops.json` — the operation list (pretty-printed).
- * - `contract.json` — the canonical-JSON serialisation of
- *   `metadata.toContract`. This is the per-package post-state contract
- *   snapshot; the canonicalisation pass guarantees byte-determinism so
- *   re-emitting the same package across machines / runs produces an
- *   identical file.
  *
  * Distinct verb from the lower-level {@link writeMigrationPackage}
  * (which takes constituent `(metadata, ops)`): callers reading
- * `materialise…` know they are persisting a struct-typed package
- * including its contract-snapshot side car.
+ * `materialise…` know they are persisting a struct-typed package.
  *
  * Overwrite-idempotent: the per-package directory is cleared before
  * each emit, so re-running against the same `targetDir` produces
  * byte-identical contents and never leaves stale files behind. The
- * spec's "re-emitting the same package across runs / machines produces
- * byte-identical files" guarantee (§ 3) covers both same-dir and
- * fresh-dir re-emits. The lower-level {@link writeMigrationPackage}
- * stays strict because the CLI authoring path (`migration plan` /
- * `migration new`) deliberately refuses to clobber an existing
- * authored migration; this helper is the re-emit path that is
- * supposed to converge on a single canonical on-disk shape.
+ * lower-level {@link writeMigrationPackage} stays strict because the
+ * CLI authoring path (`migration plan` / `migration new`) deliberately
+ * refuses to clobber an existing authored migration; this helper is
+ * the re-emit path that is supposed to converge on a single canonical
+ * on-disk shape.
  *
- * @see specs/framework-mechanism.spec.md § 3 — Emission helper (T1.7).
+ * The per-space head contract lives at
+ * `<projectMigrationsDir>/<spaceId>/contract.json` (written by
+ * {@link import('./emit-contract-space-artefacts').emitContractSpaceArtefacts}),
+ * not inside the per-package directory. The runner reads only
+ * `migration.json` + `ops.json` from each package.
  */
 export async function materialiseMigrationPackage(
   targetDir: string,
@@ -111,9 +104,6 @@ export async function materialiseMigrationPackage(
   const dir = join(targetDir, pkg.dirName);
   await rm(dir, { recursive: true, force: true });
   await writeMigrationPackage(dir, pkg.metadata, pkg.ops);
-  await writeFile(join(dir, 'contract.json'), `${canonicalizeJson(pkg.metadata.toContract)}\n`, {
-    flag: 'wx',
-  });
 }
 
 /**

package/src/migration-base.ts

@@ -1,13 +1,12 @@
 import { realpathSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
-import type { Contract } from '@prisma-next/contract/types';
 import type {
   ControlStack,
   MigrationPlan,
   MigrationPlanOperation,
 } from '@prisma-next/framework-components/control';
 import { type } from 'arktype';
-import { errorInvalidOperationEntry, errorStaleContractBookends } from './errors';
+import { errorInvalidOperationEntry } from './errors';
 import { computeMigrationHash } from './hash';
 import { deriveProvidedInvariants } from './invariants';
 import type { MigrationHints, MigrationMetadata } from './metadata';
@@ -145,21 +144,12 @@ function buildAttestedMetadata(
   ops: MigrationOps,
   existing: Partial<MigrationMetadata> | null,
 ): MigrationMetadata {
-  assertBookendsMatchMeta(meta, existing);
-
   const baseMetadata: Omit<MigrationMetadata, 'migrationHash'> = {
     from: meta.from,
     to: meta.to,
     labels: meta.labels ?? existing?.labels ?? [],
     providedInvariants: deriveProvidedInvariants(ops),
     createdAt: existing?.createdAt ?? new Date().toISOString(),
-    fromContract: existing?.fromContract ?? null,
-    // When no scaffolded metadata exists we synthesize a minimal contract
-    // stub so the package is still readable end-to-end. The cast is
-    // intentional: only the storage bookend matters for hash computation
-    // (everything else is stripped by `computeMigrationHash`), and a real
-    // contract bookend would only be available after `migration plan`.
-    toContract: existing?.toContract ?? ({ storage: { storageHash: meta.to } } as Contract),
     hints: normalizeHints(existing?.hints),
   };
 
@@ -167,49 +157,6 @@ function buildAttestedMetadata(
   return { ...baseMetadata, migrationHash };
 }
 
-/**
- * Verify each preserved contract bookend in `existing` agrees with the
- * corresponding side of `describe()`'s output. A mismatch indicates the
- * migration's `describe()` was edited after `migration plan` scaffolded
- * the package, leaving a self-inconsistent manifest. Failing fast at
- * write-time turns a silent foot-gun into an actionable diagnostic.
- *
- * Skipped when a side's `existing.<side>Contract` is null/absent (the
- * synthesis path stays open for origin-less initial migrations and for
- * bare `migration.ts` runs from scratch). When a bookend is *present*
- * but its `storage.storageHash` is missing, that's treated as a
- * mismatch — a malformed bookend is not equivalent to "no bookend".
- *
- * This check is paired with TML-2274, which removes `fromContract` /
- * `toContract` from the manifest entirely; once that lands, this
- * function and its error code are deleted.
- */
-function assertBookendsMatchMeta(
-  meta: MigrationMeta,
-  existing: Partial<MigrationMetadata> | null,
-): void {
-  if (existing?.fromContract != null) {
-    const contractHash = existing.fromContract.storage?.storageHash ?? '';
-    if (contractHash !== meta.from) {
-      throw errorStaleContractBookends({
-        side: 'from',
-        metaHash: meta.from,
-        contractHash,
-      });
-    }
-  }
-  if (existing?.toContract != null) {
-    const contractHash = existing.toContract.storage?.storageHash ?? '';
-    if (contractHash !== meta.to) {
-      throw errorStaleContractBookends({
-        side: 'to',
-        metaHash: meta.to,
-        contractHash,
-      });
-    }
-  }
-}
-
 /**
  * Project `existing.hints` down to the known `MigrationHints` shape, dropping
  * any legacy keys that may linger in metadata scaffolded by older CLI

package/src/refs/contract-ref.ts

@@ -0,0 +1,103 @@
+import type { Result } from '@prisma-next/utils/result';
+import { notOk, ok } from '@prisma-next/utils/result';
+import { validateRefName } from '../refs';
+import type {
+  ContractRef,
+  ContractRefProvenance,
+  RefResolutionContext,
+  RefResolutionError,
+} from './types';
+import { findEdgeByDirName, isFullHash, isHexPrefix, normalizeHashPrefix } from './types';
+
+/**
+ * Resolve a user-supplied string to a contract hash using the unified
+ * contract-reference grammar.
+ *
+ * Accepted forms:
+ * - Full storage hash (`sha256:<64 hex>` or `sha256:empty`)
+ * - Hex prefix (6+ hex chars, must uniquely identify one contract)
+ * - Ref name (looked up in the refs index)
+ * - Migration directory name (resolves to the migration's `to`-contract)
+ * - `<dir>^` (resolves to the migration's `from`-contract)
+ */
+export function parseContractRef(
+  input: string,
+  ctx: RefResolutionContext,
+): Result<ContractRef, RefResolutionError> {
+  if (!input) {
+    return notOk({ kind: 'invalid-format', input, reason: 'Reference cannot be empty' });
+  }
+
+  if (isFullHash(input)) {
+    if (ctx.graph.nodes.has(input)) {
+      return ok({ hash: input, provenance: { kind: 'hash', input } });
+    }
+    return notOk({ kind: 'not-found', input, grammar: 'contract' });
+  }
+
+  if (input.endsWith('^')) {
+    const dirName = input.slice(0, -1);
+    if (!dirName) {
+      return notOk({ kind: 'invalid-format', input, reason: 'Missing directory name before ^' });
+    }
+    const edge = findEdgeByDirName(ctx.graph, dirName);
+    if (edge) {
+      return ok({ hash: edge.from, provenance: { kind: 'migration-from', dirName } });
+    }
+    return notOk({ kind: 'not-found', input, grammar: 'contract' });
+  }
+
+  type Candidate = { hash: string; provenance: ContractRefProvenance; label: string };
+  const candidates: Candidate[] = [];
+
+  if (validateRefName(input) && Object.hasOwn(ctx.refs, input)) {
+    const ref = ctx.refs[input];
+    if (ref) {
+      candidates.push({
+        hash: ref.hash,
+        provenance: { kind: 'ref', refName: input },
+        label: `ref "${input}"`,
+      });
+    }
+  }
+
+  const edge = findEdgeByDirName(ctx.graph, input);
+  if (edge) {
+    candidates.push({
+      hash: edge.to,
+      provenance: { kind: 'migration-to', dirName: input },
+      label: `migration directory "${input}"`,
+    });
+  }
+
+  if (isHexPrefix(input)) {
+    const prefix = normalizeHashPrefix(input);
+    const matches = [...ctx.graph.nodes].filter((n) => n.startsWith(prefix));
+    const [firstMatch] = matches;
+    if (matches.length === 1 && firstMatch !== undefined) {
+      candidates.push({
+        hash: firstMatch,
+        provenance: { kind: 'hash', input },
+        label: `hash prefix "${input}"`,
+      });
+    } else if (matches.length > 1) {
+      return notOk({ kind: 'ambiguous', input, candidates: matches, grammar: 'contract' });
+    }
+  }
+
+  const [firstCandidate] = candidates;
+  if (candidates.length === 1 && firstCandidate !== undefined) {
+    return ok({ hash: firstCandidate.hash, provenance: firstCandidate.provenance });
+  }
+
+  if (candidates.length > 1) {
+    return notOk({
+      kind: 'ambiguous',
+      input,
+      candidates: candidates.map((c) => c.label),
+      grammar: 'contract',
+    });
+  }
+
+  return notOk({ kind: 'not-found', input, grammar: 'contract' });
+}

package/src/refs/migration-ref.ts

@@ -0,0 +1,121 @@
+import type { Result } from '@prisma-next/utils/result';
+import { notOk, ok } from '@prisma-next/utils/result';
+import { validateRefName } from '../refs';
+import type { MigrationRef, RefResolutionContext, RefResolutionError } from './types';
+import { findEdgeByDirName, isFullHash, isHexPrefix, normalizeHashPrefix } from './types';
+
+/**
+ * Resolve a user-supplied string to a migration using the migration-reference
+ * grammar.
+ *
+ * Accepted forms:
+ * - Migration directory name (e.g. `20260101-add-users`)
+ * - Migration hash (full or 6+ hex prefix)
+ *
+ * Wrong-grammar diagnostics are produced when the input matches a
+ * contract-grammar form (ref name, `<dir>^`, contract-only hash) so the
+ * user gets a targeted hint rather than a generic "not found".
+ */
+export function parseMigrationRef(
+  input: string,
+  ctx: RefResolutionContext,
+): Result<MigrationRef, RefResolutionError> {
+  if (!input) {
+    return notOk({ kind: 'invalid-format', input, reason: 'Reference cannot be empty' });
+  }
+
+  if (input.endsWith('^')) {
+    return notOk({
+      kind: 'wrong-grammar',
+      input,
+      expectedGrammar: 'migration',
+      message: '`^` syntax addresses contracts, not migrations',
+      fix: 'Pass the migration directory name without `^`, or use a contract-accepting flag like `--to` or `--from`.',
+    });
+  }
+
+  if (validateRefName(input) && Object.hasOwn(ctx.refs, input)) {
+    return notOk({
+      kind: 'wrong-grammar',
+      input,
+      expectedGrammar: 'migration',
+      message: `"${input}" is a ref name, not a migration`,
+      fix: 'Refs point at contracts, not migrations. Use a migration directory name or migration hash.',
+    });
+  }
+
+  const edge = findEdgeByDirName(ctx.graph, input);
+  if (edge) {
+    return ok({
+      dirName: edge.dirName,
+      migrationHash: edge.migrationHash,
+      from: edge.from,
+      to: edge.to,
+      provenance: { kind: 'dir-name', dirName: input },
+    });
+  }
+
+  if (isFullHash(input)) {
+    const migEdge = ctx.graph.migrationByHash.get(input);
+    if (migEdge) {
+      return ok({
+        dirName: migEdge.dirName,
+        migrationHash: migEdge.migrationHash,
+        from: migEdge.from,
+        to: migEdge.to,
+        provenance: { kind: 'hash', input },
+      });
+    }
+    if (ctx.graph.nodes.has(input)) {
+      return notOk({
+        kind: 'wrong-grammar',
+        input,
+        expectedGrammar: 'migration',
+        message: 'Hash matched a contract but not a migration',
+        fix: 'Use a contract-accepting flag like `--to` or `--from` to reference contracts by hash. Pass `migration show <dir>` for a specific migration.',
+      });
+    }
+    return notOk({ kind: 'not-found', input, grammar: 'migration' });
+  }
+
+  if (isHexPrefix(input)) {
+    const prefix = normalizeHashPrefix(input);
+    const migMatches = [...ctx.graph.migrationByHash.entries()].filter(([hash]) =>
+      hash.startsWith(prefix),
+    );
+
+    const [firstMigMatch] = migMatches;
+    if (migMatches.length === 1 && firstMigMatch !== undefined) {
+      const [, matchedEdge] = firstMigMatch;
+      return ok({
+        dirName: matchedEdge.dirName,
+        migrationHash: matchedEdge.migrationHash,
+        from: matchedEdge.from,
+        to: matchedEdge.to,
+        provenance: { kind: 'hash', input },
+      });
+    }
+
+    if (migMatches.length > 1) {
+      return notOk({
+        kind: 'ambiguous',
+        input,
+        candidates: migMatches.map(([hash]) => hash),
+        grammar: 'migration',
+      });
+    }
+
+    const contractMatches = [...ctx.graph.nodes].filter((n) => n.startsWith(prefix));
+    if (contractMatches.length > 0) {
+      return notOk({
+        kind: 'wrong-grammar',
+        input,
+        expectedGrammar: 'migration',
+        message: 'Hash matched a contract but not a migration',
+        fix: 'Use a contract-accepting flag like `--to` or `--from` to reference contracts by hash. Pass `migration show <dir>` for a specific migration.',
+      });
+    }
+  }
+
+  return notOk({ kind: 'not-found', input, grammar: 'migration' });
+}

package/src/refs/types.ts

@@ -0,0 +1,93 @@
+import type { MigrationEdge, MigrationGraph } from '../graph';
+import type { Refs } from '../refs';
+
+/** Context required to resolve a contract or migration reference. */
+export interface RefResolutionContext {
+  readonly graph: MigrationGraph;
+  readonly refs: Refs;
+}
+
+export type ContractRefProvenance =
+  | { readonly kind: 'hash'; readonly input: string }
+  | { readonly kind: 'ref'; readonly refName: string }
+  | { readonly kind: 'migration-to'; readonly dirName: string }
+  | { readonly kind: 'migration-from'; readonly dirName: string };
+
+/** A resolved contract reference: the target hash and how it was derived. */
+export interface ContractRef {
+  readonly hash: string;
+  readonly provenance: ContractRefProvenance;
+}
+
+export type MigrationRefProvenance =
+  | { readonly kind: 'dir-name'; readonly dirName: string }
+  | { readonly kind: 'hash'; readonly input: string };
+
+/** A resolved migration reference. */
+export interface MigrationRef {
+  readonly dirName: string;
+  readonly migrationHash: string;
+  readonly from: string;
+  readonly to: string;
+  readonly provenance: MigrationRefProvenance;
+}
+
+export interface RefResolutionNotFound {
+  readonly kind: 'not-found';
+  readonly input: string;
+  readonly grammar: 'contract' | 'migration';
+}
+
+export interface RefResolutionAmbiguous {
+  readonly kind: 'ambiguous';
+  readonly input: string;
+  readonly candidates: readonly string[];
+  readonly grammar: 'contract' | 'migration';
+}
+
+export interface RefResolutionWrongGrammar {
+  readonly kind: 'wrong-grammar';
+  readonly input: string;
+  readonly expectedGrammar: 'contract' | 'migration';
+  readonly message: string;
+  readonly fix: string;
+}
+
+export interface RefResolutionInvalidFormat {
+  readonly kind: 'invalid-format';
+  readonly input: string;
+  readonly reason: string;
+}
+
+export type RefResolutionError =
+  | RefResolutionNotFound
+  | RefResolutionAmbiguous
+  | RefResolutionWrongGrammar
+  | RefResolutionInvalidFormat;
+
+const FULL_HASH_PATTERN = /^sha256:([0-9a-f]{64}|empty)$/;
+const HEX_PREFIX_PATTERN = /^(sha256:)?[0-9a-f]{6,}$/;
+
+export function isFullHash(input: string): boolean {
+  return FULL_HASH_PATTERN.test(input);
+}
+
+export function isHexPrefix(input: string): boolean {
+  return HEX_PREFIX_PATTERN.test(input);
+}
+
+export function normalizeHashPrefix(input: string): string {
+  return input.startsWith('sha256:') ? input : `sha256:${input}`;
+}
+
+export function findEdgeByDirName(
+  graph: MigrationGraph,
+  dirName: string,
+): MigrationEdge | undefined {
+  for (const edges of graph.forwardChain.values()) {
+    for (const edge of edges) {
+      if (edge.dirName === dirName) return edge;
+    }
+  }
+  return undefined;
+}

package/src/refs.ts

@@ -61,7 +61,7 @@ export async function readRef(refsDir: string, name: string): Promise<RefEntry>
     if (error instanceof Error && (error as { code?: string }).code === 'ENOENT') {
       throw new MigrationToolsError('MIGRATION.UNKNOWN_REF', `Unknown ref "${name}"`, {
         why: `No ref file found at "${filePath}".`,
-        fix: `Create the ref with: prisma-next migration ref set ${name} <hash>`,
+        fix: `Create the ref with: prisma-next ref set ${name} <hash>`,
         details: { refName: name, filePath },
       });
     }
@@ -166,7 +166,7 @@ export async function deleteRef(refsDir: string, name: string): Promise<void> {
     if (error instanceof Error && (error as { code?: string }).code === 'ENOENT') {
       throw new MigrationToolsError('MIGRATION.UNKNOWN_REF', `Unknown ref "${name}"`, {
         why: `No ref file found at "${filePath}".`,
-        fix: 'Run `prisma-next migration ref list` to see available refs.',
+        fix: 'Run `prisma-next ref list` to see available refs.',
         details: { refName: name, filePath },
       });
     }
@@ -203,7 +203,7 @@ export function resolveRef(refs: Refs, name: string): RefEntry {
   if (!Object.hasOwn(refs, name)) {
     throw new MigrationToolsError('MIGRATION.UNKNOWN_REF', `Unknown ref "${name}"`, {
       why: `No ref named "${name}" exists.`,
-      fix: `Available refs: ${Object.keys(refs).join(', ') || '(none)'}. Create a ref with: prisma-next migration ref set ${name} <hash>`,
+      fix: `Available refs: ${Object.keys(refs).join(', ') || '(none)'}. Create a ref with: prisma-next ref set ${name} <hash>`,
       details: { refName: name, availableRefs: Object.keys(refs) },
     });
   }

package/dist/errors-EPL_9p9f.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"errors-EPL_9p9f.mjs","names":[],"sources":["../src/errors.ts"],"sourcesContent":["import { ifDefined } from '@prisma-next/utils/defined';\nimport { basename, dirname, relative } from 'pathe';\n\n/**\n * Build the canonical \"re-emit this package\" remediation hint.\n *\n * Every on-disk migration package ships its own `migration.ts` author-time\n * file. Running it regenerates `migration.json` and `ops.json` with the\n * correct hash + metadata, so it is the right primitive whenever a single\n * package's on-disk artifacts are missing, malformed, or otherwise corrupt.\n * Pointing users at `migration plan` would emit a *new* package rather than\n * heal the broken one.\n */\nfunction reemitHint(dir: string, fallback?: string): string {\n  const relativeDir = relative(process.cwd(), dir);\n  const reemit = `Re-emit the package by running \\`node \"${relativeDir}/migration.ts\"\\``;\n  return fallback ? `${reemit}, ${fallback}` : `${reemit}.`;\n}\n\n/**\n * Structured error for migration tooling operations.\n *\n * Follows the NAMESPACE.SUBCODE convention from ADR 027. All codes live under\n * the MIGRATION namespace. These are tooling-time errors (file I/O, hash\n * verification, migration history reconstruction), distinct from the runtime\n * MIGRATION.* codes for apply-time failures (PRECHECK_FAILED, POSTCHECK_FAILED,\n * etc.).\n *\n * Fields:\n * - code:     Stable machine-readable code (MIGRATION.SUBCODE)\n * - category: Always 'MIGRATION'\n * - why:      Explains the cause in plain language\n * - fix:      Actionable remediation step\n * - details:  Machine-readable structured data for agents\n */\nexport class MigrationToolsError extends Error {\n  readonly code: string;\n  readonly category = 'MIGRATION' as const;\n  readonly why: string;\n  readonly fix: string;\n  readonly details: Record<string, unknown> | undefined;\n\n  constructor(\n    code: string,\n    summary: string,\n    options: {\n      readonly why: string;\n      readonly fix: string;\n      readonly details?: Record<string, unknown>;\n    },\n  ) {\n    super(summary);\n    this.name = 'MigrationToolsError';\n    this.code = code;\n    this.why = options.why;\n    this.fix = options.fix;\n    this.details = options.details;\n  }\n\n  static is(error: unknown): error is MigrationToolsError {\n    if (!(error instanceof Error)) return false;\n    const candidate = error as MigrationToolsError;\n    return candidate.name === 'MigrationToolsError' && typeof candidate.code === 'string';\n  }\n}\n\nexport function errorDirectoryExists(dir: string): MigrationToolsError {\n  return new MigrationToolsError('MIGRATION.DIR_EXISTS', 'Migration directory already exists', {\n    why: `The directory \"${dir}\" already exists. Each migration must have a unique directory.`,\n    fix: 'Use --name to pick a different name, or delete the existing directory and re-run.',\n    details: { dir },\n  });\n}\n\nexport function errorMissingFile(file: string, dir: string): MigrationToolsError {\n  return new MigrationToolsError('MIGRATION.FILE_MISSING', `Missing ${file}`, {\n    why: `Expected \"${file}\" in \"${dir}\" but the file does not exist.`,\n    fix: reemitHint(\n      dir,\n      'or delete the directory if the migration is unwanted and the source TypeScript is gone.',\n    ),\n    details: { file, dir },\n  });\n}\n\nexport function errorInvalidJson(filePath: string, parseError: string): MigrationToolsError {\n  return new MigrationToolsError('MIGRATION.INVALID_JSON', 'Invalid JSON in migration file', {\n    why: `Failed to parse \"${filePath}\": ${parseError}`,\n    fix: reemitHint(dirname(filePath), 'or restore the directory from version control.'),\n    details: { filePath, parseError },\n  });\n}\n\nexport function errorInvalidManifest(filePath: string, reason: string): MigrationToolsError {\n  return new MigrationToolsError('MIGRATION.INVALID_MANIFEST', 'Invalid migration manifest', {\n    why: `Migration manifest at \"${filePath}\" is invalid: ${reason}`,\n    fix: reemitHint(dirname(filePath), 'or restore the directory from version control.'),\n    details: { filePath, reason },\n  });\n}\n\nexport function errorInvalidOperationEntry(index: number, reason: string): MigrationToolsError {\n  return new MigrationToolsError(\n    'MIGRATION.INVALID_OPERATION_ENTRY',\n    'Migration operation entry is malformed',\n    {\n      why: `Operation at index ${index} returned by the migration class failed schema validation: ${reason}.`,\n      fix: \"Update the migration class so each entry of `operations` carries `id` (string), `label` (string), and `operationClass` (one of 'additive' | 'widening' | 'destructive' | 'data').\",\n      details: { index, reason },\n    },\n  );\n}\n\nexport function errorStaleContractBookends(args: {\n  readonly side: 'from' | 'to';\n  readonly metaHash: string | null;\n  readonly contractHash: string;\n}): MigrationToolsError {\n  const { side, metaHash, contractHash } = args;\n  // `meta.from` is `string | null` (null = baseline). Render `null` as a\n  // human-readable token in the diagnostic so the message stays clear when\n  // the mismatch is a baseline-vs-non-baseline disagreement.\n  const renderedMetaHash = metaHash === null ? 'null (baseline)' : `\"${metaHash}\"`;\n  return new MigrationToolsError(\n    'MIGRATION.STALE_CONTRACT_BOOKENDS',\n    'Migration manifest contract bookends disagree with describe()',\n    {\n      why: `migration.json stores ${side}Contract.storage.storageHash \"${contractHash}\", but describe() returned meta.${side} = ${renderedMetaHash}. The bookend is stale — most likely the migration's describe() was edited after the package was scaffolded by \\`migration plan\\`.`,\n      fix: 'Re-run `migration plan` to regenerate the package with fresh contract bookends, or restore the directory from version control.',\n      details: { side, metaHash, contractHash },\n    },\n  );\n}\n\nexport function errorInvalidSlug(slug: string): MigrationToolsError {\n  return new MigrationToolsError('MIGRATION.INVALID_NAME', 'Invalid migration name', {\n    why: `The slug \"${slug}\" contains no valid characters after sanitization (only a-z, 0-9 are kept).`,\n    fix: 'Provide a name with at least one alphanumeric character, e.g. --name add_users.',\n    details: { slug },\n  });\n}\n\nexport function errorInvalidDestName(destName: string): MigrationToolsError {\n  return new MigrationToolsError('MIGRATION.INVALID_DEST_NAME', 'Invalid copy destination name', {\n    why: `The destination name \"${destName}\" must be a single path segment (no \"..\" or directory separators).`,\n    fix: 'Use a simple file name such as \"contract.json\" for each destination in the copy list.',\n    details: { destName },\n  });\n}\n\nexport function errorInvalidSpaceId(spaceId: string): MigrationToolsError {\n  return new MigrationToolsError(\n    'MIGRATION.INVALID_SPACE_ID',\n    'Invalid contract space identifier',\n    {\n      why: `The space id \"${spaceId}\" does not match the required pattern /^[a-z][a-z0-9_-]{0,63}$/. Space ids are used as filesystem directory names under \\`migrations/\\`, so the pattern is conservative on purpose.`,\n      fix: 'Pick a lowercase identifier that begins with a letter and contains only lowercase letters, digits, hyphens, or underscores; max 64 characters total.',\n      details: { spaceId },\n    },\n  );\n}\n\nexport function errorDescriptorHeadHashMismatch(args: {\n  readonly extensionId: string;\n  readonly recomputedHash: string;\n  readonly headRefHash: string;\n}): MigrationToolsError {\n  const { extensionId, recomputedHash, headRefHash } = args;\n  return new MigrationToolsError(\n    'MIGRATION.DESCRIPTOR_HEAD_HASH_MISMATCH',\n    \"Extension descriptor's headRef.hash does not match its contractJson\",\n    {\n      why: `Extension \"${extensionId}\" publishes a \\`contractSpace\\` whose \\`headRef.hash\\` (${headRefHash}) does not match the canonical hash recomputed from \\`contractSpace.contractJson\\` (${recomputedHash}). This means the extension descriptor was published with stale \\`headRef.hash\\` — typically because the contract was bumped without rerunning the extension's emit pipeline.`,\n      fix: 'Re-run the extension authoring pipeline so `contractJson.storage.storageHash` and `headRef.hash` agree, then republish the extension. If you are the extension author and you intentionally bumped `contractJson`, recompute and update `headRef.hash` (and refresh any on-disk migration metadata that derives from it).',\n      details: { extensionId, recomputedHash, headRefHash },\n    },\n  );\n}\n\nexport function errorDuplicateSpaceId(spaceId: string): MigrationToolsError {\n  return new MigrationToolsError(\n    'MIGRATION.DUPLICATE_SPACE_ID',\n    'Duplicate contract space identifier',\n    {\n      why: `The space id \"${spaceId}\" appears more than once in the per-space planner input. Each space id must be unique across the inputs (the per-space planner emits one output entry per id).`,\n      fix: 'Deduplicate the inputs before passing them to `planAllSpaces` — typically by checking your `extensionPacks` declaration for repeated entries.',\n      details: { spaceId },\n    },\n  );\n}\n\nexport function errorSameSourceAndTarget(dir: string, hash: string): MigrationToolsError {\n  const dirName = basename(dir);\n  return new MigrationToolsError(\n    'MIGRATION.SAME_SOURCE_AND_TARGET',\n    'Migration without data-transform operations has same source and target',\n    {\n      why: `Migration \"${dirName}\" has from === to === \"${hash}\" and declares no data-transform operations. Self-edges are only allowed when the migration runs at least one dataTransform — otherwise the migration is a no-op.`,\n      fix: reemitHint(\n        dir,\n        'and either change the contract so from ≠ to, add a dataTransform op, or delete the directory if the migration is unwanted.',\n      ),\n      details: { dirName, hash },\n    },\n  );\n}\n\nexport function errorAmbiguousTarget(\n  branchTips: readonly string[],\n  context?: {\n    divergencePoint: string;\n    branches: readonly {\n      tip: string;\n      edges: readonly { dirName: string; from: string; to: string }[];\n    }[];\n  },\n): MigrationToolsError {\n  const divergenceInfo = context\n    ? `\\nDivergence point: ${context.divergencePoint}\\nBranches:\\n${context.branches.map((b) => `  → ${b.tip} (${b.edges.length} edge(s): ${b.edges.map((e) => e.dirName).join(' → ') || 'direct'})`).join('\\n')}`\n    : '';\n  return new MigrationToolsError('MIGRATION.AMBIGUOUS_TARGET', 'Ambiguous migration target', {\n    why: `The migration history has diverged into multiple branches: ${branchTips.join(', ')}. This typically happens when two developers plan migrations from the same starting point.${divergenceInfo}`,\n    fix: 'Use `migration ref set <name> <hash>` to target a specific branch, delete one of the conflicting migration directories and re-run `migration plan`, or use --from <hash> to explicitly select a starting point.',\n    details: {\n      branchTips,\n      ...(context ? { divergencePoint: context.divergencePoint, branches: context.branches } : {}),\n    },\n  });\n}\n\nexport function errorNoInitialMigration(nodes: readonly string[]): MigrationToolsError {\n  return new MigrationToolsError('MIGRATION.NO_INITIAL_MIGRATION', 'No initial migration found', {\n    why: `No migration starts from the empty contract state (known hashes: ${nodes.join(', ')}). At least one migration must originate from the empty state.`,\n    fix: 'Inspect the migrations directory for corrupted migration.json files. At least one migration must start from the empty contract hash.',\n    details: { nodes },\n  });\n}\n\nexport function errorInvalidRefs(refsPath: string, reason: string): MigrationToolsError {\n  return new MigrationToolsError('MIGRATION.INVALID_REFS', 'Invalid refs.json', {\n    why: `refs.json at \"${refsPath}\" is invalid: ${reason}`,\n    fix: 'Ensure refs.json is a flat object mapping valid ref names to contract hash strings.',\n    details: { path: refsPath, reason },\n  });\n}\n\nexport function errorInvalidRefFile(filePath: string, reason: string): MigrationToolsError {\n  return new MigrationToolsError('MIGRATION.INVALID_REF_FILE', 'Invalid ref file', {\n    why: `Ref file at \"${filePath}\" is invalid: ${reason}`,\n    fix: 'Ensure the ref file contains valid JSON with { \"hash\": \"sha256:<64 hex chars>\", \"invariants\": [\"...\"] }.',\n    details: { path: filePath, reason },\n  });\n}\n\nexport function errorInvalidRefName(refName: string): MigrationToolsError {\n  return new MigrationToolsError('MIGRATION.INVALID_REF_NAME', 'Invalid ref name', {\n    why: `Ref name \"${refName}\" is invalid. Names must be lowercase alphanumeric with hyphens or forward slashes (no \".\" or \"..\" segments).`,\n    fix: `Use a valid ref name (e.g., \"staging\", \"envs/production\").`,\n    details: { refName },\n  });\n}\n\nexport function errorNoTarget(reachableHashes: readonly string[]): MigrationToolsError {\n  return new MigrationToolsError('MIGRATION.NO_TARGET', 'No migration target could be resolved', {\n    why: `The migration history contains cycles and no target can be resolved automatically (reachable hashes: ${reachableHashes.join(', ')}). This typically happens after rollback migrations (e.g., C1→C2→C1).`,\n    fix: 'Use --from <hash> to specify the planning origin explicitly.',\n    details: { reachableHashes },\n  });\n}\n\nexport function errorInvalidRefValue(value: string): MigrationToolsError {\n  return new MigrationToolsError('MIGRATION.INVALID_REF_VALUE', 'Invalid ref value', {\n    why: `Ref value \"${value}\" is not a valid contract hash. Values must be in the format \"sha256:<64 hex chars>\" or \"sha256:empty\".`,\n    fix: 'Use a valid storage hash from `prisma-next contract emit` output or an existing migration.',\n    details: { value },\n  });\n}\n\nexport function errorDuplicateMigrationHash(migrationHash: string): MigrationToolsError {\n  return new MigrationToolsError(\n    'MIGRATION.DUPLICATE_MIGRATION_HASH',\n    'Duplicate migrationHash in migration graph',\n    {\n      why: `Multiple migrations share migrationHash \"${migrationHash}\". Each migration must have a unique content-addressed identity.`,\n      fix: 'Regenerate one of the conflicting migrations so each migrationHash is unique, then re-run migration commands.',\n      details: { migrationHash },\n    },\n  );\n}\n\nexport function errorInvalidInvariantId(invariantId: string): MigrationToolsError {\n  return new MigrationToolsError('MIGRATION.INVALID_INVARIANT_ID', 'Invalid invariantId', {\n    why: `invariantId ${JSON.stringify(invariantId)} is invalid. Ids must be non-empty and contain no whitespace or control characters (including Unicode whitespace like NBSP); other content (kebab-case, camelCase, namespaced, Unicode letters) is allowed.`,\n    fix: 'Pick an invariantId without spaces, tabs, newlines, or control characters — e.g. \"backfill-user-phone\", \"users/backfill-phone\", or \"BackfillUserPhone\".',\n    details: { invariantId },\n  });\n}\n\nexport function errorDuplicateInvariantInEdge(invariantId: string): MigrationToolsError {\n  return new MigrationToolsError(\n    'MIGRATION.DUPLICATE_INVARIANT_IN_EDGE',\n    'Duplicate invariantId on a single migration',\n    {\n      why: `invariantId \"${invariantId}\" is declared by more than one dataTransform on the same migration. The marker stores invariants as a set and the routing layer treats them as edge-level, so two ops cannot share a routing identity.`,\n      fix: 'Rename one of the conflicting dataTransform invariantIds, or drop invariantId on the op that does not need to be routing-visible.',\n      details: { invariantId },\n    },\n  );\n}\n\nexport function errorProvidedInvariantsMismatch(\n  filePath: string,\n  stored: readonly string[],\n  derived: readonly string[],\n): MigrationToolsError {\n  const storedSet = new Set(stored);\n  const derivedSet = new Set(derived);\n  const missing = [...derivedSet].filter((id) => !storedSet.has(id));\n  const extra = [...storedSet].filter((id) => !derivedSet.has(id));\n  // When sets agree but arrays don't, the only difference is ordering — call\n  // it out so the reader doesn't stare at two visually-identical arrays.\n  // Canonical providedInvariants is sorted ascending; a manifest with the\n  // same ids in a different order is still a mismatch (the hash check would\n  // also fail), but the human-readable diagnostic is otherwise unhelpful.\n  const orderingOnly = missing.length === 0 && extra.length === 0;\n  const why = orderingOnly\n    ? `migration.json at \"${filePath}\" stores providedInvariants ${JSON.stringify(stored)}, but the canonical value derived from ops.json is ${JSON.stringify(derived)} — same ids, different order. Canonical providedInvariants is sorted ascending.`\n    : `migration.json at \"${filePath}\" stores providedInvariants ${JSON.stringify(stored)}, but the value derived from ops.json is ${JSON.stringify(derived)}. The manifest copy was likely hand-edited without re-emitting.`;\n  return new MigrationToolsError(\n    'MIGRATION.PROVIDED_INVARIANTS_MISMATCH',\n    'providedInvariants on migration.json disagrees with ops.json',\n    {\n      why,\n      fix: reemitHint(dirname(filePath), 'or restore the directory from version control.'),\n      details: { filePath, stored, derived, difference: { missing, extra } },\n    },\n  );\n}\n\n/**\n * Wire-shape edge surfaced through the JSON envelope's\n * `meta.structuralPath` of `MIGRATION.NO_INVARIANT_PATH`. Slim by design —\n * authoring metadata (`createdAt`, `labels`) lives on `MigrationEdge` but\n * is intentionally dropped here so the envelope stays stable across\n * graph-internal refactors.\n *\n * Stability: any field added here is part of the public CLI JSON contract.\n * Callers (CLI consumers, agents) must be able to treat\n * `(dirName, migrationHash, from, to, invariants)` as the canonical shape.\n */\nexport interface NoInvariantPathStructuralEdge {\n  readonly dirName: string;\n  readonly migrationHash: string;\n  readonly from: string;\n  readonly to: string;\n  readonly invariants: readonly string[];\n}\n\nexport function errorNoInvariantPath(args: {\n  readonly refName?: string;\n  readonly required: readonly string[];\n  readonly missing: readonly string[];\n  readonly structuralPath: readonly NoInvariantPathStructuralEdge[];\n}): MigrationToolsError {\n  const { refName, required, missing, structuralPath } = args;\n  const refClause = refName ? `Ref \"${refName}\"` : 'Target';\n  const missingList = missing.map((id) => JSON.stringify(id)).join(', ');\n  const requiredList = required.map((id) => JSON.stringify(id)).join(', ');\n  return new MigrationToolsError(\n    'MIGRATION.NO_INVARIANT_PATH',\n    'No path covers the required invariants',\n    {\n      why: `${refClause} requires invariants the reachable path doesn't cover. required=[${requiredList}], missing=[${missingList}].`,\n      fix: 'Add a migration on the path that runs `dataTransform({ invariantId: \"<id>\", … })` for each missing invariant, or retarget the ref to a hash whose path already provides them.',\n      details: {\n        required,\n        missing,\n        structuralPath,\n        ...ifDefined('refName', refName),\n      },\n    },\n  );\n}\n\nexport function errorUnknownInvariant(args: {\n  readonly refName?: string;\n  readonly unknown: readonly string[];\n  readonly declared: readonly string[];\n}): MigrationToolsError {\n  const { refName, unknown, declared } = args;\n  const refClause = refName ? `Ref \"${refName}\" declares` : 'Declares';\n  const unknownList = unknown.map((id) => JSON.stringify(id)).join(', ');\n  return new MigrationToolsError(\n    'MIGRATION.UNKNOWN_INVARIANT',\n    'Ref declares invariants no migration in the graph provides',\n    {\n      why: `${refClause} invariants no migration in the graph provides. unknown=[${unknownList}].`,\n      fix: 'Either the ref has a typo, or the declaring migration has not been authored/attested yet. Re-check the ref file and the migrations directory.',\n      details: {\n        unknown,\n        declared,\n        ...ifDefined('refName', refName),\n      },\n    },\n  );\n}\n\nexport function errorMigrationHashMismatch(\n  dir: string,\n  storedHash: string,\n  computedHash: string,\n): MigrationToolsError {\n  // Render a cwd-relative path in the human-readable diagnostic so users\n  // running CLI commands from the project root see a familiar short path.\n  // Keep the absolute path in `details.dir` for machine consumers.\n  const relativeDir = relative(process.cwd(), dir);\n  return new MigrationToolsError('MIGRATION.HASH_MISMATCH', 'Migration package is corrupt', {\n    why: `Stored migrationHash \"${storedHash}\" does not match the recomputed hash \"${computedHash}\" for \"${relativeDir}\". The migration.json or ops.json has been edited or partially written since emit.`,\n    fix: reemitHint(dir, 'or restore the directory from version control.'),\n    details: { dir, storedHash, computedHash },\n  });\n}\n"],"mappings":"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"}

package/dist/exports/refs.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"refs.d.mts","names":[],"sources":["../../src/refs.ts"],"mappings":";UAUiB,QAAA;EAAA,SACN,IAAA;EAAA,SACA,UAAA;AAAA;AAAA,KAGC,IAAA,GAAO,QAAA,CAAS,MAAA,SAAe,QAAA;AAAA,iBAK3B,eAAA,CAAgB,IAAA;AAAA,iBAQhB,gBAAA,CAAiB,KAAA;AAAA,iBAsBX,OAAA,CAAQ,OAAA,UAAiB,IAAA,WAAe,OAAA,CAAQ,QAAA;AAAA,iBAmChD,QAAA,CAAS,OAAA,WAAkB,OAAA,CAAQ,IAAA;AAAA,iBAmDnC,QAAA,CAAS,OAAA,UAAiB,IAAA,UAAc,KAAA,EAAO,QAAA,GAAW,OAAA;AAAA,iBAoB1D,SAAA,CAAU,OAAA,UAAiB,IAAA,WAAe,OAAA;AAAA,iBAsChD,UAAA,CAAW,IAAA,EAAM,IAAA,EAAM,IAAA,WAAe,QAAA"}