@prisma-next/migration-tools 0.6.0-dev.13 → 0.6.0-dev.14

package/dist/exports/aggregate.d.mts

@@ -412,33 +412,58 @@ declare function planAggregate<TFamilyId extends string, TTargetId extends strin
 //#endregion
 //#region src/aggregate/project-schema-to-space.d.ts
 /**
- * Project the introspected live schema to the slice claimed by a single
- * contract-space member.
- *
- * Returns the same `schema` value with every top-level table claimed by
- * **other** members of the aggregate removed. Tables not claimed by any
- * member flow through unchanged — the planner / verifier sees them as
- * orphans (extras in strict mode).
+ * Project the **introspected live schema** to the slice claimed by a
+ * single contract-space member.
+ *
+ * "Schema" here means the live introspected database state — the
+ * planner / verifier sees this object as a `MongoSchemaIR` (Mongo) or
+ * `SqlSchemaIR` (SQL). It is **not** a database schema in the SQL
+ * `CREATE SCHEMA` sense, nor a contract-space namespace. The
+ * function's job is to filter that introspected state down to the
+ * elements claimed by one space, so a per-space verify pass doesn't
+ * see another space's storage as "extras".
+ *
+ * Returns the same `schema` value with every top-level storage element
+ * (table or collection) claimed by **other** members of the aggregate
+ * removed. Elements not claimed by any member flow through unchanged —
+ * the planner / verifier sees them as orphans (extras in strict mode).
  *
  * Used by:
  *
  * - The aggregate planner's **synth strategy**: when synthesising a
  *   plan against a member's contract, the live schema must be projected
- *   to that member's slice so the planner doesn't treat tables claimed
- *   by other members as "extras" and emit destructive ops to drop
- *   them.
+ *   to that member's slice so the planner doesn't treat elements claimed
+ *   by other members as "extras" and emit destructive ops to drop them.
  * - The aggregate verifier's **schemaCheck**: projects per member so the
- *   single-contract `verifySqlSchema` only sees the slice claimed by
- *   the member it is checking. Closes the F23 architectural concern
- *   (multi-member deployments where each member's tables look like
- *   extras to every other member's verify pass).
+ *   single-contract verify only sees the slice claimed by the member it
+ *   is checking. Closes the architectural concern that a multi-member
+ *   deployment makes each member's elements look like extras to every
+ *   other member's verify pass.
  *
  * **Duck-typing semantics**: the helper operates on `unknown` for the
  * schema and falls through structurally if the shape doesn't match.
- * Every family today exposes `storage.tables: Record<string, ...>` and
- * the introspected schema mirrors the same shape; a future family with
- * a different storage shape gets the schema returned unchanged rather
- * than blowing up the aggregate planner.
+ * Two storage shapes are recognised today:
+ *
+ * - SQL families expose `storage.tables: Record<string, ...>` on
+ *   contracts and the introspected schema mirrors the same record shape.
+ *   Pruning iterates the record entries.
+ * - Mongo exposes `storage.collections: Record<string, ...>` on
+ *   contracts; the introspected `MongoSchemaIR` exposes
+ *   `collections: ReadonlyArray<{name: string, ...}>`. Pruning iterates
+ *   the array on the schema side and the record's keys on the
+ *   other-member side.
+ *
+ * Schemas of unrecognised shape are returned unchanged. The function
+ * never imports family classes (`SqlSchemaIR`, `MongoSchemaIR`); the
+ * projected schema is a plain object — `{...schema, tables: pruned}` or
+ * `{...schema, collections: pruned}` — that downstream consumers
+ * duck-type. A future family with a different storage shape gets the
+ * schema returned unchanged rather than blowing up the aggregate
+ * planner.
+ *
+ * Record-shape detection guards against arrays (`!Array.isArray`) so
+ * an unrecognised array-shaped value falls through unchanged rather
+ * than being pruned by numeric keys.
  */
 declare function projectSchemaToSpace(schema: unknown, member: ContractSpaceMember, otherMembers: ReadonlyArray<ContractSpaceMember>): unknown;
 //#endregion

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

@@ -3,6 +3,55 @@ import "../constants-DWV9_o2Z.mjs";
 import { l as reconstructGraph, o as findPathWithDecision } from "../migration-graph-DGNnKDY5.mjs";
 import { a as APP_SPACE_ID, c as spaceMigrationDirectory, i as readContractSpaceHeadRef, n as listContractSpaceDirectories, t as readContractSpaceContract } from "../read-contract-space-contract-BfN6Uk_v.mjs";
 import { notOk, ok } from "@prisma-next/utils/result";
+//#region src/aggregate/extract-storage-element-names.ts
+/**
+* Extract the set of top-level storage element names a contract claims.
+*
+* Used by the aggregate loader's disjointness check and by
+* `projectSchemaToSpace`'s "names owned by other members" walk.
+*
+* **Stopgap — known layering violation.** This helper duck-types the
+* storage shape (`storage.tables` for SQL families, `storage.collections`
+* for Mongo) from framework-domain code that has no business naming
+* family-specific storage idioms. The framework lacks a typed primitive
+* for storage *topology* — the structural backbone of "what named things
+* does this contract claim?" independent of what those things are.
+*
+* The correct fix introduces that primitive at the framework level
+* (`interface Storage { readonly namespaces: Record<string, Namespace> }`
+* and friends), with each family's storage type required to conform.
+* That work is scoped in TML-2459 (target-extensible-ir), which will
+* remove this duck-typed walk when the IR class flip rebases onto this
+* PR. Landing an interim typed shape here would create a third on-disk
+* shape that TML-2459 would have to migrate away from again, opening a
+* dual-shape transition window that TML-2459 explicitly rules out.
+*
+* Behavioural notes for the lifetime of this helper:
+*
+* - Both `tables` and `collections` are unioned (a hypothetical
+*   cross-family contract exposing both would contribute both sets).
+* - Unrecognised storage shapes return an empty set, so a future family
+*   with a different layout silently disables disjointness rather than
+*   hard-failing. This is a stopgap default; the typed `Storage` shape
+*   in TML-2459 will replace it with a compile-time guarantee.
+* - Record-shape detection excludes arrays so array-shaped values aren't
+*   walked as records via numeric keys.
+* - Names that appear in both `tables` and `collections` are deduplicated
+*   by the returned `Set`.
+*/
+function extractStorageElementNames(contract) {
+	const names = /* @__PURE__ */ new Set();
+	if (typeof contract !== "object" || contract === null) return names;
+	const storage = contract.storage;
+	if (typeof storage !== "object" || storage === null) return names;
+	const storageObj = storage;
+	for (const field of ["tables", "collections"]) {
+		const value = storageObj[field];
+		if (typeof value === "object" && value !== null && !Array.isArray(value)) for (const name of Object.keys(value)) names.add(name);
+	}
+	return names;
+}
+//#endregion
 //#region src/aggregate/loader.ts
 /**
 * Hydrate a {@link ContractSpaceAggregate} from on-disk state and
@@ -164,11 +213,11 @@ async function loadContractSpaceAggregate(input) {
 	}));
 	const elementClaimedBy = /* @__PURE__ */ new Map();
 	for (const member of [appMember, ...extensionMembers]) {
-		const tables = extractTableNames(member.contract);
-		for (const tableName of tables) {
-			const claimers = elementClaimedBy.get(tableName);
+		const elements = extractStorageElementNames(member.contract);
+		for (const elementName of elements) {
+			const claimers = elementClaimedBy.get(elementName);
 			if (claimers) claimers.push(member.spaceId);
-			else elementClaimedBy.set(tableName, [member.spaceId]);
+			else elementClaimedBy.set(elementName, [member.spaceId]);
 		}
 	}
 	for (const [element, claimedBy] of elementClaimedBy) if (claimedBy.length > 1) return notOk({
@@ -182,20 +231,6 @@ async function loadContractSpaceAggregate(input) {
 		extensions: extensionMembers
 	} });
 }
-/**
-* Extract the set of top-level storage table names from a contract.
-* Duck-typed: returns `[]` if the contract's storage shape doesn't
-* match the canonical `storage.tables: Record<string, ...>` form. A
-* future family with a different storage shape gets disjointness
-* effectively disabled (not enforced) rather than a hard failure.
-*/
-function extractTableNames(contract) {
-	const storage = contract.storage;
-	if (typeof storage !== "object" || storage === null) return [];
-	const tables = storage.tables;
-	if (typeof tables !== "object" || tables === null) return [];
-	return Object.keys(tables);
-}
 //#endregion
 //#region src/aggregate/strategies/graph-walk.ts
 /**
@@ -266,54 +301,112 @@ function graphWalkStrategy(input) {
 //#endregion
 //#region src/aggregate/project-schema-to-space.ts
 /**
-* Project the introspected live schema to the slice claimed by a single
-* contract-space member.
+* Project the **introspected live schema** to the slice claimed by a
+* single contract-space member.
+*
+* "Schema" here means the live introspected database state — the
+* planner / verifier sees this object as a `MongoSchemaIR` (Mongo) or
+* `SqlSchemaIR` (SQL). It is **not** a database schema in the SQL
+* `CREATE SCHEMA` sense, nor a contract-space namespace. The
+* function's job is to filter that introspected state down to the
+* elements claimed by one space, so a per-space verify pass doesn't
+* see another space's storage as "extras".
 *
-* Returns the same `schema` value with every top-level table claimed by
-* **other** members of the aggregate removed. Tables not claimed by any
-* member flow through unchanged — the planner / verifier sees them as
-* orphans (extras in strict mode).
+* Returns the same `schema` value with every top-level storage element
+* (table or collection) claimed by **other** members of the aggregate
+* removed. Elements not claimed by any member flow through unchanged —
+* the planner / verifier sees them as orphans (extras in strict mode).
 *
 * Used by:
 *
 * - The aggregate planner's **synth strategy**: when synthesising a
 *   plan against a member's contract, the live schema must be projected
-*   to that member's slice so the planner doesn't treat tables claimed
-*   by other members as "extras" and emit destructive ops to drop
-*   them.
+*   to that member's slice so the planner doesn't treat elements claimed
+*   by other members as "extras" and emit destructive ops to drop them.
 * - The aggregate verifier's **schemaCheck**: projects per member so the
-*   single-contract `verifySqlSchema` only sees the slice claimed by
-*   the member it is checking. Closes the F23 architectural concern
-*   (multi-member deployments where each member's tables look like
-*   extras to every other member's verify pass).
+*   single-contract verify only sees the slice claimed by the member it
+*   is checking. Closes the architectural concern that a multi-member
+*   deployment makes each member's elements look like extras to every
+*   other member's verify pass.
 *
 * **Duck-typing semantics**: the helper operates on `unknown` for the
 * schema and falls through structurally if the shape doesn't match.
-* Every family today exposes `storage.tables: Record<string, ...>` and
-* the introspected schema mirrors the same shape; a future family with
-* a different storage shape gets the schema returned unchanged rather
-* than blowing up the aggregate planner.
+* Two storage shapes are recognised today:
+*
+* - SQL families expose `storage.tables: Record<string, ...>` on
+*   contracts and the introspected schema mirrors the same record shape.
+*   Pruning iterates the record entries.
+* - Mongo exposes `storage.collections: Record<string, ...>` on
+*   contracts; the introspected `MongoSchemaIR` exposes
+*   `collections: ReadonlyArray<{name: string, ...}>`. Pruning iterates
+*   the array on the schema side and the record's keys on the
+*   other-member side.
+*
+* Schemas of unrecognised shape are returned unchanged. The function
+* never imports family classes (`SqlSchemaIR`, `MongoSchemaIR`); the
+* projected schema is a plain object — `{...schema, tables: pruned}` or
+* `{...schema, collections: pruned}` — that downstream consumers
+* duck-type. A future family with a different storage shape gets the
+* schema returned unchanged rather than blowing up the aggregate
+* planner.
+*
+* Record-shape detection guards against arrays (`!Array.isArray`) so
+* an unrecognised array-shaped value falls through unchanged rather
+* than being pruned by numeric keys.
 */
 function projectSchemaToSpace(schema, member, otherMembers) {
 	if (typeof schema !== "object" || schema === null) return schema;
+	const ownedByOthers = collectOwnedNames(member, otherMembers);
+	if (ownedByOthers.size === 0) return schema;
 	const schemaObj = schema;
-	if (typeof schemaObj.tables !== "object" || schemaObj.tables === null) return schema;
-	const schemaTables = schemaObj.tables;
-	const ownedByOthers = /* @__PURE__ */ new Set();
+	if (typeof schemaObj.tables === "object" && schemaObj.tables !== null && !Array.isArray(schemaObj.tables)) return pruneRecord(schemaObj, "tables", ownedByOthers);
+	if (Array.isArray(schemaObj.collections)) return pruneCollectionsArray(schemaObj, ownedByOthers);
+	if (typeof schemaObj.collections === "object" && schemaObj.collections !== null && !Array.isArray(schemaObj.collections)) return pruneRecord(schemaObj, "collections", ownedByOthers);
+	return schema;
+}
+/**
+* Collect the set of storage element names claimed by other members.
+* Reuses the loader's `extractStorageElementNames` helper so the
+* tables/collections walk lives in exactly one place.
+*/
+function collectOwnedNames(member, otherMembers) {
+	const owned = /* @__PURE__ */ new Set();
 	for (const other of otherMembers) {
 		if (other.spaceId === member.spaceId) continue;
-		const storage = other.contract.storage;
-		if (typeof storage !== "object" || storage === null) continue;
-		const tables = storage.tables;
-		if (typeof tables !== "object" || tables === null) continue;
-		for (const tableName of Object.keys(tables)) ownedByOthers.add(tableName);
+		for (const name of extractStorageElementNames(other.contract)) owned.add(name);
 	}
-	if (ownedByOthers.size === 0) return schema;
-	const prunedTables = {};
-	for (const [name, table] of Object.entries(schemaTables)) if (!ownedByOthers.has(name)) prunedTables[name] = table;
+	return owned;
+}
+function pruneRecord(schemaObj, field, ownedByOthers) {
+	const source = schemaObj[field];
+	let removed = false;
+	const pruned = {};
+	for (const [name, value] of Object.entries(source)) if (ownedByOthers.has(name)) removed = true;
+	else pruned[name] = value;
+	if (!removed) return schemaObj;
+	return {
+		...schemaObj,
+		[field]: pruned
+	};
+}
+function pruneCollectionsArray(schemaObj, ownedByOthers) {
+	const source = schemaObj.collections;
+	let removed = false;
+	const pruned = [];
+	for (const entry of source) {
+		if (typeof entry === "object" && entry !== null) {
+			const name = entry.name;
+			if (typeof name === "string" && ownedByOthers.has(name)) {
+				removed = true;
+				continue;
+			}
+		}
+		pruned.push(entry);
+	}
+	if (!removed) return schemaObj;
 	return {
 		...schemaObj,
-		tables: prunedTables
+		collections: pruned
 	};
 }
 //#endregion

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 { 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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"}
+{"version":3,"file":"aggregate.mjs","names":[],"sources":["../../src/aggregate/extract-storage-element-names.ts","../../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":["/**\n * Extract the set of top-level storage element names a contract claims.\n *\n * Used by the aggregate loader's disjointness check and by\n * `projectSchemaToSpace`'s \"names owned by other members\" walk.\n *\n * **Stopgap — known layering violation.** This helper duck-types the\n * storage shape (`storage.tables` for SQL families, `storage.collections`\n * for Mongo) from framework-domain code that has no business naming\n * family-specific storage idioms. The framework lacks a typed primitive\n * for storage *topology* — the structural backbone of \"what named things\n * does this contract claim?\" independent of what those things are.\n *\n * The correct fix introduces that primitive at the framework level\n * (`interface Storage { readonly namespaces: Record<string, Namespace> }`\n * and friends), with each family's storage type required to conform.\n * That work is scoped in TML-2459 (target-extensible-ir), which will\n * remove this duck-typed walk when the IR class flip rebases onto this\n * PR. Landing an interim typed shape here would create a third on-disk\n * shape that TML-2459 would have to migrate away from again, opening a\n * dual-shape transition window that TML-2459 explicitly rules out.\n *\n * Behavioural notes for the lifetime of this helper:\n *\n * - Both `tables` and `collections` are unioned (a hypothetical\n *   cross-family contract exposing both would contribute both sets).\n * - Unrecognised storage shapes return an empty set, so a future family\n *   with a different layout silently disables disjointness rather than\n *   hard-failing. This is a stopgap default; the typed `Storage` shape\n *   in TML-2459 will replace it with a compile-time guarantee.\n * - Record-shape detection excludes arrays so array-shaped values aren't\n *   walked as records via numeric keys.\n * - Names that appear in both `tables` and `collections` are deduplicated\n *   by the returned `Set`.\n */\nexport function extractStorageElementNames(contract: unknown): Set<string> {\n  const names = new Set<string>();\n  if (typeof contract !== 'object' || contract === null) return names;\n  const storage = (contract as { readonly storage?: unknown }).storage;\n  if (typeof storage !== 'object' || storage === null) return names;\n  const storageObj = storage as { readonly tables?: unknown; readonly collections?: unknown };\n  for (const field of ['tables', 'collections'] as const) {\n    const value = storageObj[field];\n    if (typeof value === 'object' && value !== null && !Array.isArray(value)) {\n      for (const name of Object.keys(value as Record<string, unknown>)) {\n        names.add(name);\n      }\n    }\n  }\n  return names;\n}\n","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 { extractStorageElementNames } from './extract-storage-element-names';\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 elements = extractStorageElementNames(member.contract);\n    for (const elementName of elements) {\n      const claimers = elementClaimedBy.get(elementName);\n      if (claimers) claimers.push(member.spaceId);\n      else elementClaimedBy.set(elementName, [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","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 { extractStorageElementNames } from './extract-storage-element-names';\nimport type { ContractSpaceMember } from './types';\n\n/**\n * Project the **introspected live schema** to the slice claimed by a\n * single contract-space member.\n *\n * \"Schema\" here means the live introspected database state — the\n * planner / verifier sees this object as a `MongoSchemaIR` (Mongo) or\n * `SqlSchemaIR` (SQL). It is **not** a database schema in the SQL\n * `CREATE SCHEMA` sense, nor a contract-space namespace. The\n * function's job is to filter that introspected state down to the\n * elements claimed by one space, so a per-space verify pass doesn't\n * see another space's storage as \"extras\".\n *\n * Returns the same `schema` value with every top-level storage element\n * (table or collection) claimed by **other** members of the aggregate\n * removed. Elements not claimed by any member flow through unchanged —\n * the planner / verifier sees them as 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 elements claimed\n *   by other members as \"extras\" and emit destructive ops to drop them.\n * - The aggregate verifier's **schemaCheck**: projects per member so the\n *   single-contract verify only sees the slice claimed by the member it\n *   is checking. Closes the architectural concern that a multi-member\n *   deployment makes each member's elements look like extras to every\n *   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 * Two storage shapes are recognised today:\n *\n * - SQL families expose `storage.tables: Record<string, ...>` on\n *   contracts and the introspected schema mirrors the same record shape.\n *   Pruning iterates the record entries.\n * - Mongo exposes `storage.collections: Record<string, ...>` on\n *   contracts; the introspected `MongoSchemaIR` exposes\n *   `collections: ReadonlyArray<{name: string, ...}>`. Pruning iterates\n *   the array on the schema side and the record's keys on the\n *   other-member side.\n *\n * Schemas of unrecognised shape are returned unchanged. The function\n * never imports family classes (`SqlSchemaIR`, `MongoSchemaIR`); the\n * projected schema is a plain object — `{...schema, tables: pruned}` or\n * `{...schema, collections: pruned}` — that downstream consumers\n * duck-type. A future family with a different storage shape gets the\n * schema returned unchanged rather than blowing up the aggregate\n * planner.\n *\n * Record-shape detection guards against arrays (`!Array.isArray`) so\n * an unrecognised array-shaped value falls through unchanged rather\n * than being pruned by numeric keys.\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\n  const ownedByOthers = collectOwnedNames(member, otherMembers);\n  if (ownedByOthers.size === 0) return schema;\n\n  const schemaObj = schema as { readonly tables?: unknown; readonly collections?: unknown };\n\n  if (\n    typeof schemaObj.tables === 'object' &&\n    schemaObj.tables !== null &&\n    !Array.isArray(schemaObj.tables)\n  ) {\n    return pruneRecord(schemaObj, 'tables', ownedByOthers);\n  }\n\n  if (Array.isArray(schemaObj.collections)) {\n    return pruneCollectionsArray(schemaObj, ownedByOthers);\n  }\n\n  if (\n    typeof schemaObj.collections === 'object' &&\n    schemaObj.collections !== null &&\n    !Array.isArray(schemaObj.collections)\n  ) {\n    return pruneRecord(schemaObj, 'collections', ownedByOthers);\n  }\n\n  return schema;\n}\n\n/**\n * Collect the set of storage element names claimed by other members.\n * Reuses the loader's `extractStorageElementNames` helper so the\n * tables/collections walk lives in exactly one place.\n */\nfunction collectOwnedNames(\n  member: ContractSpaceMember,\n  otherMembers: ReadonlyArray<ContractSpaceMember>,\n): Set<string> {\n  const owned = new Set<string>();\n  for (const other of otherMembers) {\n    if (other.spaceId === member.spaceId) continue;\n    for (const name of extractStorageElementNames(other.contract)) {\n      owned.add(name);\n    }\n  }\n  return owned;\n}\n\nfunction pruneRecord(\n  schemaObj: { readonly tables?: unknown; readonly collections?: unknown },\n  field: 'tables' | 'collections',\n  ownedByOthers: ReadonlySet<string>,\n): unknown {\n  const source = schemaObj[field] as Record<string, unknown>;\n  let removed = false;\n  const pruned: Record<string, unknown> = {};\n  for (const [name, value] of Object.entries(source)) {\n    if (ownedByOthers.has(name)) {\n      removed = true;\n    } else {\n      pruned[name] = value;\n    }\n  }\n  if (!removed) return schemaObj;\n  return { ...schemaObj, [field]: pruned };\n}\n\nfunction pruneCollectionsArray(\n  schemaObj: { readonly collections?: unknown },\n  ownedByOthers: ReadonlySet<string>,\n): unknown {\n  const source = schemaObj.collections as ReadonlyArray<unknown>;\n  let removed = false;\n  const pruned: unknown[] = [];\n  for (const entry of source) {\n    if (typeof entry === 'object' && entry !== null) {\n      const name = (entry as { readonly name?: unknown }).name;\n      if (typeof name === 'string' && ownedByOthers.has(name)) {\n        removed = true;\n        continue;\n      }\n    }\n    pruned.push(entry);\n  }\n  if (!removed) return schemaObj;\n  return { ...schemaObj, collections: pruned };\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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma-next/migration-tools",
-  "version": "0.6.0-dev.13",
+  "version": "0.6.0-dev.14",
   "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
@@ -9,9 +9,9 @@
     "arktype": "^2.1.29",
     "pathe": "^2.0.3",
     "prettier": "^3.8.3",
-    "@prisma-next/framework-components": "0.6.0-dev.13",
-    "@prisma-next/utils": "0.6.0-dev.13",
-    "@prisma-next/contract": "0.6.0-dev.13"
+    "@prisma-next/contract": "0.6.0-dev.14",
+    "@prisma-next/framework-components": "0.6.0-dev.14",
+    "@prisma-next/utils": "0.6.0-dev.14"
   },
   "devDependencies": {
     "tsdown": "0.22.0",

package/src/aggregate/extract-storage-element-names.ts

@@ -0,0 +1,51 @@
+/**
+ * Extract the set of top-level storage element names a contract claims.
+ *
+ * Used by the aggregate loader's disjointness check and by
+ * `projectSchemaToSpace`'s "names owned by other members" walk.
+ *
+ * **Stopgap — known layering violation.** This helper duck-types the
+ * storage shape (`storage.tables` for SQL families, `storage.collections`
+ * for Mongo) from framework-domain code that has no business naming
+ * family-specific storage idioms. The framework lacks a typed primitive
+ * for storage *topology* — the structural backbone of "what named things
+ * does this contract claim?" independent of what those things are.
+ *
+ * The correct fix introduces that primitive at the framework level
+ * (`interface Storage { readonly namespaces: Record<string, Namespace> }`
+ * and friends), with each family's storage type required to conform.
+ * That work is scoped in TML-2459 (target-extensible-ir), which will
+ * remove this duck-typed walk when the IR class flip rebases onto this
+ * PR. Landing an interim typed shape here would create a third on-disk
+ * shape that TML-2459 would have to migrate away from again, opening a
+ * dual-shape transition window that TML-2459 explicitly rules out.
+ *
+ * Behavioural notes for the lifetime of this helper:
+ *
+ * - Both `tables` and `collections` are unioned (a hypothetical
+ *   cross-family contract exposing both would contribute both sets).
+ * - Unrecognised storage shapes return an empty set, so a future family
+ *   with a different layout silently disables disjointness rather than
+ *   hard-failing. This is a stopgap default; the typed `Storage` shape
+ *   in TML-2459 will replace it with a compile-time guarantee.
+ * - Record-shape detection excludes arrays so array-shaped values aren't
+ *   walked as records via numeric keys.
+ * - Names that appear in both `tables` and `collections` are deduplicated
+ *   by the returned `Set`.
+ */
+export function extractStorageElementNames(contract: unknown): Set<string> {
+  const names = new Set<string>();
+  if (typeof contract !== 'object' || contract === null) return names;
+  const storage = (contract as { readonly storage?: unknown }).storage;
+  if (typeof storage !== 'object' || storage === null) return names;
+  const storageObj = storage as { readonly tables?: unknown; readonly collections?: unknown };
+  for (const field of ['tables', 'collections'] as const) {
+    const value = storageObj[field];
+    if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+      for (const name of Object.keys(value as Record<string, unknown>)) {
+        names.add(name);
+      }
+    }
+  }
+  return names;
+}

package/src/aggregate/loader.ts

@@ -8,6 +8,7 @@ import { readContractSpaceContract } from '../read-contract-space-contract';
 import { readContractSpaceHeadRef } from '../read-contract-space-head-ref';
 import { APP_SPACE_ID, spaceMigrationDirectory } from '../space-layout';
 import { listContractSpaceDirectories } from '../verify-contract-spaces';
+import { extractStorageElementNames } from './extract-storage-element-names';
 import type { ContractSpaceAggregate, ContractSpaceMember, HydratedMigrationGraph } from './types';
 
 /**
@@ -337,11 +338,11 @@ export async function loadContractSpaceAggregate(
   // 7. Disjointness: no two members claim the same storage element.
   const elementClaimedBy = new Map<string, string[]>();
   for (const member of [appMember, ...extensionMembers]) {
-    const tables = extractTableNames(member.contract);
-    for (const tableName of tables) {
-      const claimers = elementClaimedBy.get(tableName);
+    const elements = extractStorageElementNames(member.contract);
+    for (const elementName of elements) {
+      const claimers = elementClaimedBy.get(elementName);
       if (claimers) claimers.push(member.spaceId);
-      else elementClaimedBy.set(tableName, [member.spaceId]);
+      else elementClaimedBy.set(elementName, [member.spaceId]);
     }
   }
   for (const [element, claimedBy] of elementClaimedBy) {
@@ -362,18 +363,3 @@ export async function loadContractSpaceAggregate(
     },
   });
 }
-
-/**
- * Extract the set of top-level storage table names from a contract.
- * Duck-typed: returns `[]` if the contract's storage shape doesn't
- * match the canonical `storage.tables: Record<string, ...>` form. A
- * future family with a different storage shape gets disjointness
- * effectively disabled (not enforced) rather than a hard failure.
- */
-function extractTableNames(contract: Contract): readonly string[] {
-  const storage = (contract as { readonly storage?: unknown }).storage;
-  if (typeof storage !== 'object' || storage === null) return [];
-  const tables = (storage as { readonly tables?: unknown }).tables;
-  if (typeof tables !== 'object' || tables === null) return [];
-  return Object.keys(tables as Record<string, unknown>);
-}

package/src/aggregate/project-schema-to-space.ts

@@ -1,33 +1,59 @@
+import { extractStorageElementNames } from './extract-storage-element-names';
 import type { ContractSpaceMember } from './types';
 
 /**
- * Project the introspected live schema to the slice claimed by a single
- * contract-space member.
+ * Project the **introspected live schema** to the slice claimed by a
+ * single contract-space member.
  *
- * Returns the same `schema` value with every top-level table claimed by
- * **other** members of the aggregate removed. Tables not claimed by any
- * member flow through unchanged — the planner / verifier sees them as
- * orphans (extras in strict mode).
+ * "Schema" here means the live introspected database state — the
+ * planner / verifier sees this object as a `MongoSchemaIR` (Mongo) or
+ * `SqlSchemaIR` (SQL). It is **not** a database schema in the SQL
+ * `CREATE SCHEMA` sense, nor a contract-space namespace. The
+ * function's job is to filter that introspected state down to the
+ * elements claimed by one space, so a per-space verify pass doesn't
+ * see another space's storage as "extras".
+ *
+ * Returns the same `schema` value with every top-level storage element
+ * (table or collection) claimed by **other** members of the aggregate
+ * removed. Elements not claimed by any member flow through unchanged —
+ * the planner / verifier sees them as orphans (extras in strict mode).
  *
  * Used by:
  *
  * - The aggregate planner's **synth strategy**: when synthesising a
  *   plan against a member's contract, the live schema must be projected
- *   to that member's slice so the planner doesn't treat tables claimed
- *   by other members as "extras" and emit destructive ops to drop
- *   them.
+ *   to that member's slice so the planner doesn't treat elements claimed
+ *   by other members as "extras" and emit destructive ops to drop them.
  * - The aggregate verifier's **schemaCheck**: projects per member so the
- *   single-contract `verifySqlSchema` only sees the slice claimed by
- *   the member it is checking. Closes the F23 architectural concern
- *   (multi-member deployments where each member's tables look like
- *   extras to every other member's verify pass).
+ *   single-contract verify only sees the slice claimed by the member it
+ *   is checking. Closes the architectural concern that a multi-member
+ *   deployment makes each member's elements look like extras to every
+ *   other member's verify pass.
  *
  * **Duck-typing semantics**: the helper operates on `unknown` for the
  * schema and falls through structurally if the shape doesn't match.
- * Every family today exposes `storage.tables: Record<string, ...>` and
- * the introspected schema mirrors the same shape; a future family with
- * a different storage shape gets the schema returned unchanged rather
- * than blowing up the aggregate planner.
+ * Two storage shapes are recognised today:
+ *
+ * - SQL families expose `storage.tables: Record<string, ...>` on
+ *   contracts and the introspected schema mirrors the same record shape.
+ *   Pruning iterates the record entries.
+ * - Mongo exposes `storage.collections: Record<string, ...>` on
+ *   contracts; the introspected `MongoSchemaIR` exposes
+ *   `collections: ReadonlyArray<{name: string, ...}>`. Pruning iterates
+ *   the array on the schema side and the record's keys on the
+ *   other-member side.
+ *
+ * Schemas of unrecognised shape are returned unchanged. The function
+ * never imports family classes (`SqlSchemaIR`, `MongoSchemaIR`); the
+ * projected schema is a plain object — `{...schema, tables: pruned}` or
+ * `{...schema, collections: pruned}` — that downstream consumers
+ * duck-type. A future family with a different storage shape gets the
+ * schema returned unchanged rather than blowing up the aggregate
+ * planner.
+ *
+ * Record-shape detection guards against arrays (`!Array.isArray`) so
+ * an unrecognised array-shaped value falls through unchanged rather
+ * than being pruned by numeric keys.
  */
 export function projectSchemaToSpace(
   schema: unknown,
@@ -35,30 +61,90 @@ export function projectSchemaToSpace(
   otherMembers: ReadonlyArray<ContractSpaceMember>,
 ): unknown {
   if (typeof schema !== 'object' || schema === null) return schema;
-  const schemaObj = schema as { readonly tables?: unknown };
-  if (typeof schemaObj.tables !== 'object' || schemaObj.tables === null) return schema;
-  const schemaTables = schemaObj.tables as Record<string, unknown>;
 
-  const ownedByOthers = new Set<string>();
+  const ownedByOthers = collectOwnedNames(member, otherMembers);
+  if (ownedByOthers.size === 0) return schema;
+
+  const schemaObj = schema as { readonly tables?: unknown; readonly collections?: unknown };
+
+  if (
+    typeof schemaObj.tables === 'object' &&
+    schemaObj.tables !== null &&
+    !Array.isArray(schemaObj.tables)
+  ) {
+    return pruneRecord(schemaObj, 'tables', ownedByOthers);
+  }
+
+  if (Array.isArray(schemaObj.collections)) {
+    return pruneCollectionsArray(schemaObj, ownedByOthers);
+  }
+
+  if (
+    typeof schemaObj.collections === 'object' &&
+    schemaObj.collections !== null &&
+    !Array.isArray(schemaObj.collections)
+  ) {
+    return pruneRecord(schemaObj, 'collections', ownedByOthers);
+  }
+
+  return schema;
+}
+
+/**
+ * Collect the set of storage element names claimed by other members.
+ * Reuses the loader's `extractStorageElementNames` helper so the
+ * tables/collections walk lives in exactly one place.
+ */
+function collectOwnedNames(
+  member: ContractSpaceMember,
+  otherMembers: ReadonlyArray<ContractSpaceMember>,
+): Set<string> {
+  const owned = new Set<string>();
   for (const other of otherMembers) {
     if (other.spaceId === member.spaceId) continue;
-    const storage = (other.contract as { readonly storage?: unknown }).storage;
-    if (typeof storage !== 'object' || storage === null) continue;
-    const tables = (storage as { readonly tables?: unknown }).tables;
-    if (typeof tables !== 'object' || tables === null) continue;
-    for (const tableName of Object.keys(tables as Record<string, unknown>)) {
-      ownedByOthers.add(tableName);
+    for (const name of extractStorageElementNames(other.contract)) {
+      owned.add(name);
     }
   }
+  return owned;
+}
 
-  if (ownedByOthers.size === 0) return schema;
-
-  const prunedTables: Record<string, unknown> = {};
-  for (const [name, table] of Object.entries(schemaTables)) {
-    if (!ownedByOthers.has(name)) {
-      prunedTables[name] = table;
+function pruneRecord(
+  schemaObj: { readonly tables?: unknown; readonly collections?: unknown },
+  field: 'tables' | 'collections',
+  ownedByOthers: ReadonlySet<string>,
+): unknown {
+  const source = schemaObj[field] as Record<string, unknown>;
+  let removed = false;
+  const pruned: Record<string, unknown> = {};
+  for (const [name, value] of Object.entries(source)) {
+    if (ownedByOthers.has(name)) {
+      removed = true;
+    } else {
+      pruned[name] = value;
     }
   }
+  if (!removed) return schemaObj;
+  return { ...schemaObj, [field]: pruned };
+}
 
-  return { ...schemaObj, tables: prunedTables };
+function pruneCollectionsArray(
+  schemaObj: { readonly collections?: unknown },
+  ownedByOthers: ReadonlySet<string>,
+): unknown {
+  const source = schemaObj.collections as ReadonlyArray<unknown>;
+  let removed = false;
+  const pruned: unknown[] = [];
+  for (const entry of source) {
+    if (typeof entry === 'object' && entry !== null) {
+      const name = (entry as { readonly name?: unknown }).name;
+      if (typeof name === 'string' && ownedByOthers.has(name)) {
+        removed = true;
+        continue;
+      }
+    }
+    pruned.push(entry);
+  }
+  if (!removed) return schemaObj;
+  return { ...schemaObj, collections: pruned };
 }