@prisma-next/migration-tools 0.5.0 → 0.5.1

package/dist/exports/aggregate.d.mts

@@ -92,17 +92,6 @@ interface ContractSpaceAggregate {
 }
 //#endregion
 //#region src/aggregate/loader.d.ts
-/**
- * Hash function used by drift detection. Defaults to a canonical-JSON +
- * SHA-256 pipeline that mirrors the framework's contract-hash convention,
- * but the loader accepts a callback so SQL-family callers can pass their
- * `coreHash` / `storageHash` derivation through unchanged.
- *
- * The contract value passed in is the framework-neutral `unknown` form;
- * callers that have already validated typed contracts can simply hand
- * the validated value back through.
- */
-type AggregateContractHasher = (contract: unknown) => string;
 /**
  * Single declared extension entry the loader needs from `Config.extensionPacks`.
  *
@@ -112,20 +101,20 @@ type AggregateContractHasher = (contract: unknown) => string;
  * - `targetId` — the configured `Config.adapter.targetId` value the
  *   declaring extension declared. The loader rejects mismatches against
  *   the aggregate's `targetId` with `targetMismatch`.
- * - `contractSpace` — present iff the descriptor declares a contract
- *   space (extensions can ship without one and remain runtime-only /
- *   codec-only). Drift detection compares the descriptor's
- *   `contractJson` hash against the on-disk on-disk head hash; the loader
- *   rejects drift fatally.
+ *
+ * Whether the descriptor declares a contract space is decided by whether
+ * its corresponding `migrations/<id>/` directory exists on disk
+ * (materialised by the seed phase before the loader runs); the loader
+ * never reads the descriptor's `contractJson` itself. That makes the
+ * aggregate's apply / verify paths byte-for-byte independent of the
+ * descriptor module — `db verify` succeeds even if the descriptor's
+ * `contractJson` is a throwing getter.
  *
  * Typed structurally so the migration-tools layer stays framework-neutral.
  */
 interface DeclaredExtensionEntry {
   readonly id: string;
   readonly targetId: string;
-  readonly contractSpace?: {
-    readonly contractJson: unknown;
-  };
 }
 /**
  * Inputs for {@link loadContractSpaceAggregate}.
@@ -142,7 +131,6 @@ interface LoadAggregateInput {
   readonly appContract: Contract;
   readonly declaredExtensions: ReadonlyArray<DeclaredExtensionEntry>;
   readonly validateContract: (contractJson: unknown) => Contract;
-  readonly hashContract: AggregateContractHasher;
   /**
    * Hydrated migration graph for the **app member**.
    *
@@ -175,11 +163,6 @@ type LoadAggregateError = {
   readonly kind: 'validationFailure';
   readonly spaceId: string;
   readonly detail: string;
-} | {
-  readonly kind: 'driftViolation';
-  readonly spaceId: string;
-  readonly priorHeadHash: string;
-  readonly liveHash: string;
 } | {
   readonly kind: 'disjointnessViolation';
   readonly element: string;
@@ -214,20 +197,22 @@ type LoadAggregateOutput = Result<{
 }, LoadAggregateError>;
 /**
  * Hydrate a {@link ContractSpaceAggregate} from on-disk state and
- * caller-provided descriptor data.
- *
- * This is the **only** descriptor-import boundary in the post-M2.5
- * pipeline: callers read `extensionPacks` from `Config`, validate the
- * app contract, and pass everything through. The loader composes
- * existing migration-tools primitives — layout precheck (via
+ * the app contract value the caller supplies.
+ *
+ * The loader is the **only** descriptor-import boundary at apply /
+ * verify time, but it intentionally does **not** read the extension
+ * descriptor's `contractJson` value. Each extension space's contract
+ * is read from its on-disk `migrations/<id>/contract.json` mirror; the
+ * descriptor's role is exhausted by the seed phase that wrote that
+ * mirror in the first place. The loader composes existing
+ * migration-tools primitives — layout precheck (via
  * {@link listContractSpaceDirectories}), integrity checks (via
  * {@link readMigrationsDir} / {@link readContractSpaceHeadRef} /
- * {@link readContractSpaceContract} / `validateContract`), drift detection
- * (via {@link detectSpaceContractDrift}), and disjointness — into a
- * single typed value.
+ * {@link readContractSpaceContract} / `validateContract`), and
+ * disjointness — into a single typed value.
  *
  * Failure semantics: every failure variant in {@link LoadAggregateError}
- * short-circuits the load. Drift is fatal (M2.5 spec § Loader, step 5).
+ * short-circuits the load.
  */
 declare function loadContractSpaceAggregate(input: LoadAggregateInput): Promise<LoadAggregateOutput>;
 //#endregion
@@ -610,5 +595,5 @@ type AggregateVerifierOutput<TSchemaResult> = Result<AggregateVerifierSuccess<TS
  */
 declare function verifyAggregate<TSchemaResult>(input: AggregateVerifierInput<TSchemaResult>): AggregateVerifierOutput<TSchemaResult>;
 //#endregion
-export { type AggregateContractHasher, type AggregateCurrentDBState, type AggregatePerSpacePlan, type AggregatePlannerError, type AggregatePlannerInput, type AggregatePlannerOutput, type AggregatePlannerSuccess, type AggregateVerifierError, type AggregateVerifierInput, type AggregateVerifierOutput, type AggregateVerifierSuccess, type CallerPolicy, type ContractMarkerRecordLike, type ContractSpaceAggregate, type ContractSpaceMember, type DeclaredExtensionEntry, type GraphWalkOutcome, type GraphWalkStrategyInputs, type HydratedMigrationGraph, type LayoutViolation, type LoadAggregateError, type LoadAggregateInput, type LoadAggregateOutput, type MarkerCheckResult, type MarkerCheckSection, type OrphanElement, type SchemaCheckSection, graphWalkStrategy, loadContractSpaceAggregate, planAggregate, projectSchemaToSpace, verifyAggregate };
+export { type AggregateCurrentDBState, type AggregateMigrationEdgeRef, type AggregatePerSpacePlan, type AggregatePlannerError, type AggregatePlannerInput, type AggregatePlannerOutput, type AggregatePlannerSuccess, type AggregateVerifierError, type AggregateVerifierInput, type AggregateVerifierOutput, type AggregateVerifierSuccess, type CallerPolicy, type ContractMarkerRecordLike, type ContractSpaceAggregate, type ContractSpaceMember, type DeclaredExtensionEntry, type GraphWalkOutcome, type GraphWalkStrategyInputs, type HydratedMigrationGraph, type LayoutViolation, type LoadAggregateError, type LoadAggregateInput, type LoadAggregateOutput, type MarkerCheckResult, type MarkerCheckSection, type OrphanElement, type SchemaCheckSection, graphWalkStrategy, loadContractSpaceAggregate, planAggregate, projectSchemaToSpace, verifyAggregate };
 //# sourceMappingURL=aggregate.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"aggregate.d.mts","names":[],"sources":["../../src/aggregate/types.ts","../../src/aggregate/loader.ts","../../src/aggregate/marker-types.ts","../../src/aggregate/planner-types.ts","../../src/aggregate/planner.ts","../../src/aggregate/project-schema-to-space.ts","../../src/aggregate/strategies/graph-walk.ts","../../src/aggregate/verifier.ts"],"mappings":"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"}
+{"version":3,"file":"aggregate.d.mts","names":[],"sources":["../../src/aggregate/types.ts","../../src/aggregate/loader.ts","../../src/aggregate/marker-types.ts","../../src/aggregate/planner-types.ts","../../src/aggregate/planner.ts","../../src/aggregate/project-schema-to-space.ts","../../src/aggregate/strategies/graph-walk.ts","../../src/aggregate/verifier.ts"],"mappings":"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"}

package/dist/exports/aggregate.mjs

@@ -1,25 +1,27 @@
-import { s as readMigrationsDir } from "../io-D13dLvUh.mjs";
+import { s as readMigrationsDir } from "../io-D5YYptRO.mjs";
 import "../constants-DWV9_o2Z.mjs";
 import { l as reconstructGraph, o as findPathWithDecision } from "../migration-graph-DGNnKDY5.mjs";
-import { a as readContractSpaceHeadRef, i as detectSpaceContractDrift, l as spaceMigrationDirectory, n as listContractSpaceDirectories, o as APP_SPACE_ID, t as readContractSpaceContract } from "../read-contract-space-contract-C3-1eyaI.mjs";
+import { a as APP_SPACE_ID, c as spaceMigrationDirectory, i as readContractSpaceHeadRef, n as listContractSpaceDirectories, t as readContractSpaceContract } from "../read-contract-space-contract-Cme8KZk_.mjs";
 import { notOk, ok } from "@prisma-next/utils/result";
 //#region src/aggregate/loader.ts
 /**
 * Hydrate a {@link ContractSpaceAggregate} from on-disk state and
-* caller-provided descriptor data.
+* the app contract value the caller supplies.
 *
-* This is the **only** descriptor-import boundary in the post-M2.5
-* pipeline: callers read `extensionPacks` from `Config`, validate the
-* app contract, and pass everything through. The loader composes
-* existing migration-tools primitives — layout precheck (via
+* The loader is the **only** descriptor-import boundary at apply /
+* verify time, but it intentionally does **not** read the extension
+* descriptor's `contractJson` value. Each extension space's contract
+* is read from its on-disk `migrations/<id>/contract.json` mirror; the
+* descriptor's role is exhausted by the seed phase that wrote that
+* mirror in the first place. The loader composes existing
+* migration-tools primitives — layout precheck (via
 * {@link listContractSpaceDirectories}), integrity checks (via
 * {@link readMigrationsDir} / {@link readContractSpaceHeadRef} /
-* {@link readContractSpaceContract} / `validateContract`), drift detection
-* (via {@link detectSpaceContractDrift}), and disjointness — into a
-* single typed value.
+* {@link readContractSpaceContract} / `validateContract`), and
+* disjointness — into a single typed value.
 *
 * Failure semantics: every failure variant in {@link LoadAggregateError}
-* short-circuits the load. Drift is fatal (M2.5 spec § Loader, step 5).
+* short-circuits the load.
 */
 async function loadContractSpaceAggregate(input) {
 	const appContractTarget = input.appContract.target;
@@ -35,8 +37,7 @@ async function loadContractSpaceAggregate(input) {
 		expected: input.targetId,
 		actual: entry.targetId
 	});
-	const declaredWithSpace = input.declaredExtensions.filter((e) => e.contractSpace !== void 0);
-	const declaredSpaceIds = new Set(declaredWithSpace.map((e) => e.id));
+	const declaredSpaceIds = new Set(input.declaredExtensions.map((e) => e.id));
 	const extensionDirsOnDisk = (await listContractSpaceDirectories(input.migrationsDir)).filter((d) => d !== APP_SPACE_ID);
 	const spaceDirSet = new Set(extensionDirsOnDisk);
 	const layoutViolations = [];
@@ -53,7 +54,7 @@ async function loadContractSpaceAggregate(input) {
 		violations: layoutViolations
 	});
 	const loadedExtensions = [];
-	for (const entry of [...declaredWithSpace].sort((a, b) => a.id.localeCompare(b.id))) {
+	for (const entry of [...input.declaredExtensions].sort((a, b) => a.id.localeCompare(b.id))) {
 		const headRef = await readContractSpaceHeadRef(input.migrationsDir, entry.id);
 		if (headRef === null) return notOk({
 			kind: "integrityFailure",
@@ -86,19 +87,6 @@ async function loadContractSpaceAggregate(input) {
 			expected: input.targetId,
 			actual: spaceContract.target
 		});
-		if (entry.contractSpace) {
-			const liveHash = input.hashContract(entry.contractSpace.contractJson);
-			const drift = detectSpaceContractDrift(entry.id, {
-				descriptorHash: liveHash,
-				priorHeadHash: headRef.hash
-			});
-			if (drift.kind === "drift") return notOk({
-				kind: "driftViolation",
-				spaceId: entry.id,
-				priorHeadHash: drift.priorHeadHash ?? "",
-				liveHash: drift.descriptorHash
-			});
-		}
 		let packages;
 		try {
 			packages = await readMigrationsDir(spaceMigrationDirectory(input.migrationsDir, entry.id));

package/dist/exports/aggregate.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"aggregate.mjs","names":[],"sources":["../../src/aggregate/loader.ts","../../src/aggregate/strategies/graph-walk.ts","../../src/aggregate/project-schema-to-space.ts","../../src/aggregate/strategies/synth.ts","../../src/aggregate/planner.ts","../../src/aggregate/verifier.ts"],"sourcesContent":["import type { Contract } from '@prisma-next/contract/types';\nimport { notOk, ok, type Result } from '@prisma-next/utils/result';\nimport { EMPTY_CONTRACT_HASH } from '../constants';\nimport { detectSpaceContractDrift } from '../detect-space-contract-drift';\nimport { readMigrationsDir } from '../io';\nimport { reconstructGraph } from '../migration-graph';\nimport type { OnDiskMigrationPackage } from '../package';\nimport { readContractSpaceContract } from '../read-contract-space-contract';\nimport { readContractSpaceHeadRef } from '../read-contract-space-head-ref';\nimport { APP_SPACE_ID, spaceMigrationDirectory } from '../space-layout';\nimport { listContractSpaceDirectories } from '../verify-contract-spaces';\nimport type { ContractSpaceAggregate, ContractSpaceMember, HydratedMigrationGraph } from './types';\n\n/**\n * Hash function used by drift detection. Defaults to a canonical-JSON +\n * SHA-256 pipeline that mirrors the framework's contract-hash convention,\n * but the loader accepts a callback so SQL-family callers can pass their\n * `coreHash` / `storageHash` derivation through unchanged.\n *\n * The contract value passed in is the framework-neutral `unknown` form;\n * callers that have already validated typed contracts can simply hand\n * the validated value back through.\n */\nexport type AggregateContractHasher = (contract: unknown) => string;\n\n/**\n * Single declared extension entry the loader needs from `Config.extensionPacks`.\n *\n * Only the subset of fields the loader operates on:\n *\n * - `id` — the space id (also the directory name under `migrations/`).\n * - `targetId` — the configured `Config.adapter.targetId` value the\n *   declaring extension declared. The loader rejects mismatches against\n *   the aggregate's `targetId` with `targetMismatch`.\n * - `contractSpace` — present iff the descriptor declares a contract\n *   space (extensions can ship without one and remain runtime-only /\n *   codec-only). Drift detection compares the descriptor's\n *   `contractJson` hash against the on-disk on-disk head hash; the loader\n *   rejects drift fatally.\n *\n * Typed structurally so the migration-tools layer stays framework-neutral.\n */\nexport interface DeclaredExtensionEntry {\n  readonly id: string;\n  readonly targetId: string;\n  readonly contractSpace?: {\n    readonly contractJson: unknown;\n  };\n}\n\n/**\n * Inputs for {@link loadContractSpaceAggregate}.\n *\n * The loader is the **sole** descriptor-import boundary in the M2.5\n * pipeline: callers gather the descriptor data (already-validated app\n * contract, declared extension entries) and pass it through. Once the\n * loader returns, no descriptor module is imported again for this\n * aggregate's lifetime.\n */\nexport interface LoadAggregateInput {\n  readonly targetId: string;\n  readonly migrationsDir: string;\n  readonly appContract: Contract;\n  readonly declaredExtensions: ReadonlyArray<DeclaredExtensionEntry>;\n  readonly validateContract: (contractJson: unknown) => Contract;\n  readonly hashContract: AggregateContractHasher;\n  /**\n   * Hydrated migration graph for the **app member**.\n   *\n   * The framework-neutral migration-tools layer doesn't know how to read\n   * the user's authored `migrations/` directory (the app member's\n   * migration-package layout is family-aware: ops.json shape, manifest\n   * keys, etc.). Callers — the SQL family today — read the user's\n   * `migrations/` and hand the resulting `OnDiskMigrationPackage[]` through.\n   *\n   * Passing `[]` is valid (greenfield project, no authored migrations).\n   * Equivalent to `migrations/` not existing or being empty.\n   */\n  readonly appMigrationPackages: ReadonlyArray<OnDiskMigrationPackage>;\n}\n\n/**\n * Discriminated failure variants the loader emits.\n *\n * Every variant short-circuits at first hit; the loader does not keep\n * collecting after the first violation in any phase except for layout\n * (where every layout offence is bundled into one `layoutViolation`).\n */\nexport type LoadAggregateError =\n  | { readonly kind: 'layoutViolation'; readonly violations: readonly LayoutViolation[] }\n  | { readonly kind: 'integrityFailure'; readonly spaceId: string; readonly detail: string }\n  | { readonly kind: 'validationFailure'; readonly spaceId: string; readonly detail: string }\n  | {\n      readonly kind: 'driftViolation';\n      readonly spaceId: string;\n      readonly priorHeadHash: string;\n      readonly liveHash: string;\n    }\n  | {\n      readonly kind: 'disjointnessViolation';\n      readonly element: string;\n      readonly claimedBy: readonly string[];\n    }\n  | {\n      readonly kind: 'targetMismatch';\n      readonly spaceId: string;\n      readonly expected: string;\n      readonly actual: string;\n    };\n\n/**\n * Single layout violation; bundled into a `layoutViolation` error so\n * users see every layout offence at once rather than fixing them one\n * at a time across re-runs.\n *\n * - `declaredButUnmigrated`: extension declared in `extensionPacks` with\n *   a `contractSpace` but no contract-space dir on disk. Remediation:\n *   `prisma-next migrate`.\n * - `orphanSpaceDir`: contract-space dir under `migrations/` for an extension\n *   not in `extensionPacks`. Remediation: remove the directory, or\n *   re-add the extension to `extensionPacks`.\n */\nexport type LayoutViolation =\n  | { readonly kind: 'declaredButUnmigrated'; readonly spaceId: string }\n  | { readonly kind: 'orphanSpaceDir'; readonly spaceId: string };\n\nexport type LoadAggregateOutput = Result<\n  { readonly aggregate: ContractSpaceAggregate },\n  LoadAggregateError\n>;\n\ninterface LoadedExtensionState {\n  readonly entry: DeclaredExtensionEntry;\n  readonly contract: Contract;\n  readonly headRefHash: string;\n  readonly headRefInvariants: readonly string[];\n  readonly migrations: HydratedMigrationGraph;\n}\n\n/**\n * Hydrate a {@link ContractSpaceAggregate} from on-disk state and\n * caller-provided descriptor data.\n *\n * This is the **only** descriptor-import boundary in the post-M2.5\n * pipeline: callers read `extensionPacks` from `Config`, validate the\n * app contract, and pass everything through. The loader composes\n * existing migration-tools primitives — layout precheck (via\n * {@link listContractSpaceDirectories}), integrity checks (via\n * {@link readMigrationsDir} / {@link readContractSpaceHeadRef} /\n * {@link readContractSpaceContract} / `validateContract`), drift detection\n * (via {@link detectSpaceContractDrift}), and disjointness — into a\n * single typed value.\n *\n * Failure semantics: every failure variant in {@link LoadAggregateError}\n * short-circuits the load. Drift is fatal (M2.5 spec § Loader, step 5).\n */\nexport async function loadContractSpaceAggregate(\n  input: LoadAggregateInput,\n): Promise<LoadAggregateOutput> {\n  // 1. Validate target consistency on the app contract.\n  const appContractTarget = input.appContract.target;\n  if (appContractTarget !== input.targetId) {\n    return notOk({\n      kind: 'targetMismatch',\n      spaceId: APP_SPACE_ID,\n      expected: input.targetId,\n      actual: appContractTarget,\n    });\n  }\n\n  for (const entry of input.declaredExtensions) {\n    if (entry.targetId !== input.targetId) {\n      return notOk({\n        kind: 'targetMismatch',\n        spaceId: entry.id,\n        expected: input.targetId,\n        actual: entry.targetId,\n      });\n    }\n  }\n\n  // 2. Layout precheck: bundle every layout offence at once.\n  const declaredWithSpace = input.declaredExtensions.filter((e) => e.contractSpace !== undefined);\n  const declaredSpaceIds = new Set(declaredWithSpace.map((e) => e.id));\n  const allDirs = await listContractSpaceDirectories(input.migrationsDir);\n  // The app member is implicitly declared (it is always part of the\n  // aggregate); its `migrations/<APP_SPACE_ID>/` directory may exist or\n  // not (greenfield projects start with neither). Filter it out of the\n  // orphan / declared-but-unmigrated checks so the layout precheck is\n  // about extensions only.\n  const extensionDirsOnDisk = allDirs.filter((d) => d !== APP_SPACE_ID);\n  const spaceDirSet = new Set(extensionDirsOnDisk);\n\n  const layoutViolations: LayoutViolation[] = [];\n  for (const dir of extensionDirsOnDisk) {\n    if (!declaredSpaceIds.has(dir)) {\n      layoutViolations.push({ kind: 'orphanSpaceDir', spaceId: dir });\n    }\n  }\n  for (const id of [...declaredSpaceIds].sort()) {\n    if (!spaceDirSet.has(id)) {\n      layoutViolations.push({ kind: 'declaredButUnmigrated', spaceId: id });\n    }\n  }\n  if (layoutViolations.length > 0) {\n    return notOk({ kind: 'layoutViolation', violations: layoutViolations });\n  }\n\n  // 3-5. Per-extension: read + validate + integrity-check + drift.\n  const loadedExtensions: LoadedExtensionState[] = [];\n  for (const entry of [...declaredWithSpace].sort((a, b) => a.id.localeCompare(b.id))) {\n    const headRef = await readContractSpaceHeadRef(input.migrationsDir, entry.id);\n    if (headRef === null) {\n      return notOk({\n        kind: 'integrityFailure',\n        spaceId: entry.id,\n        detail: `Head ref \\`refs/head.json\\` is missing for extension space \"${entry.id}\".`,\n      });\n    }\n\n    let spaceContractRaw: unknown;\n    try {\n      spaceContractRaw = await readContractSpaceContract(input.migrationsDir, entry.id);\n    } catch (error) {\n      return notOk({\n        kind: 'integrityFailure',\n        spaceId: entry.id,\n        detail: error instanceof Error ? error.message : String(error),\n      });\n    }\n\n    let spaceContract: Contract;\n    try {\n      spaceContract = input.validateContract(spaceContractRaw);\n    } catch (error) {\n      return notOk({\n        kind: 'validationFailure',\n        spaceId: entry.id,\n        detail: error instanceof Error ? error.message : String(error),\n      });\n    }\n\n    if (spaceContract.target !== input.targetId) {\n      return notOk({\n        kind: 'targetMismatch',\n        spaceId: entry.id,\n        expected: input.targetId,\n        actual: spaceContract.target,\n      });\n    }\n\n    // Drift: compare descriptor's live `contractJson` to on-disk\n    // `refs/head.json.hash`.\n    if (entry.contractSpace) {\n      const liveHash = input.hashContract(entry.contractSpace.contractJson);\n      const drift = detectSpaceContractDrift(entry.id, {\n        descriptorHash: liveHash,\n        priorHeadHash: headRef.hash,\n      });\n      if (drift.kind === 'drift') {\n        return notOk({\n          kind: 'driftViolation',\n          spaceId: entry.id,\n          priorHeadHash: drift.priorHeadHash ?? '',\n          liveHash: drift.descriptorHash,\n        });\n      }\n    }\n\n    // Read + integrity-check the migration packages. `readMigrationsDir`\n    // re-derives `providedInvariants` and verifies migrationHash for\n    // every package.\n    let packages: readonly OnDiskMigrationPackage[];\n    try {\n      packages = await readMigrationsDir(spaceMigrationDirectory(input.migrationsDir, entry.id));\n    } catch (error) {\n      return notOk({\n        kind: 'integrityFailure',\n        spaceId: entry.id,\n        detail: error instanceof Error ? error.message : String(error),\n      });\n    }\n\n    let graph: ReturnType<typeof reconstructGraph>;\n    try {\n      graph = reconstructGraph(packages);\n    } catch (error) {\n      return notOk({\n        kind: 'integrityFailure',\n        spaceId: entry.id,\n        detail: error instanceof Error ? error.message : String(error),\n      });\n    }\n\n    // The on-disk head ref must be reachable in the graph. Empty graphs\n    // are tolerated only when the head ref points at the empty-contract\n    // sentinel (a never-emitted extension space; not a typical scenario\n    // because the layout precheck would have flagged the missing\n    // dir, but defensible).\n    if (graph.nodes.size === 0) {\n      if (headRef.hash !== EMPTY_CONTRACT_HASH) {\n        return notOk({\n          kind: 'integrityFailure',\n          spaceId: entry.id,\n          detail: `Head ref \"${headRef.hash}\" is not present in the (empty) on-disk migration graph.`,\n        });\n      }\n    } else if (!graph.nodes.has(headRef.hash)) {\n      return notOk({\n        kind: 'integrityFailure',\n        spaceId: entry.id,\n        detail: `Head ref \"${headRef.hash}\" is not present in the on-disk migration graph.`,\n      });\n    }\n\n    const packagesByMigrationHash = new Map<string, OnDiskMigrationPackage>(\n      packages.map((p) => [p.metadata.migrationHash, p]),\n    );\n\n    loadedExtensions.push({\n      entry,\n      contract: spaceContract,\n      headRefHash: headRef.hash,\n      headRefInvariants: [...headRef.invariants].sort(),\n      migrations: { graph, packagesByMigrationHash },\n    });\n  }\n\n  // 6. Build app member with hydrated graph from caller-supplied packages.\n  let appGraph: ReturnType<typeof reconstructGraph>;\n  try {\n    appGraph = reconstructGraph(input.appMigrationPackages);\n  } catch (error) {\n    return notOk({\n      kind: 'integrityFailure',\n      spaceId: APP_SPACE_ID,\n      detail: error instanceof Error ? error.message : String(error),\n    });\n  }\n  const appPackagesByMigrationHash = new Map<string, OnDiskMigrationPackage>(\n    input.appMigrationPackages.map((p) => [p.metadata.migrationHash, p]),\n  );\n\n  const appMember: ContractSpaceMember = {\n    spaceId: APP_SPACE_ID,\n    contract: input.appContract,\n    headRef: {\n      hash: input.appContract.storage.storageHash,\n      invariants: [],\n    },\n    migrations: {\n      graph: appGraph,\n      packagesByMigrationHash: appPackagesByMigrationHash,\n    },\n  };\n\n  const extensionMembers: ContractSpaceMember[] = loadedExtensions.map((s) => ({\n    spaceId: s.entry.id,\n    contract: s.contract,\n    headRef: {\n      hash: s.headRefHash,\n      invariants: s.headRefInvariants,\n    },\n    migrations: s.migrations,\n  }));\n\n  // 7. Disjointness: no two members claim the same storage element.\n  const elementClaimedBy = new Map<string, string[]>();\n  for (const member of [appMember, ...extensionMembers]) {\n    const tables = extractTableNames(member.contract);\n    for (const tableName of tables) {\n      const claimers = elementClaimedBy.get(tableName);\n      if (claimers) claimers.push(member.spaceId);\n      else elementClaimedBy.set(tableName, [member.spaceId]);\n    }\n  }\n  for (const [element, claimedBy] of elementClaimedBy) {\n    if (claimedBy.length > 1) {\n      return notOk({\n        kind: 'disjointnessViolation',\n        element,\n        claimedBy: [...claimedBy].sort(),\n      });\n    }\n  }\n\n  return ok({\n    aggregate: {\n      targetId: input.targetId,\n      app: appMember,\n      extensions: extensionMembers,\n    },\n  });\n}\n\n/**\n * Extract the set of top-level storage table names from a contract.\n * Duck-typed: returns `[]` if the contract's storage shape doesn't\n * match the canonical `storage.tables: Record<string, ...>` form. A\n * future family with a different storage shape gets disjointness\n * effectively disabled (not enforced) rather than a hard failure.\n */\nfunction extractTableNames(contract: Contract): readonly string[] {\n  const storage = (contract as { readonly storage?: unknown }).storage;\n  if (typeof storage !== 'object' || storage === null) return [];\n  const tables = (storage as { readonly tables?: unknown }).tables;\n  if (typeof tables !== 'object' || tables === null) return [];\n  return Object.keys(tables as Record<string, unknown>);\n}\n","import type { Contract } from '@prisma-next/contract/types';\nimport type { MigrationPlan } from '@prisma-next/framework-components/control';\nimport { EMPTY_CONTRACT_HASH } from '../../constants';\nimport { findPathWithDecision } from '../../migration-graph';\nimport type { MigrationOps } from '../../package';\nimport type { ContractMarkerRecordLike } from '../marker-types';\nimport type { AggregatePerSpacePlan } from '../planner-types';\nimport type { ContractSpaceMember } from '../types';\n\n/**\n * Outcome variants for the graph-walk strategy. Mirrors\n * {@link import('../../compute-extension-space-apply-path').ExtensionSpaceApplyPathOutcome}\n * but operates against the **already-hydrated** `member.migrations.graph`\n * instead of re-reading from disk. The aggregate planner converts\n * these into {@link import('../planner-types').AggregatePlannerError}\n * variants.\n */\nexport type GraphWalkOutcome =\n  | { readonly kind: 'ok'; readonly result: AggregatePerSpacePlan }\n  | { readonly kind: 'unreachable' }\n  | { readonly kind: 'unsatisfiable'; readonly missing: readonly string[] };\n\nexport interface GraphWalkStrategyInputs {\n  readonly aggregateTargetId: string;\n  readonly member: ContractSpaceMember;\n  readonly currentMarker: ContractMarkerRecordLike | null;\n  /**\n   * Optional ref name to decorate the resulting `PathDecision`. Used by\n   * `migration apply` to surface the user-supplied `--ref <name>` in\n   * structured-progress events and invariant-path error envelopes. The\n   * strategy itself does not interpret it.\n   */\n  readonly refName?: string;\n}\n\n/**\n * Walk a member's hydrated migration graph from the live marker to\n * `member.headRef.hash`, covering every required invariant.\n *\n * Pure synchronous function — no I/O. The aggregate's loader has\n * already integrity-checked every package and reconstructed the graph;\n * this strategy just looks up ops by `migrationHash` and assembles a\n * `MigrationPlan` with `targetId` set from the aggregate (no\n * placeholder cast).\n *\n * Required invariants are computed as `headRef.invariants \\ marker.invariants`\n * — the marker already declares some invariants satisfied; the path\n * only needs to provide the remainder. Mirrors today's\n * `computeExtensionSpaceApplyPath` semantics.\n */\nexport function graphWalkStrategy(input: GraphWalkStrategyInputs): GraphWalkOutcome {\n  const { aggregateTargetId, member, currentMarker, refName } = input;\n  const { graph, packagesByMigrationHash } = member.migrations;\n\n  const fromHash = currentMarker?.storageHash ?? EMPTY_CONTRACT_HASH;\n  const markerInvariants = new Set(currentMarker?.invariants ?? []);\n  const required = new Set(member.headRef.invariants.filter((id) => !markerInvariants.has(id)));\n\n  const outcome = findPathWithDecision(graph, fromHash, member.headRef.hash, {\n    required,\n    ...(refName !== undefined ? { refName } : {}),\n  });\n\n  if (outcome.kind === 'unreachable') {\n    return { kind: 'unreachable' };\n  }\n  if (outcome.kind === 'unsatisfiable') {\n    return { kind: 'unsatisfiable', missing: outcome.missing };\n  }\n\n  const pathOps: MigrationOps[number][] = [];\n  const providedInvariantsSet = new Set<string>();\n  const edgeRefs: Array<{\n    migrationHash: string;\n    dirName: string;\n    from: string;\n    to: string;\n    operationCount: number;\n  }> = [];\n  for (const edge of outcome.decision.selectedPath) {\n    const pkg = packagesByMigrationHash.get(edge.migrationHash);\n    if (!pkg) {\n      throw new Error(\n        `Migration package missing for edge ${edge.migrationHash} in space \"${member.spaceId}\". The hydrated migration graph and packagesByMigrationHash map are out of sync — this should be unreachable; report.`,\n      );\n    }\n    for (const op of pkg.ops) pathOps.push(op);\n    for (const invariant of pkg.metadata.providedInvariants) providedInvariantsSet.add(invariant);\n    edgeRefs.push({\n      migrationHash: edge.migrationHash,\n      dirName: edge.dirName,\n      from: edge.from,\n      to: edge.to,\n      operationCount: pkg.ops.length,\n    });\n  }\n\n  const plan: MigrationPlan = {\n    targetId: aggregateTargetId,\n    spaceId: member.spaceId,\n    origin: currentMarker === null ? null : { storageHash: currentMarker.storageHash },\n    destination: { storageHash: member.headRef.hash },\n    operations: pathOps,\n    providedInvariants: [...providedInvariantsSet].sort(),\n  };\n\n  return {\n    kind: 'ok',\n    result: {\n      plan,\n      displayOps: pathOps,\n      destinationContract: member.contract as Contract,\n      strategy: 'graph-walk',\n      migrationEdges: edgeRefs,\n      pathDecision: outcome.decision,\n    },\n  };\n}\n","import type { ContractSpaceMember } from './types';\n\n/**\n * Project the introspected live schema to the slice claimed by a single\n * contract-space member.\n *\n * Returns the same `schema` value with every top-level table claimed by\n * **other** members of the aggregate removed. Tables not claimed by any\n * member flow through unchanged — the planner / verifier sees them as\n * orphans (extras in strict mode).\n *\n * Used by:\n *\n * - The aggregate planner's **synth strategy**: when synthesising a\n *   plan against a member's contract, the live schema must be projected\n *   to that member's slice so the planner doesn't treat tables claimed\n *   by other members as \"extras\" and emit destructive ops to drop\n *   them.\n * - The aggregate verifier's **schemaCheck**: projects per member so the\n *   single-contract `verifySqlSchema` only sees the slice claimed by\n *   the member it is checking. Closes the F23 architectural concern\n *   (multi-member deployments where each member's tables look like\n *   extras to every other member's verify pass).\n *\n * **Duck-typing semantics**: the helper operates on `unknown` for the\n * schema and falls through structurally if the shape doesn't match.\n * Every family today exposes `storage.tables: Record<string, ...>` and\n * the introspected schema mirrors the same shape; a future family with\n * a different storage shape gets the schema returned unchanged rather\n * than blowing up the aggregate planner.\n */\nexport function projectSchemaToSpace(\n  schema: unknown,\n  member: ContractSpaceMember,\n  otherMembers: ReadonlyArray<ContractSpaceMember>,\n): unknown {\n  if (typeof schema !== 'object' || schema === null) return schema;\n  const schemaObj = schema as { readonly tables?: unknown };\n  if (typeof schemaObj.tables !== 'object' || schemaObj.tables === null) return schema;\n  const schemaTables = schemaObj.tables as Record<string, unknown>;\n\n  const ownedByOthers = new Set<string>();\n  for (const other of otherMembers) {\n    if (other.spaceId === member.spaceId) continue;\n    const storage = (other.contract as { readonly storage?: unknown }).storage;\n    if (typeof storage !== 'object' || storage === null) continue;\n    const tables = (storage as { readonly tables?: unknown }).tables;\n    if (typeof tables !== 'object' || tables === null) continue;\n    for (const tableName of Object.keys(tables as Record<string, unknown>)) {\n      ownedByOthers.add(tableName);\n    }\n  }\n\n  if (ownedByOthers.size === 0) return schema;\n\n  const prunedTables: Record<string, unknown> = {};\n  for (const [name, table] of Object.entries(schemaTables)) {\n    if (!ownedByOthers.has(name)) {\n      prunedTables[name] = table;\n    }\n  }\n\n  return { ...schemaObj, tables: prunedTables };\n}\n","import type { Contract } from '@prisma-next/contract/types';\nimport type { TargetBoundComponentDescriptor } from '@prisma-next/framework-components/components';\nimport type {\n  ControlFamilyInstance,\n  MigrationOperationPolicy,\n  MigrationPlan,\n  MigrationPlannerConflict,\n  MigrationPlannerResult,\n  TargetMigrationsCapability,\n} from '@prisma-next/framework-components/control';\nimport type { AggregatePerSpacePlan } from '../planner-types';\nimport { projectSchemaToSpace } from '../project-schema-to-space';\nimport type { ContractSpaceMember } from '../types';\n\nexport interface SynthStrategyInputs<TFamilyId extends string, TTargetId extends string> {\n  readonly aggregateTargetId: string;\n  readonly member: ContractSpaceMember;\n  readonly otherMembers: ReadonlyArray<ContractSpaceMember>;\n  readonly schemaIntrospection: unknown;\n  readonly familyInstance: ControlFamilyInstance<TFamilyId, unknown>;\n  readonly migrations: TargetMigrationsCapability<\n    TFamilyId,\n    TTargetId,\n    ControlFamilyInstance<TFamilyId, unknown>\n  >;\n  readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<TFamilyId, TTargetId>>;\n  readonly operationPolicy: MigrationOperationPolicy;\n}\n\nexport type SynthStrategyOutcome =\n  | { readonly kind: 'ok'; readonly result: AggregatePerSpacePlan }\n  | { readonly kind: 'failure'; readonly conflicts: readonly MigrationPlannerConflict[] };\n\n/**\n * The {@link MigrationPlanner.plan} interface is declared as synchronous,\n * but historical and test fixture call sites have always invoked it\n * with `await` (see prior `db-apply-per-space.ts`). Tolerating a\n * Promise here keeps existing test mocks working without changing the\n * declared family SPI.\n */\ntype MaybeAsyncPlannerResult = MigrationPlannerResult | Promise<MigrationPlannerResult>;\n\n/**\n * Synthesise a migration plan for a single member by projecting the\n * live schema down to that member's claimed slice and delegating to\n * the family's `createPlanner(...).plan(...)`.\n *\n * Pre-projection (via {@link projectSchemaToSpace}) closes the F23\n * concern: without it, the family's planner sees other members'\n * tables as \"extras\" and emits destructive ops to drop them. With it,\n * the planner only sees the slice this member claims.\n *\n * The synthesised plan's `targetId` is set from `aggregateTargetId`\n * (the aggregate's ambient target). The family's planner does not\n * stamp `targetId` on the produced plan; the aggregate planner is\n * the single point that knows the target.\n *\n * Used by:\n *\n * - The app member by default (CLI policy\n *   `ignoreGraphFor: { app.spaceId }`).\n * - Any extension member whose `headRef.invariants` is empty (the\n *   strategy selector falls back to synth when graph-walk isn't\n *   required).\n */\nexport async function synthStrategy<TFamilyId extends string, TTargetId extends string>(\n  input: SynthStrategyInputs<TFamilyId, TTargetId>,\n): Promise<SynthStrategyOutcome> {\n  const projectedSchema = projectSchemaToSpace(\n    input.schemaIntrospection,\n    input.member,\n    input.otherMembers,\n  );\n\n  const planner = input.migrations.createPlanner(input.familyInstance);\n  const plannerResult: MigrationPlannerResult = await (planner.plan({\n    contract: input.member.contract,\n    schema: projectedSchema,\n    policy: input.operationPolicy,\n    fromContract: null,\n    frameworkComponents: input.frameworkComponents,\n    spaceId: input.member.spaceId,\n  }) as MaybeAsyncPlannerResult);\n\n  if (plannerResult.kind === 'failure') {\n    return { kind: 'failure', conflicts: plannerResult.conflicts };\n  }\n\n  const synthedPlan = plannerResult.plan;\n  // The family planner returns a class-instance-shaped plan whose\n  // `destination` / `operations` are accessors on the prototype, often\n  // backed by private fields. A naive spread (`{ ...synthedPlan }`)\n  // would lose those accessors and produce a plan with\n  // `destination: undefined`; rebinding the prototype on a plain\n  // object would break private-field access. We instead wrap the plan\n  // in a Proxy that forwards every read except `targetId`, which is\n  // stamped from the aggregate's ambient target. This preserves the\n  // planner's class semantics while keeping the aggregate the single\n  // source of truth for `targetId`.\n  const plan: MigrationPlan = new Proxy(synthedPlan, {\n    get(target, prop) {\n      if (prop === 'targetId') return input.aggregateTargetId;\n      // Forward `this` as the original target so prototype-bound\n      // private fields (#destination, #operations, …) resolve.\n      return Reflect.get(target, prop, target);\n    },\n    has(target, prop) {\n      if (prop === 'targetId') return true;\n      return Reflect.has(target, prop);\n    },\n  });\n\n  return {\n    kind: 'ok',\n    result: {\n      plan,\n      displayOps: synthedPlan.operations,\n      destinationContract: input.member.contract as Contract,\n      strategy: 'synth',\n    },\n  };\n}\n","import { notOk, ok } from '@prisma-next/utils/result';\nimport type {\n  AggregatePerSpacePlan,\n  AggregatePlannerError,\n  AggregatePlannerInput,\n  AggregatePlannerOutput,\n} from './planner-types';\nimport { graphWalkStrategy } from './strategies/graph-walk';\nimport { synthStrategy } from './strategies/synth';\nimport type { ContractSpaceMember } from './types';\n\nexport type {\n  AggregateCurrentDBState,\n  AggregatePerSpacePlan,\n  AggregatePlannerError,\n  AggregatePlannerInput,\n  AggregatePlannerOutput,\n  AggregatePlannerSuccess,\n  CallerPolicy,\n} from './planner-types';\n\n/**\n * Plan a migration across every member of a {@link ContractSpaceAggregate}.\n *\n * Strategy selection per member, in order; first match wins:\n *\n * 1. If `callerPolicy.ignoreGraphFor.has(member.spaceId)`:\n *    - If `member.headRef.invariants` is empty → synth.\n *    - Else → `policyConflict` (synth cannot satisfy authored invariants).\n * 2. Else if `member.migrations.graph` is non-empty AND graph-walk\n *    succeeds → graph-walk.\n * 3. Else if `member.headRef.invariants` is empty → synth.\n * 4. Else → graph-walk failure → `extensionPathUnreachable` /\n *    `extensionPathUnsatisfiable`.\n *\n * Output `applyOrder` is `[...aggregate.extensions.map(spaceId), aggregate.app.spaceId]`\n * — extensions alphabetical, then app — matching today's\n * `concatenateSpaceApplyInputs` ordering. This preserves\n * `MultiSpaceRunnerFailure.failingSpace` attribution byte-for-byte.\n *\n * Every emitted `MigrationPlan` has `targetId = aggregate.targetId`.\n * No placeholder cast; no patch step.\n */\nexport async function planAggregate<TFamilyId extends string, TTargetId extends string>(\n  input: AggregatePlannerInput<TFamilyId, TTargetId>,\n): Promise<AggregatePlannerOutput> {\n  const { aggregate, currentDBState, callerPolicy } = input;\n  const allMembers: ReadonlyArray<ContractSpaceMember> = [aggregate.app, ...aggregate.extensions];\n\n  const perSpace = new Map<string, AggregatePerSpacePlan>();\n\n  // Iterate in apply order so a per-member error short-circuits the\n  // walk in the same order the runner would walk inputs.\n  const orderedMembers: ReadonlyArray<ContractSpaceMember> = [\n    ...aggregate.extensions,\n    aggregate.app,\n  ];\n\n  for (const member of orderedMembers) {\n    const otherMembers = allMembers.filter((m) => m.spaceId !== member.spaceId);\n    const currentMarker = currentDBState.markersBySpaceId.get(member.spaceId) ?? null;\n\n    const ignoreGraph = callerPolicy.ignoreGraphFor.has(member.spaceId);\n    const invariantsRequired = member.headRef.invariants.length > 0;\n\n    if (ignoreGraph && invariantsRequired) {\n      const conflict: AggregatePlannerError = {\n        kind: 'policyConflict',\n        spaceId: member.spaceId,\n        detail: `\\`callerPolicy.ignoreGraphFor\\` requested for space \"${member.spaceId}\", but the member declares non-empty head-ref invariants (${member.headRef.invariants.join(', ')}). Synthesising a plan from the contract IR cannot satisfy authored invariants — the graph must be walked. Either remove \"${member.spaceId}\" from \\`ignoreGraphFor\\` or amend the on-disk head ref to declare zero invariants.`,\n      };\n      return notOk(conflict);\n    }\n\n    if (ignoreGraph) {\n      const synthOutcome = await synthStrategy({\n        aggregateTargetId: aggregate.targetId,\n        member,\n        otherMembers,\n        schemaIntrospection: currentDBState.schemaIntrospection,\n        familyInstance: input.familyInstance,\n        migrations: input.migrations,\n        frameworkComponents: input.frameworkComponents,\n        operationPolicy: input.operationPolicy,\n      });\n      if (synthOutcome.kind === 'failure') {\n        return notOk({\n          kind: 'appSynthFailure',\n          spaceId: member.spaceId,\n          conflicts: synthOutcome.conflicts,\n        });\n      }\n      perSpace.set(member.spaceId, synthOutcome.result);\n      continue;\n    }\n\n    // Try graph-walk first when the graph has nodes; fall back to synth\n    // when the graph is empty AND no invariants are required.\n    if (member.migrations.graph.nodes.size > 0) {\n      const walked = graphWalkStrategy({\n        aggregateTargetId: aggregate.targetId,\n        member,\n        currentMarker,\n      });\n      if (walked.kind === 'ok') {\n        perSpace.set(member.spaceId, walked.result);\n        continue;\n      }\n      if (walked.kind === 'unreachable') {\n        return notOk({\n          kind: 'extensionPathUnreachable',\n          spaceId: member.spaceId,\n          target: member.headRef.hash,\n        });\n      }\n      // unsatisfiable — surface\n      return notOk({\n        kind: 'extensionPathUnsatisfiable',\n        spaceId: member.spaceId,\n        missingInvariants: walked.missing,\n      });\n    }\n\n    // Empty graph: synth is the only option, and it can only satisfy\n    // empty-invariant members.\n    if (invariantsRequired) {\n      return notOk({\n        kind: 'extensionPathUnsatisfiable',\n        spaceId: member.spaceId,\n        missingInvariants: [...member.headRef.invariants].sort(),\n      });\n    }\n\n    const synthOutcome = await synthStrategy({\n      aggregateTargetId: aggregate.targetId,\n      member,\n      otherMembers,\n      schemaIntrospection: currentDBState.schemaIntrospection,\n      familyInstance: input.familyInstance,\n      migrations: input.migrations,\n      frameworkComponents: input.frameworkComponents,\n      operationPolicy: input.operationPolicy,\n    });\n    if (synthOutcome.kind === 'failure') {\n      return notOk({\n        kind: 'appSynthFailure',\n        spaceId: member.spaceId,\n        conflicts: synthOutcome.conflicts,\n      });\n    }\n    perSpace.set(member.spaceId, synthOutcome.result);\n  }\n\n  return ok({\n    perSpace,\n    applyOrder: [...aggregate.extensions.map((m) => m.spaceId), aggregate.app.spaceId],\n  });\n}\n","import type { Result } from '@prisma-next/utils/result';\nimport { notOk, ok } from '@prisma-next/utils/result';\nimport type { ContractMarkerRecordLike } from './marker-types';\nimport { projectSchemaToSpace } from './project-schema-to-space';\nimport type { ContractSpaceAggregate, ContractSpaceMember } from './types';\n\n/**\n * Caller policy for the aggregate verifier. Today's only knob is\n * `mode`: `strict` treats orphan elements (live tables not claimed by\n * any aggregate member) as errors; `lenient` treats them as\n * informational. Maps directly to `db verify --strict`.\n */\nexport interface AggregateVerifierInput<TSchemaResult> {\n  readonly aggregate: ContractSpaceAggregate;\n  readonly markersBySpaceId: ReadonlyMap<string, ContractMarkerRecordLike | null>;\n  readonly schemaIntrospection: unknown;\n  readonly mode: 'strict' | 'lenient';\n  /**\n   * Caller-supplied per-space schema verifier. The CLI wires this to\n   * the family's `verifySqlSchema` (SQL) / equivalent (other\n   * families). The aggregate verifier projects the schema to the\n   * member's slice via {@link projectSchemaToSpace} before invoking\n   * the callback, so single-contract semantics are preserved.\n   *\n   * Typed structurally with a generic `TSchemaResult` so the\n   * migration-tools layer doesn't depend on the SQL family's\n   * `VerifySqlSchemaResult`. CLI callers pass the family's type\n   * through unchanged.\n   */\n  readonly verifySchemaForMember: (\n    projectedSchema: unknown,\n    member: ContractSpaceMember,\n    mode: 'strict' | 'lenient',\n  ) => TSchemaResult;\n}\n\n/**\n * Marker-check result per member. Mirrors the four cases the\n * `verifyContractSpaces` primitive surfaces today, plus an `'absent'`\n * case for greenfield spaces (no marker row written yet — `db init`\n * not run).\n */\nexport type MarkerCheckResult =\n  | { readonly kind: 'ok' }\n  | { readonly kind: 'absent' }\n  | {\n      readonly kind: 'hashMismatch';\n      readonly markerHash: string;\n      readonly expected: string;\n    }\n  | { readonly kind: 'missingInvariants'; readonly missing: readonly string[] };\n\nexport interface MarkerCheckSection {\n  readonly perSpace: ReadonlyMap<string, MarkerCheckResult>;\n  readonly orphanMarkers: readonly {\n    readonly spaceId: string;\n    readonly row: ContractMarkerRecordLike;\n  }[];\n}\n\n/**\n * A live storage element (today: a top-level table) not claimed by any\n * member of the aggregate. The aggregate verifier always reports these;\n * the caller decides what to do — `db verify --strict` treats them as\n * errors, the lenient default treats them as informational.\n *\n * Today only `kind: 'table'` exists. The discriminated shape leaves\n * room for orphan columns / indexes / sequences in the future without\n * breaking the type contract.\n */\nexport type OrphanElement = { readonly kind: 'table'; readonly name: string };\n\nexport interface SchemaCheckSection<TSchemaResult> {\n  readonly perSpace: ReadonlyMap<string, TSchemaResult>;\n  /**\n   * Live elements present in the introspected schema that are not\n   * claimed by **any** aggregate member. Sorted alphabetically by name.\n   */\n  readonly orphanElements: readonly OrphanElement[];\n}\n\nexport interface AggregateVerifierSuccess<TSchemaResult> {\n  readonly markerCheck: MarkerCheckSection;\n  readonly schemaCheck: SchemaCheckSection<TSchemaResult>;\n}\n\nexport type AggregateVerifierError = {\n  readonly kind: 'introspectionFailure';\n  readonly detail: string;\n};\n\nexport type AggregateVerifierOutput<TSchemaResult> = Result<\n  AggregateVerifierSuccess<TSchemaResult>,\n  AggregateVerifierError\n>;\n\n/**\n * Verify a {@link ContractSpaceAggregate} against the live database\n * state. Bundles two checks:\n *\n * - `markerCheck` per member: compare the live marker row against the\n *   member's `headRef.hash` + `headRef.invariants`. Absence is a\n *   distinct kind, not an error (callers — `db verify` strict vs\n *   `db init` precondition — choose how to interpret it).\n * - `schemaCheck` per member: project the live schema to the slice\n *   the member claims via {@link projectSchemaToSpace}, then delegate\n *   to the caller-supplied `verifySchemaForMember`. The pre-projection\n *   means the family's single-contract verifier no longer sees other\n *   members' tables as `extras`, so a multi-member deployment never\n *   surfaces cross-member tables as orphaned schema elements.\n *\n * `markerCheck.orphanMarkers` lists every marker row whose `space` is\n * not a member of the aggregate. `db verify` callers reject orphans;\n * future tooling may not.\n *\n * Pure synchronous function; no I/O. The caller (CLI) gathers\n * `markersBySpaceId` and `schemaIntrospection` ahead of the call.\n */\nexport function verifyAggregate<TSchemaResult>(\n  input: AggregateVerifierInput<TSchemaResult>,\n): AggregateVerifierOutput<TSchemaResult> {\n  try {\n    return runVerifyAggregate(input);\n  } catch (error) {\n    return notOk({\n      kind: 'introspectionFailure',\n      detail: error instanceof Error ? error.message : String(error),\n    });\n  }\n}\n\nfunction runVerifyAggregate<TSchemaResult>(\n  input: AggregateVerifierInput<TSchemaResult>,\n): AggregateVerifierOutput<TSchemaResult> {\n  const { aggregate, markersBySpaceId, schemaIntrospection, mode, verifySchemaForMember } = input;\n  const allMembers: ReadonlyArray<ContractSpaceMember> = [aggregate.app, ...aggregate.extensions];\n  const memberSpaceIds = new Set(allMembers.map((m) => m.spaceId));\n\n  // Marker check per member.\n  const markerPerSpace = new Map<string, MarkerCheckResult>();\n  for (const member of allMembers) {\n    const marker = markersBySpaceId.get(member.spaceId) ?? null;\n    if (marker === null) {\n      markerPerSpace.set(member.spaceId, { kind: 'absent' });\n      continue;\n    }\n    if (marker.storageHash !== member.headRef.hash) {\n      markerPerSpace.set(member.spaceId, {\n        kind: 'hashMismatch',\n        markerHash: marker.storageHash,\n        expected: member.headRef.hash,\n      });\n      continue;\n    }\n    const markerInvariants = new Set(marker.invariants);\n    const missing = member.headRef.invariants.filter((id) => !markerInvariants.has(id));\n    if (missing.length > 0) {\n      markerPerSpace.set(member.spaceId, {\n        kind: 'missingInvariants',\n        missing: [...missing].sort(),\n      });\n      continue;\n    }\n    markerPerSpace.set(member.spaceId, { kind: 'ok' });\n  }\n\n  // Orphan markers: entries in markersBySpaceId whose spaceId is not a\n  // member of the aggregate.\n  const orphanMarkers: { spaceId: string; row: ContractMarkerRecordLike }[] = [];\n  for (const [spaceId, row] of markersBySpaceId) {\n    if (row !== null && !memberSpaceIds.has(spaceId)) {\n      orphanMarkers.push({ spaceId, row });\n    }\n  }\n  orphanMarkers.sort((a, b) => a.spaceId.localeCompare(b.spaceId));\n\n  // Schema check per member (with per-space pre-projection).\n  const schemaPerSpace = new Map<string, TSchemaResult>();\n  for (const member of allMembers) {\n    const others = allMembers.filter((m) => m.spaceId !== member.spaceId);\n    const projected = projectSchemaToSpace(schemaIntrospection, member, others);\n    schemaPerSpace.set(member.spaceId, verifySchemaForMember(projected, member, mode));\n  }\n\n  return ok({\n    markerCheck: {\n      perSpace: markerPerSpace,\n      orphanMarkers,\n    },\n    schemaCheck: {\n      perSpace: schemaPerSpace,\n      orphanElements: detectOrphanElements(schemaIntrospection, allMembers),\n    },\n  });\n}\n\n/**\n * Live tables not claimed by any aggregate member. Duck-typed against\n * the introspected schema's `tables` map; schemas whose shape doesn't\n * match return an empty list (consistent with\n * {@link projectSchemaToSpace}'s fall-through).\n */\nfunction detectOrphanElements(\n  schemaIntrospection: unknown,\n  members: ReadonlyArray<ContractSpaceMember>,\n): readonly OrphanElement[] {\n  if (typeof schemaIntrospection !== 'object' || schemaIntrospection === null) return [];\n  const liveTables = (schemaIntrospection as { readonly tables?: unknown }).tables;\n  if (typeof liveTables !== 'object' || liveTables === null) return [];\n\n  const claimedTables = new Set<string>();\n  for (const member of members) {\n    const storage = (member.contract as { readonly storage?: unknown }).storage;\n    if (typeof storage !== 'object' || storage === null) continue;\n    const tables = (storage as { readonly tables?: unknown }).tables;\n    if (typeof tables !== 'object' || tables === null) continue;\n    for (const tableName of Object.keys(tables as Record<string, unknown>)) {\n      claimedTables.add(tableName);\n    }\n  }\n\n  const orphans: OrphanElement[] = [];\n  for (const tableName of Object.keys(liveTables as Record<string, unknown>)) {\n    if (!claimedTables.has(tableName)) {\n      orphans.push({ kind: 'table', name: tableName });\n    }\n  }\n  orphans.sort((a, b) => a.name.localeCompare(b.name));\n  return orphans;\n}\n"],"mappings":"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"}
+{"version":3,"file":"aggregate.mjs","names":[],"sources":["../../src/aggregate/loader.ts","../../src/aggregate/strategies/graph-walk.ts","../../src/aggregate/project-schema-to-space.ts","../../src/aggregate/strategies/synth.ts","../../src/aggregate/planner.ts","../../src/aggregate/verifier.ts"],"sourcesContent":["import type { Contract } from '@prisma-next/contract/types';\nimport { notOk, ok, type Result } from '@prisma-next/utils/result';\nimport { EMPTY_CONTRACT_HASH } from '../constants';\nimport { readMigrationsDir } from '../io';\nimport { reconstructGraph } from '../migration-graph';\nimport type { OnDiskMigrationPackage } from '../package';\nimport { readContractSpaceContract } from '../read-contract-space-contract';\nimport { readContractSpaceHeadRef } from '../read-contract-space-head-ref';\nimport { APP_SPACE_ID, spaceMigrationDirectory } from '../space-layout';\nimport { listContractSpaceDirectories } from '../verify-contract-spaces';\nimport type { ContractSpaceAggregate, ContractSpaceMember, HydratedMigrationGraph } from './types';\n\n/**\n * Single declared extension entry the loader needs from `Config.extensionPacks`.\n *\n * Only the subset of fields the loader operates on:\n *\n * - `id` — the space id (also the directory name under `migrations/`).\n * - `targetId` — the configured `Config.adapter.targetId` value the\n *   declaring extension declared. The loader rejects mismatches against\n *   the aggregate's `targetId` with `targetMismatch`.\n *\n * Whether the descriptor declares a contract space is decided by whether\n * its corresponding `migrations/<id>/` directory exists on disk\n * (materialised by the seed phase before the loader runs); the loader\n * never reads the descriptor's `contractJson` itself. That makes the\n * aggregate's apply / verify paths byte-for-byte independent of the\n * descriptor module — `db verify` succeeds even if the descriptor's\n * `contractJson` is a throwing getter.\n *\n * Typed structurally so the migration-tools layer stays framework-neutral.\n */\nexport interface DeclaredExtensionEntry {\n  readonly id: string;\n  readonly targetId: string;\n}\n\n/**\n * Inputs for {@link loadContractSpaceAggregate}.\n *\n * The loader is the **sole** descriptor-import boundary in the M2.5\n * pipeline: callers gather the descriptor data (already-validated app\n * contract, declared extension entries) and pass it through. Once the\n * loader returns, no descriptor module is imported again for this\n * aggregate's lifetime.\n */\nexport interface LoadAggregateInput {\n  readonly targetId: string;\n  readonly migrationsDir: string;\n  readonly appContract: Contract;\n  readonly declaredExtensions: ReadonlyArray<DeclaredExtensionEntry>;\n  readonly validateContract: (contractJson: unknown) => Contract;\n  /**\n   * Hydrated migration graph for the **app member**.\n   *\n   * The framework-neutral migration-tools layer doesn't know how to read\n   * the user's authored `migrations/` directory (the app member's\n   * migration-package layout is family-aware: ops.json shape, manifest\n   * keys, etc.). Callers — the SQL family today — read the user's\n   * `migrations/` and hand the resulting `OnDiskMigrationPackage[]` through.\n   *\n   * Passing `[]` is valid (greenfield project, no authored migrations).\n   * Equivalent to `migrations/` not existing or being empty.\n   */\n  readonly appMigrationPackages: ReadonlyArray<OnDiskMigrationPackage>;\n}\n\n/**\n * Discriminated failure variants the loader emits.\n *\n * Every variant short-circuits at first hit; the loader does not keep\n * collecting after the first violation in any phase except for layout\n * (where every layout offence is bundled into one `layoutViolation`).\n */\nexport type LoadAggregateError =\n  | { readonly kind: 'layoutViolation'; readonly violations: readonly LayoutViolation[] }\n  | { readonly kind: 'integrityFailure'; readonly spaceId: string; readonly detail: string }\n  | { readonly kind: 'validationFailure'; readonly spaceId: string; readonly detail: string }\n  | {\n      readonly kind: 'disjointnessViolation';\n      readonly element: string;\n      readonly claimedBy: readonly string[];\n    }\n  | {\n      readonly kind: 'targetMismatch';\n      readonly spaceId: string;\n      readonly expected: string;\n      readonly actual: string;\n    };\n\n/**\n * Single layout violation; bundled into a `layoutViolation` error so\n * users see every layout offence at once rather than fixing them one\n * at a time across re-runs.\n *\n * - `declaredButUnmigrated`: extension declared in `extensionPacks` with\n *   a `contractSpace` but no contract-space dir on disk. Remediation:\n *   `prisma-next migrate`.\n * - `orphanSpaceDir`: contract-space dir under `migrations/` for an extension\n *   not in `extensionPacks`. Remediation: remove the directory, or\n *   re-add the extension to `extensionPacks`.\n */\nexport type LayoutViolation =\n  | { readonly kind: 'declaredButUnmigrated'; readonly spaceId: string }\n  | { readonly kind: 'orphanSpaceDir'; readonly spaceId: string };\n\nexport type LoadAggregateOutput = Result<\n  { readonly aggregate: ContractSpaceAggregate },\n  LoadAggregateError\n>;\n\ninterface LoadedExtensionState {\n  readonly entry: DeclaredExtensionEntry;\n  readonly contract: Contract;\n  readonly headRefHash: string;\n  readonly headRefInvariants: readonly string[];\n  readonly migrations: HydratedMigrationGraph;\n}\n\n/**\n * Hydrate a {@link ContractSpaceAggregate} from on-disk state and\n * the app contract value the caller supplies.\n *\n * The loader is the **only** descriptor-import boundary at apply /\n * verify time, but it intentionally does **not** read the extension\n * descriptor's `contractJson` value. Each extension space's contract\n * is read from its on-disk `migrations/<id>/contract.json` mirror; the\n * descriptor's role is exhausted by the seed phase that wrote that\n * mirror in the first place. The loader composes existing\n * migration-tools primitives — layout precheck (via\n * {@link listContractSpaceDirectories}), integrity checks (via\n * {@link readMigrationsDir} / {@link readContractSpaceHeadRef} /\n * {@link readContractSpaceContract} / `validateContract`), and\n * disjointness — into a single typed value.\n *\n * Failure semantics: every failure variant in {@link LoadAggregateError}\n * short-circuits the load.\n */\nexport async function loadContractSpaceAggregate(\n  input: LoadAggregateInput,\n): Promise<LoadAggregateOutput> {\n  // 1. Validate target consistency on the app contract.\n  const appContractTarget = input.appContract.target;\n  if (appContractTarget !== input.targetId) {\n    return notOk({\n      kind: 'targetMismatch',\n      spaceId: APP_SPACE_ID,\n      expected: input.targetId,\n      actual: appContractTarget,\n    });\n  }\n\n  for (const entry of input.declaredExtensions) {\n    if (entry.targetId !== input.targetId) {\n      return notOk({\n        kind: 'targetMismatch',\n        spaceId: entry.id,\n        expected: input.targetId,\n        actual: entry.targetId,\n      });\n    }\n  }\n\n  // 2. Layout precheck: bundle every layout offence at once.\n  //\n  // Every declared extension contributes an entry to the aggregate when\n  // a corresponding `migrations/<id>/` directory exists on disk. The\n  // loader treats the directory's presence as the membership signal —\n  // the descriptor itself is not read — so codec-only extensions (no\n  // on-disk dir) and contract-space extensions (dir present) are\n  // distinguished structurally.\n  const declaredSpaceIds = new Set(input.declaredExtensions.map((e) => e.id));\n  const allDirs = await listContractSpaceDirectories(input.migrationsDir);\n  // The app member is implicitly declared (it is always part of the\n  // aggregate); its `migrations/<APP_SPACE_ID>/` directory may exist or\n  // not (greenfield projects start with neither). Filter it out of the\n  // orphan / declared-but-unmigrated checks so the layout precheck is\n  // about extensions only.\n  const extensionDirsOnDisk = allDirs.filter((d) => d !== APP_SPACE_ID);\n  const spaceDirSet = new Set(extensionDirsOnDisk);\n\n  const layoutViolations: LayoutViolation[] = [];\n  for (const dir of extensionDirsOnDisk) {\n    if (!declaredSpaceIds.has(dir)) {\n      layoutViolations.push({ kind: 'orphanSpaceDir', spaceId: dir });\n    }\n  }\n  for (const id of [...declaredSpaceIds].sort()) {\n    if (!spaceDirSet.has(id)) {\n      layoutViolations.push({ kind: 'declaredButUnmigrated', spaceId: id });\n    }\n  }\n  if (layoutViolations.length > 0) {\n    return notOk({ kind: 'layoutViolation', violations: layoutViolations });\n  }\n\n  // 3-5. Per-extension: read + validate + integrity-check.\n  const loadedExtensions: LoadedExtensionState[] = [];\n  for (const entry of [...input.declaredExtensions].sort((a, b) => a.id.localeCompare(b.id))) {\n    const headRef = await readContractSpaceHeadRef(input.migrationsDir, entry.id);\n    if (headRef === null) {\n      return notOk({\n        kind: 'integrityFailure',\n        spaceId: entry.id,\n        detail: `Head ref \\`refs/head.json\\` is missing for extension space \"${entry.id}\".`,\n      });\n    }\n\n    let spaceContractRaw: unknown;\n    try {\n      spaceContractRaw = await readContractSpaceContract(input.migrationsDir, entry.id);\n    } catch (error) {\n      return notOk({\n        kind: 'integrityFailure',\n        spaceId: entry.id,\n        detail: error instanceof Error ? error.message : String(error),\n      });\n    }\n\n    let spaceContract: Contract;\n    try {\n      spaceContract = input.validateContract(spaceContractRaw);\n    } catch (error) {\n      return notOk({\n        kind: 'validationFailure',\n        spaceId: entry.id,\n        detail: error instanceof Error ? error.message : String(error),\n      });\n    }\n\n    if (spaceContract.target !== input.targetId) {\n      return notOk({\n        kind: 'targetMismatch',\n        spaceId: entry.id,\n        expected: input.targetId,\n        actual: spaceContract.target,\n      });\n    }\n\n    // Read + integrity-check the migration packages. `readMigrationsDir`\n    // re-derives `providedInvariants` and verifies migrationHash for\n    // every package.\n    let packages: readonly OnDiskMigrationPackage[];\n    try {\n      packages = await readMigrationsDir(spaceMigrationDirectory(input.migrationsDir, entry.id));\n    } catch (error) {\n      return notOk({\n        kind: 'integrityFailure',\n        spaceId: entry.id,\n        detail: error instanceof Error ? error.message : String(error),\n      });\n    }\n\n    let graph: ReturnType<typeof reconstructGraph>;\n    try {\n      graph = reconstructGraph(packages);\n    } catch (error) {\n      return notOk({\n        kind: 'integrityFailure',\n        spaceId: entry.id,\n        detail: error instanceof Error ? error.message : String(error),\n      });\n    }\n\n    // The on-disk head ref must be reachable in the graph. Empty graphs\n    // are tolerated only when the head ref points at the empty-contract\n    // sentinel (a never-emitted extension space; not a typical scenario\n    // because the layout precheck would have flagged the missing\n    // dir, but defensible).\n    if (graph.nodes.size === 0) {\n      if (headRef.hash !== EMPTY_CONTRACT_HASH) {\n        return notOk({\n          kind: 'integrityFailure',\n          spaceId: entry.id,\n          detail: `Head ref \"${headRef.hash}\" is not present in the (empty) on-disk migration graph.`,\n        });\n      }\n    } else if (!graph.nodes.has(headRef.hash)) {\n      return notOk({\n        kind: 'integrityFailure',\n        spaceId: entry.id,\n        detail: `Head ref \"${headRef.hash}\" is not present in the on-disk migration graph.`,\n      });\n    }\n\n    const packagesByMigrationHash = new Map<string, OnDiskMigrationPackage>(\n      packages.map((p) => [p.metadata.migrationHash, p]),\n    );\n\n    loadedExtensions.push({\n      entry,\n      contract: spaceContract,\n      headRefHash: headRef.hash,\n      headRefInvariants: [...headRef.invariants].sort(),\n      migrations: { graph, packagesByMigrationHash },\n    });\n  }\n\n  // 6. Build app member with hydrated graph from caller-supplied packages.\n  let appGraph: ReturnType<typeof reconstructGraph>;\n  try {\n    appGraph = reconstructGraph(input.appMigrationPackages);\n  } catch (error) {\n    return notOk({\n      kind: 'integrityFailure',\n      spaceId: APP_SPACE_ID,\n      detail: error instanceof Error ? error.message : String(error),\n    });\n  }\n  const appPackagesByMigrationHash = new Map<string, OnDiskMigrationPackage>(\n    input.appMigrationPackages.map((p) => [p.metadata.migrationHash, p]),\n  );\n\n  const appMember: ContractSpaceMember = {\n    spaceId: APP_SPACE_ID,\n    contract: input.appContract,\n    headRef: {\n      hash: input.appContract.storage.storageHash,\n      invariants: [],\n    },\n    migrations: {\n      graph: appGraph,\n      packagesByMigrationHash: appPackagesByMigrationHash,\n    },\n  };\n\n  const extensionMembers: ContractSpaceMember[] = loadedExtensions.map((s) => ({\n    spaceId: s.entry.id,\n    contract: s.contract,\n    headRef: {\n      hash: s.headRefHash,\n      invariants: s.headRefInvariants,\n    },\n    migrations: s.migrations,\n  }));\n\n  // 7. Disjointness: no two members claim the same storage element.\n  const elementClaimedBy = new Map<string, string[]>();\n  for (const member of [appMember, ...extensionMembers]) {\n    const tables = extractTableNames(member.contract);\n    for (const tableName of tables) {\n      const claimers = elementClaimedBy.get(tableName);\n      if (claimers) claimers.push(member.spaceId);\n      else elementClaimedBy.set(tableName, [member.spaceId]);\n    }\n  }\n  for (const [element, claimedBy] of elementClaimedBy) {\n    if (claimedBy.length > 1) {\n      return notOk({\n        kind: 'disjointnessViolation',\n        element,\n        claimedBy: [...claimedBy].sort(),\n      });\n    }\n  }\n\n  return ok({\n    aggregate: {\n      targetId: input.targetId,\n      app: appMember,\n      extensions: extensionMembers,\n    },\n  });\n}\n\n/**\n * Extract the set of top-level storage table names from a contract.\n * Duck-typed: returns `[]` if the contract's storage shape doesn't\n * match the canonical `storage.tables: Record<string, ...>` form. A\n * future family with a different storage shape gets disjointness\n * effectively disabled (not enforced) rather than a hard failure.\n */\nfunction extractTableNames(contract: Contract): readonly string[] {\n  const storage = (contract as { readonly storage?: unknown }).storage;\n  if (typeof storage !== 'object' || storage === null) return [];\n  const tables = (storage as { readonly tables?: unknown }).tables;\n  if (typeof tables !== 'object' || tables === null) return [];\n  return Object.keys(tables as Record<string, unknown>);\n}\n","import type { Contract } from '@prisma-next/contract/types';\nimport type { MigrationPlan } from '@prisma-next/framework-components/control';\nimport { EMPTY_CONTRACT_HASH } from '../../constants';\nimport { findPathWithDecision } from '../../migration-graph';\nimport type { MigrationOps } from '../../package';\nimport type { ContractMarkerRecordLike } from '../marker-types';\nimport type { AggregatePerSpacePlan } from '../planner-types';\nimport type { ContractSpaceMember } from '../types';\n\n/**\n * Outcome variants for the graph-walk strategy. Mirrors\n * {@link import('../../compute-extension-space-apply-path').ExtensionSpaceApplyPathOutcome}\n * but operates against the **already-hydrated** `member.migrations.graph`\n * instead of re-reading from disk. The aggregate planner converts\n * these into {@link import('../planner-types').AggregatePlannerError}\n * variants.\n */\nexport type GraphWalkOutcome =\n  | { readonly kind: 'ok'; readonly result: AggregatePerSpacePlan }\n  | { readonly kind: 'unreachable' }\n  | { readonly kind: 'unsatisfiable'; readonly missing: readonly string[] };\n\nexport interface GraphWalkStrategyInputs {\n  readonly aggregateTargetId: string;\n  readonly member: ContractSpaceMember;\n  readonly currentMarker: ContractMarkerRecordLike | null;\n  /**\n   * Optional ref name to decorate the resulting `PathDecision`. Used by\n   * `migration apply` to surface the user-supplied `--ref <name>` in\n   * structured-progress events and invariant-path error envelopes. The\n   * strategy itself does not interpret it.\n   */\n  readonly refName?: string;\n}\n\n/**\n * Walk a member's hydrated migration graph from the live marker to\n * `member.headRef.hash`, covering every required invariant.\n *\n * Pure synchronous function — no I/O. The aggregate's loader has\n * already integrity-checked every package and reconstructed the graph;\n * this strategy just looks up ops by `migrationHash` and assembles a\n * `MigrationPlan` with `targetId` set from the aggregate (no\n * placeholder cast).\n *\n * Required invariants are computed as `headRef.invariants \\ marker.invariants`\n * — the marker already declares some invariants satisfied; the path\n * only needs to provide the remainder. Mirrors today's\n * `computeExtensionSpaceApplyPath` semantics.\n */\nexport function graphWalkStrategy(input: GraphWalkStrategyInputs): GraphWalkOutcome {\n  const { aggregateTargetId, member, currentMarker, refName } = input;\n  const { graph, packagesByMigrationHash } = member.migrations;\n\n  const fromHash = currentMarker?.storageHash ?? EMPTY_CONTRACT_HASH;\n  const markerInvariants = new Set(currentMarker?.invariants ?? []);\n  const required = new Set(member.headRef.invariants.filter((id) => !markerInvariants.has(id)));\n\n  const outcome = findPathWithDecision(graph, fromHash, member.headRef.hash, {\n    required,\n    ...(refName !== undefined ? { refName } : {}),\n  });\n\n  if (outcome.kind === 'unreachable') {\n    return { kind: 'unreachable' };\n  }\n  if (outcome.kind === 'unsatisfiable') {\n    return { kind: 'unsatisfiable', missing: outcome.missing };\n  }\n\n  const pathOps: MigrationOps[number][] = [];\n  const providedInvariantsSet = new Set<string>();\n  const edgeRefs: Array<{\n    migrationHash: string;\n    dirName: string;\n    from: string;\n    to: string;\n    operationCount: number;\n  }> = [];\n  for (const edge of outcome.decision.selectedPath) {\n    const pkg = packagesByMigrationHash.get(edge.migrationHash);\n    if (!pkg) {\n      throw new Error(\n        `Migration package missing for edge ${edge.migrationHash} in space \"${member.spaceId}\". The hydrated migration graph and packagesByMigrationHash map are out of sync — this should be unreachable; report.`,\n      );\n    }\n    for (const op of pkg.ops) pathOps.push(op);\n    for (const invariant of pkg.metadata.providedInvariants) providedInvariantsSet.add(invariant);\n    edgeRefs.push({\n      migrationHash: edge.migrationHash,\n      dirName: edge.dirName,\n      from: edge.from,\n      to: edge.to,\n      operationCount: pkg.ops.length,\n    });\n  }\n\n  const plan: MigrationPlan = {\n    targetId: aggregateTargetId,\n    spaceId: member.spaceId,\n    origin: currentMarker === null ? null : { storageHash: currentMarker.storageHash },\n    destination: { storageHash: member.headRef.hash },\n    operations: pathOps,\n    providedInvariants: [...providedInvariantsSet].sort(),\n  };\n\n  return {\n    kind: 'ok',\n    result: {\n      plan,\n      displayOps: pathOps,\n      destinationContract: member.contract as Contract,\n      strategy: 'graph-walk',\n      migrationEdges: edgeRefs,\n      pathDecision: outcome.decision,\n    },\n  };\n}\n","import type { ContractSpaceMember } from './types';\n\n/**\n * Project the introspected live schema to the slice claimed by a single\n * contract-space member.\n *\n * Returns the same `schema` value with every top-level table claimed by\n * **other** members of the aggregate removed. Tables not claimed by any\n * member flow through unchanged — the planner / verifier sees them as\n * orphans (extras in strict mode).\n *\n * Used by:\n *\n * - The aggregate planner's **synth strategy**: when synthesising a\n *   plan against a member's contract, the live schema must be projected\n *   to that member's slice so the planner doesn't treat tables claimed\n *   by other members as \"extras\" and emit destructive ops to drop\n *   them.\n * - The aggregate verifier's **schemaCheck**: projects per member so the\n *   single-contract `verifySqlSchema` only sees the slice claimed by\n *   the member it is checking. Closes the F23 architectural concern\n *   (multi-member deployments where each member's tables look like\n *   extras to every other member's verify pass).\n *\n * **Duck-typing semantics**: the helper operates on `unknown` for the\n * schema and falls through structurally if the shape doesn't match.\n * Every family today exposes `storage.tables: Record<string, ...>` and\n * the introspected schema mirrors the same shape; a future family with\n * a different storage shape gets the schema returned unchanged rather\n * than blowing up the aggregate planner.\n */\nexport function projectSchemaToSpace(\n  schema: unknown,\n  member: ContractSpaceMember,\n  otherMembers: ReadonlyArray<ContractSpaceMember>,\n): unknown {\n  if (typeof schema !== 'object' || schema === null) return schema;\n  const schemaObj = schema as { readonly tables?: unknown };\n  if (typeof schemaObj.tables !== 'object' || schemaObj.tables === null) return schema;\n  const schemaTables = schemaObj.tables as Record<string, unknown>;\n\n  const ownedByOthers = new Set<string>();\n  for (const other of otherMembers) {\n    if (other.spaceId === member.spaceId) continue;\n    const storage = (other.contract as { readonly storage?: unknown }).storage;\n    if (typeof storage !== 'object' || storage === null) continue;\n    const tables = (storage as { readonly tables?: unknown }).tables;\n    if (typeof tables !== 'object' || tables === null) continue;\n    for (const tableName of Object.keys(tables as Record<string, unknown>)) {\n      ownedByOthers.add(tableName);\n    }\n  }\n\n  if (ownedByOthers.size === 0) return schema;\n\n  const prunedTables: Record<string, unknown> = {};\n  for (const [name, table] of Object.entries(schemaTables)) {\n    if (!ownedByOthers.has(name)) {\n      prunedTables[name] = table;\n    }\n  }\n\n  return { ...schemaObj, tables: prunedTables };\n}\n","import type { Contract } from '@prisma-next/contract/types';\nimport type { TargetBoundComponentDescriptor } from '@prisma-next/framework-components/components';\nimport type {\n  ControlFamilyInstance,\n  MigrationOperationPolicy,\n  MigrationPlan,\n  MigrationPlannerConflict,\n  MigrationPlannerResult,\n  TargetMigrationsCapability,\n} from '@prisma-next/framework-components/control';\nimport type { AggregatePerSpacePlan } from '../planner-types';\nimport { projectSchemaToSpace } from '../project-schema-to-space';\nimport type { ContractSpaceMember } from '../types';\n\nexport interface SynthStrategyInputs<TFamilyId extends string, TTargetId extends string> {\n  readonly aggregateTargetId: string;\n  readonly member: ContractSpaceMember;\n  readonly otherMembers: ReadonlyArray<ContractSpaceMember>;\n  readonly schemaIntrospection: unknown;\n  readonly familyInstance: ControlFamilyInstance<TFamilyId, unknown>;\n  readonly migrations: TargetMigrationsCapability<\n    TFamilyId,\n    TTargetId,\n    ControlFamilyInstance<TFamilyId, unknown>\n  >;\n  readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<TFamilyId, TTargetId>>;\n  readonly operationPolicy: MigrationOperationPolicy;\n}\n\nexport type SynthStrategyOutcome =\n  | { readonly kind: 'ok'; readonly result: AggregatePerSpacePlan }\n  | { readonly kind: 'failure'; readonly conflicts: readonly MigrationPlannerConflict[] };\n\n/**\n * The {@link MigrationPlanner.plan} interface is declared as synchronous,\n * but historical and test fixture call sites have always invoked it\n * with `await` (see prior `db-apply-per-space.ts`). Tolerating a\n * Promise here keeps existing test mocks working without changing the\n * declared family SPI.\n */\ntype MaybeAsyncPlannerResult = MigrationPlannerResult | Promise<MigrationPlannerResult>;\n\n/**\n * Synthesise a migration plan for a single member by projecting the\n * live schema down to that member's claimed slice and delegating to\n * the family's `createPlanner(...).plan(...)`.\n *\n * Pre-projection (via {@link projectSchemaToSpace}) closes the F23\n * concern: without it, the family's planner sees other members'\n * tables as \"extras\" and emits destructive ops to drop them. With it,\n * the planner only sees the slice this member claims.\n *\n * The synthesised plan's `targetId` is set from `aggregateTargetId`\n * (the aggregate's ambient target). The family's planner does not\n * stamp `targetId` on the produced plan; the aggregate planner is\n * the single point that knows the target.\n *\n * Used by:\n *\n * - The app member by default (CLI policy\n *   `ignoreGraphFor: { app.spaceId }`).\n * - Any extension member whose `headRef.invariants` is empty (the\n *   strategy selector falls back to synth when graph-walk isn't\n *   required).\n */\nexport async function synthStrategy<TFamilyId extends string, TTargetId extends string>(\n  input: SynthStrategyInputs<TFamilyId, TTargetId>,\n): Promise<SynthStrategyOutcome> {\n  const projectedSchema = projectSchemaToSpace(\n    input.schemaIntrospection,\n    input.member,\n    input.otherMembers,\n  );\n\n  const planner = input.migrations.createPlanner(input.familyInstance);\n  const plannerResult: MigrationPlannerResult = await (planner.plan({\n    contract: input.member.contract,\n    schema: projectedSchema,\n    policy: input.operationPolicy,\n    fromContract: null,\n    frameworkComponents: input.frameworkComponents,\n    spaceId: input.member.spaceId,\n  }) as MaybeAsyncPlannerResult);\n\n  if (plannerResult.kind === 'failure') {\n    return { kind: 'failure', conflicts: plannerResult.conflicts };\n  }\n\n  const synthedPlan = plannerResult.plan;\n  // The family planner returns a class-instance-shaped plan whose\n  // `destination` / `operations` are accessors on the prototype, often\n  // backed by private fields. A naive spread (`{ ...synthedPlan }`)\n  // would lose those accessors and produce a plan with\n  // `destination: undefined`; rebinding the prototype on a plain\n  // object would break private-field access. We instead wrap the plan\n  // in a Proxy that forwards every read except `targetId`, which is\n  // stamped from the aggregate's ambient target. This preserves the\n  // planner's class semantics while keeping the aggregate the single\n  // source of truth for `targetId`.\n  const plan: MigrationPlan = new Proxy(synthedPlan, {\n    get(target, prop) {\n      if (prop === 'targetId') return input.aggregateTargetId;\n      // Forward `this` as the original target so prototype-bound\n      // private fields (#destination, #operations, …) resolve.\n      return Reflect.get(target, prop, target);\n    },\n    has(target, prop) {\n      if (prop === 'targetId') return true;\n      return Reflect.has(target, prop);\n    },\n  });\n\n  return {\n    kind: 'ok',\n    result: {\n      plan,\n      displayOps: synthedPlan.operations,\n      destinationContract: input.member.contract as Contract,\n      strategy: 'synth',\n    },\n  };\n}\n","import { notOk, ok } from '@prisma-next/utils/result';\nimport type {\n  AggregatePerSpacePlan,\n  AggregatePlannerError,\n  AggregatePlannerInput,\n  AggregatePlannerOutput,\n} from './planner-types';\nimport { graphWalkStrategy } from './strategies/graph-walk';\nimport { synthStrategy } from './strategies/synth';\nimport type { ContractSpaceMember } from './types';\n\nexport type {\n  AggregateCurrentDBState,\n  AggregateMigrationEdgeRef,\n  AggregatePerSpacePlan,\n  AggregatePlannerError,\n  AggregatePlannerInput,\n  AggregatePlannerOutput,\n  AggregatePlannerSuccess,\n  CallerPolicy,\n} from './planner-types';\n\n/**\n * Plan a migration across every member of a {@link ContractSpaceAggregate}.\n *\n * Strategy selection per member, in order; first match wins:\n *\n * 1. If `callerPolicy.ignoreGraphFor.has(member.spaceId)`:\n *    - If `member.headRef.invariants` is empty → synth.\n *    - Else → `policyConflict` (synth cannot satisfy authored invariants).\n * 2. Else if `member.migrations.graph` is non-empty AND graph-walk\n *    succeeds → graph-walk.\n * 3. Else if `member.headRef.invariants` is empty → synth.\n * 4. Else → graph-walk failure → `extensionPathUnreachable` /\n *    `extensionPathUnsatisfiable`.\n *\n * Output `applyOrder` is `[...aggregate.extensions.map(spaceId), aggregate.app.spaceId]`\n * — extensions alphabetical, then app — matching today's\n * `concatenateSpaceApplyInputs` ordering. This preserves\n * `MultiSpaceRunnerFailure.failingSpace` attribution byte-for-byte.\n *\n * Every emitted `MigrationPlan` has `targetId = aggregate.targetId`.\n * No placeholder cast; no patch step.\n */\nexport async function planAggregate<TFamilyId extends string, TTargetId extends string>(\n  input: AggregatePlannerInput<TFamilyId, TTargetId>,\n): Promise<AggregatePlannerOutput> {\n  const { aggregate, currentDBState, callerPolicy } = input;\n  const allMembers: ReadonlyArray<ContractSpaceMember> = [aggregate.app, ...aggregate.extensions];\n\n  const perSpace = new Map<string, AggregatePerSpacePlan>();\n\n  // Iterate in apply order so a per-member error short-circuits the\n  // walk in the same order the runner would walk inputs.\n  const orderedMembers: ReadonlyArray<ContractSpaceMember> = [\n    ...aggregate.extensions,\n    aggregate.app,\n  ];\n\n  for (const member of orderedMembers) {\n    const otherMembers = allMembers.filter((m) => m.spaceId !== member.spaceId);\n    const currentMarker = currentDBState.markersBySpaceId.get(member.spaceId) ?? null;\n\n    const ignoreGraph = callerPolicy.ignoreGraphFor.has(member.spaceId);\n    const invariantsRequired = member.headRef.invariants.length > 0;\n\n    if (ignoreGraph && invariantsRequired) {\n      const conflict: AggregatePlannerError = {\n        kind: 'policyConflict',\n        spaceId: member.spaceId,\n        detail: `\\`callerPolicy.ignoreGraphFor\\` requested for space \"${member.spaceId}\", but the member declares non-empty head-ref invariants (${member.headRef.invariants.join(', ')}). Synthesising a plan from the contract IR cannot satisfy authored invariants — the graph must be walked. Either remove \"${member.spaceId}\" from \\`ignoreGraphFor\\` or amend the on-disk head ref to declare zero invariants.`,\n      };\n      return notOk(conflict);\n    }\n\n    if (ignoreGraph) {\n      const synthOutcome = await synthStrategy({\n        aggregateTargetId: aggregate.targetId,\n        member,\n        otherMembers,\n        schemaIntrospection: currentDBState.schemaIntrospection,\n        familyInstance: input.familyInstance,\n        migrations: input.migrations,\n        frameworkComponents: input.frameworkComponents,\n        operationPolicy: input.operationPolicy,\n      });\n      if (synthOutcome.kind === 'failure') {\n        return notOk({\n          kind: 'appSynthFailure',\n          spaceId: member.spaceId,\n          conflicts: synthOutcome.conflicts,\n        });\n      }\n      perSpace.set(member.spaceId, synthOutcome.result);\n      continue;\n    }\n\n    // Try graph-walk first when the graph has nodes; fall back to synth\n    // when the graph is empty AND no invariants are required.\n    if (member.migrations.graph.nodes.size > 0) {\n      const walked = graphWalkStrategy({\n        aggregateTargetId: aggregate.targetId,\n        member,\n        currentMarker,\n      });\n      if (walked.kind === 'ok') {\n        perSpace.set(member.spaceId, walked.result);\n        continue;\n      }\n      if (walked.kind === 'unreachable') {\n        return notOk({\n          kind: 'extensionPathUnreachable',\n          spaceId: member.spaceId,\n          target: member.headRef.hash,\n        });\n      }\n      // unsatisfiable — surface\n      return notOk({\n        kind: 'extensionPathUnsatisfiable',\n        spaceId: member.spaceId,\n        missingInvariants: walked.missing,\n      });\n    }\n\n    // Empty graph: synth is the only option, and it can only satisfy\n    // empty-invariant members.\n    if (invariantsRequired) {\n      return notOk({\n        kind: 'extensionPathUnsatisfiable',\n        spaceId: member.spaceId,\n        missingInvariants: [...member.headRef.invariants].sort(),\n      });\n    }\n\n    const synthOutcome = await synthStrategy({\n      aggregateTargetId: aggregate.targetId,\n      member,\n      otherMembers,\n      schemaIntrospection: currentDBState.schemaIntrospection,\n      familyInstance: input.familyInstance,\n      migrations: input.migrations,\n      frameworkComponents: input.frameworkComponents,\n      operationPolicy: input.operationPolicy,\n    });\n    if (synthOutcome.kind === 'failure') {\n      return notOk({\n        kind: 'appSynthFailure',\n        spaceId: member.spaceId,\n        conflicts: synthOutcome.conflicts,\n      });\n    }\n    perSpace.set(member.spaceId, synthOutcome.result);\n  }\n\n  return ok({\n    perSpace,\n    applyOrder: [...aggregate.extensions.map((m) => m.spaceId), aggregate.app.spaceId],\n  });\n}\n","import type { Result } from '@prisma-next/utils/result';\nimport { notOk, ok } from '@prisma-next/utils/result';\nimport type { ContractMarkerRecordLike } from './marker-types';\nimport { projectSchemaToSpace } from './project-schema-to-space';\nimport type { ContractSpaceAggregate, ContractSpaceMember } from './types';\n\n/**\n * Caller policy for the aggregate verifier. Today's only knob is\n * `mode`: `strict` treats orphan elements (live tables not claimed by\n * any aggregate member) as errors; `lenient` treats them as\n * informational. Maps directly to `db verify --strict`.\n */\nexport interface AggregateVerifierInput<TSchemaResult> {\n  readonly aggregate: ContractSpaceAggregate;\n  readonly markersBySpaceId: ReadonlyMap<string, ContractMarkerRecordLike | null>;\n  readonly schemaIntrospection: unknown;\n  readonly mode: 'strict' | 'lenient';\n  /**\n   * Caller-supplied per-space schema verifier. The CLI wires this to\n   * the family's `verifySqlSchema` (SQL) / equivalent (other\n   * families). The aggregate verifier projects the schema to the\n   * member's slice via {@link projectSchemaToSpace} before invoking\n   * the callback, so single-contract semantics are preserved.\n   *\n   * Typed structurally with a generic `TSchemaResult` so the\n   * migration-tools layer doesn't depend on the SQL family's\n   * `VerifySqlSchemaResult`. CLI callers pass the family's type\n   * through unchanged.\n   */\n  readonly verifySchemaForMember: (\n    projectedSchema: unknown,\n    member: ContractSpaceMember,\n    mode: 'strict' | 'lenient',\n  ) => TSchemaResult;\n}\n\n/**\n * Marker-check result per member. Mirrors the four cases the\n * `verifyContractSpaces` primitive surfaces today, plus an `'absent'`\n * case for greenfield spaces (no marker row written yet — `db init`\n * not run).\n */\nexport type MarkerCheckResult =\n  | { readonly kind: 'ok' }\n  | { readonly kind: 'absent' }\n  | {\n      readonly kind: 'hashMismatch';\n      readonly markerHash: string;\n      readonly expected: string;\n    }\n  | { readonly kind: 'missingInvariants'; readonly missing: readonly string[] };\n\nexport interface MarkerCheckSection {\n  readonly perSpace: ReadonlyMap<string, MarkerCheckResult>;\n  readonly orphanMarkers: readonly {\n    readonly spaceId: string;\n    readonly row: ContractMarkerRecordLike;\n  }[];\n}\n\n/**\n * A live storage element (today: a top-level table) not claimed by any\n * member of the aggregate. The aggregate verifier always reports these;\n * the caller decides what to do — `db verify --strict` treats them as\n * errors, the lenient default treats them as informational.\n *\n * Today only `kind: 'table'` exists. The discriminated shape leaves\n * room for orphan columns / indexes / sequences in the future without\n * breaking the type contract.\n */\nexport type OrphanElement = { readonly kind: 'table'; readonly name: string };\n\nexport interface SchemaCheckSection<TSchemaResult> {\n  readonly perSpace: ReadonlyMap<string, TSchemaResult>;\n  /**\n   * Live elements present in the introspected schema that are not\n   * claimed by **any** aggregate member. Sorted alphabetically by name.\n   */\n  readonly orphanElements: readonly OrphanElement[];\n}\n\nexport interface AggregateVerifierSuccess<TSchemaResult> {\n  readonly markerCheck: MarkerCheckSection;\n  readonly schemaCheck: SchemaCheckSection<TSchemaResult>;\n}\n\nexport type AggregateVerifierError = {\n  readonly kind: 'introspectionFailure';\n  readonly detail: string;\n};\n\nexport type AggregateVerifierOutput<TSchemaResult> = Result<\n  AggregateVerifierSuccess<TSchemaResult>,\n  AggregateVerifierError\n>;\n\n/**\n * Verify a {@link ContractSpaceAggregate} against the live database\n * state. Bundles two checks:\n *\n * - `markerCheck` per member: compare the live marker row against the\n *   member's `headRef.hash` + `headRef.invariants`. Absence is a\n *   distinct kind, not an error (callers — `db verify` strict vs\n *   `db init` precondition — choose how to interpret it).\n * - `schemaCheck` per member: project the live schema to the slice\n *   the member claims via {@link projectSchemaToSpace}, then delegate\n *   to the caller-supplied `verifySchemaForMember`. The pre-projection\n *   means the family's single-contract verifier no longer sees other\n *   members' tables as `extras`, so a multi-member deployment never\n *   surfaces cross-member tables as orphaned schema elements.\n *\n * `markerCheck.orphanMarkers` lists every marker row whose `space` is\n * not a member of the aggregate. `db verify` callers reject orphans;\n * future tooling may not.\n *\n * Pure synchronous function; no I/O. The caller (CLI) gathers\n * `markersBySpaceId` and `schemaIntrospection` ahead of the call.\n */\nexport function verifyAggregate<TSchemaResult>(\n  input: AggregateVerifierInput<TSchemaResult>,\n): AggregateVerifierOutput<TSchemaResult> {\n  try {\n    return runVerifyAggregate(input);\n  } catch (error) {\n    return notOk({\n      kind: 'introspectionFailure',\n      detail: error instanceof Error ? error.message : String(error),\n    });\n  }\n}\n\nfunction runVerifyAggregate<TSchemaResult>(\n  input: AggregateVerifierInput<TSchemaResult>,\n): AggregateVerifierOutput<TSchemaResult> {\n  const { aggregate, markersBySpaceId, schemaIntrospection, mode, verifySchemaForMember } = input;\n  const allMembers: ReadonlyArray<ContractSpaceMember> = [aggregate.app, ...aggregate.extensions];\n  const memberSpaceIds = new Set(allMembers.map((m) => m.spaceId));\n\n  // Marker check per member.\n  const markerPerSpace = new Map<string, MarkerCheckResult>();\n  for (const member of allMembers) {\n    const marker = markersBySpaceId.get(member.spaceId) ?? null;\n    if (marker === null) {\n      markerPerSpace.set(member.spaceId, { kind: 'absent' });\n      continue;\n    }\n    if (marker.storageHash !== member.headRef.hash) {\n      markerPerSpace.set(member.spaceId, {\n        kind: 'hashMismatch',\n        markerHash: marker.storageHash,\n        expected: member.headRef.hash,\n      });\n      continue;\n    }\n    const markerInvariants = new Set(marker.invariants);\n    const missing = member.headRef.invariants.filter((id) => !markerInvariants.has(id));\n    if (missing.length > 0) {\n      markerPerSpace.set(member.spaceId, {\n        kind: 'missingInvariants',\n        missing: [...missing].sort(),\n      });\n      continue;\n    }\n    markerPerSpace.set(member.spaceId, { kind: 'ok' });\n  }\n\n  // Orphan markers: entries in markersBySpaceId whose spaceId is not a\n  // member of the aggregate.\n  const orphanMarkers: { spaceId: string; row: ContractMarkerRecordLike }[] = [];\n  for (const [spaceId, row] of markersBySpaceId) {\n    if (row !== null && !memberSpaceIds.has(spaceId)) {\n      orphanMarkers.push({ spaceId, row });\n    }\n  }\n  orphanMarkers.sort((a, b) => a.spaceId.localeCompare(b.spaceId));\n\n  // Schema check per member (with per-space pre-projection).\n  const schemaPerSpace = new Map<string, TSchemaResult>();\n  for (const member of allMembers) {\n    const others = allMembers.filter((m) => m.spaceId !== member.spaceId);\n    const projected = projectSchemaToSpace(schemaIntrospection, member, others);\n    schemaPerSpace.set(member.spaceId, verifySchemaForMember(projected, member, mode));\n  }\n\n  return ok({\n    markerCheck: {\n      perSpace: markerPerSpace,\n      orphanMarkers,\n    },\n    schemaCheck: {\n      perSpace: schemaPerSpace,\n      orphanElements: detectOrphanElements(schemaIntrospection, allMembers),\n    },\n  });\n}\n\n/**\n * Live tables not claimed by any aggregate member. Duck-typed against\n * the introspected schema's `tables` map; schemas whose shape doesn't\n * match return an empty list (consistent with\n * {@link projectSchemaToSpace}'s fall-through).\n */\nfunction detectOrphanElements(\n  schemaIntrospection: unknown,\n  members: ReadonlyArray<ContractSpaceMember>,\n): readonly OrphanElement[] {\n  if (typeof schemaIntrospection !== 'object' || schemaIntrospection === null) return [];\n  const liveTables = (schemaIntrospection as { readonly tables?: unknown }).tables;\n  if (typeof liveTables !== 'object' || liveTables === null) return [];\n\n  const claimedTables = new Set<string>();\n  for (const member of members) {\n    const storage = (member.contract as { readonly storage?: unknown }).storage;\n    if (typeof storage !== 'object' || storage === null) continue;\n    const tables = (storage as { readonly tables?: unknown }).tables;\n    if (typeof tables !== 'object' || tables === null) continue;\n    for (const tableName of Object.keys(tables as Record<string, unknown>)) {\n      claimedTables.add(tableName);\n    }\n  }\n\n  const orphans: OrphanElement[] = [];\n  for (const tableName of Object.keys(liveTables as Record<string, unknown>)) {\n    if (!claimedTables.has(tableName)) {\n      orphans.push({ kind: 'table', name: tableName });\n    }\n  }\n  orphans.sort((a, b) => a.name.localeCompare(b.name));\n  return orphans;\n}\n"],"mappings":"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"}

package/dist/exports/invariants.d.mts

@@ -27,6 +27,11 @@ declare function validateInvariantId(invariantId: string): boolean;
  *
  * Throws `MIGRATION.INVALID_INVARIANT_ID` on a malformed id and
  * `MIGRATION.DUPLICATE_INVARIANT_IN_EDGE` on duplicates.
+ *
+ * @see docs/architecture docs/adrs/ADR 212 - Contract spaces.md
+ *   — extension migrations carry `invariantId`s on additive ops; e.g.
+ *   cipherstash's `installEqlBundle` and structural `create-*` ops are
+ *   additive-class but carry `cipherstash:*` invariantIds.
  */
 declare function deriveProvidedInvariants(ops: MigrationOps): readonly string[];
 //#endregion

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

@@ -1 +1 @@
-{"version":3,"file":"invariants.d.mts","names":[],"sources":["../../src/invariants.ts"],"mappings":";;;;;AAUA;;;;iBAAgB,mBAAA,CAAoB,WAAA;AAyBpC;;;;;;;;;;;;;;;;;;;;AAAA,iBAAgB,wBAAA,CAAyB,GAAA,EAAK,YAAA"}
+{"version":3,"file":"invariants.d.mts","names":[],"sources":["../../src/invariants.ts"],"mappings":";;;;;AAUA;;;;iBAAgB,mBAAA,CAAoB,WAAA;AA8BpC;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,iBAAgB,wBAAA,CAAyB,GAAA,EAAK,YAAA"}

package/dist/exports/invariants.mjs

@@ -1,2 +1,2 @@
-import { n as validateInvariantId, t as deriveProvidedInvariants } from "../invariants-Duc8f9NM.mjs";
+import { n as validateInvariantId, t as deriveProvidedInvariants } from "../invariants-qgQGlsrV.mjs";
 export { deriveProvidedInvariants, validateInvariantId };

package/dist/exports/io.mjs

@@ -1,2 +1,2 @@
-import { a as materialiseMigrationPackage, c as writeMigrationMetadata, i as materialiseExtensionMigrationPackageIfMissing, l as writeMigrationOps, n as copyFilesWithRename, o as readMigrationPackage, r as formatMigrationDirName, s as readMigrationsDir, u as writeMigrationPackage } from "../io-D13dLvUh.mjs";
+import { a as materialiseMigrationPackage, c as writeMigrationMetadata, i as materialiseExtensionMigrationPackageIfMissing, l as writeMigrationOps, n as copyFilesWithRename, o as readMigrationPackage, r as formatMigrationDirName, s as readMigrationsDir, u as writeMigrationPackage } from "../io-D5YYptRO.mjs";
 export { copyFilesWithRename, formatMigrationDirName, materialiseExtensionMigrationPackageIfMissing, materialiseMigrationPackage, readMigrationPackage, readMigrationsDir, writeMigrationMetadata, writeMigrationOps, writeMigrationPackage };

package/dist/exports/migration.mjs

@@ -1,6 +1,6 @@
 import { T as errorStaleContractBookends, f as errorInvalidOperationEntry } from "../errors-EPL_9p9f.mjs";
 import { t as computeMigrationHash } from "../hash-By50zM_E.mjs";
-import { t as deriveProvidedInvariants } from "../invariants-Duc8f9NM.mjs";
+import { t as deriveProvidedInvariants } from "../invariants-qgQGlsrV.mjs";
 import { t as MigrationOpSchema } from "../op-schema-D5qkXfEf.mjs";
 import { ifDefined } from "@prisma-next/utils/defined";
 import { type } from "arktype";