@prisma-next/family-sql 0.12.0-dev.17 → 0.12.0-dev.2

package/dist/{verify-sql-schema-CXW_D9dW.mjs → verify-sql-schema-CYLsGCFO.mjs}

@@ -1,8 +1,7 @@
-import { assertUniqueCodecOwner, dispositionForCategory } from "@prisma-next/framework-components/control";
+import { assertUniqueCodecOwner } from "@prisma-next/framework-components/control";
 import { ifDefined } from "@prisma-next/utils/defined";
 import { UNBOUND_NAMESPACE_ID } from "@prisma-next/framework-components/ir";
 import { StorageTable, isPostgresEnumStorageEntry, 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) {
@@ -32,71 +31,6 @@ function extractCodecControlHooks(descriptors) {
 	return hooks;
 }
 //#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": 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";
-	}
-}
-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() : [];
@@ -158,27 +92,27 @@ function isIndexSatisfied(indexes, uniques, columns) {
 * 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) {
+function verifyPrimaryKey(contractPK, schemaPK, tableName, namespaceId, issues) {
 	if (!schemaPK) {
-		const outcome = emitIssueUnderControlPolicy(tableControlPolicy, {
+		issues.push({
 			kind: "primary_key_mismatch",
 			table: tableName,
 			namespaceId,
 			expected: contractPK.columns.join(", "),
 			message: `Table "${tableName}" is missing primary key`
-		}, issues);
-		return outcome === "suppress" ? "pass" : outcome;
+		});
+		return "fail";
 	}
 	if (!arraysEqual(contractPK.columns, schemaPK.columns)) {
-		const outcome = emitIssueUnderControlPolicy(tableControlPolicy, {
+		issues.push({
 			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 "fail";
 	}
 	return "pass";
 }
@@ -189,7 +123,7 @@ function verifyPrimaryKey(contractPK, schemaPK, tableName, namespaceId, tableCon
 * 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) {
+function verifyForeignKeys(contractFKs, schemaFKs, tableName, namespaceId, tablePath, issues, strict) {
 	const nodes = [];
 	for (const contractFK of contractFKs) {
 		const fkPath = `${tablePath}.foreignKeys[${contractFK.source.columns.join(",")}]`;
@@ -197,30 +131,32 @@ function verifyForeignKeys(contractFKs, schemaFKs, tableName, namespaceId, table
 			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 {
+		if (!matchingFK) {
+			issues.push({
+				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(", ")})`
+			});
+			nodes.push({
+				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: []
+			});
+		} 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, {
+				issues.push({
 					kind: "foreign_key_mismatch",
 					table: tableName,
 					namespaceId,
@@ -228,7 +164,8 @@ function verifyForeignKeys(contractFKs, schemaFKs, tableName, namespaceId, table
 					expected: combinedExpected,
 					actual: combinedActual,
 					message: `Table "${tableName}" foreign key ${contractFK.source.columns.join(", ")} -> ${contractFK.target.tableName}: ${combinedMessage}`
-				}, {
+				});
+				nodes.push({
 					status: "fail",
 					kind: "foreignKey",
 					name: `foreignKey(${contractFK.source.columns.join(", ")})`,
@@ -238,7 +175,7 @@ function verifyForeignKeys(contractFKs, schemaFKs, tableName, namespaceId, table
 					expected: contractFK,
 					actual: matchingFK,
 					children: []
-				}, issues, nodes);
+				});
 			} else nodes.push({
 				status: "pass",
 				kind: "foreignKey",
@@ -256,23 +193,26 @@ function verifyForeignKeys(contractFKs, schemaFKs, tableName, namespaceId, table
 		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);
+		})) {
+			issues.push({
+				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(", ")})`
+			});
+			nodes.push({
+				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: []
+			});
+		}
 	}
 	return nodes;
 }
@@ -287,30 +227,32 @@ function verifyForeignKeys(contractFKs, schemaFKs, tableName, namespaceId, table
 *
 * Name differences are ignored by default (names are for DDL/diagnostics, not identity).
 */
-function verifyUniqueConstraints(contractUniques, schemaUniques, schemaIndexes, tableName, namespaceId, tablePath, tableControlPolicy, issues, strict) {
+function verifyUniqueConstraints(contractUniques, schemaUniques, schemaIndexes, tableName, namespaceId, tablePath, 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({
+		if (!matchingUnique && !matchingUniqueIndex) {
+			issues.push({
+				kind: "unique_constraint_mismatch",
+				table: tableName,
+				namespaceId,
+				expected: contractUnique.columns.join(", "),
+				message: `Table "${tableName}" is missing unique constraint: ${contractUnique.columns.join(", ")}`
+			});
+			nodes.push({
+				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: []
+			});
+		} else nodes.push({
 			status: "pass",
 			kind: "unique",
 			name: `unique(${contractUnique.columns.join(", ")})`,
@@ -323,23 +265,26 @@ function verifyUniqueConstraints(contractUniques, schemaUniques, schemaIndexes,
 		});
 	}
 	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);
+		for (const schemaUnique of schemaUniques) if (!contractUniques.find((u) => arraysEqual(u.columns, schemaUnique.columns))) {
+			issues.push({
+				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(", ")}`
+			});
+			nodes.push({
+				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: []
+			});
+		}
 	}
 	return nodes;
 }
@@ -354,30 +299,32 @@ function verifyUniqueConstraints(contractUniques, schemaUniques, schemaIndexes,
 *
 * Name differences are ignored by default (names are for DDL/diagnostics, not identity).
 */
-function verifyIndexes(contractIndexes, schemaIndexes, schemaUniques, tableName, namespaceId, tablePath, tableControlPolicy, issues, strict) {
+function verifyIndexes(contractIndexes, schemaIndexes, schemaUniques, tableName, namespaceId, tablePath, 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({
+		if (!matchingIndex && !matchingUniqueConstraint) {
+			issues.push({
+				kind: "index_mismatch",
+				table: tableName,
+				namespaceId,
+				expected: contractIndex.columns.join(", "),
+				message: `Table "${tableName}" is missing index: ${contractIndex.columns.join(", ")}`
+			});
+			nodes.push({
+				status: "fail",
+				kind: "index",
+				name: `index(${contractIndex.columns.join(", ")})`,
+				contractPath: indexPath,
+				code: "index_mismatch",
+				message: "Index missing",
+				expected: contractIndex,
+				actual: void 0,
+				children: []
+			});
+		} else nodes.push({
 			status: "pass",
 			kind: "index",
 			name: `index(${contractIndex.columns.join(", ")})`,
@@ -391,23 +338,26 @@ function verifyIndexes(contractIndexes, schemaIndexes, schemaUniques, tableName,
 	}
 	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);
+		if (!contractIndexes.find((idx) => arraysEqual(idx.columns, schemaIndex.columns) && indexExtrasMatch(idx, schemaIndex))) {
+			issues.push({
+				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(", ")}`
+			});
+			nodes.push({
+				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: []
+			});
+		}
 	}
 	return nodes;
 }
@@ -479,7 +429,7 @@ function normalizeReferentialAction(action) {
 * @returns VerifyDatabaseSchemaResult with verification tree and issues
 */
 function verifySqlSchema(options) {
-	const { contract, schema, strict, context, typeMetadataRegistry, normalizeDefault, normalizeNativeType, resolveExistingEnumValues, columnsCompatible } = options;
+	const { contract, schema, strict, context, typeMetadataRegistry, normalizeDefault, normalizeNativeType, resolveExistingEnumValues } = options;
 	const startTime = Date.now();
 	const codecHooks = extractCodecControlHooks(options.frameworkComponents);
 	const { contractStorageHash, contractProfileHash, contractTarget } = extractContractMetadata(contract);
@@ -496,31 +446,19 @@ function verifySqlSchema(options) {
 		codecHooks,
 		storageTypes: allStorageTypesMap,
 		...ifDefined("normalizeDefault", normalizeDefault),
-		...ifDefined("normalizeNativeType", normalizeNativeType),
-		...ifDefined("columnsCompatible", columnsCompatible)
+		...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";
-		}
+	const pushTypeNode = (typeName, contractPath, typeIssues) => {
+		if (typeIssues.length > 0) issues.push(...typeIssues);
 		typeNodes.push({
-			status,
+			status: typeIssues.length > 0 ? "fail" : "pass",
 			kind: "storageType",
 			name: `type ${typeName}`,
 			contractPath,
-			code: status === "pass" ? "" : code,
-			message: emitted > 0 ? `${emitted} issue${emitted === 1 ? "" : "s"}` : "",
+			code: typeIssues.length > 0 ? typeIssues[0]?.kind ?? "" : "",
+			message: typeIssues.length > 0 ? `${typeIssues.length} issue${typeIssues.length === 1 ? "" : "s"}` : "",
 			expected: void 0,
 			actual: void 0,
 			children: []
@@ -532,14 +470,14 @@ function verifySqlSchema(options) {
 		schema,
 		resolveExistingEnumValues,
 		namespaceId: UNBOUND_NAMESPACE_ID
-	}), effectiveControlPolicy(typeInstance.control, contract.defaultControl));
+	}));
 	else 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.defaultControl));
+		}) : []);
 	}
 	for (const nsId of Object.keys(contract.storage.namespaces)) {
 		const ns = contract.storage.namespaces[nsId];
@@ -554,11 +492,11 @@ function verifySqlSchema(options) {
 				schema,
 				resolveExistingEnumValues,
 				namespaceId: nsId
-			}), effectiveControlPolicy(entry.control, contract.defaultControl));
+			}));
 		}
 	}
 	if (typeNodes.length > 0) {
-		const typesStatus = typeNodes.some((n) => n.status === "fail") ? "fail" : typeNodes.some((n) => n.status === "warn") ? "warn" : "pass";
+		const typesStatus = typeNodes.some((n) => n.status === "fail") ? "fail" : "pass";
 		rootChildren.push({
 			status: typesStatus,
 			kind: "storageTypes",
@@ -642,8 +580,7 @@ function extractContractMetadata(contract) {
 	};
 }
 function verifySchemaTables(options) {
-	const { contract, schema, strict, typeMetadataRegistry, codecHooks, storageTypes, normalizeDefault, normalizeNativeType, columnsCompatible } = options;
-	const contractDefaultControl = contract.defaultControl;
+	const { contract, schema, strict, typeMetadataRegistry, codecHooks, storageTypes, normalizeDefault, normalizeNativeType } = options;
 	const issues = [];
 	const rootChildren = [];
 	const schemaTables = schema.tables;
@@ -654,16 +591,16 @@ function verifySchemaTables(options) {
 		for (const [tableName, contractTableRaw] of Object.entries(ns.tables)) {
 			if (!(contractTableRaw instanceof StorageTable)) throw new Error(`verifySqlSchema: expected StorageTable at storage.namespaces.${namespaceId}.tables.${tableName}`);
 			const contractTable = contractTableRaw;
-			const tableControlPolicy = effectiveControlPolicy(contractTable.control, contractDefaultControl);
 			const schemaTable = schemaTables[tableName];
 			const tablePath = `storage.namespaces.${namespaceId}.tables.${tableName}`;
 			if (!schemaTable) {
-				emitIssueAndNodeUnderControlPolicy(tableControlPolicy, {
+				issues.push({
 					kind: "missing_table",
 					table: tableName,
 					namespaceId,
 					message: `Table "${tableName}" is missing from database`
-				}, {
+				});
+				rootChildren.push({
 					status: "fail",
 					kind: "table",
 					name: `table ${tableName}`,
@@ -673,7 +610,7 @@ function verifySchemaTables(options) {
 					expected: void 0,
 					actual: void 0,
 					children: []
-				}, issues, rootChildren);
+				});
 				continue;
 			}
 			const tableChildren = verifyTableChildren({
@@ -682,35 +619,36 @@ function verifySchemaTables(options) {
 				tableName,
 				namespaceId,
 				tablePath,
-				tableControlPolicy,
 				issues,
 				strict,
 				typeMetadataRegistry,
 				codecHooks,
 				storageTypes,
 				...ifDefined("normalizeDefault", normalizeDefault),
-				...ifDefined("normalizeNativeType", normalizeNativeType),
-				...ifDefined("columnsCompatible", columnsCompatible)
+				...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]?.tables[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.*.tables.${tableName}`,
-			code: "extra_table",
-			message: `Extra table "${tableName}" found`,
-			expected: void 0,
-			actual: void 0,
-			children: []
-		}, issues, rootChildren);
+		for (const tableName of Object.keys(schemaTables)) if (!namespaceIds.some((namespaceId) => contract.storage.namespaces[namespaceId]?.tables[tableName] !== void 0)) {
+			issues.push({
+				kind: "extra_table",
+				table: tableName,
+				message: `Extra table "${tableName}" found in database (not in contract)`
+			});
+			rootChildren.push({
+				status: "fail",
+				kind: "table",
+				name: `table ${tableName}`,
+				contractPath: `storage.namespaces.*.tables.${tableName}`,
+				code: "extra_table",
+				message: `Extra table "${tableName}" found`,
+				expected: void 0,
+				actual: void 0,
+				children: []
+			});
+		}
 	}
 	return {
 		issues,
@@ -718,7 +656,7 @@ function verifySchemaTables(options) {
 	};
 }
 function verifyTableChildren(options) {
-	const { contractTable, schemaTable, tableName, namespaceId, tablePath, tableControlPolicy, issues, strict, typeMetadataRegistry, codecHooks, storageTypes, normalizeDefault, normalizeNativeType, columnsCompatible } = options;
+	const { contractTable, schemaTable, tableName, namespaceId, tablePath, issues, strict, typeMetadataRegistry, codecHooks, storageTypes, normalizeDefault, normalizeNativeType } = options;
 	const tableChildren = [];
 	const columnNodes = collectContractColumnNodes({
 		contractTable,
@@ -726,15 +664,13 @@ function verifyTableChildren(options) {
 		tableName,
 		namespaceId,
 		tablePath,
-		tableControlPolicy,
 		issues,
 		strict,
 		typeMetadataRegistry,
 		codecHooks,
 		storageTypes,
 		...ifDefined("normalizeDefault", normalizeDefault),
-		...ifDefined("normalizeNativeType", normalizeNativeType),
-		...ifDefined("columnsCompatible", columnsCompatible)
+		...ifDefined("normalizeNativeType", normalizeNativeType)
 	});
 	if (columnNodes.length > 0) tableChildren.push(buildColumnsNode(tablePath, columnNodes));
 	if (strict) appendExtraColumnNodes({
@@ -743,87 +679,77 @@ function verifyTableChildren(options) {
 		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: []
+	if (contractTable.primaryKey) if (verifyPrimaryKey(contractTable.primaryKey, schemaTable.primaryKey, tableName, namespaceId, issues) === "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 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) {
+		issues.push({
+			kind: "extra_primary_key",
+			table: tableName,
+			namespaceId,
+			message: "Extra primary key found in database (not in contract)"
 		});
-		else tableChildren.push({
-			status: "pass",
+		tableChildren.push({
+			status: "fail",
 			kind: "primaryKey",
-			name: `primary key: ${contractTable.primaryKey.columns.join(", ")}`,
+			name: `primary key: ${schemaTable.primaryKey.columns.join(", ")}`,
 			contractPath: `${tablePath}.primaryKey`,
-			code: "",
-			message: "",
+			code: "extra_primary_key",
+			message: "Extra primary key found",
 			expected: void 0,
-			actual: void 0,
+			actual: schemaTable.primaryKey,
 			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);
+		const fkStatuses = verifyForeignKeys(constraintFks, schemaTable.foreignKeys, tableName, namespaceId, tablePath, issues, strict);
 		tableChildren.push(...fkStatuses);
 	}
-	const uniqueStatuses = verifyUniqueConstraints(contractTable.uniques, schemaTable.uniques, schemaTable.indexes, tableName, namespaceId, tablePath, tableControlPolicy, issues, strict);
+	const uniqueStatuses = verifyUniqueConstraints(contractTable.uniques, schemaTable.uniques, schemaTable.indexes, tableName, namespaceId, tablePath, 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);
+	const indexStatuses = verifyIndexes([...contractTable.indexes, ...fkBackingIndexes], schemaTable.indexes, schemaTable.uniques, tableName, namespaceId, tablePath, issues, strict);
 	tableChildren.push(...indexStatuses);
 	return tableChildren;
 }
 function collectContractColumnNodes(options) {
-	const { contractTable, schemaTable, tableName, namespaceId, tablePath, tableControlPolicy, issues, strict, typeMetadataRegistry, codecHooks, storageTypes, normalizeDefault, normalizeNativeType, columnsCompatible } = options;
+	const { contractTable, schemaTable, tableName, namespaceId, tablePath, 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, {
+			issues.push({
 				kind: "missing_column",
 				table: tableName,
 				namespaceId,
 				column: columnName,
 				message: `Column "${tableName}"."${columnName}" is missing from database`
-			}, {
+			});
+			columnNodes.push({
 				status: "fail",
 				kind: "column",
 				name: `${columnName}: missing`,
@@ -833,7 +759,7 @@ function collectContractColumnNodes(options) {
 				expected: void 0,
 				actual: void 0,
 				children: []
-			}, issues, columnNodes);
+			});
 			continue;
 		}
 		columnNodes.push(verifyColumn({
@@ -843,41 +769,42 @@ function collectContractColumnNodes(options) {
 			contractColumn,
 			schemaColumn,
 			columnPath,
-			tableControlPolicy,
 			issues,
 			strict,
 			typeMetadataRegistry,
 			codecHooks,
 			storageTypes,
 			...ifDefined("normalizeDefault", normalizeDefault),
-			...ifDefined("normalizeNativeType", normalizeNativeType),
-			...ifDefined("columnsCompatible", columnsCompatible)
+			...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);
+	const { contractTable, schemaTable, tableName, namespaceId, tablePath, issues, columnNodes } = options;
+	for (const [columnName, { nativeType }] of Object.entries(schemaTable.columns)) if (!contractTable.columns[columnName]) {
+		issues.push({
+			kind: "extra_column",
+			table: tableName,
+			namespaceId,
+			column: columnName,
+			message: `Extra column "${tableName}"."${columnName}" found in database (not in contract)`
+		});
+		columnNodes.push({
+			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: []
+		});
+	}
 }
 function verifyColumn(options) {
-	const { tableName, namespaceId, columnName, contractColumn, schemaColumn, columnPath, tableControlPolicy, issues, strict, codecHooks, storageTypes, normalizeDefault, normalizeNativeType, columnsCompatible } = options;
+	const { tableName, namespaceId, columnName, contractColumn, schemaColumn, columnPath, issues, strict, codecHooks, storageTypes, normalizeDefault, normalizeNativeType } = options;
 	const columnChildren = [];
 	let columnStatus = "pass";
 	const resolvedContractColumn = resolveContractColumnTypeMetadata(contractColumn, storageTypes, {
@@ -889,8 +816,8 @@ function verifyColumn(options) {
 		columnName
 	});
 	const schemaNativeType = normalizeNativeType?.(schemaColumn.nativeType) ?? schemaColumn.nativeType;
-	if (!(contractNativeType === schemaNativeType || tableControlPolicy === "external" && (columnsCompatible?.(contractNativeType, schemaNativeType) ?? contractNativeType === schemaNativeType))) {
-		const issue = {
+	if (contractNativeType !== schemaNativeType) {
+		issues.push({
 			kind: "type_mismatch",
 			table: tableName,
 			namespaceId,
@@ -898,23 +825,19 @@ function verifyColumn(options) {
 			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;
-		}
+		});
+		columnChildren.push({
+			status: "fail",
+			kind: "type",
+			name: "type",
+			contractPath: `${columnPath}.nativeType`,
+			code: "type_mismatch",
+			message: `Type mismatch: expected ${contractNativeType}, got ${schemaNativeType}`,
+			expected: contractNativeType,
+			actual: schemaNativeType,
+			children: []
+		});
+		columnStatus = "fail";
 	}
 	if (resolvedContractColumn.codecId) {
 		const typeMetadata = options.typeMetadataRegistry.get(resolvedContractColumn.codecId);
@@ -942,7 +865,7 @@ function verifyColumn(options) {
 		});
 	}
 	if (contractColumn.nullable !== schemaColumn.nullable) {
-		const issue = {
+		issues.push({
 			kind: "nullability_mismatch",
 			table: tableName,
 			namespaceId,
@@ -950,55 +873,47 @@ function verifyColumn(options) {
 			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;
-		}
+		});
+		columnChildren.push({
+			status: "fail",
+			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 = "fail";
 	}
 	if (contractColumn.default) {
 		if (!schemaColumn.default) {
 			const defaultDescription = describeColumnDefault(contractColumn.default);
-			const issue = {
+			issues.push({
 				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;
-			}
+			});
+			columnChildren.push({
+				status: "fail",
+				kind: "default",
+				name: "default",
+				contractPath: `${columnPath}.default`,
+				code: "default_missing",
+				message: `Default missing: expected ${defaultDescription}`,
+				expected: defaultDescription,
+				actual: void 0,
+				children: []
+			});
+			columnStatus = "fail";
 		} else if (!columnDefaultsEqual(contractColumn.default, schemaColumn.default, normalizeDefault, schemaNativeType)) {
 			const expectedDescription = describeColumnDefault(contractColumn.default);
 			const actualDescription = schemaColumn.default;
-			const issue = {
+			issues.push({
 				kind: "default_mismatch",
 				table: tableName,
 				namespaceId,
@@ -1006,49 +921,41 @@ function verifyColumn(options) {
 				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;
-			}
+			});
+			columnChildren.push({
+				status: "fail",
+				kind: "default",
+				name: "default",
+				contractPath: `${columnPath}.default`,
+				code: "default_mismatch",
+				message: `Default mismatch: expected ${expectedDescription}, got ${actualDescription}`,
+				expected: expectedDescription,
+				actual: actualDescription,
+				children: []
+			});
+			columnStatus = "fail";
 		}
 	} else if (strict && schemaColumn.default) {
-		const issue = {
+		issues.push({
 			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;
-		}
+		});
+		columnChildren.push({
+			status: "fail",
+			kind: "default",
+			name: "default",
+			contractPath: `${columnPath}.default`,
+			code: "extra_default",
+			message: `Extra default: ${schemaColumn.default}`,
+			expected: void 0,
+			actual: schemaColumn.default,
+			children: []
+		});
+		columnStatus = "fail";
 	}
 	const aggregated = aggregateChildState(columnChildren, columnStatus);
 	const nullableText = contractColumn.nullable ? "nullable" : "not nullable";
@@ -1247,4 +1154,4 @@ function formatLiteralValue(value) {
 //#endregion
 export { extractCodecControlHooks as a, isUniqueConstraintSatisfied as i, arraysEqual as n, isIndexSatisfied as r, verifySqlSchema as t };
 
-//# sourceMappingURL=verify-sql-schema-CXW_D9dW.mjs.map
+//# sourceMappingURL=verify-sql-schema-CYLsGCFO.mjs.map