@prisma-next/migration-tools 0.11.0-dev.46 → 0.11.0-dev.48

package/src/aggregate/strategies/synth.ts

@@ -73,7 +73,7 @@ export async function synthStrategy<TFamilyId extends string, TTargetId extends
 
   const planner = input.migrations.createPlanner(input.familyInstance);
   const plannerResult: MigrationPlannerResult = await (planner.plan({
-    contract: input.member.contract,
+    contract: input.member.contract(),
     schema: projectedSchema,
     policy: input.operationPolicy,
     fromContract: null,
@@ -114,7 +114,7 @@ export async function synthStrategy<TFamilyId extends string, TTargetId extends
     result: {
       plan,
       displayOps: synthedPlan.operations,
-      destinationContract: input.member.contract,
+      destinationContract: input.member.contract(),
       strategy: 'synth',
     },
   };

package/src/aggregate/types.ts

@@ -1,89 +1,81 @@
 import type { Contract } from '@prisma-next/contract/types';
 import type { MigrationGraph } from '../graph';
+import type { IntegrityQueryOptions, IntegrityViolation } from '../integrity-violation';
 import type { OnDiskMigrationPackage } from '../package';
-
-/**
- * Hydrated migration graph for a single contract space.
- *
- * `graph` is the structural shortest-path graph (forward / reverse chain,
- * deterministic tie-break order) reconstructed from a set of on-disk
- * migration packages. `packagesByMigrationHash` is the lookup table the
- * graph-walk strategy uses to resolve a path's edge sequence back to the
- * concrete `OnDiskMigrationPackage` (and therefore the operation list) for
- * apply.
- *
- * Eagerly hydrated by the loader. Once a `ContractSpaceAggregate` exists,
- * downstream consumers do **not** touch the filesystem to walk graphs or
- * resolve packages — the aggregate is the boundary.
- */
-export interface HydratedMigrationGraph {
-  readonly graph: MigrationGraph;
-  readonly packagesByMigrationHash: ReadonlyMap<string, OnDiskMigrationPackage>;
-}
+import type { Refs } from '../refs';
+import type { ContractSpaceHeadRecord } from '../verify-contract-spaces';
 
 /**
  * One contract space — app or extension — as a member of a
  * {@link ContractSpaceAggregate}. Every member has the same shape.
  *
+ * A member is a tolerant snapshot of one space's on-disk state, not a
+ * validated value: `packages` is the raw migration-package list as read
+ * from disk (a hash- or invariants-mismatched package is retained here;
+ * a genuinely unparseable one is omitted), and integrity is judged
+ * separately by {@link ContractSpaceAggregate.checkIntegrity}.
+ *
  * - `spaceId`: `'app'` for the application, otherwise the extension's
  *   id (validated against `[a-z][a-z0-9_-]{0,63}`).
- * - `contract`: the validated contract value for this member. For the
- *   app, the user's authored contract; for an extension, the on-disk
- *   `migrations/<spaceId>/contract.json`. Both have already passed the
- *   family's `deserializeContract` at the loader boundary.
- * - `headRef.hash`: the storage hash this member is targeting. For the
- *   app, equals `contract.storage.storageHash`. For extensions, the
- *   on-disk `refs/head.json.hash`.
- * - `headRef.invariants`: alphabetically sorted, deduplicated invariant
- *   ids declared on the head ref. Empty for the app member (the app's
- *   plan is synthesised from the contract IR, no invariants required).
- * - `migrations`: the hydrated migration graph for this space. Possibly
- *   empty (an extension whose on-disk head ref points at the
- *   empty-contract sentinel and ships no migrations yet, or the app
- *   when the user hasn't authored any).
+ * - `packages`: raw on-disk migration packages, as read; never
+ *   integrity-validated at load.
+ * - `refs`: the user-authored refs under `migrations/<spaceId>/refs/*.json`.
+ * - `headRef`: the system head ref read from
+ *   `migrations/<spaceId>/refs/head.json`, or `null` when absent
+ *   (represented as a `headRefMissing` violation, never fatal). The app
+ *   member's head ref is always synthesised from its live contract's
+ *   storage hash, so it is never `null`.
+ * - `graph()`: the migration graph this space's packages induce —
+ *   lazily reconstructed on first call and memoised. Pure structure: a
+ *   `from === to` self-edge is represented, not rejected.
+ * - `contract()`: the deserialized contract for this member — lazily
+ *   produced on first call and memoised. For the app it is the live
+ *   contract the caller supplied; for an extension it is the on-disk
+ *   `migrations/<spaceId>/contract.json` run through the family's
+ *   `deserializeContract`. Throws if the on-disk contract is missing or
+ *   undeserializable (surfaced as `contractUnreadable` by `checkIntegrity`
+ *   under `checkContracts`); callers gate before querying it.
  */
 export interface ContractSpaceMember {
   readonly spaceId: string;
-  readonly contract: Contract;
-  readonly headRef: {
-    readonly hash: string;
-    readonly invariants: readonly string[];
-  };
-  readonly migrations: HydratedMigrationGraph;
+  readonly packages: readonly OnDiskMigrationPackage[];
+  readonly refs: Refs;
+  readonly headRef: ContractSpaceHeadRecord | null;
+  graph(): MigrationGraph;
+  contract(): Contract;
 }
 
 /**
- * Typed value carrying the user's app contract plus every loaded
- * extension contract space, fully hydrated and internally consistent.
+ * Tolerant, queryable snapshot of a project's on-disk migration state:
+ * the app contract space plus every extension contract space, each a
+ * {@link ContractSpaceMember}.
  *
  * Produced once per CLI invocation by `loadContractSpaceAggregate`.
- * Every downstream component (planner, verifier, runner adapter)
- * consumes this value rather than rebuilding state from disk.
- *
- * Invariants the loader enforces at construction:
- *
- * 1. `targetId` is consistent across every member (`contract.target`
- *    matches `aggregate.targetId`). The aggregate's `targetId` is the
- *    `Config.adapter.targetId` value the loader was told to use.
- * 2. `aggregate.extensions` is sorted alphabetically by `spaceId`.
- *    Mirrors {@link import('../concatenate-space-apply-inputs').concatenateSpaceApplyInputs}'s
- *    extension ordering convention so downstream apply order matches
- *    today's behaviour byte-for-byte.
- * 3. No two members claim the same storage element (table / type / etc.).
- * 4. For each extension member: `member.headRef.hash` is reachable from
- *    the empty-contract sentinel in `member.migrations.graph` (or the
- *    graph is empty and `member.headRef.hash === EMPTY_CONTRACT_HASH`).
- * 5. For the app member: `member.headRef.hash` equals
- *    `member.contract.storage.storageHash`. The app's `migrations`
- *    is hydrated from the user's authored `migrations/` (or empty if
- *    none).
+ * Building the aggregate never throws on disk content; every consumer
+ * obtains spaces / packages / refs / graphs from this one value rather
+ * than re-deriving them from disk.
  *
- * The aggregate is **type-uniform** post-construction: app/extension
- * distinguishability survives only at the caller-policy layer
- * (`ignoreGraphFor: new Set([appSpaceId])`), not on member shape.
+ * - `targetId`: the app contract's target; every member is expected to
+ *   share it (a mismatch surfaces as a `targetMismatch` violation under
+ *   `checkContracts`).
+ * - `app` / `extensions`: retained as fields for the existing planner /
+ *   verifier / runner consumers. `extensions` is sorted alphabetically
+ *   by `spaceId` (the apply-ordering convention).
+ * - `listSpaces()` / `hasSpace()` / `space()` / `spaces()`: the query
+ *   surface the read commands consume — `app` first, then extension ids
+ *   lex-ascending.
+ * - `checkIntegrity()`: judges the loaded model and returns every
+ *   violation (never bailing at the first). Config/contract-dependent
+ *   checks run only when the matching {@link IntegrityQueryOptions} opt
+ *   is set.
  */
 export interface ContractSpaceAggregate {
   readonly targetId: string;
   readonly app: ContractSpaceMember;
   readonly extensions: readonly ContractSpaceMember[];
+  listSpaces(): readonly string[];
+  hasSpace(id: string): boolean;
+  space(id: string): ContractSpaceMember | undefined;
+  spaces(): readonly ContractSpaceMember[];
+  checkIntegrity(opts?: IntegrityQueryOptions): readonly IntegrityViolation[];
 }

package/src/aggregate/verifier.ts

@@ -1,5 +1,6 @@
 import type { Result } from '@prisma-next/utils/result';
 import { notOk, ok } from '@prisma-next/utils/result';
+import { requireHeadRef } from './aggregate';
 import { extractStorageElementNames } from './extract-storage-element-names';
 import type { ContractMarkerRecordLike } from './marker-types';
 import { projectSchemaToSpace } from './project-schema-to-space';
@@ -145,16 +146,17 @@ function runVerifyAggregate<TSchemaResult>(
       markerPerSpace.set(member.spaceId, { kind: 'absent' });
       continue;
     }
-    if (marker.storageHash !== member.headRef.hash) {
+    const headRef = requireHeadRef(member);
+    if (marker.storageHash !== headRef.hash) {
       markerPerSpace.set(member.spaceId, {
         kind: 'hashMismatch',
         markerHash: marker.storageHash,
-        expected: member.headRef.hash,
+        expected: headRef.hash,
       });
       continue;
     }
     const markerInvariants = new Set(marker.invariants);
-    const missing = member.headRef.invariants.filter((id) => !markerInvariants.has(id));
+    const missing = headRef.invariants.filter((id) => !markerInvariants.has(id));
     if (missing.length > 0) {
       markerPerSpace.set(member.spaceId, {
         kind: 'missingInvariants',
@@ -211,7 +213,7 @@ function detectOrphanElements(
 
   const claimedTables = new Set<string>();
   for (const member of members) {
-    for (const name of extractStorageElementNames(member.contract)) {
+    for (const name of extractStorageElementNames(member.contract())) {
       claimedTables.add(name);
     }
   }

package/src/compute-extension-space-apply-path.ts

@@ -97,7 +97,7 @@ export async function computeExtensionSpaceApplyPath(
   }
 
   const spaceDir = spaceMigrationDirectory(projectMigrationsDir, spaceId);
-  const packages = await readMigrationsDir(spaceDir);
+  const { packages } = await readMigrationsDir(spaceDir);
   const graph = reconstructGraph(packages);
 
   // Live-marker layer encodes "no prior state" as EMPTY_CONTRACT_HASH;

package/src/enumerate-migration-spaces.ts

@@ -104,7 +104,7 @@ export async function enumerateMigrationSpaces(args: {
   const spaces: MigrationSpaceListEntry[] = [];
   for (const spaceId of spaceIds) {
     const spaceDir = spaceMigrationDirectory(projectMigrationsDir, spaceId);
-    const packages = await readMigrationsDir(spaceDir);
+    const { packages } = await readMigrationsDir(spaceDir);
     const refsByHash = await resolveRefsByContractHash(spaceRefsDirectory(spaceDir));
 
     const migrations: MigrationListEntry[] = packages

package/src/exports/aggregate.ts

@@ -1,11 +1,15 @@
 export {
-  type DeclaredExtensionEntry,
-  type LayoutViolation,
-  type LoadAggregateError,
-  type LoadAggregateInput,
-  type LoadAggregateOutput,
-  loadContractSpaceAggregate,
-} from '../aggregate/loader';
+  createContractSpaceAggregate,
+  createContractSpaceMember,
+  requireHeadRef,
+} from '../aggregate/aggregate';
+export {
+  computeIntegrityViolations,
+  type IntegrityComputationInput,
+  type IntegritySpaceState,
+  loadProblemToViolation,
+} from '../aggregate/check-integrity';
+export { type LoadAggregateInput, loadContractSpaceAggregate } from '../aggregate/loader';
 export type { ContractMarkerRecordLike } from '../aggregate/marker-types';
 export {
   type AggregateCurrentDBState,
@@ -24,11 +28,7 @@ export {
   type GraphWalkStrategyInputs,
   graphWalkStrategy,
 } from '../aggregate/strategies/graph-walk';
-export type {
-  ContractSpaceAggregate,
-  ContractSpaceMember,
-  HydratedMigrationGraph,
-} from '../aggregate/types';
+export type { ContractSpaceAggregate, ContractSpaceMember } from '../aggregate/types';
 export {
   type AggregateVerifierError,
   type AggregateVerifierInput,
@@ -40,3 +40,8 @@ export {
   type SchemaCheckSection,
   verifyAggregate,
 } from '../aggregate/verifier';
+export type {
+  DeclaredExtensionEntry,
+  IntegrityQueryOptions,
+  IntegrityViolation,
+} from '../integrity-violation';

package/src/exports/io.ts

@@ -3,6 +3,8 @@ export {
   formatMigrationDirName,
   materialiseExtensionMigrationPackageIfMissing,
   materialiseMigrationPackage,
+  type PackageLoadProblem,
+  type ReadMigrationsDirResult,
   readMigrationPackage,
   readMigrationsDir,
   writeMigrationMetadata,

package/src/integrity-violation.ts

@@ -0,0 +1,114 @@
+/**
+ * Every structural problem the migration model can carry.
+ *
+ * Violations come in three groups:
+ *
+ * - **Recoverable**: the package or space is retained in the model;
+ *   the violation is surfaced for policy (report, refuse, or ignore
+ *   depending on the command).
+ * - **Config/contract-dependent**: produced only when the matching
+ *   `IntegrityQueryOptions` opt is set (declaredExtensions /
+ *   checkContracts). The model is built without them; they surface
+ *   when the caller explicitly asks for the broader integrity view.
+ * - **Unloadable**: the package is omitted from the model entirely
+ *   (its on-disk content cannot be parsed into an `OnDiskMigrationPackage`).
+ *
+ * `checkIntegrity()` on `ContractSpaceAggregate` returns the full set —
+ * all violations across all spaces — never bailing at the first hit.
+ */
+export type IntegrityViolation =
+  // recoverable — package/space retained, surfaced for policy
+  | {
+      readonly kind: 'sameSourceAndTarget';
+      readonly spaceId: string;
+      readonly dirName: string;
+      readonly hash: string;
+    }
+  | {
+      readonly kind: 'hashMismatch';
+      readonly spaceId: string;
+      readonly dirName: string;
+      readonly stored: string;
+      readonly computed: string;
+    }
+  | {
+      readonly kind: 'providedInvariantsMismatch';
+      readonly spaceId: string;
+      readonly dirName: string;
+    }
+  | { readonly kind: 'headRefMissing'; readonly spaceId: string }
+  | { readonly kind: 'headRefNotInGraph'; readonly spaceId: string; readonly hash: string }
+  | {
+      readonly kind: 'duplicateMigrationHash';
+      readonly spaceId: string;
+      readonly migrationHash: string;
+      readonly dirNames: readonly string[];
+    }
+  | {
+      readonly kind: 'refUnreadable';
+      readonly spaceId: string;
+      readonly refName: string;
+      readonly detail: string;
+    }
+  // config/contract-dependent — produced only when the matching opt is set
+  | { readonly kind: 'orphanSpaceDir'; readonly spaceId: string }
+  | { readonly kind: 'declaredButUnmigrated'; readonly spaceId: string }
+  | {
+      readonly kind: 'targetMismatch';
+      readonly spaceId: string;
+      readonly expected: string;
+      readonly actual: string;
+    }
+  | {
+      readonly kind: 'disjointness';
+      readonly element: string;
+      readonly claimedBy: readonly string[];
+    }
+  | { readonly kind: 'contractUnreadable'; readonly spaceId: string; readonly detail: string }
+  // genuinely unloadable — package omitted from member.packages
+  | {
+      readonly kind: 'packageUnloadable';
+      readonly spaceId: string;
+      readonly dirName: string;
+      readonly detail: string;
+    };
+
+/**
+ * One declared extension entry, drawn from `Config.extensionPacks`.
+ *
+ * The integrity layer needs only:
+ *
+ * - `id` — the space id (also the directory name under `migrations/`),
+ *   used for the layout-drift checks (`orphanSpaceDir` /
+ *   `declaredButUnmigrated`).
+ * - `targetId` — the target the declaring extension was configured for.
+ *
+ * Typed structurally so the migration-tools layer stays framework-neutral.
+ */
+export interface DeclaredExtensionEntry {
+  readonly id: string;
+  readonly targetId: string;
+}
+
+/**
+ * Options controlling which config/contract-dependent violation checks
+ * `checkIntegrity()` runs.
+ *
+ * Both opts default to disabled: a caller without the app contract or
+ * declared extensions still gets the structurally-derivable violations
+ * (hashMismatch, providedInvariantsMismatch, headRefMissing,
+ * headRefNotInGraph, refUnreadable, sameSourceAndTarget, packageUnloadable).
+ */
+export interface IntegrityQueryOptions {
+  /**
+   * When provided, enables layout-drift checks: `orphanSpaceDir`
+   * (a directory exists on disk for an extension not in the list) and
+   * `declaredButUnmigrated` (an extension in the list has no on-disk dir).
+   */
+  readonly declaredExtensions?: readonly DeclaredExtensionEntry[];
+  /**
+   * When true, enables contract/disjointness/target checks:
+   * `contractUnreadable`, `targetMismatch`, `disjointness`.
+   */
+  readonly checkContracts?: boolean;
+}

package/src/io.ts

@@ -14,6 +14,7 @@ import {
   errorMigrationHashMismatch,
   errorMissingFile,
   errorProvidedInvariantsMismatch,
+  MigrationToolsError,
 } from './errors';
 import { verifyMigrationHash } from './hash';
 import { deriveProvidedInvariants } from './invariants';
@@ -247,6 +248,60 @@ export async function readMigrationPackage(dir: string): Promise<OnDiskMigration
   return pkg;
 }
 
+/**
+ * Reads a migration package's manifest and ops without running hash or
+ * invariants verification. Returns `null` when the files cannot be read or
+ * parsed (i.e. when the package is genuinely unloadable).
+ *
+ * Used by {@link readMigrationsDir} to retain a package whose hash or
+ * invariants diverge from what is stored on disk — the raw content is still
+ * useful for display / querying; only integrity is in question.
+ */
+async function readMigrationPackageRaw(dir: string): Promise<OnDiskMigrationPackage | null> {
+  const absoluteDir = resolve(dir);
+  const manifestPath = join(absoluteDir, MANIFEST_FILE);
+  const opsPath = join(absoluteDir, OPS_FILE);
+
+  let manifestRaw: string;
+  try {
+    manifestRaw = await readFile(manifestPath, 'utf-8');
+  } catch {
+    return null;
+  }
+  let opsRaw: string;
+  try {
+    opsRaw = await readFile(opsPath, 'utf-8');
+  } catch {
+    return null;
+  }
+
+  let metadata: MigrationMetadata;
+  try {
+    metadata = JSON.parse(manifestRaw);
+  } catch {
+    return null;
+  }
+  let ops: MigrationOps;
+  try {
+    ops = JSON.parse(opsRaw);
+  } catch {
+    return null;
+  }
+
+  const result = MigrationMetadataSchema(metadata);
+  if (result instanceof type.errors) return null;
+
+  const opsResult = MigrationOpsSchema(ops);
+  if (opsResult instanceof type.errors) return null;
+
+  return {
+    dirName: basename(absoluteDir),
+    dirPath: absoluteDir,
+    metadata,
+    ops,
+  };
+}
+
 function arraysEqual(a: readonly string[], b: readonly string[]): boolean {
   if (a.length !== b.length) return false;
   for (let i = 0; i < a.length; i++) {
@@ -272,20 +327,64 @@ function validateOps(ops: unknown, filePath: string): asserts ops is MigrationOp
   }
 }
 
-export async function readMigrationsDir(
-  migrationsRoot: string,
-): Promise<readonly OnDiskMigrationPackage[]> {
+/**
+ * A per-package load-time problem returned by {@link readMigrationsDir}.
+ *
+ * Three variants, matching the relocated throws from the load path:
+ *
+ * - `hashMismatch` — stored `migrationHash` differs from the recomputed value.
+ *   The package is **retained** in the returned `packages` array.
+ * - `providedInvariantsMismatch` — `migration.json` declares different
+ *   `providedInvariants` than `ops.json` implies.  The package is **retained**.
+ * - `packageUnloadable` — the manifest is missing, unparseable, or schema-
+ *   invalid.  The package is **omitted** from `packages`.
+ *
+ * Callers that need the `spaceId` context (e.g. the aggregate loader) attach
+ * it when converting to {@link import('./integrity-violation').IntegrityViolation}.
+ */
+export type PackageLoadProblem =
+  | {
+      readonly kind: 'hashMismatch';
+      readonly dirName: string;
+      readonly stored: string;
+      readonly computed: string;
+    }
+  | { readonly kind: 'providedInvariantsMismatch'; readonly dirName: string }
+  | { readonly kind: 'packageUnloadable'; readonly dirName: string; readonly detail: string };
+
+/**
+ * Result returned by {@link readMigrationsDir}.
+ *
+ * - `packages` — every package that could be read; hash-mismatched and
+ *   invariants-mismatched packages are included here (the problem is
+ *   represented rather than fatal).
+ * - `problems` — one entry per package that had a load-time issue.
+ *   `packageUnloadable` entries are **not** in `packages`.
+ */
+export interface ReadMigrationsDirResult {
+  readonly packages: readonly OnDiskMigrationPackage[];
+  readonly problems: readonly PackageLoadProblem[];
+}
+
+function packageLoadProblemDetailFromError(error: unknown): string {
+  if (MigrationToolsError.is(error)) return error.why;
+  if (error instanceof Error) return error.message;
+  return String(error);
+}
+
+export async function readMigrationsDir(migrationsRoot: string): Promise<ReadMigrationsDirResult> {
   let entries: string[];
   try {
     entries = await readdir(migrationsRoot);
   } catch (error) {
     if (hasErrnoCode(error, 'ENOENT')) {
-      return [];
+      return { packages: [], problems: [] };
     }
     throw error;
   }
 
   const packages: OnDiskMigrationPackage[] = [];
+  const problems: PackageLoadProblem[] = [];
 
   for (const entry of entries.sort()) {
     const entryPath = join(migrationsRoot, entry);
@@ -299,10 +398,44 @@ export async function readMigrationsDir(
       continue; // skip non-migration directories
     }
 
-    packages.push(await readMigrationPackage(entryPath));
+    let pkg: OnDiskMigrationPackage;
+    try {
+      pkg = await readMigrationPackage(entryPath);
+    } catch (error) {
+      const dirName = entry;
+      if (MigrationToolsError.is(error)) {
+        if (error.code === 'MIGRATION.HASH_MISMATCH') {
+          const details = error.details;
+          const rawPkg = await readMigrationPackageRaw(entryPath);
+          if (rawPkg !== null) packages.push(rawPkg);
+          problems.push({
+            kind: 'hashMismatch',
+            dirName,
+            stored: typeof details?.['storedHash'] === 'string' ? details['storedHash'] : '',
+            computed: typeof details?.['computedHash'] === 'string' ? details['computedHash'] : '',
+          });
+          continue;
+        }
+        if (error.code === 'MIGRATION.PROVIDED_INVARIANTS_MISMATCH') {
+          const rawPkg = await readMigrationPackageRaw(entryPath);
+          if (rawPkg !== null) packages.push(rawPkg);
+          problems.push({ kind: 'providedInvariantsMismatch', dirName });
+          continue;
+        }
+      }
+      // Any other error (missing file, invalid JSON, invalid manifest schema) →
+      // package unloadable; omit from packages.
+      problems.push({
+        kind: 'packageUnloadable',
+        dirName,
+        detail: packageLoadProblemDetailFromError(error),
+      });
+      continue;
+    }
+    packages.push(pkg);
   }
 
-  return packages;
+  return { packages, problems };
 }
 
 export function formatMigrationDirName(timestamp: Date, slug: string): string {

package/src/migration-graph.ts

@@ -1,12 +1,6 @@
 import { ifDefined } from '@prisma-next/utils/defined';
 import { EMPTY_CONTRACT_HASH } from './constants';
-import {
-  errorAmbiguousTarget,
-  errorDuplicateMigrationHash,
-  errorNoInitialMigration,
-  errorNoTarget,
-  errorSameSourceAndTarget,
-} from './errors';
+import { errorAmbiguousTarget, errorNoInitialMigration, errorNoTarget } from './errors';
 import type { MigrationEdge, MigrationGraph } from './graph';
 import { bfs } from './graph-ops';
 import type { OnDiskMigrationPackage } from './package';
@@ -50,13 +44,6 @@ export function reconstructGraph(packages: readonly OnDiskMigrationPackage[]): M
     const from = pkg.metadata.from ?? EMPTY_CONTRACT_HASH;
     const { to } = pkg.metadata;
 
-    if (from === to) {
-      const hasDataOp = pkg.ops.some((op) => op.operationClass === 'data');
-      if (!hasDataOp) {
-        throw errorSameSourceAndTarget(pkg.dirPath, from);
-      }
-    }
-
     nodes.add(from);
     nodes.add(to);
 
@@ -69,10 +56,9 @@ export function reconstructGraph(packages: readonly OnDiskMigrationPackage[]): M
       invariants: pkg.metadata.providedInvariants,
     };
 
-    if (migrationByHash.has(migration.migrationHash)) {
-      throw errorDuplicateMigrationHash(migration.migrationHash);
+    if (!migrationByHash.has(migration.migrationHash)) {
+      migrationByHash.set(migration.migrationHash, migration);
     }
-    migrationByHash.set(migration.migrationHash, migration);
 
     appendEdge(forwardChain, from, migration);
     appendEdge(reverseChain, to, migration);