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

package/README.md

@@ -68,7 +68,7 @@ graph TD
 |---|---|
 | `./types` | `MigrationManifest`, `MigrationOps`, `MigrationPackage`, `MigrationGraph`, `MigrationChainEntry`, `MigrationHints` |
 | `./io` | `writeMigrationPackage`, `readMigrationPackage`, `readMigrationsDir`, `formatMigrationDirName` |
-| `./attestation` | `computeMigrationId`, `attestMigration`, `verifyMigration` |
+| `./attestation` | `computeMigrationId`, `verifyMigration`, `verifyMigrationBundle` |
 | `./dag` | `reconstructGraph`, `findLeaf`, `findPath`, `detectCycles`, `detectOrphans` |
 | `./constants` | `EMPTY_CONTRACT_HASH` |
 

package/dist/{attestation-DnebS4XZ.mjs → attestation-DtF8tEOM.mjs}

@@ -1,4 +1,4 @@
-import { a as writeMigrationManifest, r as readMigrationPackage } from "./io-Cun81AIZ.mjs";
+import { r as readMigrationPackage } from "./io-CCnYsUHU.mjs";
 import { createHash } from "node:crypto";
 
 //#region src/canonicalize-json.ts
@@ -24,41 +24,42 @@ function sha256Hex(input) {
 * 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)))}`;
 }
-/** Compute and persist `migrationId` to `manifest.json`. */
-async function attestMigration(dir) {
-	const pkg = await readMigrationPackage(dir);
-	const migrationId = computeMigrationId(pkg.manifest, pkg.ops);
-	await writeMigrationManifest(dir, {
-		...pkg.manifest,
-		migrationId
-	});
-	return migrationId;
-}
-async function verifyMigration(dir) {
-	const pkg = await readMigrationPackage(dir);
-	if (pkg.manifest.migrationId === null) return {
-		ok: false,
-		reason: "draft"
-	};
-	const computed = computeMigrationId(pkg.manifest, pkg.ops);
-	if (pkg.manifest.migrationId === computed) return {
+/**
+* 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: pkg.manifest.migrationId,
+		storedMigrationId: bundle.manifest.migrationId,
 		computedMigrationId: computed
 	};
 	return {
 		ok: false,
 		reason: "mismatch",
-		storedMigrationId: pkg.manifest.migrationId,
+		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 { computeMigrationId as n, verifyMigration as r, attestMigration as t };
-//# sourceMappingURL=attestation-DnebS4XZ.mjs.map
+export { verifyMigration as n, verifyMigrationBundle as r, computeMigrationId as t };
+//# sourceMappingURL=attestation-DtF8tEOM.mjs.map

package/dist/attestation-DtF8tEOM.mjs.map

@@ -0,0 +1 @@
+{"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-C_XuSbX7.mjs → errors-BKbRGCJM.mjs}

@@ -78,6 +78,13 @@ function errorInvalidSlug(slug) {
 		details: { slug }
 	});
 }
+function errorInvalidDestName(destName) {
+	return new MigrationToolsError("MIGRATION.INVALID_DEST_NAME", "Invalid copy destination name", {
+		why: `The destination name "${destName}" must be a single path segment (no ".." or directory separators).`,
+		fix: "Use a simple file name such as \"contract.json\" for each destination in the copy list.",
+		details: { destName }
+	});
+}
 function errorSameSourceAndTarget(dirName, hash) {
 	return new MigrationToolsError("MIGRATION.SAME_SOURCE_AND_TARGET", "Migration has same source and target", {
 		why: `Migration "${dirName}" has from === to === "${hash}". A migration must transition between two different contract states.`,
@@ -149,5 +156,5 @@ function errorDuplicateMigrationId(migrationId) {
 }
 
 //#endregion
-export { errorInvalidJson as a, errorInvalidRefValue as c, errorMissingFile as d, errorNoInitialMigration as f, errorDuplicateMigrationId as i, errorInvalidRefs as l, errorSameSourceAndTarget as m, errorAmbiguousTarget as n, errorInvalidManifest as o, errorNoTarget as p, errorDirectoryExists as r, errorInvalidRefName as s, MigrationToolsError as t, errorInvalidSlug as u };
-//# sourceMappingURL=errors-C_XuSbX7.mjs.map
+export { errorInvalidDestName as a, errorInvalidRefName as c, errorInvalidSlug as d, errorMissingFile as f, errorSameSourceAndTarget as h, errorDuplicateMigrationId as i, errorInvalidRefValue as l, errorNoTarget as m, errorAmbiguousTarget as n, errorInvalidJson as o, errorNoInitialMigration as p, errorDirectoryExists as r, errorInvalidManifest as s, MigrationToolsError as t, errorInvalidRefs as u };
+//# sourceMappingURL=errors-BKbRGCJM.mjs.map

package/dist/errors-BKbRGCJM.mjs.map

@@ -0,0 +1 @@
+{"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,9 +1,9 @@
-import { l as MigrationManifest, u as MigrationOps } from "../types-D2uX4ql7.mjs";
+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?: 'draft' | 'mismatch';
+  readonly reason?: 'mismatch';
   readonly storedMigrationId?: string;
   readonly computedMigrationId?: string;
 }
@@ -13,11 +13,25 @@ interface VerifyResult {
  * 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: MigrationManifest, ops: MigrationOps): string;
-/** Compute and persist `migrationId` to `manifest.json`. */
-declare function attestMigration(dir: string): Promise<string>;
+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 { attestMigration, computeMigrationId, verifyMigration };
+export { type VerifyResult, computeMigrationId, verifyMigration, verifyMigrationBundle };
 //# sourceMappingURL=attestation.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"attestation.d.mts","names":[],"sources":["../../src/attestation.ts"],"sourcesContent":[],"mappings":";;;UAKiB,YAAA;;EAAA,SAAA,MAAY,CAAA,EAAA,OAAA,GAAA,UAAA;EAkBb,SAAA,iBAAkB,CAAA,EAAA,MAAW;EAoBvB,SAAA,mBAAe,CAAA,EAAe,MAAA;AAUpD;;;;;;;;iBA9BgB,kBAAA,WAA6B,wBAAwB;;iBAoB/C,eAAA,eAA8B;iBAU9B,eAAA,eAA8B,QAAQ"}
+{"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 +1,4 @@
-import "../io-Cun81AIZ.mjs";
-import { n as computeMigrationId, r as verifyMigration, t as attestMigration } from "../attestation-DnebS4XZ.mjs";
+import "../io-CCnYsUHU.mjs";
+import { n as verifyMigration, r as verifyMigrationBundle, t as computeMigrationId } from "../attestation-DtF8tEOM.mjs";
 
-export { attestMigration, computeMigrationId, verifyMigration };
+export { computeMigrationId, verifyMigration, verifyMigrationBundle };

package/dist/exports/dag.d.mts

@@ -1,7 +1,7 @@
-import { o as MigrationChainEntry, s as MigrationGraph, t as AttestedMigrationBundle } from "../types-D2uX4ql7.mjs";
+import { n as MigrationChainEntry, r as MigrationGraph, t as MigrationBundle } from "../types-DyGXcWWp.mjs";
 
 //#region src/dag.d.ts
-declare function reconstructGraph(packages: readonly AttestedMigrationBundle[]): MigrationGraph;
+declare function reconstructGraph(packages: readonly MigrationBundle[]): MigrationGraph;
 /**
  * Find the shortest path from `fromHash` to `toHash` using BFS over the
  * contract-hash graph. Returns the ordered list of edges, or null if no path
@@ -31,11 +31,13 @@ declare function findPathWithDecision(graph: MigrationGraph, fromHash: string, t
 declare function findReachableLeaves(graph: MigrationGraph, fromHash: string): readonly string[];
 /**
  * Find the target contract hash of the migration graph reachable from
- * EMPTY_CONTRACT_HASH. Throws NO_INITIAL_MIGRATION if the graph has
- * nodes but none originate from the empty hash.
- * Throws AMBIGUOUS_TARGET if multiple branch tips exist.
+ * EMPTY_CONTRACT_HASH. Returns `null` for a graph that has no target
+ * state (either empty, or containing only the root with no outgoing
+ * edges). Throws NO_INITIAL_MIGRATION if the graph has nodes but none
+ * originate from the empty hash, and AMBIGUOUS_TARGET if multiple
+ * branch tips exist.
  */
-declare function findLeaf(graph: MigrationGraph): string;
+declare function findLeaf(graph: MigrationGraph): string | null;
 /**
  * Find the latest migration entry by traversing from EMPTY_CONTRACT_HASH
  * to the single target. Returns null for an empty graph.

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

@@ -1 +1 @@
-{"version":3,"file":"dag.d.mts","names":[],"sources":["../../src/dag.ts"],"sourcesContent":[],"mappings":";;;iBAWgB,gBAAA,oBAAoC,4BAA4B;;AAAhF;AAiFA;AA6CA;AAaA;AAqGA;AAgCA;AAwCA;AAkBgB,iBAzPA,QAAA,CAyPoB,KAAA,EAxP3B,cAwPyC,EAAA,QAAA,EAAA,MAAA,EAAA,MAAA,EAAA,MAAA,CAAA,EAAA,SArPtC,mBAqPsC,EAAA,GAAA,IAAA;AAiDlC,UA7PC,YAAA,CA6PY;kCA5PK;;;;;;;;;;;iBAYlB,oBAAA,QACP,qEAIN;;;;;iBAgGa,mBAAA,QAA2B;;;;;;;iBAgC3B,QAAA,QAAgB;;;;;;iBAwChB,mBAAA,QAA2B,iBAAiB;iBAkB5C,YAAA,QAAoB;iBAiDpB,aAAA,QAAqB,0BAA0B"}
+{"version":3,"file":"dag.d.mts","names":[],"sources":["../../src/dag.ts"],"sourcesContent":[],"mappings":";;;iBAgCgB,gBAAA,oBAAoC,oBAAoB;;AAAxE;AAmFA;AAyCA;AAaA;AA8FA;AAkBA;AAwCA;AAQgB,iBAtNA,QAAA,CAsNoB,KAAA,EArN3B,cAqNyC,EAAA,QAAA,EAAA,MAAA,EAAA,MAAA,EAAA,MAAA,CAAA,EAAA,SAlNtC,mBAkNsC,EAAA,GAAA,IAAA;AA8DlC,UA3OC,YAAA,CA2OY;kCA1OK;;;;;;;;;;;iBAYlB,oBAAA,QACP,qEAIN;;;;;iBAyFa,mBAAA,QAA2B;;;;;;;;;iBAkB3B,QAAA,QAAgB;;;;;;iBAwChB,mBAAA,QAA2B,iBAAiB;iBAQ5C,YAAA,QAAoB;iBA8DpB,aAAA,QAAqB,0BAA0B"}

package/dist/exports/dag.mjs

@@ -1,8 +1,107 @@
-import { f as errorNoInitialMigration, i as errorDuplicateMigrationId, m as errorSameSourceAndTarget, n as errorAmbiguousTarget, p as errorNoTarget } from "../errors-C_XuSbX7.mjs";
+import { h as errorSameSourceAndTarget, i as errorDuplicateMigrationId, m as errorNoTarget, n as errorAmbiguousTarget, p as errorNoInitialMigration } from "../errors-BKbRGCJM.mjs";
 import { t as EMPTY_CONTRACT_HASH } from "../constants-BRi0X7B_.mjs";
 import { ifDefined } from "@prisma-next/utils/defined";
 
+//#region src/queue.ts
+/**
+* FIFO queue with amortised O(1) push and shift.
+*
+* Uses a head-index cursor over a backing array rather than
+* `Array.prototype.shift()`, which is O(n) on V8. Intended for BFS-shaped
+* traversals where the queue is drained in a single pass — it does not
+* reclaim memory for already-shifted items, so it is not suitable for
+* long-lived queues with many push/shift cycles.
+*/
+var Queue = class {
+	items;
+	head = 0;
+	constructor(initial = []) {
+		this.items = [...initial];
+	}
+	push(item) {
+		this.items.push(item);
+	}
+	/**
+	* Remove and return the next item. Caller must check `isEmpty` first —
+	* shifting an empty queue throws.
+	*/
+	shift() {
+		if (this.head >= this.items.length) throw new Error("Queue.shift called on empty queue");
+		return this.items[this.head++];
+	}
+	get isEmpty() {
+		return this.head >= this.items.length;
+	}
+};
+
+//#endregion
+//#region src/graph-ops.ts
+/**
+* Generic breadth-first traversal.
+*
+* Direction (forward/reverse) is expressed by the caller's `neighbours`
+* closure: return `{ next, edge }` pairs where `next` is the node to visit
+* next and `edge` is the edge that connects them. Callers that don't need
+* path reconstruction can ignore the `parent`/`incomingEdge` fields of each
+* yielded step.
+*
+* Stops are intrinsic — callers `break` out of the `for..of` loop when
+* they've found what they're looking for.
+*
+* `ordering`, if provided, controls the order in which neighbours of each
+* node are enqueued. Only matters for path-finding: a deterministic ordering
+* makes BFS return a deterministic shortest path when multiple exist.
+*/
+function* bfs(starts, neighbours, ordering) {
+	const visited = /* @__PURE__ */ new Set();
+	const parentMap = /* @__PURE__ */ new Map();
+	const queue = new Queue();
+	for (const start of starts) if (!visited.has(start)) {
+		visited.add(start);
+		queue.push(start);
+	}
+	while (!queue.isEmpty) {
+		const current = queue.shift();
+		const parentInfo = parentMap.get(current);
+		yield {
+			node: current,
+			parent: parentInfo?.parent ?? null,
+			incomingEdge: parentInfo?.edge ?? null
+		};
+		const items = neighbours(current);
+		const toVisit = ordering ? ordering([...items]) : items;
+		for (const { next, edge } of toVisit) if (!visited.has(next)) {
+			visited.add(next);
+			parentMap.set(next, {
+				parent: current,
+				edge
+			});
+			queue.push(next);
+		}
+	}
+}
+
+//#endregion
 //#region src/dag.ts
+/** Forward-edge neighbours for BFS: edge `e` from `n` visits `e.to` next. */
+function forwardNeighbours(graph, node) {
+	return (graph.forwardChain.get(node) ?? []).map((edge) => ({
+		next: edge.to,
+		edge
+	}));
+}
+/** Reverse-edge neighbours for BFS: edge `e` from `n` visits `e.from` next. */
+function reverseNeighbours(graph, node) {
+	return (graph.reverseChain.get(node) ?? []).map((edge) => ({
+		next: edge.from,
+		edge
+	}));
+}
+function appendEdge(map, key, entry) {
+	const bucket = map.get(key);
+	if (bucket) bucket.push(entry);
+	else map.set(key, [entry]);
+}
 function reconstructGraph(packages) {
 	const nodes = /* @__PURE__ */ new Set();
 	const forwardChain = /* @__PURE__ */ new Map();
@@ -21,16 +120,10 @@ function reconstructGraph(packages) {
 			createdAt: pkg.manifest.createdAt,
 			labels: pkg.manifest.labels
 		};
-		if (migration.migrationId !== null) {
-			if (migrationById.has(migration.migrationId)) throw errorDuplicateMigrationId(migration.migrationId);
-			migrationById.set(migration.migrationId, migration);
-		}
-		const fwd = forwardChain.get(from);
-		if (fwd) fwd.push(migration);
-		else forwardChain.set(from, [migration]);
-		const rev = reverseChain.get(to);
-		if (rev) rev.push(migration);
-		else reverseChain.set(to, [migration]);
+		if (migrationById.has(migration.migrationId)) throw errorDuplicateMigrationId(migration.migrationId);
+		migrationById.set(migration.migrationId, migration);
+		appendEdge(forwardChain, from, migration);
+		appendEdge(reverseChain, to, migration);
 	}
 	return {
 		nodes,
@@ -52,16 +145,21 @@ function labelPriority(labels) {
 	}
 	return best;
 }
+function compareTieBreak(a, b) {
+	const lp = labelPriority(a.labels) - labelPriority(b.labels);
+	if (lp !== 0) return lp;
+	const ca = a.createdAt.localeCompare(b.createdAt);
+	if (ca !== 0) return ca;
+	const tc = a.to.localeCompare(b.to);
+	if (tc !== 0) return tc;
+	return a.migrationId.localeCompare(b.migrationId);
+}
 function sortedNeighbors(edges) {
-	return [...edges].sort((a, b) => {
-		const lp = labelPriority(a.labels) - labelPriority(b.labels);
-		if (lp !== 0) return lp;
-		const ca = a.createdAt.localeCompare(b.createdAt);
-		if (ca !== 0) return ca;
-		const tc = a.to.localeCompare(b.to);
-		if (tc !== 0) return tc;
-		return (a.migrationId ?? "").localeCompare(b.migrationId ?? "");
-	});
+	return [...edges].sort(compareTieBreak);
+}
+/** Ordering adapter for `bfs` — sorts `{next, edge}` pairs by tie-break. */
+function bfsOrdering(items) {
+	return items.slice().sort((a, b) => compareTieBreak(a.edge, b.edge));
 }
 /**
 * Find the shortest path from `fromHash` to `toHash` using BFS over the
@@ -73,40 +171,37 @@ function sortedNeighbors(edges) {
 */
 function findPath(graph, fromHash, toHash) {
 	if (fromHash === toHash) return [];
-	const visited = /* @__PURE__ */ new Set();
-	const parent = /* @__PURE__ */ new Map();
-	const queue = [fromHash];
-	visited.add(fromHash);
-	while (queue.length > 0) {
-		const current = queue.shift();
-		if (current === void 0) break;
-		if (current === toHash) {
+	const parents = /* @__PURE__ */ new Map();
+	for (const step of bfs([fromHash], (n) => forwardNeighbours(graph, n), bfsOrdering)) {
+		if (step.parent !== null && step.incomingEdge !== null) parents.set(step.node, {
+			parent: step.parent,
+			edge: step.incomingEdge
+		});
+		if (step.node === toHash) {
 			const path = [];
-			let node = toHash;
-			let entry = parent.get(node);
-			while (entry) {
-				const { node: prev, edge } = entry;
-				path.push(edge);
-				node = prev;
-				entry = parent.get(node);
+			let cur = toHash;
+			let p = parents.get(cur);
+			while (p) {
+				path.push(p.edge);
+				cur = p.parent;
+				p = parents.get(cur);
 			}
 			path.reverse();
 			return path;
 		}
-		const outgoing = graph.forwardChain.get(current);
-		if (!outgoing) continue;
-		for (const edge of sortedNeighbors(outgoing)) if (!visited.has(edge.to)) {
-			visited.add(edge.to);
-			parent.set(edge.to, {
-				node: current,
-				edge
-			});
-			queue.push(edge.to);
-		}
 	}
 	return null;
 }
 /**
+* Reverse-BFS from `toHash` over `reverseChain` to collect every node from
+* which `toHash` is reachable (inclusive of `toHash` itself).
+*/
+function collectNodesReachingTarget(graph, toHash) {
+	const reached = /* @__PURE__ */ new Set();
+	for (const step of bfs([toHash], (n) => reverseNeighbours(graph, n))) reached.add(step.node);
+	return reached;
+}
+/**
 * Find the shortest path from `fromHash` to `toHash` and return structured
 * path-decision metadata for machine-readable output.
 */
@@ -121,14 +216,13 @@ function findPathWithDecision(graph, fromHash, toHash, refName) {
 	};
 	const path = findPath(graph, fromHash, toHash);
 	if (!path) return null;
+	const reachesTarget = collectNodesReachingTarget(graph, toHash);
 	const tieBreakReasons = [];
 	let alternativeCount = 0;
 	for (const edge of path) {
 		const outgoing = graph.forwardChain.get(edge.from);
 		if (outgoing && outgoing.length > 1) {
-			const reachable = outgoing.filter((e) => {
-				return findPath(graph, e.to, toHash) !== null || e.to === toHash;
-			});
+			const reachable = outgoing.filter((e) => reachesTarget.has(e.to));
 			if (reachable.length > 1) {
 				alternativeCount += reachable.length - 1;
 				const sorted = sortedNeighbors(reachable);
@@ -154,14 +248,7 @@ function findPathWithDecision(graph, fromHash, toHash, refName) {
 function findDivergencePoint(graph, fromHash, leaves) {
 	const ancestorSets = leaves.map((leaf) => {
 		const ancestors = /* @__PURE__ */ new Set();
-		const queue = [leaf];
-		while (queue.length > 0) {
-			const current = queue.shift();
-			if (ancestors.has(current)) continue;
-			ancestors.add(current);
-			const incoming = graph.reverseChain.get(current);
-			if (incoming) for (const edge of incoming) queue.push(edge.from);
-		}
+		for (const step of bfs([leaf], (n) => reverseNeighbours(graph, n))) ancestors.add(step.node);
 		return ancestors;
 	});
 	const commonAncestors = [...ancestorSets[0] ?? []].filter((node) => ancestorSets.every((s) => s.has(node)));
@@ -182,36 +269,26 @@ function findDivergencePoint(graph, fromHash, leaves) {
 * `fromHash` via forward edges.
 */
 function findReachableLeaves(graph, fromHash) {
-	const visited = /* @__PURE__ */ new Set();
-	const queue = [fromHash];
-	visited.add(fromHash);
 	const leaves = [];
-	while (queue.length > 0) {
-		const current = queue.shift();
-		if (current === void 0) break;
-		const outgoing = graph.forwardChain.get(current);
-		if (!outgoing || outgoing.length === 0) leaves.push(current);
-		else for (const edge of outgoing) if (!visited.has(edge.to)) {
-			visited.add(edge.to);
-			queue.push(edge.to);
-		}
-	}
+	for (const step of bfs([fromHash], (n) => forwardNeighbours(graph, n))) if (!graph.forwardChain.get(step.node)?.length) leaves.push(step.node);
 	return leaves;
 }
 /**
 * Find the target contract hash of the migration graph reachable from
-* EMPTY_CONTRACT_HASH. Throws NO_INITIAL_MIGRATION if the graph has
-* nodes but none originate from the empty hash.
-* Throws AMBIGUOUS_TARGET if multiple branch tips exist.
+* EMPTY_CONTRACT_HASH. Returns `null` for a graph that has no target
+* state (either empty, or containing only the root with no outgoing
+* edges). Throws NO_INITIAL_MIGRATION if the graph has nodes but none
+* originate from the empty hash, and AMBIGUOUS_TARGET if multiple
+* branch tips exist.
 */
 function findLeaf(graph) {
-	if (graph.nodes.size === 0) return EMPTY_CONTRACT_HASH;
+	if (graph.nodes.size === 0) return null;
 	if (!graph.nodes.has(EMPTY_CONTRACT_HASH)) throw errorNoInitialMigration([...graph.nodes]);
 	const leaves = findReachableLeaves(graph, EMPTY_CONTRACT_HASH);
 	if (leaves.length === 0) {
 		const reachable = [...graph.nodes].filter((n) => n !== EMPTY_CONTRACT_HASH);
 		if (reachable.length > 0) throw errorNoTarget(reachable);
-		return EMPTY_CONTRACT_HASH;
+		return null;
 	}
 	if (leaves.length > 1) {
 		const divergencePoint = findDivergencePoint(graph, EMPTY_CONTRACT_HASH, leaves);
@@ -229,8 +306,7 @@ function findLeaf(graph) {
 			})
 		});
 	}
-	const leaf = leaves[0];
-	return leaf !== void 0 ? leaf : EMPTY_CONTRACT_HASH;
+	return leaves[0];
 }
 /**
 * Find the latest migration entry by traversing from EMPTY_CONTRACT_HASH
@@ -238,12 +314,9 @@ function findLeaf(graph) {
 * Throws AMBIGUOUS_TARGET if the graph has multiple branch tips.
 */
 function findLatestMigration(graph) {
-	if (graph.nodes.size === 0) return null;
 	const leafHash = findLeaf(graph);
-	if (leafHash === EMPTY_CONTRACT_HASH) return null;
-	const path = findPath(graph, EMPTY_CONTRACT_HASH, leafHash);
-	if (!path || path.length === 0) return null;
-	return path[path.length - 1] ?? null;
+	if (leafHash === null) return null;
+	return findPath(graph, EMPTY_CONTRACT_HASH, leafHash)?.at(-1) ?? null;
 }
 function detectCycles(graph) {
 	const WHITE = 0;
@@ -253,30 +326,42 @@ function detectCycles(graph) {
 	const parentMap = /* @__PURE__ */ new Map();
 	const cycles = [];
 	for (const node of graph.nodes) color.set(node, WHITE);
-	function dfs(u) {
+	const stack = [];
+	function pushFrame(u) {
 		color.set(u, GRAY);
-		const outgoing = graph.forwardChain.get(u);
-		if (outgoing) for (const edge of outgoing) {
-			const v = edge.to;
-			if (color.get(v) === GRAY) {
+		stack.push({
+			node: u,
+			outgoing: graph.forwardChain.get(u) ?? [],
+			index: 0
+		});
+	}
+	for (const root of graph.nodes) {
+		if (color.get(root) !== WHITE) continue;
+		parentMap.set(root, null);
+		pushFrame(root);
+		while (stack.length > 0) {
+			const frame = stack[stack.length - 1];
+			if (frame.index >= frame.outgoing.length) {
+				color.set(frame.node, BLACK);
+				stack.pop();
+				continue;
+			}
+			const v = frame.outgoing[frame.index++].to;
+			const vColor = color.get(v);
+			if (vColor === GRAY) {
 				const cycle = [v];
-				let cur = u;
+				let cur = frame.node;
 				while (cur !== v) {
 					cycle.push(cur);
 					cur = parentMap.get(cur) ?? v;
 				}
 				cycle.reverse();
 				cycles.push(cycle);
-			} else if (color.get(v) === WHITE) {
-				parentMap.set(v, u);
-				dfs(v);
+			} else if (vColor === WHITE) {
+				parentMap.set(v, frame.node);
+				pushFrame(v);
 			}
 		}
-		color.set(u, BLACK);
-	}
-	for (const node of graph.nodes) if (color.get(node) === WHITE) {
-		parentMap.set(node, null);
-		dfs(node);
 	}
 	return cycles;
 }
@@ -290,18 +375,7 @@ function detectOrphans(graph) {
 		for (const edges of graph.forwardChain.values()) for (const edge of edges) allTargets.add(edge.to);
 		for (const node of graph.nodes) if (!allTargets.has(node)) startNodes.push(node);
 	}
-	const queue = [...startNodes];
-	for (const hash of queue) reachable.add(hash);
-	while (queue.length > 0) {
-		const node = queue.shift();
-		if (node === void 0) break;
-		const outgoing = graph.forwardChain.get(node);
-		if (!outgoing) continue;
-		for (const migration of outgoing) if (!reachable.has(migration.to)) {
-			reachable.add(migration.to);
-			queue.push(migration.to);
-		}
-	}
+	for (const step of bfs(startNodes, (n) => forwardNeighbours(graph, n))) reachable.add(step.node);
 	const orphans = [];
 	for (const [from, migrations] of graph.forwardChain) if (!reachable.has(from)) orphans.push(...migrations);
 	return orphans;