@prisma-next/family-sql 0.14.0-dev.49 → 0.14.0-dev.50

package/dist/diff.mjs

@@ -1,93 +1,160 @@
-import { a as extractCodecControlHooks, i as resolveValueSetValues } from "./contract-to-schema-ir-S-evq8E6.mjs";
-import { blindCast } from "@prisma-next/utils/casts";
-import { effectiveControlPolicy } from "@prisma-next/contract/types";
-import { dispositionForCategory } from "@prisma-next/framework-components/control";
-import { UNBOUND_NAMESPACE_ID } from "@prisma-next/framework-components/ir";
-import { ifDefined } from "@prisma-next/utils/defined";
-import { StorageTable, isStorageTypeInstance } from "@prisma-next/sql-contract/types";
-import { canonicalStringify } from "@prisma-next/utils/canonical-stringify";
-//#region src/core/diff/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";
+import { a as computeStorageTypeVerdict, i as computeSqlDiffVerdict, n as classifyDiffSubjectGranularity, o as verifySqlSchemaByDiff, r as classifySqlDiffIssue } from "./schema-verify-W3r631Jh.mjs";
+import { SqlForeignKeyIR, SqlIndexIR, SqlSchemaIR, SqlTableIR, SqlUniqueIR } from "@prisma-next/sql-schema-ir/types";
+//#region src/core/diff/diff-tree-normalization.ts
+/**
+* ⚠️ ACCEPTED-UNDER-PROTEST DEBT — DELETE IN SLICE 2.6 (`unify-unique-and-index-nodes`).
+*
+* A unique constraint IS a unique index. This slice modeled uniques and indexes
+* as two separate node kinds (`SqlUniqueIR` vs `SqlIndexIR` — even though
+* `SqlIndexIR` already carries `unique: boolean`), so the strict-by-kind differ
+* cannot pair a contract unique with a live unique index. This whole file
+* exists only to reconcile those two representations after the fact — it
+* should not exist.
+*
+* The fix — delete `SqlUniqueIR`, model unique enforcement as
+* `SqlIndexIR { unique: true }` on both derivation and introspection, and
+* delete `diff-tree-normalization.ts` — is specified in
+* `projects/postgres-rls/slices/unify-unique-and-index-nodes/spec.md` and
+* scheduled as the very next slice. Do NOT extend this.
+*/
+/**
+* Pre-diff tree normalization: adjustments to the actual/expected trees the
+* generic differ (`diffSchemas`) runs over, so legacy semantic-equivalence
+* rules (a unique constraint satisfied by a unique index, an FK schema
+* segment that differs only in spelling) surface as same-kind node pairs
+* instead of spurious drift.
+*/
+function sameColumns(a, b) {
+	return a.length === b.length && a.every((c, i) => c === b[i]);
+}
+/**
+* Adjusts a table pair's ACTUAL unique/index child lists so the legacy
+* walk's cross-kind semantic satisfaction materializes as same-kind node
+* pairs for the differ (the differ pairs strictly by id, so a `unique:`
+* node can never pair with an `index:` node). Three legacy rules, ported
+* from `isUniqueConstraintSatisfied` / `isIndexSatisfied` and the
+* strict-extras loops of the retired relational walk:
+*
+* 1. A contract unique satisfied by a live unique INDEX: the actual index
+*    node is reclassified as a unique node (it pairs with the expected
+*    unique and stops being a candidate extra).
+* 2. A contract index (with no type/options demands) satisfied by a live
+*    unique CONSTRAINT: a same-kind actual index node is synthesized so
+*    the expected index pairs — the unique constraint itself stays (the
+*    legacy strict-extras loop still reports it as an undeclared unique).
+* 3. Live unique indexes are never extras in the legacy walk (its
+*    strict-extras loop skips `unique: true` rows), so any remaining
+*    actual unique-index node with no expected index counterpart is
+*    dropped rather than surfacing as `not-expected`.
+*/
+function resolveSemanticSatisfaction(input) {
+	let actualIndexes = [...input.actualIndexes];
+	const actualUniques = [...input.actualUniques];
+	for (const expectedUnique of input.expectedUniques) {
+		if (actualUniques.some((u) => sameColumns(u.columns, expectedUnique.columns))) continue;
+		const satisfyingIndex = actualIndexes.find((idx) => idx.unique && sameColumns(idx.columns, expectedUnique.columns));
+		if (satisfyingIndex) {
+			actualIndexes = actualIndexes.filter((idx) => idx !== satisfyingIndex);
+			actualUniques.push(new SqlUniqueIR({
+				columns: satisfyingIndex.columns,
+				...satisfyingIndex.name !== void 0 ? { name: satisfyingIndex.name } : {}
+			}));
+		}
 	}
+	for (const expectedIndex of input.expectedIndexes) {
+		if (expectedIndex.type !== void 0 || expectedIndex.options !== void 0) continue;
+		if (actualIndexes.some((idx) => sameColumns(idx.columns, expectedIndex.columns))) continue;
+		const satisfyingUnique = actualUniques.find((u) => sameColumns(u.columns, expectedIndex.columns));
+		if (satisfyingUnique) actualIndexes.push(new SqlIndexIR({
+			columns: satisfyingUnique.columns,
+			unique: false
+		}));
+	}
+	actualIndexes = actualIndexes.filter((idx) => !idx.unique || input.expectedIndexes.some((exp) => sameColumns(exp.columns, idx.columns)));
+	return {
+		actualUniques,
+		actualIndexes
+	};
 }
-function verifierDisposition(controlPolicy, issueKind) {
-	return dispositionForCategory(controlPolicy, classifySqlVerifierIssueKind(issueKind));
-}
-//#endregion
-//#region src/core/diff/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.
+* Applies {@link resolveSemanticSatisfaction} across a flat table pair set:
+* every actual table with an expected counterpart gets its unique/index
+* child lists adjusted; unpaired tables pass through untouched.
 */
-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
+function normalizeFlatActualForDiff(expected, actual) {
+	const tables = {};
+	for (const [name, actualTable] of Object.entries(actual.tables)) {
+		const expectedTable = expected.tables[name];
+		if (expectedTable === void 0) {
+			tables[name] = actualTable;
+			continue;
+		}
+		const adjusted = resolveSemanticSatisfaction({
+			expectedUniques: expectedTable.uniques,
+			expectedIndexes: expectedTable.indexes,
+			actualUniques: actualTable.uniques,
+			actualIndexes: actualTable.indexes
+		});
+		tables[name] = new SqlTableIR({
+			name: actualTable.name,
+			columns: actualTable.columns,
+			foreignKeys: actualTable.foreignKeys,
+			uniques: adjusted.actualUniques,
+			indexes: adjusted.actualIndexes,
+			...actualTable.primaryKey !== void 0 ? { primaryKey: actualTable.primaryKey } : {},
+			...actualTable.annotations !== void 0 ? { annotations: actualTable.annotations } : {},
+			...actualTable.checks !== void 0 ? { checks: actualTable.checks } : {}
+		});
+	}
+	return new SqlSchemaIR({
+		tables,
+		...actual.annotations !== void 0 ? { annotations: actual.annotations } : {}
 	});
-	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.
+* Neutralizes the FK schema segment on a flat expected tree so its FK diff
+* nodes pair with introspected FKs on single-schema targets: the family
+* converter stamps `referencedSchema` with the contract namespace id
+* verbatim (the unbound sentinel on non-namespaced targets), while a
+* single-schema introspection stamps none — resolving both sides to the
+* empty segment makes the ids meet.
 */
-function emitIssueUnderControlPolicy(controlPolicy, issue, issues) {
-	const disposition = verifierDisposition(controlPolicy, issue.kind);
-	if (disposition === "suppress") return disposition;
-	issues.push(issue);
-	return disposition;
+function neutralizeFlatExpectedFkSchemas(expected) {
+	const tables = {};
+	for (const [name, table] of Object.entries(expected.tables)) {
+		if (table.foreignKeys.length === 0) {
+			tables[name] = table;
+			continue;
+		}
+		const foreignKeys = table.foreignKeys.map((fk) => new SqlForeignKeyIR({
+			columns: fk.columns,
+			referencedTable: fk.referencedTable,
+			referencedColumns: fk.referencedColumns,
+			...fk.referencedSchema !== void 0 ? { referencedSchema: fk.referencedSchema } : {},
+			...fk.name !== void 0 ? { name: fk.name } : {},
+			...fk.onDelete !== void 0 ? { onDelete: fk.onDelete } : {},
+			...fk.onUpdate !== void 0 ? { onUpdate: fk.onUpdate } : {},
+			...fk.annotations !== void 0 ? { annotations: fk.annotations } : {},
+			resolvedReferencedNamespace: ""
+		}));
+		tables[name] = new SqlTableIR({
+			name: table.name,
+			columns: table.columns,
+			foreignKeys,
+			uniques: table.uniques,
+			indexes: table.indexes,
+			...table.primaryKey !== void 0 ? { primaryKey: table.primaryKey } : {},
+			...table.annotations !== void 0 ? { annotations: table.annotations } : {},
+			...table.checks !== void 0 ? { checks: table.checks } : {}
+		});
+	}
+	return new SqlSchemaIR({
+		tables,
+		...expected.annotations !== void 0 ? { annotations: expected.annotations } : {}
+	});
 }
 //#endregion
-//#region src/core/diff/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);
-}
+//#region src/core/diff/sql-schema-diff.ts
 /**
 * Compares two arrays of strings for equality (order-sensitive).
 */
@@ -97,1321 +164,25 @@ function arraysEqual(a, b) {
 	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
+* Checks if a unique constraint requirement is satisfied by the given columns:
+* a unique constraint with the same columns, or a unique index with the same
+* columns (semantic satisfaction). Used by the planners to keep the
+* "stronger satisfies weaker" behavior consistent across the control plane.
 */
 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
+* Checks if an index requirement is satisfied by the given columns: any index
+* (unique or non-unique) with the same columns, or a unique constraint with
+* the same columns (stronger satisfies weaker).
 */
 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",
-			reason: "not-equal",
-			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",
-			reason: "not-equal",
-			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",
-			reason: "not-equal",
-			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",
-					reason: "not-equal",
-					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",
-			reason: "not-expected",
-			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",
-			reason: "not-equal",
-			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",
-			reason: "not-expected",
-			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",
-			reason: "not-equal",
-			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",
-			reason: "not-expected",
-			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",
-			reason: "not-found",
-			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",
-			reason: "not-equal",
-			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",
-			reason: "not-equal",
-			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/diff/sql-schema-diff.ts
-/**
-* Returns the per-schema namespace nodes of an introspected schema node, for
-* the relational verify to consume one at a time. Structure-agnostic — imports
-* no target node class. A root exposing a `namespaces` record (Postgres) yields
-* its namespace nodes (never merged, so same-named tables in different schemas
-* cannot collide); a flat schema (SQLite) is its own single namespace and
-* yields itself. Handles spread-flattened input (own-enumerable fields survive).
-*/
-function namespaceSchemaNodes(schema) {
-	const obj = blindCast(schema);
-	if (obj.namespaces !== void 0) return Object.values(obj.namespaces);
-	return [blindCast(schema)];
-}
-/**
-* 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),
-		...ifDefined("restrictToNamespaceIds", options.restrictToNamespaceIds)
-	});
-	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,
-			schemaDiffIssues: [],
-			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, restrictToNamespaceIds } = 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) {
-		if (restrictToNamespaceIds !== void 0 && !restrictToNamespaceIds.has(namespaceId)) continue;
-		const ns = contract.storage.namespaces[namespaceId];
-		if (!ns) continue;
-		for (const [tableName, contractTableRaw] of Object.entries(ns.entries.table ?? {})) {
-			StorageTable.assert(contractTableRaw, `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",
-					reason: "not-found",
-					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",
-			reason: "not-expected",
-			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: [],
-			reason: "not-expected"
-		}, 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",
-		reason: "not-expected",
-		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",
-				reason: "not-found",
-				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",
-		reason: "not-expected",
-		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 schemaBaseNativeType = normalizeNativeType?.(schemaColumn.nativeType) ?? schemaColumn.nativeType;
-	const schemaNativeType = schemaColumn.many ? `${schemaBaseNativeType}[]` : schemaBaseNativeType;
-	if (!(contractNativeType === schemaNativeType)) {
-		const issue = {
-			kind: "type_mismatch",
-			reason: "not-equal",
-			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",
-			reason: "not-equal",
-			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",
-				reason: "not-found",
-				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",
-				reason: "not-equal",
-				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",
-			reason: "not-expected",
-			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);
-	let baseType;
-	if (!typeParams || !codecId) baseType = nativeType;
-	else {
-		const hooks = codecHooks.get(codecId);
-		baseType = hooks?.expandNativeType ? hooks.expandNativeType({
-			nativeType,
-			codecId,
-			typeParams
-		}) : nativeType;
-	}
-	return contractColumn.many ? `${baseType}[]` : baseType;
-}
-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);
-}
-/**
-* Reads a namespace node's DDL schema name. Namespaced target nodes (Postgres
-* `PostgresNamespaceSchemaNode`) carry `schemaName`; a flat schema (SQLite) has
-* none and pairs by position as the sole namespace.
-*/
-function namespaceSchemaName(node) {
-	return blindCast(node).schemaName;
-}
-/**
-* Returns a shallow copy of `contract` exposing only the one named namespace —
-* used solely to resolve that namespace's live DDL schema via the target's
-* expected-tree projection (never for verification, so global value-sets it may
-* reference are not consulted).
-*/
-function scopeContractToNamespace(contract, namespaceId) {
-	const namespace = contract.storage.namespaces[namespaceId];
-	const scopedNamespaces = namespace === void 0 ? {} : { [namespaceId]: namespace };
-	return blindCast({
-		...contract,
-		storage: blindCast({
-			...contract.storage,
-			namespaces: scopedNamespaces
-		})
-	});
-}
-/**
-* Combines two `VerifyDatabaseSchemaResult`s by concatenating issues and summing
-* counts — used to fold the per-namespace pairings of a multi-schema database
-* into one result. The verification-tree `root` of the first pairing is
-* retained (multi-schema verify-tree shaping is future work).
-*/
-function mergeVerifyResults(a, b) {
-	return {
-		...a,
-		ok: a.ok && b.ok,
-		...ifDefined("code", a.code ?? b.code),
-		schema: {
-			...a.schema,
-			issues: [...a.schema.issues, ...b.schema.issues],
-			schemaDiffIssues: [...a.schema.schemaDiffIssues, ...b.schema.schemaDiffIssues],
-			counts: {
-				pass: a.schema.counts.pass + b.schema.counts.pass,
-				warn: a.schema.counts.warn + b.schema.counts.warn,
-				fail: a.schema.counts.fail + b.schema.counts.fail,
-				totalNodes: a.schema.counts.totalNodes + b.schema.counts.totalNodes
-			}
-		}
-	};
-}
-/**
-* The single per-namespace-paired relational verify shared by the migration
-* planner and the family schema verify — there is exactly one such operation.
-*
-* Each contract namespace is paired to the introspected namespace node holding
-* the same DDL schema, then `verifySqlSchema` checks that namespace's tables
-* against the matching actual node (a contract table under `auth` is only ever
-* looked up in the `auth` actual node, so a multi-schema database no longer
-* reports tables in other schemas as missing). The full contract is passed every
-* time — `restrictToNamespaceIds` scopes only which tables are checked, so
-* cross-namespace value-set / control-policy resolution is unaffected.
-*
-* The DDL schema of each contract namespace is read from a single-namespace
-* expected projection (`buildExpectedSchema`), which both callers already build
-* the same way. Empty contract namespaces verify nothing and are skipped.
-* Single-schema (one namespace) and SQLite's flat schema are one pairing —
-* byte-identical to the prior per-node verify.
-*/
-function verifySqlSchemaTree(options) {
-	const baseOptions = {
-		contract: options.contract,
-		strict: options.strict,
-		typeMetadataRegistry: options.typeMetadataRegistry,
-		frameworkComponents: options.frameworkComponents,
-		...ifDefined("normalizeDefault", options.normalizeDefault),
-		...ifDefined("normalizeNativeType", options.normalizeNativeType)
-	};
-	const actualNodes = namespaceSchemaNodes(options.actualSchema);
-	const actualByName = /* @__PURE__ */ new Map();
-	for (const node of actualNodes) {
-		const name = namespaceSchemaName(node);
-		if (name !== void 0) actualByName.set(name, node);
-	}
-	const soleFlatActual = actualByName.size === 0 ? actualNodes[0] : void 0;
-	const emptyNamespace = { tables: {} };
-	let combined;
-	for (const namespaceId of Object.keys(options.contract.storage.namespaces)) {
-		const namespace = options.contract.storage.namespaces[namespaceId];
-		if (!namespace || Object.keys(namespace.entries.table ?? {}).length === 0) continue;
-		const ddlSchema = namespaceSchemaNodes(options.buildExpectedSchema(scopeContractToNamespace(options.contract, namespaceId))).map(namespaceSchemaName).find((name) => name !== void 0);
-		const actualNode = (ddlSchema !== void 0 ? actualByName.get(ddlSchema) : soleFlatActual) ?? emptyNamespace;
-		const result = verifySqlSchema({
-			...baseOptions,
-			schema: actualNode,
-			restrictToNamespaceIds: new Set([namespaceId])
-		});
-		combined = combined === void 0 ? result : mergeVerifyResults(combined, result);
-	}
-	return combined ?? verifySqlSchema({
-		...baseOptions,
-		schema: emptyNamespace
-	});
-}
 //#endregion
-export { arraysEqual, isIndexSatisfied, isUniqueConstraintSatisfied, verifySqlSchema, verifySqlSchemaTree };
+export { arraysEqual, classifyDiffSubjectGranularity, classifySqlDiffIssue, computeSqlDiffVerdict, computeStorageTypeVerdict, isIndexSatisfied, isUniqueConstraintSatisfied, neutralizeFlatExpectedFkSchemas, normalizeFlatActualForDiff, resolveSemanticSatisfaction, verifySqlSchemaByDiff };
 
 //# sourceMappingURL=diff.mjs.map