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

package/src/refs.ts

@@ -1,14 +1,19 @@
-import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import { mkdir, readdir, readFile, rename, rmdir, unlink, writeFile } from 'node:fs/promises';
 import { type } from 'arktype';
-import { dirname, join } from 'pathe';
+import { dirname, join, relative } from 'pathe';
 import {
+  errorInvalidRefFile,
   errorInvalidRefName,
-  errorInvalidRefs,
   errorInvalidRefValue,
   MigrationToolsError,
 } from './errors';
 
-export type Refs = Readonly<Record<string, string>>;
+export interface RefEntry {
+  readonly hash: string;
+  readonly invariants: readonly string[];
+}
+
+export type Refs = Readonly<Record<string, RefEntry>>;
 
 const REF_NAME_PATTERN = /^[a-z0-9]([a-z0-9-]*[a-z0-9])?(\/[a-z0-9]([a-z0-9-]*[a-z0-9])?)*$/;
 const REF_VALUE_PATTERN = /^sha256:(empty|[0-9a-f]{64})$/;
@@ -25,22 +30,40 @@ export function validateRefValue(value: string): boolean {
   return REF_VALUE_PATTERN.test(value);
 }
 
-const RefsSchema = type('Record<string, string>').narrow((refs, ctx) => {
-  for (const [key, value] of Object.entries(refs)) {
-    if (!validateRefName(key)) return ctx.mustBe(`valid ref names (invalid: "${key}")`);
-    if (!validateRefValue(value))
-      return ctx.mustBe(`valid contract hashes (invalid value for "${key}": "${value}")`);
-  }
+const RefEntrySchema = type({
+  hash: 'string',
+  invariants: 'string[]',
+}).narrow((entry, ctx) => {
+  if (!validateRefValue(entry.hash))
+    return ctx.mustBe(`a valid contract hash (got "${entry.hash}")`);
   return true;
 });
 
-export async function readRefs(refsPath: string): Promise<Refs> {
+function refFilePath(refsDir: string, name: string): string {
+  return join(refsDir, `${name}.json`);
+}
+
+function refNameFromPath(refsDir: string, filePath: string): string {
+  const rel = relative(refsDir, filePath);
+  return rel.replace(/\.json$/, '');
+}
+
+export async function readRef(refsDir: string, name: string): Promise<RefEntry> {
+  if (!validateRefName(name)) {
+    throw errorInvalidRefName(name);
+  }
+
+  const filePath = refFilePath(refsDir, name);
   let raw: string;
   try {
-    raw = await readFile(refsPath, 'utf-8');
+    raw = await readFile(filePath, 'utf-8');
   } catch (error) {
     if (error instanceof Error && (error as { code?: string }).code === 'ENOENT') {
-      return {};
+      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>`,
+        details: { refName: name, filePath },
+      });
     }
     throw error;
   }
@@ -49,54 +72,142 @@ export async function readRefs(refsPath: string): Promise<Refs> {
   try {
     parsed = JSON.parse(raw);
   } catch {
-    throw errorInvalidRefs(refsPath, 'Failed to parse as JSON');
+    throw errorInvalidRefFile(filePath, 'Failed to parse as JSON');
   }
 
-  const result = RefsSchema(parsed);
+  const result = RefEntrySchema(parsed);
   if (result instanceof type.errors) {
-    throw errorInvalidRefs(refsPath, result.summary);
+    throw errorInvalidRefFile(filePath, result.summary);
   }
 
   return result;
 }
 
-export async function writeRefs(refsPath: string, refs: Refs): Promise<void> {
-  for (const [key, value] of Object.entries(refs)) {
-    if (!validateRefName(key)) {
-      throw errorInvalidRefName(key);
+export async function readRefs(refsDir: string): Promise<Refs> {
+  let entries: string[];
+  try {
+    entries = await readdir(refsDir, { recursive: true, encoding: 'utf-8' });
+  } catch (error) {
+    if (error instanceof Error && (error as { code?: string }).code === 'ENOENT') {
+      return {};
+    }
+    throw error;
+  }
+
+  const jsonFiles = entries.filter((entry) => entry.endsWith('.json'));
+  const refs: Record<string, RefEntry> = {};
+
+  for (const jsonFile of jsonFiles) {
+    const filePath = join(refsDir, jsonFile);
+    const name = refNameFromPath(refsDir, filePath);
+
+    let raw: string;
+    try {
+      raw = await readFile(filePath, 'utf-8');
+    } catch (error) {
+      // Tolerate the TOCTOU race between `readdir` and `readFile` (ENOENT) and
+      // benign EISDIR if a directory happens to end in `.json`. Anything else
+      // (EACCES, EIO, EMFILE, …) is a real failure and propagates so the CLI
+      // surfaces it rather than silently dropping the ref.
+      const code = error instanceof Error ? (error as { code?: string }).code : undefined;
+      if (code === 'ENOENT' || code === 'EISDIR') {
+        continue;
+      }
+      throw error;
+    }
+
+    let parsed: unknown;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      throw errorInvalidRefFile(filePath, 'Failed to parse as JSON');
     }
-    if (!validateRefValue(value)) {
-      throw errorInvalidRefValue(value);
+
+    const result = RefEntrySchema(parsed);
+    if (result instanceof type.errors) {
+      throw errorInvalidRefFile(filePath, result.summary);
     }
+
+    refs[name] = result;
   }
 
-  const sorted = Object.fromEntries(Object.entries(refs).sort(([a], [b]) => a.localeCompare(b)));
+  return refs;
+}
+
+export async function writeRef(refsDir: string, name: string, entry: RefEntry): Promise<void> {
+  if (!validateRefName(name)) {
+    throw errorInvalidRefName(name);
+  }
+  if (!validateRefValue(entry.hash)) {
+    throw errorInvalidRefValue(entry.hash);
+  }
 
-  const dir = dirname(refsPath);
+  const filePath = refFilePath(refsDir, name);
+  const dir = dirname(filePath);
   await mkdir(dir, { recursive: true });
 
-  const tmpPath = join(dir, `.refs.json.${Date.now()}.tmp`);
-  await writeFile(tmpPath, `${JSON.stringify(sorted, null, 2)}\n`);
-  await rename(tmpPath, refsPath);
+  const tmpPath = join(dir, `.${name.split('/').pop()}.json.${Date.now()}.tmp`);
+  await writeFile(
+    tmpPath,
+    `${JSON.stringify({ hash: entry.hash, invariants: [...entry.invariants] }, null, 2)}\n`,
+  );
+  await rename(tmpPath, filePath);
 }
 
-export function resolveRef(refs: Refs, name: string): string {
+export async function deleteRef(refsDir: string, name: string): Promise<void> {
   if (!validateRefName(name)) {
     throw errorInvalidRefName(name);
   }
 
-  const hash = refs[name];
-  if (hash === undefined) {
+  const filePath = refFilePath(refsDir, name);
+  try {
+    await unlink(filePath);
+  } catch (error) {
+    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.',
+        details: { refName: name, filePath },
+      });
+    }
+    throw error;
+  }
+
+  // Clean empty parent directories up to refsDir. Stop walking on the expected
+  // "directory has siblings" signal (ENOTEMPTY on Linux, EEXIST on some BSDs)
+  // and on ENOENT (concurrent removal). Anything else (EACCES, EIO, …) is a
+  // real failure and propagates.
+  let dir = dirname(filePath);
+  while (dir !== refsDir && dir.startsWith(refsDir)) {
+    try {
+      await rmdir(dir);
+      dir = dirname(dir);
+    } catch (error) {
+      const code = error instanceof Error ? (error as { code?: string }).code : undefined;
+      if (code === 'ENOTEMPTY' || code === 'EEXIST' || code === 'ENOENT') {
+        break;
+      }
+      throw error;
+    }
+  }
+}
+
+export function resolveRef(refs: Refs, name: string): RefEntry {
+  if (!validateRefName(name)) {
+    throw errorInvalidRefName(name);
+  }
+
+  // Object.hasOwn gate: plain-object `refs` would otherwise let
+  // `refs['constructor']` return Object.prototype.constructor and bypass the
+  // UNKNOWN_REF throw. validateRefName accepts `"constructor"` as a name shape.
+  if (!Object.hasOwn(refs, name)) {
     throw new MigrationToolsError('MIGRATION.UNKNOWN_REF', `Unknown ref "${name}"`, {
-      why: `No ref named "${name}" exists in refs.json.`,
-      fix: `Available refs: ${Object.keys(refs).join(', ') || '(none)'}. Create a ref with: set the "${name}" key in migrations/refs.json.`,
+      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>`,
       details: { refName: name, availableRefs: Object.keys(refs) },
     });
   }
 
-  if (!validateRefValue(hash)) {
-    throw errorInvalidRefValue(hash);
-  }
-
-  return hash;
+  // biome-ignore lint/style/noNonNullAssertion: Object.hasOwn gate above guarantees this is defined
+  return refs[name]!;
 }

package/dist/attestation-DtF8tEOM.mjs

@@ -1,65 +0,0 @@
-import { r as readMigrationPackage } from "./io-CCnYsUHU.mjs";
-import { createHash } from "node:crypto";
-
-//#region src/canonicalize-json.ts
-function sortKeys(value) {
-	if (value === null || typeof value !== "object") return value;
-	if (Array.isArray(value)) return value.map(sortKeys);
-	const sorted = {};
-	for (const key of Object.keys(value).sort()) sorted[key] = sortKeys(value[key]);
-	return sorted;
-}
-function canonicalizeJson(value) {
-	return JSON.stringify(sortKeys(value));
-}
-
-//#endregion
-//#region src/attestation.ts
-function sha256Hex(input) {
-	return createHash("sha256").update(input).digest("hex");
-}
-/**
-* Content-addressed migration identity over (manifest 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.
-*
-* The `migrationId` field on the manifest is stripped before hashing so
-* the function can be used both at write time (when no id exists yet)
-* and at verify time (rehashing an already-attested manifest).
-*/
-function computeMigrationId(manifest, ops) {
-	const { migrationId: _migrationId, signature: _signature, fromContract: _fromContract, toContract: _toContract, hints: _hints, ...strippedMeta } = manifest;
-	return `sha256:${sha256Hex(canonicalizeJson([canonicalizeJson(strippedMeta), canonicalizeJson(ops)].map(sha256Hex)))}`;
-}
-/**
-* Re-hash an on-disk migration bundle and compare against the stored
-* `migrationId`. Returns `{ ok: true }` when the package is internally
-* consistent (manifest + ops still produce the recorded id), or
-* `{ ok: false, reason: 'mismatch', stored, computed }` when they do
-* not — typically a sign of FS corruption, partial writes, or a
-* post-emit hand edit.
-*/
-function verifyMigrationBundle(bundle) {
-	const computed = computeMigrationId(bundle.manifest, bundle.ops);
-	if (bundle.manifest.migrationId === computed) return {
-		ok: true,
-		storedMigrationId: bundle.manifest.migrationId,
-		computedMigrationId: computed
-	};
-	return {
-		ok: false,
-		reason: "mismatch",
-		storedMigrationId: bundle.manifest.migrationId,
-		computedMigrationId: computed
-	};
-}
-/** Convenience wrapper: read the package from disk then verify it. */
-async function verifyMigration(dir) {
-	return verifyMigrationBundle(await readMigrationPackage(dir));
-}
-
-//#endregion
-export { verifyMigration as n, verifyMigrationBundle as r, computeMigrationId as t };
-//# sourceMappingURL=attestation-DtF8tEOM.mjs.map

package/dist/attestation-DtF8tEOM.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"attestation-DtF8tEOM.mjs","names":["sorted: Record<string, unknown>"],"sources":["../src/canonicalize-json.ts","../src/attestation.ts"],"sourcesContent":["function sortKeys(value: unknown): unknown {\n  if (value === null || typeof value !== 'object') {\n    return value;\n  }\n  if (Array.isArray(value)) {\n    return value.map(sortKeys);\n  }\n  const sorted: Record<string, unknown> = {};\n  for (const key of Object.keys(value).sort()) {\n    sorted[key] = sortKeys((value as Record<string, unknown>)[key]);\n  }\n  return sorted;\n}\n\nexport function canonicalizeJson(value: unknown): string {\n  return JSON.stringify(sortKeys(value));\n}\n","import { createHash } from 'node:crypto';\nimport { canonicalizeJson } from './canonicalize-json';\nimport { readMigrationPackage } from './io';\nimport type { MigrationBundle, MigrationManifest, MigrationOps } from './types';\n\nexport interface VerifyResult {\n  readonly ok: boolean;\n  readonly reason?: 'mismatch';\n  readonly storedMigrationId?: string;\n  readonly computedMigrationId?: string;\n}\n\nfunction sha256Hex(input: string): string {\n  return createHash('sha256').update(input).digest('hex');\n}\n\n/**\n * Content-addressed migration identity over (manifest envelope sans\n * contracts/hints, ops). See ADR 199 \"Storage-only migration identity\"\n * for the rationale: contracts are anchored separately by the\n * storage-hash bookends inside the envelope; planner hints are advisory\n * and must not affect identity.\n *\n * The `migrationId` field on the manifest is stripped before hashing so\n * the function can be used both at write time (when no id exists yet)\n * and at verify time (rehashing an already-attested manifest).\n */\nexport function computeMigrationId(\n  manifest: Omit<MigrationManifest, 'migrationId'> & { readonly migrationId?: string },\n  ops: MigrationOps,\n): string {\n  const {\n    migrationId: _migrationId,\n    signature: _signature,\n    fromContract: _fromContract,\n    toContract: _toContract,\n    hints: _hints,\n    ...strippedMeta\n  } = manifest;\n\n  const canonicalManifest = canonicalizeJson(strippedMeta);\n  const canonicalOps = canonicalizeJson(ops);\n\n  const partHashes = [canonicalManifest, canonicalOps].map(sha256Hex);\n  const hash = sha256Hex(canonicalizeJson(partHashes));\n\n  return `sha256:${hash}`;\n}\n\n/**\n * Re-hash an on-disk migration bundle and compare against the stored\n * `migrationId`. Returns `{ ok: true }` when the package is internally\n * consistent (manifest + ops still produce the recorded id), or\n * `{ ok: false, reason: 'mismatch', stored, computed }` when they do\n * not — typically a sign of FS corruption, partial writes, or a\n * post-emit hand edit.\n */\nexport function verifyMigrationBundle(bundle: MigrationBundle): VerifyResult {\n  const computed = computeMigrationId(bundle.manifest, bundle.ops);\n\n  if (bundle.manifest.migrationId === computed) {\n    return {\n      ok: true,\n      storedMigrationId: bundle.manifest.migrationId,\n      computedMigrationId: computed,\n    };\n  }\n\n  return {\n    ok: false,\n    reason: 'mismatch',\n    storedMigrationId: bundle.manifest.migrationId,\n    computedMigrationId: computed,\n  };\n}\n\n/** Convenience wrapper: read the package from disk then verify it. */\nexport async function verifyMigration(dir: string): Promise<VerifyResult> {\n  const pkg = await readMigrationPackage(dir);\n  return verifyMigrationBundle(pkg);\n}\n"],"mappings":";;;;AAAA,SAAS,SAAS,OAAyB;AACzC,KAAI,UAAU,QAAQ,OAAO,UAAU,SACrC,QAAO;AAET,KAAI,MAAM,QAAQ,MAAM,CACtB,QAAO,MAAM,IAAI,SAAS;CAE5B,MAAMA,SAAkC,EAAE;AAC1C,MAAK,MAAM,OAAO,OAAO,KAAK,MAAM,CAAC,MAAM,CACzC,QAAO,OAAO,SAAU,MAAkC,KAAK;AAEjE,QAAO;;AAGT,SAAgB,iBAAiB,OAAwB;AACvD,QAAO,KAAK,UAAU,SAAS,MAAM,CAAC;;;;;ACHxC,SAAS,UAAU,OAAuB;AACxC,QAAO,WAAW,SAAS,CAAC,OAAO,MAAM,CAAC,OAAO,MAAM;;;;;;;;;;;;;AAczD,SAAgB,mBACd,UACA,KACQ;CACR,MAAM,EACJ,aAAa,cACb,WAAW,YACX,cAAc,eACd,YAAY,aACZ,OAAO,QACP,GAAG,iBACD;AAQJ,QAAO,UAFM,UAAU,iBADJ,CAHO,iBAAiB,aAAa,EACnC,iBAAiB,IAAI,CAEU,CAAC,IAAI,UAAU,CAChB,CAAC;;;;;;;;;;AAatD,SAAgB,sBAAsB,QAAuC;CAC3E,MAAM,WAAW,mBAAmB,OAAO,UAAU,OAAO,IAAI;AAEhE,KAAI,OAAO,SAAS,gBAAgB,SAClC,QAAO;EACL,IAAI;EACJ,mBAAmB,OAAO,SAAS;EACnC,qBAAqB;EACtB;AAGH,QAAO;EACL,IAAI;EACJ,QAAQ;EACR,mBAAmB,OAAO,SAAS;EACnC,qBAAqB;EACtB;;;AAIH,eAAsB,gBAAgB,KAAoC;AAExE,QAAO,sBADK,MAAM,qBAAqB,IAAI,CACV"}

package/dist/errors-BKbRGCJM.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"errors-BKbRGCJM.mjs","names":[],"sources":["../src/errors.ts"],"sourcesContent":["/**\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, attestation,\n * migration history reconstruction), distinct from the runtime MIGRATION.* codes for apply-time\n * failures (PRECHECK_FAILED, POSTCHECK_FAILED, 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: 'Ensure the migration directory contains both migration.json and ops.json. If the directory is corrupt, delete it and re-run migration plan.',\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: 'Fix the JSON syntax error, or delete the migration directory and re-run migration plan.',\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: `Manifest at \"${filePath}\" is invalid: ${reason}`,\n    fix: 'Ensure the manifest has all required fields (from, to, kind, toContract). If corrupt, delete and re-plan.',\n    details: { filePath, reason },\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 errorSameSourceAndTarget(dirName: string, hash: string): MigrationToolsError {\n  return new MigrationToolsError(\n    'MIGRATION.SAME_SOURCE_AND_TARGET',\n    'Migration has same source and target',\n    {\n      why: `Migration \"${dirName}\" has from === to === \"${hash}\". A migration must transition between two different contract states.`,\n      fix: 'Delete the invalid migration directory and re-run migration plan.',\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 errorDuplicateMigrationId(migrationId: string): MigrationToolsError {\n  return new MigrationToolsError(\n    'MIGRATION.DUPLICATE_MIGRATION_ID',\n    'Duplicate migrationId in migration graph',\n    {\n      why: `Multiple migrations share migrationId \"${migrationId}\". Each migration must have a unique content-addressed identity.`,\n      fix: 'Regenerate one of the conflicting migrations so each migrationId is unique, then re-run migration commands.',\n      details: { migrationId },\n    },\n  );\n}\n"],"mappings":"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"}

package/dist/exports/attestation.d.mts

@@ -1,37 +0,0 @@
-import { a as MigrationManifest, o as MigrationOps, t as MigrationBundle } from "../types-DyGXcWWp.mjs";
-
-//#region src/attestation.d.ts
-interface VerifyResult {
-  readonly ok: boolean;
-  readonly reason?: 'mismatch';
-  readonly storedMigrationId?: string;
-  readonly computedMigrationId?: string;
-}
-/**
- * Content-addressed migration identity over (manifest 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.
- *
- * The `migrationId` field on the manifest is stripped before hashing so
- * the function can be used both at write time (when no id exists yet)
- * and at verify time (rehashing an already-attested manifest).
- */
-declare function computeMigrationId(manifest: Omit<MigrationManifest, 'migrationId'> & {
-  readonly migrationId?: string;
-}, ops: MigrationOps): string;
-/**
- * Re-hash an on-disk migration bundle and compare against the stored
- * `migrationId`. Returns `{ ok: true }` when the package is internally
- * consistent (manifest + ops still produce the recorded id), or
- * `{ ok: false, reason: 'mismatch', stored, computed }` when they do
- * not — typically a sign of FS corruption, partial writes, or a
- * post-emit hand edit.
- */
-declare function verifyMigrationBundle(bundle: MigrationBundle): VerifyResult;
-/** Convenience wrapper: read the package from disk then verify it. */
-declare function verifyMigration(dir: string): Promise<VerifyResult>;
-//#endregion
-export { type VerifyResult, computeMigrationId, verifyMigration, verifyMigrationBundle };
-//# sourceMappingURL=attestation.d.mts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"attestation.d.mts","names":[],"sources":["../../src/attestation.ts"],"sourcesContent":[],"mappings":";;;UAKiB,YAAA;;EAAA,SAAA,MAAY,CAAA,EAAA,UAAA;EAsBb,SAAA,iBAAkB,CAAA,EAAA,MAAA;EACjB,SAAA,mBAAA,CAAA,EAAA,MAAA;;;;AA6BjB;AAoBA;;;;;;;;iBAlDgB,kBAAA,WACJ,KAAK;;QACV;;;;;;;;;iBA4BS,qBAAA,SAA8B,kBAAkB;;iBAoB1C,eAAA,eAA8B,QAAQ"}

package/dist/exports/attestation.mjs

@@ -1,4 +0,0 @@
-import "../io-CCnYsUHU.mjs";
-import { n as verifyMigration, r as verifyMigrationBundle, t as computeMigrationId } from "../attestation-DtF8tEOM.mjs";
-
-export { computeMigrationId, verifyMigration, verifyMigrationBundle };

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

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.mts","names":[],"sources":["../../src/errors.ts"],"sourcesContent":[],"mappings":";;;;;;;AAeA;;;;;;;;;;;;cAAa,mBAAA,SAA4B,KAAA;;;;;oBAKrB;;;;uBAQK;;sCAWa"}

package/dist/exports/types.mjs

@@ -1,3 +0,0 @@
-import { t as MigrationToolsError } from "../errors-BKbRGCJM.mjs";
-
-export { MigrationToolsError };

package/dist/io-CCnYsUHU.mjs

@@ -1,153 +0,0 @@
-import { a as errorInvalidDestName, d as errorInvalidSlug, f as errorMissingFile, o as errorInvalidJson, r as errorDirectoryExists, s as errorInvalidManifest } from "./errors-BKbRGCJM.mjs";
-import { copyFile, mkdir, readFile, readdir, stat, writeFile } from "node:fs/promises";
-import { type } from "arktype";
-import { basename, dirname, join } from "pathe";
-
-//#region src/io.ts
-const MANIFEST_FILE = "migration.json";
-const OPS_FILE = "ops.json";
-const MAX_SLUG_LENGTH = 64;
-function hasErrnoCode(error, code) {
-	return error instanceof Error && error.code === code;
-}
-const MigrationManifestSchema = type({
-	from: "string",
-	to: "string",
-	migrationId: "string",
-	kind: "'regular' | 'baseline'",
-	fromContract: "object | null",
-	toContract: "object",
-	hints: type({
-		used: "string[]",
-		applied: "string[]",
-		plannerVersion: "string"
-	}),
-	labels: "string[]",
-	"authorship?": type({
-		"author?": "string",
-		"email?": "string"
-	}),
-	"signature?": type({
-		keyId: "string",
-		value: "string"
-	}).or("null"),
-	createdAt: "string"
-});
-const MigrationOpsSchema = type({
-	id: "string",
-	label: "string",
-	operationClass: "'additive' | 'widening' | 'destructive' | 'data'"
-}).array();
-async function writeMigrationPackage(dir, manifest, ops) {
-	await mkdir(dirname(dir), { recursive: true });
-	try {
-		await mkdir(dir);
-	} catch (error) {
-		if (hasErrnoCode(error, "EEXIST")) throw errorDirectoryExists(dir);
-		throw error;
-	}
-	await writeFile(join(dir, MANIFEST_FILE), JSON.stringify(manifest, null, 2), { flag: "wx" });
-	await writeFile(join(dir, OPS_FILE), JSON.stringify(ops, null, 2), { flag: "wx" });
-}
-/**
-* Copy a list of files into `destDir`, optionally renaming each one.
-*
-* The destination directory is created (with `recursive: true`) if it
-* does not already exist. Each source path is copied byte-for-byte into
-* `destDir/<destName>`; missing sources throw `ENOENT`. The helper is
-* intentionally generic: callers own the list of files (e.g. a contract
-* emitter's emitted output) and the naming convention (e.g. renaming
-* the destination contract to `end-contract.*` and the source contract
-* to `start-contract.*`).
-*/
-async function copyFilesWithRename(destDir, files) {
-	await mkdir(destDir, { recursive: true });
-	for (const file of files) {
-		if (basename(file.destName) !== file.destName) throw errorInvalidDestName(file.destName);
-		await copyFile(file.sourcePath, join(destDir, file.destName));
-	}
-}
-async function writeMigrationManifest(dir, manifest) {
-	await writeFile(join(dir, MANIFEST_FILE), `${JSON.stringify(manifest, null, 2)}\n`);
-}
-async function writeMigrationOps(dir, ops) {
-	await writeFile(join(dir, OPS_FILE), `${JSON.stringify(ops, null, 2)}\n`);
-}
-async function readMigrationPackage(dir) {
-	const manifestPath = join(dir, MANIFEST_FILE);
-	const opsPath = join(dir, OPS_FILE);
-	let manifestRaw;
-	try {
-		manifestRaw = await readFile(manifestPath, "utf-8");
-	} catch (error) {
-		if (hasErrnoCode(error, "ENOENT")) throw errorMissingFile(MANIFEST_FILE, dir);
-		throw error;
-	}
-	let opsRaw;
-	try {
-		opsRaw = await readFile(opsPath, "utf-8");
-	} catch (error) {
-		if (hasErrnoCode(error, "ENOENT")) throw errorMissingFile(OPS_FILE, dir);
-		throw error;
-	}
-	let manifest;
-	try {
-		manifest = JSON.parse(manifestRaw);
-	} catch (e) {
-		throw errorInvalidJson(manifestPath, e instanceof Error ? e.message : String(e));
-	}
-	let ops;
-	try {
-		ops = JSON.parse(opsRaw);
-	} catch (e) {
-		throw errorInvalidJson(opsPath, e instanceof Error ? e.message : String(e));
-	}
-	validateManifest(manifest, manifestPath);
-	validateOps(ops, opsPath);
-	return {
-		dirName: basename(dir),
-		dirPath: dir,
-		manifest,
-		ops
-	};
-}
-function validateManifest(manifest, filePath) {
-	const result = MigrationManifestSchema(manifest);
-	if (result instanceof type.errors) throw errorInvalidManifest(filePath, result.summary);
-}
-function validateOps(ops, filePath) {
-	const result = MigrationOpsSchema(ops);
-	if (result instanceof type.errors) throw errorInvalidManifest(filePath, result.summary);
-}
-async function readMigrationsDir(migrationsRoot) {
-	let entries;
-	try {
-		entries = await readdir(migrationsRoot);
-	} catch (error) {
-		if (hasErrnoCode(error, "ENOENT")) return [];
-		throw error;
-	}
-	const packages = [];
-	for (const entry of entries.sort()) {
-		const entryPath = join(migrationsRoot, entry);
-		if (!(await stat(entryPath)).isDirectory()) continue;
-		const manifestPath = join(entryPath, MANIFEST_FILE);
-		try {
-			await stat(manifestPath);
-		} catch {
-			continue;
-		}
-		packages.push(await readMigrationPackage(entryPath));
-	}
-	return packages;
-}
-function formatMigrationDirName(timestamp, slug) {
-	const sanitized = slug.toLowerCase().replace(/[^a-z0-9]/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "");
-	if (sanitized.length === 0) throw errorInvalidSlug(slug);
-	const truncated = sanitized.slice(0, MAX_SLUG_LENGTH);
-	return `${timestamp.getUTCFullYear()}${String(timestamp.getUTCMonth() + 1).padStart(2, "0")}${String(timestamp.getUTCDate()).padStart(2, "0")}T${String(timestamp.getUTCHours()).padStart(2, "0")}${String(timestamp.getUTCMinutes()).padStart(2, "0")}_${truncated}`;
-}
-
-//#endregion
-export { writeMigrationManifest as a, readMigrationsDir as i, formatMigrationDirName as n, writeMigrationOps as o, readMigrationPackage as r, writeMigrationPackage as s, copyFilesWithRename as t };
-//# sourceMappingURL=io-CCnYsUHU.mjs.map

package/dist/io-CCnYsUHU.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"io-CCnYsUHU.mjs","names":["manifestRaw: string","opsRaw: string","manifest: MigrationManifest","ops: MigrationOps","entries: string[]","packages: MigrationBundle[]"],"sources":["../src/io.ts"],"sourcesContent":["import { copyFile, mkdir, readdir, readFile, stat, writeFile } from 'node:fs/promises';\nimport { type } from 'arktype';\nimport { basename, dirname, join } from 'pathe';\nimport {\n  errorDirectoryExists,\n  errorInvalidDestName,\n  errorInvalidJson,\n  errorInvalidManifest,\n  errorInvalidSlug,\n  errorMissingFile,\n} from './errors';\nimport type { MigrationBundle, MigrationManifest, MigrationOps } from './types';\n\nconst MANIFEST_FILE = 'migration.json';\nconst OPS_FILE = 'ops.json';\nconst MAX_SLUG_LENGTH = 64;\n\nfunction hasErrnoCode(error: unknown, code: string): boolean {\n  return error instanceof Error && (error as { code?: string }).code === code;\n}\n\nconst MigrationHintsSchema = type({\n  used: 'string[]',\n  applied: 'string[]',\n  plannerVersion: 'string',\n});\n\nconst MigrationManifestSchema = type({\n  from: 'string',\n  to: 'string',\n  migrationId: 'string',\n  kind: \"'regular' | 'baseline'\",\n  fromContract: 'object | null',\n  toContract: 'object',\n  hints: MigrationHintsSchema,\n  labels: 'string[]',\n  'authorship?': type({\n    'author?': 'string',\n    'email?': 'string',\n  }),\n  'signature?': type({\n    keyId: 'string',\n    value: 'string',\n  }).or('null'),\n  createdAt: 'string',\n});\n\nconst MigrationOpSchema = type({\n  id: 'string',\n  label: 'string',\n  operationClass: \"'additive' | 'widening' | 'destructive' | 'data'\",\n});\n\n// Intentionally shallow: operation-specific payload validation is owned by planner/runner layers.\nconst MigrationOpsSchema = MigrationOpSchema.array();\n\nexport async function writeMigrationPackage(\n  dir: string,\n  manifest: MigrationManifest,\n  ops: MigrationOps,\n): Promise<void> {\n  await mkdir(dirname(dir), { recursive: true });\n\n  try {\n    await mkdir(dir);\n  } catch (error) {\n    if (hasErrnoCode(error, 'EEXIST')) {\n      throw errorDirectoryExists(dir);\n    }\n    throw error;\n  }\n\n  await writeFile(join(dir, MANIFEST_FILE), JSON.stringify(manifest, null, 2), { flag: 'wx' });\n  await writeFile(join(dir, OPS_FILE), JSON.stringify(ops, null, 2), { flag: 'wx' });\n}\n\n/**\n * Copy a list of files into `destDir`, optionally renaming each one.\n *\n * The destination directory is created (with `recursive: true`) if it\n * does not already exist. Each source path is copied byte-for-byte into\n * `destDir/<destName>`; missing sources throw `ENOENT`. The helper is\n * intentionally generic: callers own the list of files (e.g. a contract\n * emitter's emitted output) and the naming convention (e.g. renaming\n * the destination contract to `end-contract.*` and the source contract\n * to `start-contract.*`).\n */\nexport async function copyFilesWithRename(\n  destDir: string,\n  files: readonly { readonly sourcePath: string; readonly destName: string }[],\n): Promise<void> {\n  await mkdir(destDir, { recursive: true });\n  for (const file of files) {\n    if (basename(file.destName) !== file.destName) {\n      throw errorInvalidDestName(file.destName);\n    }\n    await copyFile(file.sourcePath, join(destDir, file.destName));\n  }\n}\n\nexport async function writeMigrationManifest(\n  dir: string,\n  manifest: MigrationManifest,\n): Promise<void> {\n  await writeFile(join(dir, MANIFEST_FILE), `${JSON.stringify(manifest, null, 2)}\\n`);\n}\n\nexport async function writeMigrationOps(dir: string, ops: MigrationOps): Promise<void> {\n  await writeFile(join(dir, OPS_FILE), `${JSON.stringify(ops, null, 2)}\\n`);\n}\n\nexport async function readMigrationPackage(dir: string): Promise<MigrationBundle> {\n  const manifestPath = join(dir, MANIFEST_FILE);\n  const opsPath = join(dir, OPS_FILE);\n\n  let manifestRaw: string;\n  try {\n    manifestRaw = await readFile(manifestPath, 'utf-8');\n  } catch (error) {\n    if (hasErrnoCode(error, 'ENOENT')) {\n      throw errorMissingFile(MANIFEST_FILE, dir);\n    }\n    throw error;\n  }\n\n  let opsRaw: string;\n  try {\n    opsRaw = await readFile(opsPath, 'utf-8');\n  } catch (error) {\n    if (hasErrnoCode(error, 'ENOENT')) {\n      throw errorMissingFile(OPS_FILE, dir);\n    }\n    throw error;\n  }\n\n  let manifest: MigrationManifest;\n  try {\n    manifest = JSON.parse(manifestRaw);\n  } catch (e) {\n    throw errorInvalidJson(manifestPath, e instanceof Error ? e.message : String(e));\n  }\n\n  let ops: MigrationOps;\n  try {\n    ops = JSON.parse(opsRaw);\n  } catch (e) {\n    throw errorInvalidJson(opsPath, e instanceof Error ? e.message : String(e));\n  }\n\n  validateManifest(manifest, manifestPath);\n  validateOps(ops, opsPath);\n\n  return {\n    dirName: basename(dir),\n    dirPath: dir,\n    manifest,\n    ops,\n  };\n}\n\nfunction validateManifest(\n  manifest: unknown,\n  filePath: string,\n): asserts manifest is MigrationManifest {\n  const result = MigrationManifestSchema(manifest);\n  if (result instanceof type.errors) {\n    throw errorInvalidManifest(filePath, result.summary);\n  }\n}\n\nfunction validateOps(ops: unknown, filePath: string): asserts ops is MigrationOps {\n  const result = MigrationOpsSchema(ops);\n  if (result instanceof type.errors) {\n    throw errorInvalidManifest(filePath, result.summary);\n  }\n}\n\nexport async function readMigrationsDir(\n  migrationsRoot: string,\n): Promise<readonly MigrationBundle[]> {\n  let entries: string[];\n  try {\n    entries = await readdir(migrationsRoot);\n  } catch (error) {\n    if (hasErrnoCode(error, 'ENOENT')) {\n      return [];\n    }\n    throw error;\n  }\n\n  const packages: MigrationBundle[] = [];\n\n  for (const entry of entries.sort()) {\n    const entryPath = join(migrationsRoot, entry);\n    const entryStat = await stat(entryPath);\n    if (!entryStat.isDirectory()) continue;\n\n    const manifestPath = join(entryPath, MANIFEST_FILE);\n    try {\n      await stat(manifestPath);\n    } catch {\n      continue; // skip non-migration directories\n    }\n\n    packages.push(await readMigrationPackage(entryPath));\n  }\n\n  return packages;\n}\n\nexport function formatMigrationDirName(timestamp: Date, slug: string): string {\n  const sanitized = slug\n    .toLowerCase()\n    .replace(/[^a-z0-9]/g, '_')\n    .replace(/_+/g, '_')\n    .replace(/^_|_$/g, '');\n\n  if (sanitized.length === 0) {\n    throw errorInvalidSlug(slug);\n  }\n\n  const truncated = sanitized.slice(0, MAX_SLUG_LENGTH);\n\n  const y = timestamp.getUTCFullYear();\n  const mo = String(timestamp.getUTCMonth() + 1).padStart(2, '0');\n  const d = String(timestamp.getUTCDate()).padStart(2, '0');\n  const h = String(timestamp.getUTCHours()).padStart(2, '0');\n  const mi = String(timestamp.getUTCMinutes()).padStart(2, '0');\n\n  return `${y}${mo}${d}T${h}${mi}_${truncated}`;\n}\n"],"mappings":"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"}

package/dist/types-DyGXcWWp.d.mts

@@ -1,71 +0,0 @@
-import { Contract } from "@prisma-next/contract/types";
-import { MigrationPlanOperation } from "@prisma-next/framework-components/control";
-
-//#region src/types.d.ts
-interface MigrationHints {
-  readonly used: readonly string[];
-  readonly applied: readonly string[];
-  readonly plannerVersion: string;
-}
-/**
- * On-disk migration manifest. Every migration is content-addressed: the
- * `migrationId` is a hash over the manifest envelope plus the operations
- * list, computed at write time. There is no draft state — a migration
- * directory either exists with a fully attested manifest or it does not.
- *
- * When the planner cannot lower an operation because of an unfilled
- * `placeholder(...)` slot, the migration is still written with
- * `migrationId` hashed over `ops: []`. Re-running self-emit after the
- * user fills the placeholder produces a *different* `migrationId`
- * (committed to the real ops); this is intentional.
- */
-interface MigrationManifest {
-  readonly migrationId: string;
-  readonly from: string;
-  readonly to: string;
-  readonly kind: 'regular' | 'baseline';
-  readonly fromContract: Contract | null;
-  readonly toContract: Contract;
-  readonly hints: MigrationHints;
-  readonly labels: readonly string[];
-  readonly authorship?: {
-    readonly author?: string;
-    readonly email?: string;
-  };
-  readonly signature?: {
-    readonly keyId: string;
-    readonly value: string;
-  } | null;
-  readonly createdAt: string;
-}
-type MigrationOps = readonly MigrationPlanOperation[];
-/**
- * An on-disk migration directory containing a manifest and operations.
- */
-interface MigrationBundle {
-  readonly dirName: string;
-  readonly dirPath: string;
-  readonly manifest: MigrationManifest;
-  readonly ops: MigrationOps;
-}
-/**
- * An entry in the migration graph. All on-disk migrations are attested,
- * so `migrationId` is always a string.
- */
-interface MigrationChainEntry {
-  readonly from: string;
-  readonly to: string;
-  readonly migrationId: string;
-  readonly dirName: string;
-  readonly createdAt: string;
-  readonly labels: readonly string[];
-}
-interface MigrationGraph {
-  readonly nodes: ReadonlySet<string>;
-  readonly forwardChain: ReadonlyMap<string, readonly MigrationChainEntry[]>;
-  readonly reverseChain: ReadonlyMap<string, readonly MigrationChainEntry[]>;
-  readonly migrationById: ReadonlyMap<string, MigrationChainEntry>;
-}
-//#endregion
-export { MigrationManifest as a, MigrationHints as i, MigrationChainEntry as n, MigrationOps as o, MigrationGraph as r, MigrationBundle as t };
-//# sourceMappingURL=types-DyGXcWWp.d.mts.map

package/dist/types-DyGXcWWp.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types-DyGXcWWp.d.mts","names":[],"sources":["../src/types.ts"],"sourcesContent":[],"mappings":";;;;UAGiB,cAAA;;EAAA,SAAA,OAAA,EAAc,SAAA,MAAA,EAAA;EAkBd,SAAA,cAAiB,EAAA,MAAA;;;;;AAclC;AAKA;AAWA;AASA;;;;;;AAI8C,UA3C7B,iBAAA,CA2C6B;EAApB,SAAA,WAAA,EAAA,MAAA;EAAW,SAAA,IAAA,EAAA,MAAA;;;yBAtCZ;uBACF;kBACL;;;;;;;;;;;;KAON,YAAA,YAAwB;;;;UAKnB,eAAA;;;qBAGI;gBACL;;;;;;UAOC,mBAAA;;;;;;;;UASA,cAAA;kBACC;yBACO,6BAA6B;yBAC7B,6BAA6B;0BAC5B,oBAAoB"}