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

package/dist/exports/aggregate.mjs

@@ -0,0 +1,611 @@
+import { s as readMigrationsDir } from "../io-D13dLvUh.mjs";
+import "../constants-DWV9_o2Z.mjs";
+import { l as reconstructGraph, o as findPathWithDecision } from "../migration-graph-DGNnKDY5.mjs";
+import { a as readContractSpaceHeadRef, i as detectSpaceContractDrift, l as spaceMigrationDirectory, n as listContractSpaceDirectories, o as APP_SPACE_ID, t as readContractSpaceContract } from "../read-contract-space-contract-C3-1eyaI.mjs";
+import { notOk, ok } from "@prisma-next/utils/result";
+//#region src/aggregate/loader.ts
+/**
+* Hydrate a {@link ContractSpaceAggregate} from on-disk state and
+* caller-provided descriptor data.
+*
+* This is the **only** descriptor-import boundary in the post-M2.5
+* pipeline: callers read `extensionPacks` from `Config`, validate the
+* app contract, and pass everything through. The loader composes
+* existing migration-tools primitives — layout precheck (via
+* {@link listContractSpaceDirectories}), integrity checks (via
+* {@link readMigrationsDir} / {@link readContractSpaceHeadRef} /
+* {@link readContractSpaceContract} / `validateContract`), drift detection
+* (via {@link detectSpaceContractDrift}), and disjointness — into a
+* single typed value.
+*
+* Failure semantics: every failure variant in {@link LoadAggregateError}
+* short-circuits the load. Drift is fatal (M2.5 spec § Loader, step 5).
+*/
+async function loadContractSpaceAggregate(input) {
+	const appContractTarget = input.appContract.target;
+	if (appContractTarget !== input.targetId) return notOk({
+		kind: "targetMismatch",
+		spaceId: APP_SPACE_ID,
+		expected: input.targetId,
+		actual: appContractTarget
+	});
+	for (const entry of input.declaredExtensions) if (entry.targetId !== input.targetId) return notOk({
+		kind: "targetMismatch",
+		spaceId: entry.id,
+		expected: input.targetId,
+		actual: entry.targetId
+	});
+	const declaredWithSpace = input.declaredExtensions.filter((e) => e.contractSpace !== void 0);
+	const declaredSpaceIds = new Set(declaredWithSpace.map((e) => e.id));
+	const extensionDirsOnDisk = (await listContractSpaceDirectories(input.migrationsDir)).filter((d) => d !== APP_SPACE_ID);
+	const spaceDirSet = new Set(extensionDirsOnDisk);
+	const layoutViolations = [];
+	for (const dir of extensionDirsOnDisk) if (!declaredSpaceIds.has(dir)) layoutViolations.push({
+		kind: "orphanSpaceDir",
+		spaceId: dir
+	});
+	for (const id of [...declaredSpaceIds].sort()) if (!spaceDirSet.has(id)) layoutViolations.push({
+		kind: "declaredButUnmigrated",
+		spaceId: id
+	});
+	if (layoutViolations.length > 0) return notOk({
+		kind: "layoutViolation",
+		violations: layoutViolations
+	});
+	const loadedExtensions = [];
+	for (const entry of [...declaredWithSpace].sort((a, b) => a.id.localeCompare(b.id))) {
+		const headRef = await readContractSpaceHeadRef(input.migrationsDir, entry.id);
+		if (headRef === null) return notOk({
+			kind: "integrityFailure",
+			spaceId: entry.id,
+			detail: `Head ref \`refs/head.json\` is missing for extension space "${entry.id}".`
+		});
+		let spaceContractRaw;
+		try {
+			spaceContractRaw = await readContractSpaceContract(input.migrationsDir, entry.id);
+		} catch (error) {
+			return notOk({
+				kind: "integrityFailure",
+				spaceId: entry.id,
+				detail: error instanceof Error ? error.message : String(error)
+			});
+		}
+		let spaceContract;
+		try {
+			spaceContract = input.validateContract(spaceContractRaw);
+		} catch (error) {
+			return notOk({
+				kind: "validationFailure",
+				spaceId: entry.id,
+				detail: error instanceof Error ? error.message : String(error)
+			});
+		}
+		if (spaceContract.target !== input.targetId) return notOk({
+			kind: "targetMismatch",
+			spaceId: entry.id,
+			expected: input.targetId,
+			actual: spaceContract.target
+		});
+		if (entry.contractSpace) {
+			const liveHash = input.hashContract(entry.contractSpace.contractJson);
+			const drift = detectSpaceContractDrift(entry.id, {
+				descriptorHash: liveHash,
+				priorHeadHash: headRef.hash
+			});
+			if (drift.kind === "drift") return notOk({
+				kind: "driftViolation",
+				spaceId: entry.id,
+				priorHeadHash: drift.priorHeadHash ?? "",
+				liveHash: drift.descriptorHash
+			});
+		}
+		let packages;
+		try {
+			packages = await readMigrationsDir(spaceMigrationDirectory(input.migrationsDir, entry.id));
+		} catch (error) {
+			return notOk({
+				kind: "integrityFailure",
+				spaceId: entry.id,
+				detail: error instanceof Error ? error.message : String(error)
+			});
+		}
+		let graph;
+		try {
+			graph = reconstructGraph(packages);
+		} catch (error) {
+			return notOk({
+				kind: "integrityFailure",
+				spaceId: entry.id,
+				detail: error instanceof Error ? error.message : String(error)
+			});
+		}
+		if (graph.nodes.size === 0) {
+			if (headRef.hash !== "sha256:empty") return notOk({
+				kind: "integrityFailure",
+				spaceId: entry.id,
+				detail: `Head ref "${headRef.hash}" is not present in the (empty) on-disk migration graph.`
+			});
+		} else if (!graph.nodes.has(headRef.hash)) return notOk({
+			kind: "integrityFailure",
+			spaceId: entry.id,
+			detail: `Head ref "${headRef.hash}" is not present in the on-disk migration graph.`
+		});
+		const packagesByMigrationHash = new Map(packages.map((p) => [p.metadata.migrationHash, p]));
+		loadedExtensions.push({
+			entry,
+			contract: spaceContract,
+			headRefHash: headRef.hash,
+			headRefInvariants: [...headRef.invariants].sort(),
+			migrations: {
+				graph,
+				packagesByMigrationHash
+			}
+		});
+	}
+	let appGraph;
+	try {
+		appGraph = reconstructGraph(input.appMigrationPackages);
+	} catch (error) {
+		return notOk({
+			kind: "integrityFailure",
+			spaceId: APP_SPACE_ID,
+			detail: error instanceof Error ? error.message : String(error)
+		});
+	}
+	const appPackagesByMigrationHash = new Map(input.appMigrationPackages.map((p) => [p.metadata.migrationHash, p]));
+	const appMember = {
+		spaceId: APP_SPACE_ID,
+		contract: input.appContract,
+		headRef: {
+			hash: input.appContract.storage.storageHash,
+			invariants: []
+		},
+		migrations: {
+			graph: appGraph,
+			packagesByMigrationHash: appPackagesByMigrationHash
+		}
+	};
+	const extensionMembers = loadedExtensions.map((s) => ({
+		spaceId: s.entry.id,
+		contract: s.contract,
+		headRef: {
+			hash: s.headRefHash,
+			invariants: s.headRefInvariants
+		},
+		migrations: s.migrations
+	}));
+	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);
+			if (claimers) claimers.push(member.spaceId);
+			else elementClaimedBy.set(tableName, [member.spaceId]);
+		}
+	}
+	for (const [element, claimedBy] of elementClaimedBy) if (claimedBy.length > 1) return notOk({
+		kind: "disjointnessViolation",
+		element,
+		claimedBy: [...claimedBy].sort()
+	});
+	return ok({ aggregate: {
+		targetId: input.targetId,
+		app: appMember,
+		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
+/**
+* Walk a member's hydrated migration graph from the live marker to
+* `member.headRef.hash`, covering every required invariant.
+*
+* Pure synchronous function — no I/O. The aggregate's loader has
+* already integrity-checked every package and reconstructed the graph;
+* this strategy just looks up ops by `migrationHash` and assembles a
+* `MigrationPlan` with `targetId` set from the aggregate (no
+* placeholder cast).
+*
+* Required invariants are computed as `headRef.invariants \ marker.invariants`
+* — the marker already declares some invariants satisfied; the path
+* only needs to provide the remainder. Mirrors today's
+* `computeExtensionSpaceApplyPath` semantics.
+*/
+function graphWalkStrategy(input) {
+	const { aggregateTargetId, member, currentMarker, refName } = input;
+	const { graph, packagesByMigrationHash } = member.migrations;
+	const fromHash = currentMarker?.storageHash ?? "sha256:empty";
+	const markerInvariants = new Set(currentMarker?.invariants ?? []);
+	const required = new Set(member.headRef.invariants.filter((id) => !markerInvariants.has(id)));
+	const outcome = findPathWithDecision(graph, fromHash, member.headRef.hash, {
+		required,
+		...refName !== void 0 ? { refName } : {}
+	});
+	if (outcome.kind === "unreachable") return { kind: "unreachable" };
+	if (outcome.kind === "unsatisfiable") return {
+		kind: "unsatisfiable",
+		missing: outcome.missing
+	};
+	const pathOps = [];
+	const providedInvariantsSet = /* @__PURE__ */ new Set();
+	const edgeRefs = [];
+	for (const edge of outcome.decision.selectedPath) {
+		const pkg = packagesByMigrationHash.get(edge.migrationHash);
+		if (!pkg) throw new Error(`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.`);
+		for (const op of pkg.ops) pathOps.push(op);
+		for (const invariant of pkg.metadata.providedInvariants) providedInvariantsSet.add(invariant);
+		edgeRefs.push({
+			migrationHash: edge.migrationHash,
+			dirName: edge.dirName,
+			from: edge.from,
+			to: edge.to,
+			operationCount: pkg.ops.length
+		});
+	}
+	return {
+		kind: "ok",
+		result: {
+			plan: {
+				targetId: aggregateTargetId,
+				spaceId: member.spaceId,
+				origin: currentMarker === null ? null : { storageHash: currentMarker.storageHash },
+				destination: { storageHash: member.headRef.hash },
+				operations: pathOps,
+				providedInvariants: [...providedInvariantsSet].sort()
+			},
+			displayOps: pathOps,
+			destinationContract: member.contract,
+			strategy: "graph-walk",
+			migrationEdges: edgeRefs,
+			pathDecision: outcome.decision
+		}
+	};
+}
+//#endregion
+//#region src/aggregate/project-schema-to-space.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).
+*
+* 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.
+* - 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).
+*
+* **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.
+*/
+function projectSchemaToSpace(schema, member, otherMembers) {
+	if (typeof schema !== "object" || schema === null) return schema;
+	const schemaObj = schema;
+	if (typeof schemaObj.tables !== "object" || schemaObj.tables === null) return schema;
+	const schemaTables = schemaObj.tables;
+	const ownedByOthers = /* @__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);
+	}
+	if (ownedByOthers.size === 0) return schema;
+	const prunedTables = {};
+	for (const [name, table] of Object.entries(schemaTables)) if (!ownedByOthers.has(name)) prunedTables[name] = table;
+	return {
+		...schemaObj,
+		tables: prunedTables
+	};
+}
+//#endregion
+//#region src/aggregate/strategies/synth.ts
+/**
+* Synthesise a migration plan for a single member by projecting the
+* live schema down to that member's claimed slice and delegating to
+* the family's `createPlanner(...).plan(...)`.
+*
+* Pre-projection (via {@link projectSchemaToSpace}) closes the F23
+* concern: without it, the family's planner sees other members'
+* tables as "extras" and emits destructive ops to drop them. With it,
+* the planner only sees the slice this member claims.
+*
+* The synthesised plan's `targetId` is set from `aggregateTargetId`
+* (the aggregate's ambient target). The family's planner does not
+* stamp `targetId` on the produced plan; the aggregate planner is
+* the single point that knows the target.
+*
+* Used by:
+*
+* - The app member by default (CLI policy
+*   `ignoreGraphFor: { app.spaceId }`).
+* - Any extension member whose `headRef.invariants` is empty (the
+*   strategy selector falls back to synth when graph-walk isn't
+*   required).
+*/
+async function synthStrategy(input) {
+	const projectedSchema = projectSchemaToSpace(input.schemaIntrospection, input.member, input.otherMembers);
+	const plannerResult = await input.migrations.createPlanner(input.familyInstance).plan({
+		contract: input.member.contract,
+		schema: projectedSchema,
+		policy: input.operationPolicy,
+		fromContract: null,
+		frameworkComponents: input.frameworkComponents,
+		spaceId: input.member.spaceId
+	});
+	if (plannerResult.kind === "failure") return {
+		kind: "failure",
+		conflicts: plannerResult.conflicts
+	};
+	const synthedPlan = plannerResult.plan;
+	return {
+		kind: "ok",
+		result: {
+			plan: new Proxy(synthedPlan, {
+				get(target, prop) {
+					if (prop === "targetId") return input.aggregateTargetId;
+					return Reflect.get(target, prop, target);
+				},
+				has(target, prop) {
+					if (prop === "targetId") return true;
+					return Reflect.has(target, prop);
+				}
+			}),
+			displayOps: synthedPlan.operations,
+			destinationContract: input.member.contract,
+			strategy: "synth"
+		}
+	};
+}
+//#endregion
+//#region src/aggregate/planner.ts
+/**
+* Plan a migration across every member of a {@link ContractSpaceAggregate}.
+*
+* Strategy selection per member, in order; first match wins:
+*
+* 1. If `callerPolicy.ignoreGraphFor.has(member.spaceId)`:
+*    - If `member.headRef.invariants` is empty → synth.
+*    - Else → `policyConflict` (synth cannot satisfy authored invariants).
+* 2. Else if `member.migrations.graph` is non-empty AND graph-walk
+*    succeeds → graph-walk.
+* 3. Else if `member.headRef.invariants` is empty → synth.
+* 4. Else → graph-walk failure → `extensionPathUnreachable` /
+*    `extensionPathUnsatisfiable`.
+*
+* Output `applyOrder` is `[...aggregate.extensions.map(spaceId), aggregate.app.spaceId]`
+* — extensions alphabetical, then app — matching today's
+* `concatenateSpaceApplyInputs` ordering. This preserves
+* `MultiSpaceRunnerFailure.failingSpace` attribution byte-for-byte.
+*
+* Every emitted `MigrationPlan` has `targetId = aggregate.targetId`.
+* No placeholder cast; no patch step.
+*/
+async function planAggregate(input) {
+	const { aggregate, currentDBState, callerPolicy } = input;
+	const allMembers = [aggregate.app, ...aggregate.extensions];
+	const perSpace = /* @__PURE__ */ new Map();
+	const orderedMembers = [...aggregate.extensions, aggregate.app];
+	for (const member of orderedMembers) {
+		const otherMembers = allMembers.filter((m) => m.spaceId !== member.spaceId);
+		const currentMarker = currentDBState.markersBySpaceId.get(member.spaceId) ?? null;
+		const ignoreGraph = callerPolicy.ignoreGraphFor.has(member.spaceId);
+		const invariantsRequired = member.headRef.invariants.length > 0;
+		if (ignoreGraph && invariantsRequired) return notOk({
+			kind: "policyConflict",
+			spaceId: member.spaceId,
+			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.`
+		});
+		if (ignoreGraph) {
+			const synthOutcome = await synthStrategy({
+				aggregateTargetId: aggregate.targetId,
+				member,
+				otherMembers,
+				schemaIntrospection: currentDBState.schemaIntrospection,
+				familyInstance: input.familyInstance,
+				migrations: input.migrations,
+				frameworkComponents: input.frameworkComponents,
+				operationPolicy: input.operationPolicy
+			});
+			if (synthOutcome.kind === "failure") return notOk({
+				kind: "appSynthFailure",
+				spaceId: member.spaceId,
+				conflicts: synthOutcome.conflicts
+			});
+			perSpace.set(member.spaceId, synthOutcome.result);
+			continue;
+		}
+		if (member.migrations.graph.nodes.size > 0) {
+			const walked = graphWalkStrategy({
+				aggregateTargetId: aggregate.targetId,
+				member,
+				currentMarker
+			});
+			if (walked.kind === "ok") {
+				perSpace.set(member.spaceId, walked.result);
+				continue;
+			}
+			if (walked.kind === "unreachable") return notOk({
+				kind: "extensionPathUnreachable",
+				spaceId: member.spaceId,
+				target: member.headRef.hash
+			});
+			return notOk({
+				kind: "extensionPathUnsatisfiable",
+				spaceId: member.spaceId,
+				missingInvariants: walked.missing
+			});
+		}
+		if (invariantsRequired) return notOk({
+			kind: "extensionPathUnsatisfiable",
+			spaceId: member.spaceId,
+			missingInvariants: [...member.headRef.invariants].sort()
+		});
+		const synthOutcome = await synthStrategy({
+			aggregateTargetId: aggregate.targetId,
+			member,
+			otherMembers,
+			schemaIntrospection: currentDBState.schemaIntrospection,
+			familyInstance: input.familyInstance,
+			migrations: input.migrations,
+			frameworkComponents: input.frameworkComponents,
+			operationPolicy: input.operationPolicy
+		});
+		if (synthOutcome.kind === "failure") return notOk({
+			kind: "appSynthFailure",
+			spaceId: member.spaceId,
+			conflicts: synthOutcome.conflicts
+		});
+		perSpace.set(member.spaceId, synthOutcome.result);
+	}
+	return ok({
+		perSpace,
+		applyOrder: [...aggregate.extensions.map((m) => m.spaceId), aggregate.app.spaceId]
+	});
+}
+//#endregion
+//#region src/aggregate/verifier.ts
+/**
+* Verify a {@link ContractSpaceAggregate} against the live database
+* state. Bundles two checks:
+*
+* - `markerCheck` per member: compare the live marker row against the
+*   member's `headRef.hash` + `headRef.invariants`. Absence is a
+*   distinct kind, not an error (callers — `db verify` strict vs
+*   `db init` precondition — choose how to interpret it).
+* - `schemaCheck` per member: project the live schema to the slice
+*   the member claims via {@link projectSchemaToSpace}, then delegate
+*   to the caller-supplied `verifySchemaForMember`. The pre-projection
+*   means the family's single-contract verifier no longer sees other
+*   members' tables as `extras`, so a multi-member deployment never
+*   surfaces cross-member tables as orphaned schema elements.
+*
+* `markerCheck.orphanMarkers` lists every marker row whose `space` is
+* not a member of the aggregate. `db verify` callers reject orphans;
+* future tooling may not.
+*
+* Pure synchronous function; no I/O. The caller (CLI) gathers
+* `markersBySpaceId` and `schemaIntrospection` ahead of the call.
+*/
+function verifyAggregate(input) {
+	try {
+		return runVerifyAggregate(input);
+	} catch (error) {
+		return notOk({
+			kind: "introspectionFailure",
+			detail: error instanceof Error ? error.message : String(error)
+		});
+	}
+}
+function runVerifyAggregate(input) {
+	const { aggregate, markersBySpaceId, schemaIntrospection, mode, verifySchemaForMember } = input;
+	const allMembers = [aggregate.app, ...aggregate.extensions];
+	const memberSpaceIds = new Set(allMembers.map((m) => m.spaceId));
+	const markerPerSpace = /* @__PURE__ */ new Map();
+	for (const member of allMembers) {
+		const marker = markersBySpaceId.get(member.spaceId) ?? null;
+		if (marker === null) {
+			markerPerSpace.set(member.spaceId, { kind: "absent" });
+			continue;
+		}
+		if (marker.storageHash !== member.headRef.hash) {
+			markerPerSpace.set(member.spaceId, {
+				kind: "hashMismatch",
+				markerHash: marker.storageHash,
+				expected: member.headRef.hash
+			});
+			continue;
+		}
+		const markerInvariants = new Set(marker.invariants);
+		const missing = member.headRef.invariants.filter((id) => !markerInvariants.has(id));
+		if (missing.length > 0) {
+			markerPerSpace.set(member.spaceId, {
+				kind: "missingInvariants",
+				missing: [...missing].sort()
+			});
+			continue;
+		}
+		markerPerSpace.set(member.spaceId, { kind: "ok" });
+	}
+	const orphanMarkers = [];
+	for (const [spaceId, row] of markersBySpaceId) if (row !== null && !memberSpaceIds.has(spaceId)) orphanMarkers.push({
+		spaceId,
+		row
+	});
+	orphanMarkers.sort((a, b) => a.spaceId.localeCompare(b.spaceId));
+	const schemaPerSpace = /* @__PURE__ */ new Map();
+	for (const member of allMembers) {
+		const projected = projectSchemaToSpace(schemaIntrospection, member, allMembers.filter((m) => m.spaceId !== member.spaceId));
+		schemaPerSpace.set(member.spaceId, verifySchemaForMember(projected, member, mode));
+	}
+	return ok({
+		markerCheck: {
+			perSpace: markerPerSpace,
+			orphanMarkers
+		},
+		schemaCheck: {
+			perSpace: schemaPerSpace,
+			orphanElements: detectOrphanElements(schemaIntrospection, allMembers)
+		}
+	});
+}
+/**
+* Live tables not claimed by any aggregate member. Duck-typed against
+* the introspected schema's `tables` map; schemas whose shape doesn't
+* match return an empty list (consistent with
+* {@link projectSchemaToSpace}'s fall-through).
+*/
+function detectOrphanElements(schemaIntrospection, members) {
+	if (typeof schemaIntrospection !== "object" || schemaIntrospection === null) return [];
+	const liveTables = schemaIntrospection.tables;
+	if (typeof liveTables !== "object" || liveTables === null) return [];
+	const claimedTables = /* @__PURE__ */ new Set();
+	for (const member of members) {
+		const storage = member.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)) claimedTables.add(tableName);
+	}
+	const orphans = [];
+	for (const tableName of Object.keys(liveTables)) if (!claimedTables.has(tableName)) orphans.push({
+		kind: "table",
+		name: tableName
+	});
+	orphans.sort((a, b) => a.name.localeCompare(b.name));
+	return orphans;
+}
+//#endregion
+export { graphWalkStrategy, loadContractSpaceAggregate, planAggregate, projectSchemaToSpace, verifyAggregate };
+
+//# sourceMappingURL=aggregate.mjs.map