@prisma/orm-family-sql 0.16.0-dev.36

package/dist/control-B7iS4jv4.mjs

@@ -0,0 +1,1326 @@
+import { t as sqlContractCanonicalizationHooks } from "./canonicalization-hooks-DfIc_lOO.mjs";
+import { s as namingOf } from "./naming-BwqqVcZy-BgTObIQw.mjs";
+import { c as StorageTable } from "./storage-table-_LWDmPfv-DFhU2dML.mjs";
+import { l as isStorageTypeInstance } from "./types-CMMQS6aG.mjs";
+import { c as SqlSchemaIR, n as RelationalSchemaNodeKind, u as SqlTableIR } from "./types-DmhUVq4u-BpqqjPJx.mjs";
+import { t as sqlEmission } from "./dist-DrScXbhq.mjs";
+import { i as sqlFamilyPslBlockDescriptors, n as sqlFamilyAuthoringTypes, r as sqlFamilyEntityTypes, t as sqlFamilyAuthoringFieldPresets } from "./authoring-type-constructors-Blqoa2Ua-DyCmD6mp.mjs";
+import { n as classifyDiffSubjectGranularity, o as extractCodecControlHooks, s as verifySqlSchemaByDiff, t as classifyDiffEntityKind } from "./schema-verify-vtFZbmGq-BNfTr6fU.mjs";
+import { t as sqlFamilyError } from "./errors-B5g0xWro-mWH2C07F.mjs";
+import { t as SqlContractSerializer } from "./sql-contract-serializer-2oBWuxTe-B9hzBBv1.mjs";
+import { t as collectSupportedCodecTypeIds } from "./verify-E6Dd2vYp-gYwnlhLm.mjs";
+import { isPlainRecord } from "@prisma/orm-framework/components/ir";
+import { InternalError } from "@prisma/orm-framework/utils/internal-error";
+import { effectiveControlPolicy } from "@prisma/orm-framework/contract/types";
+import { blindCast } from "@prisma/orm-framework/utils/casts";
+import { ifDefined } from "@prisma/orm-framework/utils/defined";
+import { notOk, ok } from "@prisma/orm-framework/utils/result";
+import { APP_SPACE_ID, SchemaTreeNode, VERIFY_CODE_HASH_MISMATCH, VERIFY_CODE_MARKER_MISSING, VERIFY_CODE_TARGET_MISMATCH, assembleAuthoringContributions } from "@prisma/orm-framework/components/control";
+import { assertDescriptorSelfConsistency } from "@prisma/orm-toolchain/migration-tools/spaces";
+//#region ../../../2-sql/9-family/dist/control.mjs
+function isDdlStatement(sqlStatement) {
+	const trimmed = sqlStatement.trim().toLowerCase();
+	return trimmed.startsWith("create ") || trimmed.startsWith("alter ") || trimmed.startsWith("drop ");
+}
+function hasExecuteSteps(operation) {
+	const candidate = operation;
+	if (!("execute" in candidate) || !Array.isArray(candidate["execute"])) return false;
+	return candidate["execute"].every((step) => typeof step === "object" && step !== null && "sql" in step);
+}
+/**
+* Extracts a best-effort SQL DDL preview for CLI plan output.
+* Presentation-only: never used to decide migration correctness.
+*/
+function extractSqlDdl(operations) {
+	const statements = [];
+	for (const operation of operations) {
+		if (!hasExecuteSteps(operation)) continue;
+		for (const step of operation.execute) if (typeof step.sql === "string" && isDdlStatement(step.sql)) statements.push(step.sql.trim());
+	}
+	return statements;
+}
+/**
+* Wraps `extractSqlDdl` into the family-agnostic `OperationPreview` shape.
+* Each statement carries `language: 'sql'`.
+*/
+function sqlOperationsToPreview(operations) {
+	return { statements: extractSqlDdl(operations).map((text) => ({
+		text,
+		language: "sql"
+	})) };
+}
+function missingDescriptorOperationError(targetId, operation) {
+	return sqlFamilyError("CONTRACT.PACK_CONTRIBUTION_INVALID", `SQL target "${targetId}" is missing the required ${operation} descriptor operation`, {
+		why: `The target descriptor does not contribute the ${operation} operation the SQL family requires for this call.`,
+		fix: `Use a target package whose control descriptor implements ${operation}.`,
+		meta: {
+			targetId,
+			operation
+		}
+	});
+}
+function extractCodecTypeIdsFromContract(contract) {
+	const typeIds = /* @__PURE__ */ new Set();
+	if (typeof contract === "object" && contract !== null && "storage" in contract && typeof contract.storage === "object" && contract.storage !== null && "namespaces" in contract.storage && typeof contract.storage.namespaces === "object" && contract.storage.namespaces !== null) {
+		const namespaces = contract.storage.namespaces;
+		for (const ns of Object.values(namespaces)) {
+			const tbls = ns.entries["table"];
+			if (typeof tbls !== "object" || tbls === null) continue;
+			for (const table of Object.values(tbls)) if (typeof table === "object" && table !== null && "columns" in table && typeof table.columns === "object" && table.columns !== null) {
+				const columns = table.columns;
+				for (const column of Object.values(columns)) if (column && typeof column === "object" && "codecId" in column && typeof column.codecId === "string") typeIds.add(column.codecId);
+			}
+		}
+	}
+	return Array.from(typeIds).sort();
+}
+function createVerifyResult(options) {
+	const contract = { storageHash: options.contractStorageHash };
+	if (options.contractProfileHash) contract.profileHash = options.contractProfileHash;
+	const target = { expected: options.expectedTargetId };
+	if (options.actualTargetId) target.actual = options.actualTargetId;
+	const meta = { contractPath: options.contractPath };
+	if (options.configPath) meta.configPath = options.configPath;
+	const result = {
+		ok: options.ok,
+		summary: options.summary,
+		contract,
+		target,
+		meta,
+		timings: { total: options.totalTime }
+	};
+	if (options.code) result.code = options.code;
+	if (options.marker) result.marker = {
+		storageHash: options.marker.storageHash,
+		profileHash: options.marker.profileHash
+	};
+	if (options.missingCodecs) result.missingCodecs = options.missingCodecs;
+	if (options.codecCoverageSkipped) result.codecCoverageSkipped = options.codecCoverageSkipped;
+	return result;
+}
+function buildSqlTypeMetadataRegistry(options) {
+	const { target, adapter, extensions } = options;
+	const registry = /* @__PURE__ */ new Map();
+	const targetId = adapter.targetId;
+	const descriptors = [
+		target,
+		adapter,
+		...extensions
+	];
+	for (const descriptor of descriptors) {
+		const storageTypes = descriptor.types?.storage;
+		if (!storageTypes) continue;
+		for (const storageType of storageTypes) if (storageType.familyId === "sql" && storageType.targetId === targetId) registry.set(storageType.typeId, {
+			typeId: storageType.typeId,
+			familyId: "sql",
+			targetId: storageType.targetId,
+			...storageType.nativeType !== void 0 ? { nativeType: storageType.nativeType } : {}
+		});
+	}
+	return registry;
+}
+/**
+* Builds a map from each extension id to the set of extension ids it
+* transitively depends on. Uses the same declared-dependency data that
+* `buildExtensionLoadOrder` in control-stack uses.
+*/
+function buildTransitiveDependsOnMap(extensions) {
+	const directDeps = /* @__PURE__ */ new Map();
+	for (const ext of extensions) {
+		const packs = ext.contractSpace?.contractJson?.extensions;
+		const deps = packs !== null && typeof packs === "object" ? Object.keys(packs) : [];
+		directDeps.set(ext.id, deps);
+	}
+	const result = /* @__PURE__ */ new Map();
+	const resolve = (id, visiting) => {
+		const cached = result.get(id);
+		if (cached !== void 0) return cached;
+		const set = /* @__PURE__ */ new Set();
+		result.set(id, set);
+		for (const depId of directDeps.get(id) ?? []) {
+			set.add(depId);
+			if (!visiting.has(depId)) {
+				visiting.add(depId);
+				for (const transitive of resolve(depId, visiting)) set.add(transitive);
+				visiting.delete(depId);
+			}
+		}
+		return set;
+	};
+	for (const ext of extensions) resolve(ext.id, /* @__PURE__ */ new Set([ext.id]));
+	return result;
+}
+/**
+* Asserts that no cross-space FK in any extension points against the
+* dependency direction.
+*
+* A cross-space FK (target.spaceId present) from extension A pointing at
+* space B is a violation when B depends on A (directly or transitively),
+* because that means A is pointing "upward" against the dependency arrows
+* established by the extension load order.
+*
+* Throws with a diagnostic naming the violating extension (source), the
+* target space, and the direction violation.
+*/
+function isObjectRecord(v) {
+	return typeof v === "object" && v !== null;
+}
+function assertNoCrossSpaceFkReverseReferences(extensions) {
+	const dependsOnMap = buildTransitiveDependsOnMap(extensions);
+	for (const ext of extensions) {
+		const namespaces = ext.contractSpace?.contractJson?.storage?.namespaces;
+		if (!isObjectRecord(namespaces)) continue;
+		for (const ns of Object.values(namespaces)) {
+			if (!isObjectRecord(ns)) continue;
+			const entries = ns["entries"];
+			if (!isObjectRecord(entries)) continue;
+			for (const slot of Object.values(entries)) {
+				if (!isObjectRecord(slot)) continue;
+				for (const table of Object.values(slot)) {
+					if (!isObjectRecord(table)) continue;
+					const foreignKeys = table["foreignKeys"];
+					if (!Array.isArray(foreignKeys)) continue;
+					for (const fk of foreignKeys) {
+						if (!isObjectRecord(fk)) continue;
+						const target = fk["target"];
+						if (!isObjectRecord(target)) continue;
+						if (target["spaceId"] === void 0) continue;
+						const targetSpaceId = target["spaceId"];
+						if (typeof targetSpaceId !== "string") continue;
+						if (dependsOnMap.get(targetSpaceId)?.has(ext.id)) throw sqlFamilyError("CONTRACT.FOREIGN_KEY_INVALID", `Cross-space FK reverse-reference detected: extension "${ext.id}" has a cross-space FK targeting space "${targetSpaceId}", but "${targetSpaceId}" depends on "${ext.id}". Cross-space FKs must follow the dependency direction (a space can only reference spaces it depends on, not spaces that depend on it).`, {
+							why: "The foreign key points against the contract-space dependency direction.",
+							fix: "Move the foreign key to the depending space, or restructure the extension dependencies so the referencing space depends on the referenced one.",
+							meta: {
+								extensionId: ext.id,
+								targetSpaceId
+							}
+						});
+					}
+				}
+			}
+		}
+	}
+}
+function createSqlFamilyInstance(stack) {
+	if (!stack.adapter) throw new InternalError("SQL family requires an adapter descriptor in ControlStack");
+	const target = stack.target;
+	const adapter = stack.adapter;
+	const extensions = stack.extensions;
+	for (const extension of extensions) if (extension.contractSpace) {
+		const { contractJson, headRef } = extension.contractSpace;
+		assertDescriptorSelfConsistency({
+			extensionId: extension.id,
+			target: contractJson.target,
+			targetFamily: contractJson.targetFamily,
+			storage: contractJson.storage,
+			headRefHash: headRef.hash,
+			...sqlContractCanonicalizationHooks
+		});
+	}
+	assertNoCrossSpaceFkReverseReferences(extensions);
+	const { codecTypeImports, extensionIds } = stack;
+	const typeMetadataRegistry = buildSqlTypeMetadataRegistry({
+		target,
+		adapter,
+		extensions
+	});
+	let controlAdapter;
+	const getControlAdapter = () => controlAdapter ??= adapter.create(stack);
+	const targetSerializer = target.contractSerializer;
+	const targetInferPslContract = blindCast(target).inferPslContract;
+	const diffSchema = blindCast(target).diffSchema;
+	const targetGranularityOf = blindCast(target).classifySubjectGranularity;
+	const targetEntityKindOf = blindCast(target).classifyEntityKind;
+	const describedContracts = extensions.flatMap((extension) => extension.contractSpace ? [{
+		spaceId: extension.id,
+		contract: extension.contractSpace.contractJson
+	}] : []);
+	const deserializeWithTargetSerializer = (contractOrJson) => {
+		const serializer = targetSerializer ?? new SqlContractSerializer();
+		const json = targetSerializer !== void 0 && !isPlainRecord(contractOrJson) ? targetSerializer.serializeContract(blindCast(contractOrJson)) : contractOrJson;
+		return serializer.deserializeContract(json);
+	};
+	return {
+		familyId: "sql",
+		codecTypeImports,
+		extensionIds,
+		typeMetadataRegistry,
+		deserializeContract(contractJson) {
+			return deserializeWithTargetSerializer(contractJson);
+		},
+		async verify(verifyOptions) {
+			const { driver, contract: rawContract, expectedTargetId, contractPath, configPath } = verifyOptions;
+			const startTime = Date.now();
+			const contract = deserializeWithTargetSerializer(rawContract);
+			const contractStorageHash = contract.storage.storageHash;
+			const contractProfileHash = contract.profileHash;
+			const contractTarget = contract.target;
+			const marker = await getControlAdapter().readMarker(driver, APP_SPACE_ID);
+			let missingCodecs;
+			let codecCoverageSkipped = false;
+			const supportedTypeIds = collectSupportedCodecTypeIds([
+				adapter,
+				target,
+				...extensions
+			]);
+			if (supportedTypeIds.length === 0) codecCoverageSkipped = true;
+			else {
+				const supportedSet = new Set(supportedTypeIds);
+				const missing = extractCodecTypeIdsFromContract(contract).filter((id) => !supportedSet.has(id));
+				if (missing.length > 0) missingCodecs = missing;
+			}
+			if (!marker) return createVerifyResult({
+				ok: false,
+				code: VERIFY_CODE_MARKER_MISSING,
+				summary: "Marker missing",
+				contractStorageHash,
+				expectedTargetId,
+				contractPath,
+				totalTime: Date.now() - startTime,
+				...contractProfileHash ? { contractProfileHash } : {},
+				...missingCodecs ? { missingCodecs } : {},
+				...codecCoverageSkipped ? { codecCoverageSkipped } : {},
+				...configPath ? { configPath } : {}
+			});
+			if (contractTarget !== expectedTargetId) return createVerifyResult({
+				ok: false,
+				code: VERIFY_CODE_TARGET_MISMATCH,
+				summary: "Target mismatch",
+				contractStorageHash,
+				marker,
+				expectedTargetId,
+				actualTargetId: contractTarget,
+				contractPath,
+				totalTime: Date.now() - startTime,
+				...contractProfileHash ? { contractProfileHash } : {},
+				...missingCodecs ? { missingCodecs } : {},
+				...codecCoverageSkipped ? { codecCoverageSkipped } : {},
+				...configPath ? { configPath } : {}
+			});
+			if (marker.storageHash !== contractStorageHash) return createVerifyResult({
+				ok: false,
+				code: VERIFY_CODE_HASH_MISMATCH,
+				summary: "Hash mismatch",
+				contractStorageHash,
+				marker,
+				expectedTargetId,
+				contractPath,
+				totalTime: Date.now() - startTime,
+				...contractProfileHash ? { contractProfileHash } : {},
+				...missingCodecs ? { missingCodecs } : {},
+				...codecCoverageSkipped ? { codecCoverageSkipped } : {},
+				...configPath ? { configPath } : {}
+			});
+			if (contractProfileHash && marker.profileHash !== contractProfileHash) return createVerifyResult({
+				ok: false,
+				code: VERIFY_CODE_HASH_MISMATCH,
+				summary: "Hash mismatch",
+				contractStorageHash,
+				contractProfileHash,
+				marker,
+				expectedTargetId,
+				contractPath,
+				totalTime: Date.now() - startTime,
+				...missingCodecs ? { missingCodecs } : {},
+				...codecCoverageSkipped ? { codecCoverageSkipped } : {},
+				...configPath ? { configPath } : {}
+			});
+			return createVerifyResult({
+				ok: true,
+				summary: "Database matches contract",
+				contractStorageHash,
+				marker,
+				expectedTargetId,
+				contractPath,
+				totalTime: Date.now() - startTime,
+				...contractProfileHash ? { contractProfileHash } : {},
+				...missingCodecs ? { missingCodecs } : {},
+				...codecCoverageSkipped ? { codecCoverageSkipped } : {},
+				...configPath ? { configPath } : {}
+			});
+		},
+		verifySchema(options) {
+			const contract = deserializeWithTargetSerializer(options.contract);
+			if (!diffSchema) throw missingDescriptorOperationError(target.targetId, "diffSchema");
+			if (!targetGranularityOf) throw missingDescriptorOperationError(target.targetId, "classifySubjectGranularity");
+			return verifySqlSchemaByDiff({
+				contract,
+				schema: options.schema,
+				strict: options.strict,
+				frameworkComponents: options.frameworkComponents,
+				diffSchema,
+				granularityOf: targetGranularityOf
+			});
+		},
+		/**
+		* Classifies a diff issue's subject granularity on demand, by resolving
+		* its node's `nodeKind` through the target's classifier — the
+		* {@link import('@internal/framework-components/control').SchemaSubjectClassifierCapable}
+		* capability. Framework consumers spanning contract spaces (the
+		* migration aggregate's unclaimed-elements sweep) detect and call this
+		* instead of reaching into the concrete schema-IR node, which they
+		* cannot read; nothing is stamped on the issue or the node.
+		*/
+		classifySubjectGranularity(issue) {
+			if (!targetGranularityOf) throw missingDescriptorOperationError(target.targetId, "classifySubjectGranularity");
+			return classifyDiffSubjectGranularity(issue, targetGranularityOf);
+		},
+		/**
+		* Classifies a diff issue's subject storage `entityKind` on demand, by
+		* resolving its node's `nodeKind` through the target's classifier —
+		* the sibling of `classifySubjectGranularity` above, and part of the
+		* same {@link import('@internal/framework-components/control').SchemaSubjectClassifierCapable}
+		* capability.
+		*/
+		classifyEntityKind(issue) {
+			if (!targetEntityKindOf) throw missingDescriptorOperationError(target.targetId, "classifyEntityKind");
+			return classifyDiffEntityKind(issue, targetEntityKindOf);
+		},
+		async sign(options) {
+			const { driver, contract: contractInput, contractPath, configPath } = options;
+			const startTime = Date.now();
+			const contract = deserializeWithTargetSerializer(contractInput);
+			const contractStorageHash = contract.storage.storageHash;
+			const contractProfileHash = "profileHash" in contract && typeof contract.profileHash === "string" ? contract.profileHash : contractStorageHash;
+			const contractTarget = contract.target;
+			const controlAdapter = getControlAdapter();
+			const lowererContext = { contract };
+			for (const query of controlAdapter.bootstrapSignMarkerQueries()) {
+				const lowered = await controlAdapter.lowerToExecuteRequest(query, lowererContext);
+				await driver.query(lowered.sql, lowered.params);
+			}
+			const existingMarker = await controlAdapter.readMarker(driver, APP_SPACE_ID);
+			let markerCreated = false;
+			let markerUpdated = false;
+			let previousHashes;
+			if (!existingMarker) {
+				await controlAdapter.insertMarker(driver, APP_SPACE_ID, {
+					storageHash: contractStorageHash,
+					profileHash: contractProfileHash
+				});
+				markerCreated = true;
+			} else {
+				const existingStorageHash = existingMarker.storageHash;
+				const existingProfileHash = existingMarker.profileHash;
+				if (!(existingStorageHash === contractStorageHash) || !(existingProfileHash === contractProfileHash)) {
+					previousHashes = {
+						storageHash: existingStorageHash,
+						profileHash: existingProfileHash
+					};
+					if (!await controlAdapter.updateMarker(driver, APP_SPACE_ID, existingStorageHash, {
+						storageHash: contractStorageHash,
+						profileHash: contractProfileHash
+					})) throw sqlFamilyError("MIGRATION.MARKER_CAS_FAILURE", "CAS conflict: marker was modified by another process during sign", {
+						why: "Another process updated the contract marker between the read and the compare-and-swap write.",
+						fix: "Re-run the sign command; if it keeps failing, make sure only one migration process runs at a time.",
+						meta: { space: APP_SPACE_ID }
+					});
+					markerUpdated = true;
+				}
+			}
+			let summary;
+			if (markerCreated) summary = "Database signed (marker created)";
+			else if (markerUpdated) summary = `Database signed (marker updated from ${previousHashes?.storageHash ?? "unknown"})`;
+			else summary = "Database already signed with this contract";
+			const totalTime = Date.now() - startTime;
+			return {
+				ok: true,
+				summary,
+				contract: {
+					storageHash: contractStorageHash,
+					profileHash: contractProfileHash
+				},
+				target: {
+					expected: contractTarget,
+					actual: contractTarget
+				},
+				marker: {
+					created: markerCreated,
+					updated: markerUpdated,
+					...previousHashes ? { previous: previousHashes } : {}
+				},
+				meta: {
+					contractPath,
+					...configPath ? { configPath } : {}
+				},
+				timings: { total: totalTime }
+			};
+		},
+		async readMarker(options) {
+			return getControlAdapter().readMarker(options.driver, options.space);
+		},
+		async readAllMarkers(options) {
+			return getControlAdapter().readAllMarkers(options.driver);
+		},
+		async readLedger(options) {
+			return getControlAdapter().readLedger(options.driver, options.space);
+		},
+		async initMarker(options) {
+			return getControlAdapter().initMarker(options.driver, options.space, options.destination);
+		},
+		async updateMarker(options) {
+			return getControlAdapter().updateMarker(options.driver, options.space, options.expectedFrom, options.destination);
+		},
+		async writeLedgerEntry(options) {
+			return getControlAdapter().writeLedgerEntry(options.driver, options.space, options.entry);
+		},
+		async introspect(options) {
+			return getControlAdapter().introspect(options.driver, options.contract);
+		},
+		inferPslContract(schemaIR) {
+			if (!targetInferPslContract) throw sqlFamilyError("CONTRACT.INFER_UNSUPPORTED", `Target "${target.targetId}" does not support contract infer (no inferPslContract on its descriptor).`, {
+				why: "The target descriptor does not provide the inferPslContract hook, so a PSL contract cannot be inferred from the database schema.",
+				fix: "Use a target package that supports contract infer, or author the contract instead of inferring it.",
+				meta: { targetId: target.targetId }
+			});
+			return targetInferPslContract(schemaIR, describedContracts);
+		},
+		lowerAst(ast, context) {
+			return getControlAdapter().lowerToExecuteRequest(ast, context);
+		},
+		bootstrapControlTableQueries() {
+			return getControlAdapter().bootstrapControlTableQueries();
+		},
+		toOperationPreview(operations) {
+			return sqlOperationsToPreview(operations);
+		},
+		toSchemaView(schema) {
+			const root = blindCast(schema);
+			const namespaceEntries = root.namespaces !== void 0 ? Object.entries(root.namespaces).map(([namespaceKey, namespace]) => [namespaceKey, namespace.tables]) : [[void 0, root.tables ?? {}]];
+			const qualify = namespaceEntries.length > 1;
+			const tableNodes = namespaceEntries.flatMap(([namespaceKey, tables]) => Object.entries(tables).map(([tableName, table]) => [
+				qualify && namespaceKey !== void 0 ? `${namespaceKey}.${tableName}` : tableName,
+				tableName,
+				table
+			])).map(([displayName, tableName, table]) => {
+				const children = [];
+				const columnNodes = [];
+				for (const [columnName, column] of Object.entries(table.columns)) {
+					const label = `${columnName}: ${column.nativeType} (${column.nullable ? "nullable" : "not nullable"})`;
+					columnNodes.push(new SchemaTreeNode({
+						kind: "field",
+						id: `column-${displayName}-${columnName}`,
+						label,
+						meta: {
+							nativeType: column.nativeType,
+							nullable: column.nullable,
+							...ifDefined("default", column.default)
+						}
+					}));
+				}
+				if (columnNodes.length > 0) children.push(new SchemaTreeNode({
+					kind: "collection",
+					id: `columns-${displayName}`,
+					label: "columns",
+					children: columnNodes
+				}));
+				if (table.primaryKey) {
+					const pkColumns = table.primaryKey.columns.join(", ");
+					children.push(new SchemaTreeNode({
+						kind: "index",
+						id: `primary-key-${displayName}`,
+						label: `primary key: ${pkColumns}`,
+						meta: {
+							columns: table.primaryKey.columns,
+							...table.primaryKey.name ? { name: table.primaryKey.name } : {}
+						}
+					}));
+				}
+				for (const unique of table.uniques) {
+					const name = unique.name ?? `${tableName}_${unique.columns.join("_")}_unique`;
+					const label = `unique ${name}`;
+					children.push(new SchemaTreeNode({
+						kind: "index",
+						id: `unique-${displayName}-${name}`,
+						label,
+						meta: {
+							columns: unique.columns,
+							unique: true
+						}
+					}));
+				}
+				for (const index of table.indexes) {
+					const name = index.name;
+					const label = index.unique ? `unique index ${name}` : `index ${name}`;
+					children.push(new SchemaTreeNode({
+						kind: "index",
+						id: `index-${displayName}-${name}`,
+						label,
+						meta: {
+							columns: index.columns,
+							unique: index.unique
+						}
+					}));
+				}
+				const tableMeta = {};
+				if (table.primaryKey) {
+					tableMeta["primaryKey"] = table.primaryKey.columns;
+					if (table.primaryKey.name) tableMeta["primaryKeyName"] = table.primaryKey.name;
+				}
+				if (table.foreignKeys.length > 0) tableMeta["foreignKeys"] = table.foreignKeys.map((fk) => ({
+					columns: fk.columns,
+					referencedTable: fk.referencedTable,
+					referencedColumns: fk.referencedColumns,
+					...fk.name ? { name: fk.name } : {}
+				}));
+				return new SchemaTreeNode({
+					kind: "entity",
+					id: `table-${displayName}`,
+					label: `table ${displayName}`,
+					...Object.keys(tableMeta).length > 0 ? { meta: tableMeta } : {},
+					...children.length > 0 ? { children } : {}
+				});
+			});
+			return { root: new SchemaTreeNode({
+				kind: "root",
+				id: "sql-schema",
+				label: "database",
+				...tableNodes.length > 0 ? { children: tableNodes } : {}
+			}) };
+		}
+	};
+}
+var SqlFamilyDescriptor = class {
+	kind = "family";
+	id = "sql";
+	familyId = "sql";
+	version = "0.0.1";
+	emission = sqlEmission;
+	authoring = {
+		field: sqlFamilyAuthoringFieldPresets,
+		type: sqlFamilyAuthoringTypes,
+		entityTypes: sqlFamilyEntityTypes,
+		pslBlockDescriptors: sqlFamilyPslBlockDescriptors
+	};
+	create(stack) {
+		return createSqlFamilyInstance(stack);
+	}
+};
+function convertColumn(name, column, storageTypes, expandNativeType, renderDefault, resolveDefault) {
+	const resolved = resolveColumnTypeMetadata(column, storageTypes);
+	const baseNativeType = expandNativeType ? expandNativeType({
+		nativeType: resolved.nativeType,
+		codecId: resolved.codecId,
+		...ifDefined("typeParams", resolved.typeParams)
+	}) : resolved.nativeType;
+	const nativeType = baseNativeType;
+	const resolvedNativeType = column.many ? `${baseNativeType}[]` : baseNativeType;
+	const rawColumnDefault = column.default ?? void 0;
+	const resolvedColumnDefault = rawColumnDefault !== void 0 && resolveDefault ? resolveDefault(rawColumnDefault, resolvedNativeType) : rawColumnDefault;
+	return {
+		name,
+		nativeType,
+		nullable: column.nullable,
+		...ifDefined("many", column.many),
+		...ifDefined("default", column.default != null && renderDefault ? renderDefault(column.default, column) : void 0),
+		resolvedNativeType,
+		...ifDefined("resolvedDefault", resolvedColumnDefault),
+		codecRef: buildColumnCodecRef(resolved, column.many),
+		codecBaseNativeType: resolved.nativeType,
+		...column.typeRef !== void 0 ? { codecNamedType: true } : {}
+	};
+}
+/**
+* Builds the column's `CodecRef` from its resolved (post-`typeRef`) codec
+* identity — the same construction the query AST and the migration DDL
+* renderer already use (TML-2456, TML-2918).
+*/
+function buildColumnCodecRef(resolved, many) {
+	return {
+		codecId: resolved.codecId,
+		...ifDefined("typeParams", resolved.typeParams !== void 0 ? blindCast(resolved.typeParams) : void 0),
+		...ifDefined("many", many)
+	};
+}
+function resolveColumnTypeMetadata(column, storageTypes) {
+	if (!column.typeRef) return column;
+	const referenced = storageTypes[column.typeRef];
+	if (!referenced) throw sqlFamilyError("CONTRACT.TYPE_UNKNOWN", `Column references storage type "${column.typeRef}" but it is not defined in storage.types.`, {
+		why: "The column typeRef does not resolve to any entry in the contract storage.types map.",
+		fix: "Regenerate the contract from its authoring source; do not hand-edit contract JSON.",
+		meta: { typeRef: column.typeRef }
+	});
+	if (isStorageTypeInstance(referenced)) return {
+		codecId: referenced.codecId,
+		nativeType: referenced.nativeType,
+		typeParams: referenced.typeParams
+	};
+	throw new InternalError(`Storage type "${column.typeRef}" has an unknown polymorphic kind; expected a codec-typed StorageTypeInstance.`);
+}
+/**
+* Resolves a `ValueSetRef` to its permitted values from the contract storage.
+*
+* Throws when the referenced namespace or value-set is absent — this indicates
+* the contract was built incorrectly (the check and the value-set must be
+* co-emitted by the lowering step). Used by `convertCheck` (schema-IR
+* projection), `verifyCheckConstraints` (verification), and
+* `checkConstraintPlanCallStrategy` (migration planning) so all three agree on
+* the resolved values and the error behavior on a missing reference.
+*/
+function allStrings(values) {
+	return values.every((value) => typeof value === "string");
+}
+function resolveValueSetValues(ref, storage, contextLabel) {
+	const ns = storage.namespaces[ref.namespaceId];
+	if (!ns) throw sqlFamilyError("CONTRACT.NAMESPACE_UNKNOWN", `resolveValueSetValues: namespace "${ref.namespaceId}" not found in storage (${contextLabel})`, {
+		why: "A value-set reference names a namespace the contract storage does not declare.",
+		fix: "Regenerate the contract from its authoring source; do not hand-edit contract JSON.",
+		meta: {
+			namespaceId: ref.namespaceId,
+			context: contextLabel
+		}
+	});
+	const valueSet = ns.entries.valueSet?.[ref.entityName];
+	if (!valueSet) throw sqlFamilyError("CONTRACT.ENUM_UNKNOWN", `resolveValueSetValues: value-set "${ref.entityName}" not found in namespace "${ref.namespaceId}" (${contextLabel})`, {
+		why: "A value-set reference names an entry its namespace does not declare.",
+		fix: "Regenerate the contract from its authoring source; do not hand-edit contract JSON.",
+		meta: {
+			valueSet: ref.entityName,
+			namespaceId: ref.namespaceId,
+			context: contextLabel
+		}
+	});
+	const values = valueSet.values;
+	if (!allStrings(values)) throw sqlFamilyError("CONTRACT.ENUM_INVALID", `resolveValueSetValues: value-set "${ref.entityName}" in namespace "${ref.namespaceId}" has a non-string value; numeric-enum CHECK constraints are not yet supported (${contextLabel})`, {
+		why: "Only string value-sets can be rendered as CHECK constraints; this value-set carries a non-string value.",
+		fix: "Use string enum values, or drop the CHECK-constrained enum until numeric enums are supported.",
+		meta: {
+			valueSet: ref.entityName,
+			namespaceId: ref.namespaceId,
+			context: contextLabel
+		}
+	});
+	return values;
+}
+/**
+* Projects a `CheckConstraint` IR into an `SqlCheckConstraintIRInput` by
+* resolving the permitted values from the storage value-set it references.
+*
+* The `CheckConstraint.valueSet` ref points to
+* `storage.namespaces[namespaceId].entries.valueSet[name]`. The resolved
+* values are lifted directly from `StorageValueSet.values` so verification
+* compares value sets, not SQL predicate strings.
+*
+* Throws if the referenced namespace or value-set is absent — this
+* indicates the contract was built incorrectly (the check and the
+* value-set must be co-emitted by the lowering step).
+*/
+function convertCheck(check, storage) {
+	const permittedValues = resolveValueSetValues(check.valueSet, storage, `check "${check.name}"`);
+	return {
+		name: check.name,
+		column: check.column,
+		permittedValues
+	};
+}
+function convertUnique(unique, tableName) {
+	return {
+		columns: unique.columns,
+		...ifDefined("name", unique.name),
+		dependsOn: flatColumnDependsOn(tableName, unique.columns)
+	};
+}
+function convertIndex(index, tableName, tableColumns) {
+	const base = {
+		naming: namingOf(index.name, index.prefix),
+		where: index.where,
+		unique: index.unique,
+		partial: index.where !== void 0,
+		type: index.type,
+		options: index.options,
+		annotations: void 0,
+		dependsOn: flatColumnDependsOn(tableName, index.columns ?? tableColumns)
+	};
+	return index.expression !== void 0 ? {
+		...base,
+		expression: index.expression
+	} : {
+		...base,
+		columns: index.columns ?? []
+	};
+}
+/**
+* The referenced table's chain in the flat (single-schema) tree
+* `contractToSchemaIR`/`contractNamespaceToSchemaIR` build: the root
+* (`SqlSchemaIR`, fixed `'database'` id) followed by the table's own id.
+* Postgres discards this when it re-derives the FK against its own
+* multi-schema tree shape (`contractToPostgresDatabaseSchemaNode`); SQLite's
+* flat tree uses it as-is.
+*/
+function flatSchemaDependsOn(tableName) {
+	return [{
+		nodeKind: RelationalSchemaNodeKind.schema,
+		id: "database"
+	}, {
+		nodeKind: RelationalSchemaNodeKind.table,
+		id: tableName
+	}];
+}
+/**
+* The chains from a table-child object (foreign key, index, unique, primary
+* key) to each of the own columns it is built on, in the flat tree. Dropping
+* a covered column auto-drops the object, so the object's drop must precede
+* the column's; the graph derives that direction from these edges.
+*/
+function flatColumnDependsOn(tableName, columns) {
+	return columns.map((column) => [
+		{
+			nodeKind: RelationalSchemaNodeKind.schema,
+			id: "database"
+		},
+		{
+			nodeKind: RelationalSchemaNodeKind.table,
+			id: tableName
+		},
+		{
+			nodeKind: RelationalSchemaNodeKind.column,
+			id: `column:${column}`
+		}
+	]);
+}
+/**
+* The FK's referenced-namespace identity comes from the target's namespace
+* node, not the raw namespace-id string. An unbound target namespace stamps
+* no `referencedSchema` at all — the FK node's id renders the absence as the
+* empty segment, which is what flat (single-schema) introspection produces,
+* so both diff sides' FK ids meet by construction. A bound namespace (or a
+* cross-space target whose namespace lives in another contract's storage)
+* stamps its coordinate verbatim; namespaced targets (Postgres) resolve the
+* real DDL schema downstream.
+*
+* `dependsOn` carries the referenced table (created before the FK, dropped
+* after it) plus the FK's own columns (dropped after the FK, since dropping a
+* column auto-drops the FK built on it).
+*/
+function convertForeignKey(fk, storage) {
+	const targetIsUnbound = storage.namespaces[fk.target.namespaceId]?.isUnbound === true;
+	return {
+		columns: fk.source.columns,
+		referencedTable: fk.target.tableName,
+		...targetIsUnbound ? {} : { referencedSchema: fk.target.namespaceId },
+		referencedColumns: fk.target.columns,
+		...ifDefined("name", fk.name),
+		...ifDefined("onDelete", fk.onDelete),
+		...ifDefined("onUpdate", fk.onUpdate),
+		dependsOn: [flatSchemaDependsOn(fk.target.tableName), ...flatColumnDependsOn(fk.source.tableName, fk.source.columns)]
+	};
+}
+function convertTable(name, table, storageTypes, expandNativeType, renderDefault, resolveDefault, storage) {
+	const columns = {};
+	for (const [colName, colDef] of Object.entries(table.columns)) columns[colName] = convertColumn(colName, colDef, storageTypes, expandNativeType, renderDefault, resolveDefault);
+	const checks = table.checks && table.checks.length > 0 ? table.checks.map((c) => convertCheck(c, storage)) : void 0;
+	return new SqlTableIR({
+		name,
+		columns,
+		...ifDefined("primaryKey", table.primaryKey !== void 0 ? {
+			columns: table.primaryKey.columns,
+			...ifDefined("name", table.primaryKey.name),
+			dependsOn: flatColumnDependsOn(name, table.primaryKey.columns)
+		} : void 0),
+		foreignKeys: table.foreignKeys.map((fk) => convertForeignKey(fk, storage)),
+		uniques: table.uniques.map((u) => convertUnique(u, name)),
+		indexes: table.indexes.map((i) => convertIndex(i, name, Object.keys(table.columns))),
+		...ifDefined("checks", checks)
+	});
+}
+/**
+* Detects destructive changes between two contract storages.
+*
+* The additive-only planner silently ignores removals (tables, columns).
+* This function detects those removals so callers can report them as conflicts
+* rather than silently producing an empty plan.
+*
+* Returns an empty array if no destructive changes are found.
+*/
+function detectDestructiveChanges(from, to) {
+	if (!from) return [];
+	const hasOwn = (value, key) => Object.hasOwn(value, key);
+	const conflicts = [];
+	const namespaceIds = [.../* @__PURE__ */ new Set([...Object.keys(from.namespaces), ...Object.keys(to.namespaces)])].sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+	for (const namespaceId of namespaceIds) {
+		const fromNs = from.namespaces[namespaceId];
+		const toNs = to.namespaces[namespaceId];
+		const fromTables = fromNs?.entries.table;
+		if (!fromTables) continue;
+		for (const tableName of Object.keys(fromTables)) {
+			const toTableRaw = toNs?.entries.table?.[tableName];
+			if (!StorageTable.is(toTableRaw)) {
+				conflicts.push({
+					kind: "tableRemoved",
+					summary: `Table "${tableName}" was removed`
+				});
+				continue;
+			}
+			const toTable = toTableRaw;
+			const fromTableRaw = fromTables[tableName];
+			if (!StorageTable.is(fromTableRaw)) continue;
+			const fromTable = fromTableRaw;
+			for (const columnName of Object.keys(fromTable.columns)) if (!hasOwn(toTable.columns, columnName)) conflicts.push({
+				kind: "columnRemoved",
+				summary: `Column "${tableName}"."${columnName}" was removed`
+			});
+		}
+	}
+	return conflicts;
+}
+/**
+* Converts a `Contract` to `SqlSchemaIR`.
+*
+* Reads `contract.storage` for tables and `contract.storage.types` for type
+* annotations. Storage-type annotations are written under
+* `options.annotationNamespace`.
+*
+* Drops codec metadata (`codecId`, `typeRef`) since the schema IR only represents
+* structural information. When `expandNativeType` is provided, parameterized types
+* are expanded (e.g. `character` + `{ length: 36 }` → `character(36)`) so the
+* resulting IR compares correctly against the "to" contract during planning.
+*
+* Returns an empty schema IR when `contract` is `null` (new project).
+*/
+/**
+* Converts the tables of a single namespace into a `SqlSchemaIR`, keyed by
+* table name within that namespace. Unlike {@link contractToSchemaIR}, which
+* flattens every namespace's tables into one bare-keyed record (and throws on a
+* cross-namespace name collision), this scopes the table iteration to one
+* namespace so the same table name can exist in two schemas.
+*
+* The full `storage` is still passed to `convertTable`, so value-set / enum /
+* type resolution that legitimately spans namespaces is unaffected. Foreign
+* keys are built purely from the FK descriptor (`fk.target`), so cross-namespace
+* FKs survive per-namespace conversion. The `annotations` block (storage-type
+* derived) is omitted here — the per-namespace tree consumer reads only the
+* per-table fields.
+*/
+function contractNamespaceToSchemaIR(storage, namespaceId, options) {
+	if (options.annotationNamespace.length === 0) throw sqlFamilyError("CONTRACT.PACK_CONTRIBUTION_INVALID", "annotationNamespace must be a non-empty string", {
+		why: "The calling target pack passed an empty annotationNamespace to the contract-to-schema-IR projection.",
+		fix: "Fix the target pack to pass its non-empty annotation namespace (e.g. \"pg\").",
+		meta: { option: "annotationNamespace" }
+	});
+	const namespace = storage.namespaces[namespaceId];
+	if (!namespace) return new SqlSchemaIR({ tables: {} });
+	const storageTypes = { ...storage.types ?? {} };
+	const tables = {};
+	for (const [tableName, tableDefRaw] of Object.entries(namespace.entries.table ?? {})) {
+		StorageTable.assert(tableDefRaw, `namespaces.${namespaceId}.entries.table.${tableName}`);
+		tables[tableName] = convertTable(tableName, tableDefRaw, storageTypes, options.expandNativeType, options.renderDefault, options.resolveDefault, storage);
+	}
+	return new SqlSchemaIR({ tables });
+}
+function contractToSchemaIR(contract, options) {
+	if (options.annotationNamespace.length === 0) throw sqlFamilyError("CONTRACT.PACK_CONTRIBUTION_INVALID", "annotationNamespace must be a non-empty string", {
+		why: "The calling target pack passed an empty annotationNamespace to the contract-to-schema-IR projection.",
+		fix: "Fix the target pack to pass its non-empty annotation namespace (e.g. \"pg\").",
+		meta: { option: "annotationNamespace" }
+	});
+	if (!contract) return new SqlSchemaIR({ tables: {} });
+	const storage = contract.storage;
+	const storageTypes = { ...storage.types ?? {} };
+	const tables = {};
+	for (const ns of Object.values(storage.namespaces)) for (const [tableName, tableDefRaw] of Object.entries(ns.entries.table ?? {})) {
+		StorageTable.assert(tableDefRaw, `namespaces.${ns.id}.entries.table.${tableName}`);
+		const tableDef = tableDefRaw;
+		if (tables[tableName] !== void 0) throw sqlFamilyError("CONTRACT.TABLE_AMBIGUOUS", `contractToSchemaIR: duplicate SQL table name "${tableName}" across namespaces (ambiguous for flat SqlSchemaIR.tables).`, {
+			why: "Two namespaces declare a table with the same name, which is ambiguous for the flat schema-IR table map.",
+			fix: "Rename one of the tables so every table name is unique across namespaces.",
+			meta: { table: tableName }
+		});
+		tables[tableName] = convertTable(tableName, tableDef, storageTypes, options.expandNativeType, options.renderDefault, options.resolveDefault, storage);
+	}
+	return new SqlSchemaIR({
+		tables,
+		...ifDefined("annotations", deriveAnnotations(storage, options.annotationNamespace, options.resolveEnumNamespaceSchema))
+	});
+}
+function deriveAnnotations(storage, annotationNamespace, _resolveEnumNamespaceSchema) {
+	const storageTypes = {};
+	for (const typeInstance of Object.values(storage.types ?? {})) if (isStorageTypeInstance(typeInstance)) storageTypes[typeInstance.nativeType] = typeInstance;
+	const envelope = { ...Object.keys(storageTypes).length > 0 ? { storageTypes } : {} };
+	if (Object.keys(envelope).length === 0) return void 0;
+	return { [annotationNamespace]: envelope };
+}
+/**
+* The control policy that governs a single call. The `external` default is an
+* un-overridable namespace floor: when the contract default is `external`, no
+* per-object `managed` override can escalate DDL above the floor, so the
+* policy is forced to `external` regardless of the node's own declaration.
+* Every other default defers to the node's effective control policy.
+*/
+function controlPolicyForCall(subject, defaultControlPolicy) {
+	if (defaultControlPolicy === "external") return "external";
+	return effectiveControlPolicy(subject?.explicitNodeControlPolicy, defaultControlPolicy);
+}
+/**
+* Whether a call is allowed to emit under a given control policy.
+*
+* - `managed` — full lifecycle, every op allowed.
+* - `tolerated` — create-if-absent only: allowed iff the call creates a whole
+*   new top-level object (and its subject was positively resolved). Anything
+*   that modifies an existing object, and anything whose subject could not be
+*   resolved, is suppressed.
+* - `external` / `observed` — no DDL at all.
+*/
+function callAllowedUnderControlPolicy(policy, subject) {
+	switch (policy) {
+		case "managed": return true;
+		case "tolerated": return subject?.createsNewObject === true;
+		case "external":
+		case "observed": return false;
+	}
+}
+/**
+* Partition the calls produced for a single set of subjects into those the
+* effective control policy permits (`kept`) and a list of
+* {@link SuppressionRecord}s describing the suppressed calls.
+*
+* **Prefer {@link partitionIssuesByControlPolicy}** for the schema-issue
+* pipeline: it filters subjects out of the planner's *input* so the planner
+* never has to reason about un-modeled state on `external`/`observed`
+* subjects. This call-level helper remains for paths that bypass the issue
+* pipeline — currently the codec-emitted field-event ops, which originate
+* from declared contract fields rather than from introspected schema state
+* and therefore cannot trip the diff engine.
+*/
+function partitionCallsByControlPolicy(options) {
+	const defaultControlPolicy = options.contract.defaultControlPolicy;
+	const kept = [];
+	const suppressions = [];
+	for (const call of options.calls) {
+		const subject = options.resolveControlPolicySubject(call);
+		const policy = controlPolicyForCall(subject, defaultControlPolicy);
+		if (callAllowedUnderControlPolicy(policy, subject)) kept.push(call);
+		else suppressions.push({
+			subject,
+			policy,
+			factoryName: options.resolveFactoryName(call),
+			createsNewObject: subject?.createsNewObject ?? false
+		});
+	}
+	return Object.freeze({
+		kept: Object.freeze(kept),
+		suppressions: Object.freeze(suppressions)
+	});
+}
+/**
+* Partition a list of schema-issue-shaped inputs by the effective control
+* policy of each issue's subject *before* the planner is invoked.
+*
+* `plannable` is the list of issues whose subject's effective policy permits
+* the planner to act on them (`managed`, or `tolerated` for whole-object
+* creation issues only). Issues for `external`/`observed` subjects, and
+* non-creation issues for `tolerated` subjects, are dropped from the planner's
+* input entirely — they never enter introspection-driven planning, never feed
+* the diff engine, and never produce DDL calls that would have to be
+* post-filtered. This sidesteps a class of failure where the diff engine
+* cannot reason about the live shape of a subject the user marked as
+* out-of-scope (`external`).
+*
+* `suppressions` is one {@link SuppressionRecord} per suppressed subject (not
+* per suppressed issue). Its `factoryName` is the creation factory name when any
+* of the subject's issues is whole-object creation (e.g. `createTable`), else
+* `undefined` — the family never invents a modification verb for an op that
+* produced no call; the target renders the message.
+*
+* Unresolved-subject issues (`resolveControlPolicySubject` returns
+* `undefined`) emit one record each; they cannot be deduplicated because they
+* carry no subject coordinate.
+*/
+function partitionIssuesByControlPolicy(options) {
+	const defaultControlPolicy = options.contract.defaultControlPolicy;
+	const plannable = [];
+	const suppressedSubjects = /* @__PURE__ */ new Map();
+	const unresolvedSuppressions = [];
+	for (const issue of options.issues) {
+		const subject = options.resolveControlPolicySubject(issue);
+		const policy = controlPolicyForCall(subject, defaultControlPolicy);
+		const creationFactoryName = options.resolveCreationFactoryName(issue);
+		if (policy === "managed") {
+			plannable.push(issue);
+			continue;
+		}
+		if (policy === "tolerated" && subject !== void 0 && creationFactoryName !== void 0 && subject.createsNewObject) {
+			plannable.push(issue);
+			continue;
+		}
+		if (subject === void 0) {
+			unresolvedSuppressions.push({
+				subject: void 0,
+				policy,
+				factoryName: creationFactoryName,
+				createsNewObject: false
+			});
+			continue;
+		}
+		const key = subjectKey(subject);
+		const existing = suppressedSubjects.get(key);
+		if (existing) {
+			if (existing.creationFactoryName === void 0 && creationFactoryName !== void 0) existing.creationFactoryName = creationFactoryName;
+		} else suppressedSubjects.set(key, {
+			subject,
+			policy,
+			...ifDefined("creationFactoryName", creationFactoryName)
+		});
+	}
+	const suppressions = [...unresolvedSuppressions];
+	for (const entry of suppressedSubjects.values()) suppressions.push({
+		subject: entry.subject,
+		policy: entry.policy,
+		factoryName: entry.creationFactoryName,
+		createsNewObject: entry.subject.createsNewObject
+	});
+	return Object.freeze({
+		plannable: Object.freeze(plannable),
+		suppressions: Object.freeze(suppressions)
+	});
+}
+function subjectKey(subject) {
+	return `${subject.namespaceId}\u0000${subject.entityKind ?? ""}\u0000${subject.entityName ?? ""}\u0000${subject.rlsPolicy ?? ""}`;
+}
+function planFieldEventOperations(options) {
+	const priorContract = options.priorContract;
+	const newContract = options.newContract;
+	const added = [];
+	const dropped = [];
+	const altered = [];
+	const namespaceIds = unionSorted(priorContract ? Object.keys(priorContract.storage.namespaces) : [], Object.keys(newContract.storage.namespaces));
+	for (const namespaceId of namespaceIds) {
+		const priorNs = priorContract?.storage.namespaces[namespaceId];
+		const newNs = newContract.storage.namespaces[namespaceId];
+		const priorTables = priorNs?.entries.table;
+		const newTables = newNs?.entries.table;
+		const tableNames = unionSorted(priorTables ? Object.keys(priorTables) : [], newTables ? Object.keys(newTables) : []);
+		for (const tableName of tableNames) {
+			const priorTableRaw = priorTables?.[tableName];
+			const newTableRaw = newTables?.[tableName];
+			const priorTable = StorageTable.is(priorTableRaw) ? priorTableRaw : void 0;
+			const newTable = StorageTable.is(newTableRaw) ? newTableRaw : void 0;
+			const fieldNames = unionSorted(priorTable ? Object.keys(priorTable.columns) : [], newTable ? Object.keys(newTable.columns) : []);
+			for (const fieldName of fieldNames) {
+				const priorField = priorTable?.columns[fieldName];
+				const newField = newTable?.columns[fieldName];
+				const entry = {
+					namespaceId,
+					tableName,
+					fieldName,
+					priorTable,
+					newTable,
+					priorField,
+					newField
+				};
+				if (priorField === void 0 && newField !== void 0) added.push(entry);
+				else if (priorField !== void 0 && newField === void 0) dropped.push(entry);
+				else if (priorField !== void 0 && newField !== void 0) {
+					if (isAlteration(priorField, newField)) altered.push(entry);
+				}
+			}
+		}
+	}
+	const calls = [];
+	appendCalls("added", added, options.codecHooks, calls, (e) => e.newField?.codecId);
+	appendCalls("dropped", dropped, options.codecHooks, calls, (e) => e.priorField?.codecId);
+	appendCalls("altered", altered, options.codecHooks, calls, (e) => e.newField?.codecId);
+	return calls;
+}
+function appendCalls(event, entries, codecHooks, calls, pickCodecId) {
+	for (const entry of entries) {
+		const codecId = pickCodecId(entry);
+		if (codecId === void 0) continue;
+		const hook = codecHooks.get(codecId);
+		if (!hook?.onFieldEvent) continue;
+		const ctx = buildContext(event, entry);
+		const emitted = hook.onFieldEvent(event, ctx);
+		for (const call of emitted) calls.push(call);
+	}
+}
+/**
+* The context's prior/new sides are scoped to the event:
+*
+* - `'added'`   — only `newTable` / `newField` populated.
+* - `'dropped'` — only `priorTable` / `priorField` populated.
+* - `'altered'` — both sides populated.
+*/
+function buildContext(event, entry) {
+	const base = {
+		namespaceId: entry.namespaceId,
+		tableName: entry.tableName,
+		fieldName: entry.fieldName
+	};
+	if (event === "added") return {
+		...base,
+		...entry.newTable !== void 0 ? { newTable: entry.newTable } : {},
+		...entry.newField !== void 0 ? { newField: entry.newField } : {}
+	};
+	if (event === "dropped") return {
+		...base,
+		...entry.priorTable !== void 0 ? { priorTable: entry.priorTable } : {},
+		...entry.priorField !== void 0 ? { priorField: entry.priorField } : {}
+	};
+	return {
+		...base,
+		...entry.priorTable !== void 0 ? { priorTable: entry.priorTable } : {},
+		...entry.newTable !== void 0 ? { newTable: entry.newTable } : {},
+		...entry.priorField !== void 0 ? { priorField: entry.priorField } : {},
+		...entry.newField !== void 0 ? { newField: entry.newField } : {}
+	};
+}
+/**
+* `'altered'` predicate. Returns `false` whenever `codecId` differs —
+* any codec change suppresses the `altered` event entirely, including
+* cases where another property also differs in the same diff. Codec
+* rotation is a v1 non-goal; avoiding the mixed event keeps the
+* migration semantics for codec changes explicit rather than smuggling
+* them through as `altered`.
+*
+* For non-`codecId` diffs, returns `true` iff any other column property
+* differs.
+*/
+function isAlteration(prior, current) {
+	if (prior.codecId !== current.codecId) return false;
+	return !sameStorageColumn(prior, current);
+}
+function sameStorageColumn(a, b) {
+	if (a === b) return true;
+	if (a.nativeType !== b.nativeType) return false;
+	if (a.nullable !== b.nullable) return false;
+	if (a.typeRef !== b.typeRef) return false;
+	if (!sameJson(a.typeParams, b.typeParams)) return false;
+	if (!sameJson(a.default, b.default)) return false;
+	return true;
+}
+function sameJson(a, b) {
+	if (a === b) return true;
+	if (a === void 0 || b === void 0) return false;
+	return JSON.stringify(a) === JSON.stringify(b);
+}
+function unionSorted(a, b) {
+	const set = /* @__PURE__ */ new Set();
+	for (const name of a) set.add(name);
+	for (const name of b) set.add(name);
+	return [...set].sort((x, y) => x < y ? -1 : x > y ? 1 : 0);
+}
+/**
+* Builds the codec-hook-composed `expandNativeType` callback the contract→IR
+* derivation uses to expand parameterized native types (e.g. `character` +
+* `{ length: 36 }` → `character(36)`). Returns `undefined` when no framework
+* components are supplied, so callers can omit the option entirely.
+*/
+function buildNativeTypeExpander(frameworkComponents) {
+	if (!frameworkComponents) return;
+	const codecHooks = extractCodecControlHooks(frameworkComponents);
+	return (input) => {
+		if (!input.typeParams) return input.nativeType;
+		if (!input.codecId) return input.nativeType;
+		const hooks = codecHooks.get(input.codecId);
+		if (!hooks?.expandNativeType) return input.nativeType;
+		return hooks.expandNativeType(input);
+	};
+}
+const readOnlyEmptyObject = Object.freeze({});
+function cloneRecord(value) {
+	if (value === readOnlyEmptyObject) return value;
+	return Object.freeze({ ...value });
+}
+function freezeSteps(steps) {
+	if (steps.length === 0) return Object.freeze([]);
+	return Object.freeze(steps.map((step) => Object.freeze({
+		description: step.description,
+		sql: step.sql,
+		...step.params ? { params: Object.freeze([...step.params]) } : {},
+		...step.meta ? { meta: cloneRecord(step.meta) } : {}
+	})));
+}
+function freezeDetailsValue(value) {
+	if (value === null || value === void 0) return value;
+	if (typeof value !== "object") return value;
+	if (Array.isArray(value)) return Object.freeze([...value]);
+	return Object.freeze({ ...value });
+}
+function freezeTargetDetails(target) {
+	return Object.freeze({
+		id: target.id,
+		...target.details !== void 0 ? { details: freezeDetailsValue(target.details) } : {}
+	});
+}
+function freezeOperation(operation) {
+	return Object.freeze({
+		id: operation.id,
+		label: operation.label,
+		...operation.summary ? { summary: operation.summary } : {},
+		operationClass: operation.operationClass,
+		...operation.invariantId ? { invariantId: operation.invariantId } : {},
+		target: freezeTargetDetails(operation.target),
+		precheck: freezeSteps(operation.precheck),
+		execute: freezeSteps(operation.execute),
+		postcheck: freezeSteps(operation.postcheck),
+		...operation.meta ? { meta: cloneRecord(operation.meta) } : {}
+	});
+}
+function freezeOperations(operations) {
+	if (operations.length === 0) return Object.freeze([]);
+	return Object.freeze(operations.map((operation) => freezeOperation(operation)));
+}
+function createMigrationPlan(options) {
+	return Object.freeze({
+		targetId: options.targetId,
+		spaceId: options.spaceId,
+		...options.origin !== void 0 ? { origin: options.origin ? Object.freeze({ ...options.origin }) : null } : {},
+		destination: Object.freeze({ ...options.destination }),
+		operations: freezeOperations(options.operations),
+		providedInvariants: Object.freeze([...options.providedInvariants]),
+		...options.meta ? { meta: cloneRecord(options.meta) } : {}
+	});
+}
+function plannerSuccess(plan, warnings) {
+	return Object.freeze({
+		kind: "success",
+		plan,
+		...warnings && warnings.length > 0 ? { warnings: Object.freeze(warnings.map((conflict) => Object.freeze({
+			kind: conflict.kind,
+			summary: conflict.summary,
+			...conflict.why ? { why: conflict.why } : {},
+			...conflict.location ? { location: Object.freeze({ ...conflict.location }) } : {},
+			...conflict.meta ? { meta: cloneRecord(conflict.meta) } : {}
+		}))) } : {}
+	});
+}
+function plannerFailure(conflicts) {
+	return Object.freeze({
+		kind: "failure",
+		conflicts: Object.freeze(conflicts.map((conflict) => Object.freeze({
+			kind: conflict.kind,
+			summary: conflict.summary,
+			...conflict.why ? { why: conflict.why } : {},
+			...conflict.location ? { location: Object.freeze({ ...conflict.location }) } : {},
+			...conflict.meta ? { meta: cloneRecord(conflict.meta) } : {}
+		})))
+	});
+}
+/**
+* Creates a successful migration runner result.
+*/
+function runnerSuccess(value) {
+	return ok(Object.freeze({
+		operationsPlanned: value.operationsPlanned,
+		operationsExecuted: value.operationsExecuted
+	}));
+}
+/**
+* Creates a failed migration runner result.
+*/
+function runnerFailure(code, summary, options) {
+	return notOk(Object.freeze({
+		code,
+		summary,
+		...options?.why ? { why: options.why } : {},
+		...options?.meta ? { meta: cloneRecord(options.meta) } : {}
+	}));
+}
+/**
+* Policy used by `db init`: additive-only operations, no widening/destructive steps.
+*/
+const INIT_ADDITIVE_POLICY = Object.freeze({ allowedOperationClasses: Object.freeze(["additive"]) });
+var control_default = new SqlFamilyDescriptor();
+//#endregion
+export { runnerSuccess as _, contractToSchemaIR as a, createMigrationPlan as c, partitionIssuesByControlPolicy as d, planFieldEventOperations as f, runnerFailure as g, resolveValueSetValues as h, contractNamespaceToSchemaIR as i, detectDestructiveChanges as l, plannerSuccess as m, assembleAuthoringContributions as n, controlPolicyForCall as o, plannerFailure as p, buildNativeTypeExpander as r, control_default as s, INIT_ADDITIVE_POLICY as t, partitionCallsByControlPolicy as u };
+
+//# sourceMappingURL=control-B7iS4jv4.mjs.map