@prisma-next/family-sql 0.14.0 → 0.15.0-dev.1

package/dist/verify-sql-schema-xT4udQLQ.mjs

@@ -1,1501 +0,0 @@
-import { assertUniqueCodecOwner, dispositionForCategory } from "@prisma-next/framework-components/control";
-import { defaultIndexName } from "@prisma-next/sql-schema-ir/naming";
-import { ifDefined } from "@prisma-next/utils/defined";
-import { UNBOUND_NAMESPACE_ID } from "@prisma-next/framework-components/ir";
-import { StorageTable, isStorageTypeInstance } from "@prisma-next/sql-contract/types";
-import { effectiveControlPolicy } from "@prisma-next/contract/types";
-import { canonicalStringify } from "@prisma-next/utils/canonical-stringify";
-//#region src/core/assembly.ts
-function hasCodecControlHooks(descriptor) {
-	if (typeof descriptor !== "object" || descriptor === null) return false;
-	const hooks = descriptor.types?.codecTypes?.controlPlaneHooks;
-	return hooks !== null && hooks !== void 0 && typeof hooks === "object";
-}
-function extractCodecControlHooks(descriptors) {
-	const hooks = /* @__PURE__ */ new Map();
-	const owners = /* @__PURE__ */ new Map();
-	for (const descriptor of descriptors) {
-		if (typeof descriptor !== "object" || descriptor === null) continue;
-		if (!hasCodecControlHooks(descriptor)) continue;
-		const controlPlaneHooks = descriptor.types.codecTypes.controlPlaneHooks;
-		for (const [codecId, hook] of Object.entries(controlPlaneHooks)) {
-			assertUniqueCodecOwner({
-				codecId,
-				owners,
-				descriptorId: descriptor.id,
-				entityLabel: "control hooks",
-				entityOwnershipLabel: "owner"
-			});
-			hooks.set(codecId, hook);
-			owners.set(codecId, descriptor.id);
-		}
-	}
-	return hooks;
-}
-//#endregion
-//#region src/core/migrations/contract-to-schema-ir.ts
-function convertColumn(name, column, storageTypes, expandNativeType, renderDefault) {
-	const resolved = resolveColumnTypeMetadata(column, storageTypes);
-	return {
-		name,
-		nativeType: expandNativeType ? expandNativeType({
-			nativeType: resolved.nativeType,
-			codecId: resolved.codecId,
-			...ifDefined("typeParams", resolved.typeParams)
-		}) : resolved.nativeType,
-		nullable: column.nullable,
-		...ifDefined("default", column.default != null && renderDefault ? renderDefault(column.default, column) : void 0)
-	};
-}
-function resolveColumnTypeMetadata(column, storageTypes) {
-	if (!column.typeRef) return column;
-	const referenced = storageTypes[column.typeRef];
-	if (!referenced) throw new Error(`Column references storage type "${column.typeRef}" but it is not defined in storage.types.`);
-	if (isStorageTypeInstance(referenced)) return {
-		codecId: referenced.codecId,
-		nativeType: referenced.nativeType,
-		typeParams: referenced.typeParams
-	};
-	throw new Error(`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 new Error(`resolveValueSetValues: namespace "${ref.namespaceId}" not found in storage (${contextLabel})`);
-	const valueSet = ns.entries.valueSet?.[ref.entityName];
-	if (!valueSet) throw new Error(`resolveValueSetValues: value-set "${ref.entityName}" not found in namespace "${ref.namespaceId}" (${contextLabel})`);
-	const values = valueSet.values;
-	if (!allStrings(values)) throw new Error(`resolveValueSetValues: value-set "${ref.entityName}" in namespace "${ref.namespaceId}" has a non-string value; numeric-enum CHECK constraints are not yet supported (${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) {
-	return {
-		columns: unique.columns,
-		...ifDefined("name", unique.name)
-	};
-}
-function convertIndex(index) {
-	return {
-		columns: index.columns,
-		unique: false,
-		...ifDefined("name", index.name)
-	};
-}
-function convertForeignKey(fk) {
-	return {
-		columns: fk.source.columns,
-		referencedTable: fk.target.tableName,
-		referencedSchema: fk.target.namespaceId,
-		referencedColumns: fk.target.columns,
-		...ifDefined("name", fk.name),
-		...ifDefined("onDelete", fk.onDelete),
-		...ifDefined("onUpdate", fk.onUpdate)
-	};
-}
-function convertTable(name, table, storageTypes, expandNativeType, renderDefault, storage) {
-	const columns = {};
-	for (const [colName, colDef] of Object.entries(table.columns)) columns[colName] = convertColumn(colName, colDef, storageTypes, expandNativeType, renderDefault);
-	const satisfiedIndexColumns = new Set([
-		...table.indexes.map((idx) => idx.columns.join(",")),
-		...table.uniques.map((unique) => unique.columns.join(",")),
-		...table.primaryKey ? [table.primaryKey.columns.join(",")] : []
-	]);
-	const fkBackingIndexes = [];
-	for (const fk of table.foreignKeys) {
-		if (fk.index === false) continue;
-		const key = fk.source.columns.join(",");
-		if (satisfiedIndexColumns.has(key)) continue;
-		fkBackingIndexes.push({
-			columns: fk.source.columns,
-			unique: false,
-			name: defaultIndexName(name, fk.source.columns)
-		});
-		satisfiedIndexColumns.add(key);
-	}
-	const checks = table.checks && table.checks.length > 0 ? table.checks.map((c) => convertCheck(c, storage)) : void 0;
-	return {
-		name,
-		columns,
-		...ifDefined("primaryKey", table.primaryKey),
-		foreignKeys: table.foreignKeys.filter((fk) => fk.constraint !== false).map(convertForeignKey),
-		uniques: table.uniques.map(convertUnique),
-		indexes: [...table.indexes.map(convertIndex), ...fkBackingIndexes],
-		...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 = [...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 (!(toTableRaw instanceof StorageTable)) {
-				conflicts.push({
-					kind: "tableRemoved",
-					summary: `Table "${tableName}" was removed`
-				});
-				continue;
-			}
-			const toTable = toTableRaw;
-			const fromTableRaw = fromTables[tableName];
-			if (!(fromTableRaw instanceof StorageTable)) 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).
-*/
-function contractToSchemaIR(contract, options) {
-	if (options.annotationNamespace.length === 0) throw new Error("annotationNamespace must be a non-empty string");
-	if (!contract) return { 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 ?? {})) {
-		if (!(tableDefRaw instanceof StorageTable)) throw new Error(`contractToSchemaIR: expected StorageTable at namespaces.${ns.id}.entries.table.${tableName}`);
-		const tableDef = tableDefRaw;
-		if (tables[tableName] !== void 0) throw new Error(`contractToSchemaIR: duplicate SQL table name "${tableName}" across namespaces (ambiguous for flat SqlSchemaIR.tables).`);
-		tables[tableName] = convertTable(tableName, tableDef, storageTypes, options.expandNativeType, options.renderDefault, storage);
-	}
-	return {
-		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 };
-}
-//#endregion
-//#region src/core/schema-verify/verifier-disposition.ts
-/**
-* Classifies the relational verifier issue kinds the SQL family emits (tables,
-* columns, constraints, indexes, defaults, enum types) into the target-neutral
-* categories the framework grades. The relational vocabulary lives here, in the
-* SQL domain — the framework never switches over `extra_foreign_key` and friends.
-*/
-function classifySqlVerifierIssueKind(kind) {
-	switch (kind) {
-		case "extra_column": return "extraNestedElement";
-		case "extra_primary_key":
-		case "extra_foreign_key":
-		case "extra_unique_constraint":
-		case "extra_index":
-		case "extra_validator":
-		case "extra_default": return "extraAuxiliary";
-		case "extra_table": return "extraTopLevelObject";
-		case "missing_schema":
-		case "missing_table":
-		case "missing_column":
-		case "type_missing":
-		case "default_missing": return "declaredMissing";
-		case "type_values_mismatch":
-		case "enum_values_changed":
-		case "check_mismatch": return "valueDrift";
-		case "type_mismatch":
-		case "nullability_mismatch":
-		case "primary_key_mismatch":
-		case "foreign_key_mismatch":
-		case "unique_constraint_mismatch":
-		case "index_mismatch":
-		case "default_mismatch": return "declaredIncompatible";
-		case "check_missing": return "declaredMissing";
-		case "check_removed": return "extraAuxiliary";
-	}
-}
-function verifierDisposition(controlPolicy, issueKind) {
-	return dispositionForCategory(controlPolicy, classifySqlVerifierIssueKind(issueKind));
-}
-//#endregion
-//#region src/core/schema-verify/control-verify-emit.ts
-/**
-* Grades `issue` under `controlPolicy` and, unless suppressed, pushes both the
-* issue and a status-stamped verification node. Returns the resolved outcome so
-* the caller never re-grades the same issue.
-*/
-function emitIssueAndNodeUnderControlPolicy(controlPolicy, issue, node, issues, nodes) {
-	const disposition = verifierDisposition(controlPolicy, issue.kind);
-	if (disposition === "suppress") return disposition;
-	issues.push(issue);
-	nodes.push({
-		...node,
-		status: disposition
-	});
-	return disposition;
-}
-/**
-* Grades `issue` under `controlPolicy` and, unless suppressed, pushes the issue
-* (no verification node). Returns the resolved outcome so the caller maps it to
-* a node status itself without re-grading.
-*/
-function emitIssueUnderControlPolicy(controlPolicy, issue, issues) {
-	const disposition = verifierDisposition(controlPolicy, issue.kind);
-	if (disposition === "suppress") return disposition;
-	issues.push(issue);
-	return disposition;
-}
-//#endregion
-//#region src/core/schema-verify/verify-helpers.ts
-function indexOptionsLooselyEqual(a, b) {
-	const aKeys = a ? Object.keys(a).sort() : [];
-	const bKeys = b ? Object.keys(b).sort() : [];
-	if (aKeys.length !== bKeys.length) return false;
-	for (let i = 0; i < aKeys.length; i += 1) if (aKeys[i] !== bKeys[i]) return false;
-	if (aKeys.length === 0) return true;
-	for (const key of aKeys) if (String(a[key]) !== String(b[key])) return false;
-	return true;
-}
-function indexExtrasMatch(contractIndex, schemaIndex) {
-	if ((contractIndex.type ?? null) !== (schemaIndex.type ?? null)) return false;
-	return indexOptionsLooselyEqual(contractIndex.options, schemaIndex.options);
-}
-/**
-* Compares two arrays of strings for equality (order-sensitive).
-*/
-function arraysEqual(a, b) {
-	if (a.length !== b.length) return false;
-	for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
-	return true;
-}
-/**
-* Checks if a unique constraint requirement is satisfied by the given columns.
-*
-* Semantic satisfaction: a unique constraint requirement can be satisfied by:
-* - A unique constraint with the same columns, OR
-* - A unique index with the same columns
-*
-* @param uniques - The unique constraints in the schema table
-* @param indexes - The indexes in the schema table
-* @param columns - The columns required by the unique constraint
-* @returns true if the requirement is satisfied
-*/
-function isUniqueConstraintSatisfied(uniques, indexes, columns) {
-	if (uniques.some((unique) => arraysEqual(unique.columns, columns))) return true;
-	return indexes.some((index) => index.unique && arraysEqual(index.columns, columns));
-}
-/**
-* Checks if an index requirement is satisfied by the given columns.
-*
-* Semantic satisfaction: a non-unique index requirement can be satisfied by:
-* - Any index (unique or non-unique) with the same columns, OR
-* - A unique constraint with the same columns (stronger satisfies weaker)
-*
-* @param indexes - The indexes in the schema table
-* @param uniques - The unique constraints in the schema table
-* @param columns - The columns required by the index
-* @returns true if the requirement is satisfied
-*/
-function isIndexSatisfied(indexes, uniques, columns) {
-	if (indexes.some((index) => arraysEqual(index.columns, columns))) return true;
-	return uniques.some((unique) => arraysEqual(unique.columns, columns));
-}
-/**
-* Verifies primary key matches between contract and schema.
-* Returns 'pass' or 'fail'.
-*
-* Uses semantic satisfaction: identity is based on (table + kind + columns).
-* Name differences are ignored by default (names are for DDL/diagnostics, not identity).
-*/
-function verifyPrimaryKey(contractPK, schemaPK, tableName, namespaceId, tableControlPolicy, issues) {
-	if (!schemaPK) {
-		const outcome = emitIssueUnderControlPolicy(tableControlPolicy, {
-			kind: "primary_key_mismatch",
-			table: tableName,
-			namespaceId,
-			expected: contractPK.columns.join(", "),
-			message: `Table "${tableName}" is missing primary key`
-		}, issues);
-		return outcome === "suppress" ? "pass" : outcome;
-	}
-	if (!arraysEqual(contractPK.columns, schemaPK.columns)) {
-		const outcome = emitIssueUnderControlPolicy(tableControlPolicy, {
-			kind: "primary_key_mismatch",
-			table: tableName,
-			namespaceId,
-			expected: contractPK.columns.join(", "),
-			actual: schemaPK.columns.join(", "),
-			message: `Table "${tableName}" has primary key mismatch: expected columns [${contractPK.columns.join(", ")}], got [${schemaPK.columns.join(", ")}]`
-		}, issues);
-		return outcome === "suppress" ? "pass" : outcome;
-	}
-	return "pass";
-}
-/**
-* Verifies foreign keys match between contract and schema.
-* Returns verification nodes for the tree.
-*
-* Uses semantic satisfaction: identity is based on (table + columns + referenced table + referenced columns).
-* Name differences are ignored by default (names are for DDL/diagnostics, not identity).
-*/
-function verifyForeignKeys(contractFKs, schemaFKs, tableName, namespaceId, tablePath, tableControlPolicy, issues, strict) {
-	const nodes = [];
-	for (const contractFK of contractFKs) {
-		const fkPath = `${tablePath}.foreignKeys[${contractFK.source.columns.join(",")}]`;
-		const matchingFK = schemaFKs.find((fk) => {
-			const tablesMatch = fk.referencedSchema !== void 0 && contractFK.target.namespaceId !== UNBOUND_NAMESPACE_ID ? fk.referencedSchema === contractFK.target.namespaceId && fk.referencedTable === contractFK.target.tableName : fk.referencedTable === contractFK.target.tableName;
-			return arraysEqual(fk.columns, contractFK.source.columns) && tablesMatch && arraysEqual(fk.referencedColumns, contractFK.target.columns);
-		});
-		if (!matchingFK) emitIssueAndNodeUnderControlPolicy(tableControlPolicy, {
-			kind: "foreign_key_mismatch",
-			table: tableName,
-			namespaceId,
-			expected: `${contractFK.source.columns.join(", ")} -> ${contractFK.target.tableName}(${contractFK.target.columns.join(", ")})`,
-			message: `Table "${tableName}" is missing foreign key: ${contractFK.source.columns.join(", ")} -> ${contractFK.target.tableName}(${contractFK.target.columns.join(", ")})`
-		}, {
-			status: "fail",
-			kind: "foreignKey",
-			name: `foreignKey(${contractFK.source.columns.join(", ")})`,
-			contractPath: fkPath,
-			code: "foreign_key_mismatch",
-			message: "Foreign key missing",
-			expected: contractFK,
-			actual: void 0,
-			children: []
-		}, issues, nodes);
-		else {
-			const actionMismatches = getReferentialActionMismatches(contractFK, matchingFK);
-			if (actionMismatches.length > 0) {
-				const combinedMessage = actionMismatches.map((m) => m.message).join("; ");
-				const combinedExpected = actionMismatches.map((m) => m.expected).join(", ");
-				const combinedActual = actionMismatches.map((m) => m.actual).join(", ");
-				emitIssueAndNodeUnderControlPolicy(tableControlPolicy, {
-					kind: "foreign_key_mismatch",
-					table: tableName,
-					namespaceId,
-					indexOrConstraint: matchingFK.name ?? `fk(${contractFK.source.columns.join(",")})`,
-					expected: combinedExpected,
-					actual: combinedActual,
-					message: `Table "${tableName}" foreign key ${contractFK.source.columns.join(", ")} -> ${contractFK.target.tableName}: ${combinedMessage}`
-				}, {
-					status: "fail",
-					kind: "foreignKey",
-					name: `foreignKey(${contractFK.source.columns.join(", ")})`,
-					contractPath: fkPath,
-					code: "foreign_key_mismatch",
-					message: combinedMessage,
-					expected: contractFK,
-					actual: matchingFK,
-					children: []
-				}, issues, nodes);
-			} else nodes.push({
-				status: "pass",
-				kind: "foreignKey",
-				name: `foreignKey(${contractFK.source.columns.join(", ")})`,
-				contractPath: fkPath,
-				code: "",
-				message: "",
-				expected: void 0,
-				actual: void 0,
-				children: []
-			});
-		}
-	}
-	if (strict) {
-		for (const schemaFK of schemaFKs) if (!contractFKs.find((fk) => {
-			const tablesMatch = schemaFK.referencedSchema !== void 0 && fk.target.namespaceId !== UNBOUND_NAMESPACE_ID ? schemaFK.referencedSchema === fk.target.namespaceId && schemaFK.referencedTable === fk.target.tableName : schemaFK.referencedTable === fk.target.tableName;
-			return arraysEqual(fk.source.columns, schemaFK.columns) && tablesMatch && arraysEqual(fk.target.columns, schemaFK.referencedColumns);
-		})) emitIssueAndNodeUnderControlPolicy(tableControlPolicy, {
-			kind: "extra_foreign_key",
-			table: tableName,
-			namespaceId,
-			indexOrConstraint: schemaFK.name ?? `fk(${schemaFK.columns.join(",")})`,
-			message: `Extra foreign key found in database (not in contract): ${schemaFK.columns.join(", ")} -> ${schemaFK.referencedTable}(${schemaFK.referencedColumns.join(", ")})`
-		}, {
-			status: "fail",
-			kind: "foreignKey",
-			name: `foreignKey(${schemaFK.columns.join(", ")})`,
-			contractPath: `${tablePath}.foreignKeys[${schemaFK.columns.join(",")}]`,
-			code: "extra_foreign_key",
-			message: "Extra foreign key found",
-			expected: void 0,
-			actual: schemaFK,
-			children: []
-		}, issues, nodes);
-	}
-	return nodes;
-}
-/**
-* Verifies unique constraints match between contract and schema.
-* Returns verification nodes for the tree.
-*
-* Uses semantic satisfaction: identity is based on (table + kind + columns).
-* A unique constraint requirement can be satisfied by either:
-* - A unique constraint with the same columns, or
-* - A unique index with the same columns
-*
-* Name differences are ignored by default (names are for DDL/diagnostics, not identity).
-*/
-function verifyUniqueConstraints(contractUniques, schemaUniques, schemaIndexes, tableName, namespaceId, tablePath, tableControlPolicy, issues, strict) {
-	const nodes = [];
-	for (const contractUnique of contractUniques) {
-		const uniquePath = `${tablePath}.uniques[${contractUnique.columns.join(",")}]`;
-		const matchingUnique = schemaUniques.find((u) => arraysEqual(u.columns, contractUnique.columns));
-		const matchingUniqueIndex = !matchingUnique && schemaIndexes.find((idx) => idx.unique && arraysEqual(idx.columns, contractUnique.columns));
-		if (!matchingUnique && !matchingUniqueIndex) emitIssueAndNodeUnderControlPolicy(tableControlPolicy, {
-			kind: "unique_constraint_mismatch",
-			table: tableName,
-			namespaceId,
-			expected: contractUnique.columns.join(", "),
-			message: `Table "${tableName}" is missing unique constraint: ${contractUnique.columns.join(", ")}`
-		}, {
-			status: "fail",
-			kind: "unique",
-			name: `unique(${contractUnique.columns.join(", ")})`,
-			contractPath: uniquePath,
-			code: "unique_constraint_mismatch",
-			message: "Unique constraint missing",
-			expected: contractUnique,
-			actual: void 0,
-			children: []
-		}, issues, nodes);
-		else nodes.push({
-			status: "pass",
-			kind: "unique",
-			name: `unique(${contractUnique.columns.join(", ")})`,
-			contractPath: uniquePath,
-			code: "",
-			message: "",
-			expected: void 0,
-			actual: void 0,
-			children: []
-		});
-	}
-	if (strict) {
-		for (const schemaUnique of schemaUniques) if (!contractUniques.find((u) => arraysEqual(u.columns, schemaUnique.columns))) emitIssueAndNodeUnderControlPolicy(tableControlPolicy, {
-			kind: "extra_unique_constraint",
-			table: tableName,
-			namespaceId,
-			indexOrConstraint: schemaUnique.name ?? `unique(${schemaUnique.columns.join(",")})`,
-			message: `Extra unique constraint found in database (not in contract): ${schemaUnique.columns.join(", ")}`
-		}, {
-			status: "fail",
-			kind: "unique",
-			name: `unique(${schemaUnique.columns.join(", ")})`,
-			contractPath: `${tablePath}.uniques[${schemaUnique.columns.join(",")}]`,
-			code: "extra_unique_constraint",
-			message: "Extra unique constraint found",
-			expected: void 0,
-			actual: schemaUnique,
-			children: []
-		}, issues, nodes);
-	}
-	return nodes;
-}
-/**
-* Verifies indexes match between contract and schema.
-* Returns verification nodes for the tree.
-*
-* Uses semantic satisfaction: identity is based on (table + kind + columns).
-* A non-unique index requirement can be satisfied by either:
-* - A non-unique index with the same columns, or
-* - A unique index with the same columns (stronger satisfies weaker)
-*
-* Name differences are ignored by default (names are for DDL/diagnostics, not identity).
-*/
-function verifyIndexes(contractIndexes, schemaIndexes, schemaUniques, tableName, namespaceId, tablePath, tableControlPolicy, issues, strict) {
-	const nodes = [];
-	for (const contractIndex of contractIndexes) {
-		const indexPath = `${tablePath}.indexes[${contractIndex.columns.join(",")}]`;
-		const matchingIndex = schemaIndexes.find((idx) => arraysEqual(idx.columns, contractIndex.columns) && indexExtrasMatch(contractIndex, idx));
-		const matchingUniqueConstraint = !matchingIndex && contractIndex.type === void 0 && contractIndex.options === void 0 && schemaUniques.find((u) => arraysEqual(u.columns, contractIndex.columns));
-		if (!matchingIndex && !matchingUniqueConstraint) emitIssueAndNodeUnderControlPolicy(tableControlPolicy, {
-			kind: "index_mismatch",
-			table: tableName,
-			namespaceId,
-			expected: contractIndex.columns.join(", "),
-			message: `Table "${tableName}" is missing index: ${contractIndex.columns.join(", ")}`
-		}, {
-			status: "fail",
-			kind: "index",
-			name: `index(${contractIndex.columns.join(", ")})`,
-			contractPath: indexPath,
-			code: "index_mismatch",
-			message: "Index missing",
-			expected: contractIndex,
-			actual: void 0,
-			children: []
-		}, issues, nodes);
-		else nodes.push({
-			status: "pass",
-			kind: "index",
-			name: `index(${contractIndex.columns.join(", ")})`,
-			contractPath: indexPath,
-			code: "",
-			message: "",
-			expected: void 0,
-			actual: void 0,
-			children: []
-		});
-	}
-	if (strict) for (const schemaIndex of schemaIndexes) {
-		if (schemaIndex.unique) continue;
-		if (!contractIndexes.find((idx) => arraysEqual(idx.columns, schemaIndex.columns) && indexExtrasMatch(idx, schemaIndex))) emitIssueAndNodeUnderControlPolicy(tableControlPolicy, {
-			kind: "extra_index",
-			table: tableName,
-			namespaceId,
-			indexOrConstraint: schemaIndex.name ?? `idx(${schemaIndex.columns.join(",")})`,
-			message: `Extra index found in database (not in contract): ${schemaIndex.columns.join(", ")}`
-		}, {
-			status: "fail",
-			kind: "index",
-			name: `index(${schemaIndex.columns.join(", ")})`,
-			contractPath: `${tablePath}.indexes[${schemaIndex.columns.join(",")}]`,
-			code: "extra_index",
-			message: "Extra index found",
-			expected: void 0,
-			actual: schemaIndex,
-			children: []
-		}, issues, nodes);
-	}
-	return nodes;
-}
-/**
-* Computes counts of pass/warn/fail nodes by traversing the tree.
-*/
-function computeCounts(node) {
-	let pass = 0;
-	let warn = 0;
-	let fail = 0;
-	function traverse(n) {
-		if (n.status === "pass") pass++;
-		else if (n.status === "warn") warn++;
-		else if (n.status === "fail") fail++;
-		if (n.children) for (const child of n.children) traverse(child);
-	}
-	traverse(node);
-	return {
-		pass,
-		warn,
-		fail,
-		totalNodes: pass + warn + fail
-	};
-}
-/**
-* Compares referential actions between a contract FK and a schema FK.
-* Only compares when the contract FK explicitly specifies onDelete or onUpdate.
-* Returns all mismatches (both onDelete and onUpdate) so both are reported at once.
-*
-* Note: 'noAction' in the contract is semantically equivalent to undefined in the
-* schema IR, because the introspection adapter omits 'NO ACTION' (the database default)
-* to keep the IR sparse. We normalize both sides before comparing.
-*/
-function getReferentialActionMismatches(contractFK, schemaFK) {
-	const mismatches = [];
-	const contractOnDelete = normalizeReferentialAction(contractFK.onDelete);
-	const schemaOnDelete = normalizeReferentialAction(schemaFK.onDelete);
-	if (contractOnDelete !== void 0 && contractOnDelete !== schemaOnDelete) mismatches.push({
-		expected: `onDelete: ${contractFK.onDelete}`,
-		actual: `onDelete: ${schemaFK.onDelete ?? "noAction (default)"}`,
-		message: `onDelete mismatch: expected ${contractFK.onDelete}, got ${schemaFK.onDelete ?? "noAction (default)"}`
-	});
-	const contractOnUpdate = normalizeReferentialAction(contractFK.onUpdate);
-	const schemaOnUpdate = normalizeReferentialAction(schemaFK.onUpdate);
-	if (contractOnUpdate !== void 0 && contractOnUpdate !== schemaOnUpdate) mismatches.push({
-		expected: `onUpdate: ${contractFK.onUpdate}`,
-		actual: `onUpdate: ${schemaFK.onUpdate ?? "noAction (default)"}`,
-		message: `onUpdate mismatch: expected ${contractFK.onUpdate}, got ${schemaFK.onUpdate ?? "noAction (default)"}`
-	});
-	return mismatches;
-}
-/**
-* Normalizes a referential action value for comparison.
-* 'noAction' is the database default and equivalent to undefined (omitted) in the sparse IR.
-*/
-function normalizeReferentialAction(action) {
-	return action === "noAction" ? void 0 : action;
-}
-/**
-* Compares two value arrays as unordered sets.
-* Returns true when both sides contain exactly the same values.
-*/
-function valueSetsEqual(a, b) {
-	const aSet = new Set(a);
-	const bSet = new Set(b);
-	if (aSet.size !== bSet.size) return false;
-	return [...aSet].every((v) => bSet.has(v));
-}
-/**
-* Verifies check constraints match between contract-projected checks and
-* introspected live checks.
-*
-* Comparison is value-set-based, not SQL-string-based. Postgres rewrites
-* `col IN ('a','b')` as `col = ANY (ARRAY['a','b'])` in
-* `pg_get_constraintdef`, so comparing the extracted value sets (after
-* the introspection adapter parses the predicate) avoids false mismatches
-* from the `IN`-vs-`= ANY (ARRAY…)` rendering difference.
-*
-* Issues emitted:
-* - `check_missing` — check expected by contract but absent from live DB
-* - `check_removed` — check present in live DB but not in contract
-* - `check_mismatch` — check present on both sides but permitted values differ
-*
-* `check_removed` is emitted only when `strict` is true so non-strict
-* verification (the normal path) does not complain about extra constraints.
-*/
-function verifyCheckConstraints(contractChecks, schemaChecks, tableName, namespaceId, tablePath, tableControlPolicy, issues, strict) {
-	const nodes = [];
-	for (const contractCheck of contractChecks) {
-		const checkPath = `${tablePath}.checks[${contractCheck.name}]`;
-		const liveCheck = schemaChecks.find((c) => c.name === contractCheck.name);
-		if (!liveCheck) emitIssueAndNodeUnderControlPolicy(tableControlPolicy, {
-			kind: "check_missing",
-			table: tableName,
-			namespaceId,
-			indexOrConstraint: contractCheck.name,
-			expected: contractCheck.permittedValues.join(", "),
-			message: `Table "${tableName}" is missing check constraint "${contractCheck.name}" (column "${contractCheck.column}" IN (${contractCheck.permittedValues.join(", ")}))`
-		}, {
-			status: "fail",
-			kind: "checkConstraint",
-			name: `check(${contractCheck.name})`,
-			contractPath: checkPath,
-			code: "check_missing",
-			message: `Check constraint "${contractCheck.name}" missing`,
-			expected: contractCheck,
-			actual: void 0,
-			children: []
-		}, issues, nodes);
-		else if (!valueSetsEqual(contractCheck.permittedValues, liveCheck.permittedValues)) emitIssueAndNodeUnderControlPolicy(tableControlPolicy, {
-			kind: "check_mismatch",
-			table: tableName,
-			namespaceId,
-			indexOrConstraint: contractCheck.name,
-			expected: contractCheck.permittedValues.join(", "),
-			actual: liveCheck.permittedValues.join(", "),
-			message: `Table "${tableName}" check constraint "${contractCheck.name}" has different permitted values: expected [${contractCheck.permittedValues.join(", ")}], got [${liveCheck.permittedValues.join(", ")}]`
-		}, {
-			status: "fail",
-			kind: "checkConstraint",
-			name: `check(${contractCheck.name})`,
-			contractPath: checkPath,
-			code: "check_mismatch",
-			message: `Check constraint "${contractCheck.name}" values mismatch`,
-			expected: contractCheck,
-			actual: liveCheck,
-			children: []
-		}, issues, nodes);
-		else nodes.push({
-			status: "pass",
-			kind: "checkConstraint",
-			name: `check(${contractCheck.name})`,
-			contractPath: checkPath,
-			code: "",
-			message: "",
-			expected: void 0,
-			actual: void 0,
-			children: []
-		});
-	}
-	if (strict) {
-		for (const liveCheck of schemaChecks) if (!contractChecks.find((c) => c.name === liveCheck.name)) emitIssueAndNodeUnderControlPolicy(tableControlPolicy, {
-			kind: "check_removed",
-			table: tableName,
-			namespaceId,
-			indexOrConstraint: liveCheck.name,
-			actual: liveCheck.permittedValues.join(", "),
-			message: `Table "${tableName}" has extra check constraint "${liveCheck.name}" in database (not in contract)`
-		}, {
-			status: "fail",
-			kind: "checkConstraint",
-			name: `check(${liveCheck.name})`,
-			contractPath: `${tablePath}.checks[${liveCheck.name}]`,
-			code: "check_removed",
-			message: `Extra check constraint "${liveCheck.name}" found`,
-			expected: void 0,
-			actual: liveCheck,
-			children: []
-		}, issues, nodes);
-	}
-	return nodes;
-}
-//#endregion
-//#region src/core/schema-verify/verify-sql-schema.ts
-/**
-* Verifies that a SqlSchemaIR matches a Contract.
-*
-* This is a pure function that does NOT perform any database I/O.
-* It takes an already-introspected schema IR and compares it against
-* the contract requirements.
-*
-* @param options - Verification options
-* @returns VerifyDatabaseSchemaResult with verification tree and issues
-*/
-function verifySqlSchema(options) {
-	const { contract, schema, strict, context, typeMetadataRegistry, normalizeDefault, normalizeNativeType } = options;
-	const startTime = Date.now();
-	const codecHooks = extractCodecControlHooks(options.frameworkComponents);
-	const { contractStorageHash, contractProfileHash, contractTarget } = extractContractMetadata(contract);
-	const { issues, rootChildren } = verifySchemaTables({
-		contract,
-		schema,
-		strict,
-		typeMetadataRegistry,
-		codecHooks,
-		storageTypes: contract.storage.types ?? {},
-		...ifDefined("normalizeDefault", normalizeDefault),
-		...ifDefined("normalizeNativeType", normalizeNativeType)
-	});
-	validateFrameworkComponentsForExtensions(contract, options.frameworkComponents);
-	const typeNodes = [];
-	const pushTypeNode = (typeName, contractPath, typeIssues, controlPolicy) => {
-		let status = "pass";
-		let code = "";
-		let emitted = 0;
-		for (const issue of typeIssues) {
-			const disposition = verifierDisposition(controlPolicy, issue.kind);
-			if (disposition === "suppress") continue;
-			issues.push(issue);
-			emitted += 1;
-			if (code === "") code = issue.kind;
-			if (disposition === "fail") status = "fail";
-			else if (disposition === "warn" && status !== "fail") status = "warn";
-		}
-		typeNodes.push({
-			status,
-			kind: "storageType",
-			name: `type ${typeName}`,
-			contractPath,
-			code: status === "pass" ? "" : code,
-			message: emitted > 0 ? `${emitted} issue${emitted === 1 ? "" : "s"}` : "",
-			expected: void 0,
-			actual: void 0,
-			children: []
-		});
-	};
-	for (const [typeName, typeInstance] of Object.entries(contract.storage.types ?? {})) if (isStorageTypeInstance(typeInstance)) {
-		const hook = codecHooks.get(typeInstance.codecId);
-		pushTypeNode(typeName, `storage.types.${typeName}`, hook?.verifyType ? hook.verifyType({
-			typeName,
-			typeInstance,
-			schema
-		}) : [], effectiveControlPolicy(void 0, contract.defaultControlPolicy));
-	}
-	if (typeNodes.length > 0) {
-		const typesStatus = typeNodes.some((n) => n.status === "fail") ? "fail" : typeNodes.some((n) => n.status === "warn") ? "warn" : "pass";
-		rootChildren.push({
-			status: typesStatus,
-			kind: "storageTypes",
-			name: "types",
-			contractPath: "storage.types",
-			code: typesStatus === "fail" ? "type_mismatch" : "",
-			message: "",
-			expected: void 0,
-			actual: void 0,
-			children: typeNodes
-		});
-	}
-	const root = buildRootNode(rootChildren);
-	const counts = computeCounts(root);
-	const ok = counts.fail === 0;
-	const code = ok ? void 0 : "PN-SCHEMA-0001";
-	const summary = ok ? "Database schema satisfies contract" : `Database schema does not satisfy contract (${counts.fail} failure${counts.fail === 1 ? "" : "s"})`;
-	const totalTime = Date.now() - startTime;
-	return {
-		ok,
-		...ifDefined("code", code),
-		summary,
-		contract: {
-			storageHash: contractStorageHash,
-			...ifDefined("profileHash", contractProfileHash)
-		},
-		target: {
-			expected: contractTarget,
-			actual: contractTarget
-		},
-		schema: {
-			issues,
-			root,
-			counts
-		},
-		meta: {
-			strict,
-			...ifDefined("contractPath", context?.contractPath),
-			...ifDefined("configPath", context?.configPath)
-		},
-		timings: { total: totalTime }
-	};
-}
-function extractContractMetadata(contract) {
-	return {
-		contractStorageHash: contract.storage.storageHash,
-		contractProfileHash: "profileHash" in contract && typeof contract.profileHash === "string" ? contract.profileHash : void 0,
-		contractTarget: contract.target
-	};
-}
-function verifySchemaTables(options) {
-	const { contract, schema, strict, typeMetadataRegistry, codecHooks, storageTypes, normalizeDefault, normalizeNativeType } = options;
-	const contractDefaultControl = contract.defaultControlPolicy;
-	const issues = [];
-	const rootChildren = [];
-	const schemaTables = schema.tables;
-	const namespaceIds = Object.keys(contract.storage.namespaces).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
-	for (const namespaceId of namespaceIds) {
-		const ns = contract.storage.namespaces[namespaceId];
-		if (!ns) continue;
-		for (const [tableName, contractTableRaw] of Object.entries(ns.entries.table ?? {})) {
-			if (!(contractTableRaw instanceof StorageTable)) throw new Error(`verifySqlSchema: expected StorageTable at storage.namespaces.${namespaceId}.entries.table.${tableName}`);
-			const contractTable = contractTableRaw;
-			const tableControlPolicy = effectiveControlPolicy(contractTable.control, contractDefaultControl);
-			const schemaTable = schemaTables[tableName];
-			const tablePath = `storage.namespaces.${namespaceId}.entries.table.${tableName}`;
-			if (!schemaTable) {
-				emitIssueAndNodeUnderControlPolicy(tableControlPolicy, {
-					kind: "missing_table",
-					table: tableName,
-					namespaceId,
-					message: `Table "${tableName}" is missing from database`
-				}, {
-					status: "fail",
-					kind: "table",
-					name: `table ${tableName}`,
-					contractPath: tablePath,
-					code: "missing_table",
-					message: `Table "${tableName}" is missing`,
-					expected: void 0,
-					actual: void 0,
-					children: []
-				}, issues, rootChildren);
-				continue;
-			}
-			const tableChildren = verifyTableChildren({
-				contractTable,
-				schemaTable,
-				tableName,
-				namespaceId,
-				tablePath,
-				tableControlPolicy,
-				issues,
-				strict,
-				typeMetadataRegistry,
-				codecHooks,
-				storageTypes,
-				contractStorage: contract.storage,
-				...ifDefined("normalizeDefault", normalizeDefault),
-				...ifDefined("normalizeNativeType", normalizeNativeType)
-			});
-			rootChildren.push(buildTableNode(tableName, tablePath, tableChildren));
-		}
-	}
-	if (strict) {
-		for (const tableName of Object.keys(schemaTables)) if (!namespaceIds.some((namespaceId) => contract.storage.namespaces[namespaceId]?.entries.table?.[tableName] !== void 0)) emitIssueAndNodeUnderControlPolicy(effectiveControlPolicy(void 0, contractDefaultControl), {
-			kind: "extra_table",
-			table: tableName,
-			message: `Extra table "${tableName}" found in database (not in contract)`
-		}, {
-			status: "fail",
-			kind: "table",
-			name: `table ${tableName}`,
-			contractPath: `storage.namespaces.*.entries.table.${tableName}`,
-			code: "extra_table",
-			message: `Extra table "${tableName}" found`,
-			expected: void 0,
-			actual: void 0,
-			children: []
-		}, issues, rootChildren);
-	}
-	return {
-		issues,
-		rootChildren
-	};
-}
-function verifyTableChildren(options) {
-	const { contractTable, schemaTable, tableName, namespaceId, tablePath, tableControlPolicy, issues, strict, typeMetadataRegistry, codecHooks, storageTypes, normalizeDefault, normalizeNativeType, contractStorage } = options;
-	const tableChildren = [];
-	const columnNodes = collectContractColumnNodes({
-		contractTable,
-		schemaTable,
-		tableName,
-		namespaceId,
-		tablePath,
-		tableControlPolicy,
-		issues,
-		strict,
-		typeMetadataRegistry,
-		codecHooks,
-		storageTypes,
-		...ifDefined("normalizeDefault", normalizeDefault),
-		...ifDefined("normalizeNativeType", normalizeNativeType)
-	});
-	if (columnNodes.length > 0) tableChildren.push(buildColumnsNode(tablePath, columnNodes));
-	if (strict) appendExtraColumnNodes({
-		contractTable,
-		schemaTable,
-		tableName,
-		namespaceId,
-		tablePath,
-		tableControlPolicy,
-		issues,
-		columnNodes
-	});
-	if (contractTable.primaryKey) {
-		const pkStatus = verifyPrimaryKey(contractTable.primaryKey, schemaTable.primaryKey, tableName, namespaceId, tableControlPolicy, issues);
-		if (pkStatus === "fail") tableChildren.push({
-			status: "fail",
-			kind: "primaryKey",
-			name: `primary key: ${contractTable.primaryKey.columns.join(", ")}`,
-			contractPath: `${tablePath}.primaryKey`,
-			code: "primary_key_mismatch",
-			message: "Primary key mismatch",
-			expected: contractTable.primaryKey,
-			actual: schemaTable.primaryKey,
-			children: []
-		});
-		else if (pkStatus === "warn") tableChildren.push({
-			status: "warn",
-			kind: "primaryKey",
-			name: `primary key: ${contractTable.primaryKey.columns.join(", ")}`,
-			contractPath: `${tablePath}.primaryKey`,
-			code: "primary_key_mismatch",
-			message: "Primary key mismatch",
-			expected: contractTable.primaryKey,
-			actual: schemaTable.primaryKey,
-			children: []
-		});
-		else tableChildren.push({
-			status: "pass",
-			kind: "primaryKey",
-			name: `primary key: ${contractTable.primaryKey.columns.join(", ")}`,
-			contractPath: `${tablePath}.primaryKey`,
-			code: "",
-			message: "",
-			expected: void 0,
-			actual: void 0,
-			children: []
-		});
-	} else if (schemaTable.primaryKey && strict) emitIssueAndNodeUnderControlPolicy(tableControlPolicy, {
-		kind: "extra_primary_key",
-		table: tableName,
-		namespaceId,
-		message: "Extra primary key found in database (not in contract)"
-	}, {
-		status: "fail",
-		kind: "primaryKey",
-		name: `primary key: ${schemaTable.primaryKey.columns.join(", ")}`,
-		contractPath: `${tablePath}.primaryKey`,
-		code: "extra_primary_key",
-		message: "Extra primary key found",
-		expected: void 0,
-		actual: schemaTable.primaryKey,
-		children: []
-	}, issues, tableChildren);
-	const constraintFks = contractTable.foreignKeys.filter((fk) => fk.constraint === true);
-	if (constraintFks.length > 0 || strict) {
-		const fkStatuses = verifyForeignKeys(constraintFks, schemaTable.foreignKeys, tableName, namespaceId, tablePath, tableControlPolicy, issues, strict);
-		tableChildren.push(...fkStatuses);
-	}
-	const uniqueStatuses = verifyUniqueConstraints(contractTable.uniques, schemaTable.uniques, schemaTable.indexes, tableName, namespaceId, tablePath, tableControlPolicy, issues, strict);
-	tableChildren.push(...uniqueStatuses);
-	const fkBackingIndexes = contractTable.foreignKeys.filter((fk) => fk.index === true && !contractTable.indexes.some((idx) => arraysEqual(idx.columns, fk.source.columns))).map((fk) => ({ columns: fk.source.columns }));
-	const indexStatuses = verifyIndexes([...contractTable.indexes, ...fkBackingIndexes], schemaTable.indexes, schemaTable.uniques, tableName, namespaceId, tablePath, tableControlPolicy, issues, strict);
-	tableChildren.push(...indexStatuses);
-	const contractCheckIRs = (contractTable.checks ?? []).map((c) => ({
-		name: c.name,
-		column: c.column,
-		permittedValues: resolveValueSetValues(c.valueSet, contractStorage, `check "${c.name}"`)
-	}));
-	if (strict || contractCheckIRs.length > 0) {
-		const checkStatuses = verifyCheckConstraints(contractCheckIRs, schemaTable.checks ?? [], tableName, namespaceId, tablePath, tableControlPolicy, issues, strict);
-		tableChildren.push(...checkStatuses);
-	}
-	return tableChildren;
-}
-function collectContractColumnNodes(options) {
-	const { contractTable, schemaTable, tableName, namespaceId, tablePath, tableControlPolicy, issues, strict, typeMetadataRegistry, codecHooks, storageTypes, normalizeDefault, normalizeNativeType } = options;
-	const columnNodes = [];
-	for (const [columnName, contractColumn] of Object.entries(contractTable.columns)) {
-		const schemaColumn = schemaTable.columns[columnName];
-		const columnPath = `${tablePath}.columns.${columnName}`;
-		if (!schemaColumn) {
-			emitIssueAndNodeUnderControlPolicy(tableControlPolicy, {
-				kind: "missing_column",
-				table: tableName,
-				namespaceId,
-				column: columnName,
-				message: `Column "${tableName}"."${columnName}" is missing from database`
-			}, {
-				status: "fail",
-				kind: "column",
-				name: `${columnName}: missing`,
-				contractPath: columnPath,
-				code: "missing_column",
-				message: `Column "${columnName}" is missing`,
-				expected: void 0,
-				actual: void 0,
-				children: []
-			}, issues, columnNodes);
-			continue;
-		}
-		columnNodes.push(verifyColumn({
-			tableName,
-			namespaceId,
-			columnName,
-			contractColumn,
-			schemaColumn,
-			columnPath,
-			tableControlPolicy,
-			issues,
-			strict,
-			typeMetadataRegistry,
-			codecHooks,
-			storageTypes,
-			...ifDefined("normalizeDefault", normalizeDefault),
-			...ifDefined("normalizeNativeType", normalizeNativeType)
-		}));
-	}
-	return columnNodes;
-}
-function appendExtraColumnNodes(options) {
-	const { contractTable, schemaTable, tableName, namespaceId, tablePath, tableControlPolicy, issues, columnNodes } = options;
-	for (const [columnName, { nativeType }] of Object.entries(schemaTable.columns)) if (!contractTable.columns[columnName]) emitIssueAndNodeUnderControlPolicy(tableControlPolicy, {
-		kind: "extra_column",
-		table: tableName,
-		namespaceId,
-		column: columnName,
-		message: `Extra column "${tableName}"."${columnName}" found in database (not in contract)`
-	}, {
-		status: "fail",
-		kind: "column",
-		name: `${columnName}: extra`,
-		contractPath: `${tablePath}.columns.${columnName}`,
-		code: "extra_column",
-		message: `Extra column "${columnName}" found`,
-		expected: void 0,
-		actual: nativeType,
-		children: []
-	}, issues, columnNodes);
-}
-function verifyColumn(options) {
-	const { tableName, namespaceId, columnName, contractColumn, schemaColumn, columnPath, tableControlPolicy, issues, strict, codecHooks, storageTypes, normalizeDefault, normalizeNativeType } = options;
-	const columnChildren = [];
-	let columnStatus = "pass";
-	const resolvedContractColumn = resolveContractColumnTypeMetadata(contractColumn, storageTypes, {
-		tableName,
-		columnName
-	});
-	const contractNativeType = renderExpectedNativeType(contractColumn, storageTypes, codecHooks, {
-		tableName,
-		columnName
-	});
-	const schemaNativeType = normalizeNativeType?.(schemaColumn.nativeType) ?? schemaColumn.nativeType;
-	if (!(contractNativeType === schemaNativeType)) {
-		const issue = {
-			kind: "type_mismatch",
-			table: tableName,
-			namespaceId,
-			column: columnName,
-			expected: contractNativeType,
-			actual: schemaNativeType,
-			message: `Column "${tableName}"."${columnName}" has type mismatch: expected "${contractNativeType}", got "${schemaNativeType}"`
-		};
-		const disposition = verifierDisposition(tableControlPolicy, issue.kind);
-		if (disposition !== "suppress") {
-			issues.push(issue);
-			columnChildren.push({
-				status: disposition,
-				kind: "type",
-				name: "type",
-				contractPath: `${columnPath}.nativeType`,
-				code: "type_mismatch",
-				message: `Type mismatch: expected ${contractNativeType}, got ${schemaNativeType}`,
-				expected: contractNativeType,
-				actual: schemaNativeType,
-				children: []
-			});
-			columnStatus = disposition;
-		}
-	}
-	if (resolvedContractColumn.codecId) {
-		const typeMetadata = options.typeMetadataRegistry.get(resolvedContractColumn.codecId);
-		if (!typeMetadata) columnChildren.push({
-			status: "warn",
-			kind: "type",
-			name: "type_metadata_missing",
-			contractPath: `${columnPath}.codecId`,
-			code: "type_metadata_missing",
-			message: `codecId "${resolvedContractColumn.codecId}" not found in type metadata registry`,
-			expected: resolvedContractColumn.codecId,
-			actual: void 0,
-			children: []
-		});
-		else if (typeMetadata.nativeType && typeMetadata.nativeType !== resolvedContractColumn.nativeType) columnChildren.push({
-			status: "warn",
-			kind: "type",
-			name: "type_consistency",
-			contractPath: `${columnPath}.codecId`,
-			code: "type_consistency_warning",
-			message: `codecId "${resolvedContractColumn.codecId}" maps to nativeType "${typeMetadata.nativeType}" in registry, but contract has "${resolvedContractColumn.nativeType}"`,
-			expected: typeMetadata.nativeType,
-			actual: resolvedContractColumn.nativeType,
-			children: []
-		});
-	}
-	if (contractColumn.nullable !== schemaColumn.nullable) {
-		const issue = {
-			kind: "nullability_mismatch",
-			table: tableName,
-			namespaceId,
-			column: columnName,
-			expected: String(contractColumn.nullable),
-			actual: String(schemaColumn.nullable),
-			message: `Column "${tableName}"."${columnName}" has nullability mismatch: expected ${contractColumn.nullable ? "nullable" : "not null"}, got ${schemaColumn.nullable ? "nullable" : "not null"}`
-		};
-		const disposition = verifierDisposition(tableControlPolicy, issue.kind);
-		if (disposition !== "suppress") {
-			issues.push(issue);
-			columnChildren.push({
-				status: disposition,
-				kind: "nullability",
-				name: "nullability",
-				contractPath: `${columnPath}.nullable`,
-				code: "nullability_mismatch",
-				message: `Nullability mismatch: expected ${contractColumn.nullable ? "nullable" : "not null"}, got ${schemaColumn.nullable ? "nullable" : "not null"}`,
-				expected: contractColumn.nullable,
-				actual: schemaColumn.nullable,
-				children: []
-			});
-			columnStatus = disposition;
-		}
-	}
-	if (contractColumn.default) {
-		if (!schemaColumn.default) {
-			const defaultDescription = describeColumnDefault(contractColumn.default);
-			const issue = {
-				kind: "default_missing",
-				table: tableName,
-				namespaceId,
-				column: columnName,
-				expected: defaultDescription,
-				message: `Column "${tableName}"."${columnName}" should have default ${defaultDescription} but database has no default`
-			};
-			const disposition = verifierDisposition(tableControlPolicy, issue.kind);
-			if (disposition !== "suppress") {
-				issues.push(issue);
-				columnChildren.push({
-					status: disposition,
-					kind: "default",
-					name: "default",
-					contractPath: `${columnPath}.default`,
-					code: "default_missing",
-					message: `Default missing: expected ${defaultDescription}`,
-					expected: defaultDescription,
-					actual: void 0,
-					children: []
-				});
-				columnStatus = disposition;
-			}
-		} else if (!columnDefaultsEqual(contractColumn.default, schemaColumn.default, normalizeDefault, schemaNativeType)) {
-			const expectedDescription = describeColumnDefault(contractColumn.default);
-			const actualDescription = schemaColumn.default;
-			const issue = {
-				kind: "default_mismatch",
-				table: tableName,
-				namespaceId,
-				column: columnName,
-				expected: expectedDescription,
-				actual: actualDescription,
-				message: `Column "${tableName}"."${columnName}" has default mismatch: expected ${expectedDescription}, got ${actualDescription}`
-			};
-			const disposition = verifierDisposition(tableControlPolicy, issue.kind);
-			if (disposition !== "suppress") {
-				issues.push(issue);
-				columnChildren.push({
-					status: disposition,
-					kind: "default",
-					name: "default",
-					contractPath: `${columnPath}.default`,
-					code: "default_mismatch",
-					message: `Default mismatch: expected ${expectedDescription}, got ${actualDescription}`,
-					expected: expectedDescription,
-					actual: actualDescription,
-					children: []
-				});
-				columnStatus = disposition;
-			}
-		}
-	} else if (strict && schemaColumn.default) {
-		const issue = {
-			kind: "extra_default",
-			table: tableName,
-			namespaceId,
-			column: columnName,
-			actual: schemaColumn.default,
-			message: `Column "${tableName}"."${columnName}" has default ${schemaColumn.default} in database but contract specifies no default`
-		};
-		const disposition = verifierDisposition(tableControlPolicy, issue.kind);
-		if (disposition !== "suppress") {
-			issues.push(issue);
-			columnChildren.push({
-				status: disposition,
-				kind: "default",
-				name: "default",
-				contractPath: `${columnPath}.default`,
-				code: "extra_default",
-				message: `Extra default: ${schemaColumn.default}`,
-				expected: void 0,
-				actual: schemaColumn.default,
-				children: []
-			});
-			columnStatus = disposition;
-		}
-	}
-	const aggregated = aggregateChildState(columnChildren, columnStatus);
-	const nullableText = contractColumn.nullable ? "nullable" : "not nullable";
-	const columnTypeDisplay = resolvedContractColumn.codecId ? `${contractNativeType} (${resolvedContractColumn.codecId})` : contractNativeType;
-	const columnMessage = aggregated.failureMessages.join("; ");
-	return {
-		status: aggregated.status,
-		kind: "column",
-		name: `${columnName}: ${columnTypeDisplay} (${nullableText})`,
-		contractPath: columnPath,
-		code: aggregated.firstCode,
-		message: columnMessage,
-		expected: void 0,
-		actual: void 0,
-		children: columnChildren
-	};
-}
-function buildColumnsNode(tablePath, columnNodes) {
-	return {
-		status: aggregateChildState(columnNodes, "pass").status,
-		kind: "columns",
-		name: "columns",
-		contractPath: `${tablePath}.columns`,
-		code: "",
-		message: "",
-		expected: void 0,
-		actual: void 0,
-		children: columnNodes
-	};
-}
-function buildTableNode(tableName, tablePath, tableChildren) {
-	const tableStatus = aggregateChildState(tableChildren, "pass").status;
-	const tableFailureMessages = tableChildren.filter((child) => child.status === "fail" && child.message).map((child) => child.message).filter((msg) => typeof msg === "string" && msg.length > 0);
-	const tableMessage = tableStatus === "fail" && tableFailureMessages.length > 0 ? `${tableFailureMessages.length} issue${tableFailureMessages.length === 1 ? "" : "s"}` : "";
-	const tableCode = tableStatus === "fail" && tableChildren.length > 0 && tableChildren[0] ? tableChildren[0].code : "";
-	return {
-		status: tableStatus,
-		kind: "table",
-		name: `table ${tableName}`,
-		contractPath: tablePath,
-		code: tableCode,
-		message: tableMessage,
-		expected: void 0,
-		actual: void 0,
-		children: tableChildren
-	};
-}
-function buildRootNode(rootChildren) {
-	return {
-		status: aggregateChildState(rootChildren, "pass").status,
-		kind: "contract",
-		name: "contract",
-		contractPath: "",
-		code: "",
-		message: "",
-		expected: void 0,
-		actual: void 0,
-		children: rootChildren
-	};
-}
-/**
-* Aggregates status, failure messages, and code from children in a single pass.
-* This is more efficient than calling separate functions that each iterate the array.
-*/
-function aggregateChildState(children, fallback) {
-	let status = fallback;
-	const failureMessages = [];
-	let firstCode = "";
-	for (const child of children) if (child.status === "fail") {
-		status = "fail";
-		if (!firstCode) firstCode = child.code;
-		if (child.message && typeof child.message === "string" && child.message.length > 0) failureMessages.push(child.message);
-	} else if (child.status === "warn" && status !== "fail") {
-		status = "warn";
-		if (!firstCode) firstCode = child.code;
-	}
-	return {
-		status,
-		failureMessages,
-		firstCode
-	};
-}
-function validateFrameworkComponentsForExtensions(contract, frameworkComponents) {
-	const contractExtensionPacks = contract.extensionPacks ?? {};
-	for (const extensionNamespace of Object.keys(contractExtensionPacks)) if (!frameworkComponents.some((component) => component.id === extensionNamespace && (component.kind === "extension" || component.kind === "adapter" || component.kind === "target"))) throw new Error(`Extension pack '${extensionNamespace}' is declared in the contract but not found in framework components. This indicates a configuration mismatch - the contract was emitted with this extension pack, but it is not provided in the current configuration.`);
-}
-/**
-* Renders the expected native type for a contract column, expanding parameterized types
-* using codec control hooks when available.
-*
-* This function delegates to the `expandNativeType` hook if the codec provides one,
-* ensuring that the SQL family layer remains dialect-agnostic while allowing
-* target-specific adapters (like Postgres) to provide their own expansion logic.
-*/
-function renderExpectedNativeType(contractColumn, storageTypes, codecHooks, context) {
-	const { codecId, nativeType, typeParams } = resolveContractColumnTypeMetadata(contractColumn, storageTypes, context);
-	if (!typeParams || !codecId) return nativeType;
-	const hooks = codecHooks.get(codecId);
-	if (hooks?.expandNativeType) return hooks.expandNativeType({
-		nativeType,
-		codecId,
-		typeParams
-	});
-	return nativeType;
-}
-function resolveContractColumnTypeMetadata(contractColumn, storageTypes, context) {
-	if (!contractColumn.typeRef) return contractColumn;
-	const referencedType = storageTypes[contractColumn.typeRef];
-	if (!referencedType) {
-		const columnLabel = context ? `Column "${context.tableName}"."${context.columnName}"` : "Column";
-		throw new Error(`${columnLabel} references storage type "${contractColumn.typeRef}" but it is not defined in storage.types.`);
-	}
-	if (isStorageTypeInstance(referencedType)) return {
-		codecId: referencedType.codecId,
-		nativeType: referencedType.nativeType,
-		typeParams: referencedType.typeParams
-	};
-	throw new Error(`Storage type "${contractColumn.typeRef}" has an unknown kind; expected a codec-typed StorageTypeInstance.`);
-}
-/**
-* Describes a column default for display purposes.
-*/
-function describeColumnDefault(columnDefault) {
-	switch (columnDefault.kind) {
-		case "literal": return `literal(${formatLiteralValue(columnDefault.value)})`;
-		case "function": return columnDefault.expression;
-	}
-}
-/**
-* Compares a contract ColumnDefault against a schema raw default string for semantic equality.
-*
-* When a normalizer is provided, the raw schema default is first normalized to a ColumnDefault
-* before comparison. Without a normalizer, falls back to direct string comparison against
-* the contract expression.
-*
-* @param contractDefault - The expected default from the contract (normalized ColumnDefault)
-* @param schemaDefault - The raw default expression from the database (string)
-* @param normalizer - Optional target-specific normalizer to convert raw defaults
-* @param nativeType - The column's native type, passed to normalizer for context
-*/
-function columnDefaultsEqual(contractDefault, schemaDefault, normalizer, nativeType) {
-	if (!normalizer) {
-		if (contractDefault.kind === "function") return contractDefault.expression === schemaDefault;
-		const normalizedValue = normalizeLiteralValue(contractDefault.value, nativeType);
-		if (typeof normalizedValue === "string") return normalizedValue === schemaDefault || `'${normalizedValue}'` === schemaDefault;
-		return String(normalizedValue) === schemaDefault;
-	}
-	const normalizedSchema = normalizer(schemaDefault, nativeType ?? "");
-	if (!normalizedSchema) return false;
-	if (contractDefault.kind !== normalizedSchema.kind) return false;
-	if (contractDefault.kind === "literal" && normalizedSchema.kind === "literal") return literalValuesEqual(normalizeLiteralValue(contractDefault.value, nativeType), normalizeLiteralValue(normalizedSchema.value, nativeType));
-	if (contractDefault.kind === "function" && normalizedSchema.kind === "function") {
-		const normalizeExpr = (expr) => expr.toLowerCase().replace(/\s+/g, "");
-		return normalizeExpr(contractDefault.expression) === normalizeExpr(normalizedSchema.expression);
-	}
-	return false;
-}
-function isTemporalNativeType(nativeType) {
-	if (!nativeType) return false;
-	const normalized = nativeType.toLowerCase();
-	return normalized.includes("timestamp") || normalized === "date";
-}
-function normalizeLiteralValue(value, nativeType) {
-	if (value instanceof Date) return value.toISOString();
-	if (typeof value === "string" && isTemporalNativeType(nativeType)) {
-		const parsed = new Date(value);
-		if (!Number.isNaN(parsed.getTime())) return parsed.toISOString();
-	}
-	return value;
-}
-function literalValuesEqual(a, b) {
-	if (a === b) return true;
-	if (typeof a === "object" && a !== null && typeof b === "object" && b !== null) return canonicalStringify(a) === canonicalStringify(b);
-	if (typeof a === "object" && a !== null && typeof b === "string") try {
-		return canonicalStringify(a) === canonicalStringify(JSON.parse(b));
-	} catch {
-		return false;
-	}
-	if (typeof a === "string" && typeof b === "object" && b !== null) try {
-		return canonicalStringify(JSON.parse(a)) === canonicalStringify(b);
-	} catch {
-		return false;
-	}
-	return false;
-}
-function formatLiteralValue(value) {
-	if (value instanceof Date) return value.toISOString();
-	if (typeof value === "string") return value;
-	return JSON.stringify(value);
-}
-//#endregion
-export { contractToSchemaIR as a, extractCodecControlHooks as c, isUniqueConstraintSatisfied as i, arraysEqual as n, detectDestructiveChanges as o, isIndexSatisfied as r, resolveValueSetValues as s, verifySqlSchema as t };
-
-//# sourceMappingURL=verify-sql-schema-xT4udQLQ.mjs.map