@prisma-next/family-sql 0.14.0-dev.4 → 0.14.0-dev.40

package/dist/control.mjs

@@ -1,17 +1,18 @@
-import { i as sqlFamilyPslBlockDescriptors, n as sqlFamilyAuthoringFieldPresets, r as sqlFamilyEntityTypes, t as sqlFamilyAuthoringTypes } from "./authoring-type-constructors-CjFfO6LM.mjs";
-import { t as SqlContractSerializer } from "./sql-contract-serializer-BR2vC7Z-.mjs";
-import { a as contractToSchemaIR, c as extractCodecControlHooks, o as detectDestructiveChanges, s as resolveValueSetValues, t as verifySqlSchema } from "./verify-sql-schema-xT4udQLQ.mjs";
+import { i as sqlFamilyPslBlockDescriptors, n as sqlFamilyAuthoringFieldPresets, r as sqlFamilyEntityTypes, t as sqlFamilyAuthoringTypes } from "./authoring-type-constructors-CXd-8ydc.mjs";
+import { t as SqlContractSerializer } from "./sql-contract-serializer-CYtXg_zs.mjs";
 import { t as collectSupportedCodecTypeIds } from "./verify-C-G0obRm.mjs";
+import { a as extractCodecControlHooks, i as resolveValueSetValues, n as contractToSchemaIR, r as detectDestructiveChanges, t as contractNamespaceToSchemaIR } from "./contract-to-schema-ir-S-evq8E6.mjs";
 import { n as temporalAuthoringPresets, r as timestampNowControlDescriptor } from "./timestamp-now-generator-CloimujU.mjs";
 import { sqlEmission } from "@prisma-next/sql-contract-emitter";
-import { APP_SPACE_ID, SchemaTreeNode, VERIFY_CODE_HASH_MISMATCH, VERIFY_CODE_MARKER_MISSING, VERIFY_CODE_TARGET_MISMATCH, assembleAuthoringContributions } from "@prisma-next/framework-components/control";
+import { blindCast } from "@prisma-next/utils/casts";
+import { effectiveControlPolicy } from "@prisma-next/contract/types";
+import { APP_SPACE_ID, SchemaTreeNode, VERIFY_CODE_HASH_MISMATCH, VERIFY_CODE_MARKER_MISSING, VERIFY_CODE_TARGET_MISMATCH, assembleAuthoringContributions, dispositionForCategory } from "@prisma-next/framework-components/control";
+import { isPlainRecord } from "@prisma-next/framework-components/ir";
 import { assertDescriptorSelfConsistency } from "@prisma-next/migration-tools/spaces";
 import { sqlContractCanonicalizationHooks } from "@prisma-next/sql-contract/canonicalization-hooks";
 import { defaultIndexName } from "@prisma-next/sql-schema-ir/naming";
 import { ifDefined } from "@prisma-next/utils/defined";
 import { StorageTable } from "@prisma-next/sql-contract/types";
-import { UNSPECIFIED_PSL_NAMESPACE_ID, makePslNamespace, makePslNamespaceEntries } from "@prisma-next/framework-components/psl-ast";
-import { effectiveControlPolicy } from "@prisma-next/contract/types";
 import { notOk, ok } from "@prisma-next/utils/result";
 //#region src/core/operation-preview.ts
 function isDdlStatement(sqlStatement) {
@@ -46,921 +47,6 @@ function sqlOperationsToPreview(operations) {
 	})) };
 }
 //#endregion
-//#region src/core/psl-contract-infer/default-mapping.ts
-const DEFAULT_FUNCTION_ATTRIBUTES = {
-	"autoincrement()": "@default(autoincrement())",
-	"now()": "@default(now())"
-};
-function mapDefault(columnDefault, options) {
-	switch (columnDefault.kind) {
-		case "literal": return { attribute: `@default(${formatLiteralValue(columnDefault.value)})` };
-		case "function": {
-			const attribute = options?.functionAttributes?.[columnDefault.expression] ?? DEFAULT_FUNCTION_ATTRIBUTES[columnDefault.expression] ?? options?.fallbackFunctionAttribute?.(columnDefault.expression);
-			return attribute ? { attribute } : { comment: `// Raw default: ${columnDefault.expression.replace(/[\r\n]+/g, " ")}` };
-		}
-	}
-}
-function formatLiteralValue(value) {
-	if (value === null) return "null";
-	switch (typeof value) {
-		case "boolean":
-		case "number": return String(value);
-		case "string": return quoteString(value);
-		default: return quoteString(JSON.stringify(value));
-	}
-}
-function quoteString(str) {
-	return `"${escapeString(str)}"`;
-}
-function escapeString(str) {
-	return JSON.stringify(str).slice(1, -1);
-}
-//#endregion
-//#region src/core/psl-contract-infer/name-transforms.ts
-const PSL_RESERVED_WORDS = new Set([
-	"model",
-	"enum",
-	"types",
-	"type",
-	"generator",
-	"datasource"
-]);
-const IDENTIFIER_PART_PATTERN = /[A-Za-z0-9]+/g;
-function hasSeparators(input) {
-	return /[^A-Za-z0-9]/.test(input);
-}
-function extractIdentifierParts(input) {
-	return input.match(IDENTIFIER_PART_PATTERN) ?? [];
-}
-function createSyntheticIdentifier(input) {
-	let hash = 2166136261;
-	for (const char of input) {
-		hash ^= char.codePointAt(0) ?? 0;
-		hash = Math.imul(hash, 16777619);
-	}
-	return `x${(hash >>> 0).toString(16)}`;
-}
-function sanitizeIdentifierCharacters(input) {
-	const sanitized = input.replace(/[^\w]/g, "");
-	return sanitized.length > 0 ? sanitized : createSyntheticIdentifier(input);
-}
-function capitalize(word) {
-	return word.charAt(0).toUpperCase() + word.slice(1);
-}
-function snakeToPascalCase(input) {
-	const parts = extractIdentifierParts(input);
-	if (parts.length === 0) return capitalize(sanitizeIdentifierCharacters(input));
-	return parts.map(capitalize).join("");
-}
-function snakeToCamelCase(input) {
-	const parts = extractIdentifierParts(input);
-	if (parts.length === 0) return sanitizeIdentifierCharacters(input);
-	const [firstPart = input, ...rest] = parts;
-	return firstPart.charAt(0).toLowerCase() + firstPart.slice(1) + rest.map(capitalize).join("");
-}
-function needsEscaping(name) {
-	return PSL_RESERVED_WORDS.has(name.toLowerCase()) || /^\d/.test(name);
-}
-function escapeName(name) {
-	return `_${name}`;
-}
-function escapeIfNeeded(name) {
-	return needsEscaping(name) ? escapeName(name) : name;
-}
-function toModelName(tableName) {
-	let name;
-	if (hasSeparators(tableName)) name = snakeToPascalCase(tableName);
-	else name = tableName.charAt(0).toUpperCase() + tableName.slice(1);
-	if (needsEscaping(name)) return {
-		name: escapeName(name),
-		map: tableName
-	};
-	if (name !== tableName) return {
-		name,
-		map: tableName
-	};
-	return { name };
-}
-function toFieldName(columnName) {
-	let name;
-	if (hasSeparators(columnName)) name = snakeToCamelCase(columnName);
-	else name = columnName.charAt(0).toLowerCase() + columnName.slice(1);
-	if (needsEscaping(name)) return {
-		name: escapeName(name),
-		map: columnName
-	};
-	if (name !== columnName) return {
-		name,
-		map: columnName
-	};
-	return { name };
-}
-function pluralize(word) {
-	if (word.endsWith("s") || word.endsWith("x") || word.endsWith("z") || word.endsWith("ch") || word.endsWith("sh")) return `${word}es`;
-	if (word.endsWith("y") && !/[aeiou]y$/i.test(word)) return `${word.slice(0, -1)}ies`;
-	return `${word}s`;
-}
-function deriveRelationFieldName(fkColumns, referencedTableName) {
-	if (fkColumns.length === 1) {
-		const [col = referencedTableName] = fkColumns;
-		const stripped = col.replace(/_id$/i, "").replace(/Id$/, "");
-		if (stripped.length > 0 && stripped !== col) return escapeIfNeeded(snakeToCamelCase(stripped));
-		return escapeIfNeeded(snakeToCamelCase(referencedTableName));
-	}
-	return escapeIfNeeded(snakeToCamelCase(referencedTableName));
-}
-function deriveBackRelationFieldName(childModelName, isOneToOne) {
-	const base = childModelName.charAt(0).toLowerCase() + childModelName.slice(1);
-	return isOneToOne ? base : pluralize(base);
-}
-function toNamedTypeName(columnName) {
-	let name;
-	if (hasSeparators(columnName)) name = snakeToPascalCase(columnName);
-	else name = columnName.charAt(0).toUpperCase() + columnName.slice(1);
-	return escapeIfNeeded(name);
-}
-//#endregion
-//#region src/core/psl-contract-infer/postgres-default-mapping.ts
-const POSTGRES_FUNCTION_ATTRIBUTES = { "gen_random_uuid()": "@default(dbgenerated(\"gen_random_uuid()\"))" };
-function formatDbGeneratedAttribute(expression) {
-	return `@default(dbgenerated(${JSON.stringify(expression)}))`;
-}
-function createPostgresDefaultMapping() {
-	return {
-		functionAttributes: POSTGRES_FUNCTION_ATTRIBUTES,
-		fallbackFunctionAttribute: formatDbGeneratedAttribute
-	};
-}
-//#endregion
-//#region src/core/psl-contract-infer/postgres-type-map.ts
-const POSTGRES_TO_PSL = {
-	text: "String",
-	bool: "Boolean",
-	boolean: "Boolean",
-	int4: "Int",
-	integer: "Int",
-	int8: "BigInt",
-	bigint: "BigInt",
-	float8: "Float",
-	"double precision": "Float",
-	numeric: "Decimal",
-	decimal: "Decimal",
-	timestamptz: "DateTime",
-	"timestamp with time zone": "DateTime",
-	jsonb: "Json",
-	bytea: "Bytes"
-};
-const PRESERVED_NATIVE_TYPES = {
-	"character varying": {
-		pslType: "String",
-		attributeName: "db.VarChar"
-	},
-	character: {
-		pslType: "String",
-		attributeName: "db.Char"
-	},
-	char: {
-		pslType: "String",
-		attributeName: "db.Char"
-	},
-	varchar: {
-		pslType: "String",
-		attributeName: "db.VarChar"
-	},
-	uuid: {
-		pslType: "String",
-		attributeName: "db.Uuid"
-	},
-	int2: {
-		pslType: "Int",
-		attributeName: "db.SmallInt"
-	},
-	smallint: {
-		pslType: "Int",
-		attributeName: "db.SmallInt"
-	},
-	float4: {
-		pslType: "Float",
-		attributeName: "db.Real"
-	},
-	real: {
-		pslType: "Float",
-		attributeName: "db.Real"
-	},
-	timestamp: {
-		pslType: "DateTime",
-		attributeName: "db.Timestamp"
-	},
-	"timestamp without time zone": {
-		pslType: "DateTime",
-		attributeName: "db.Timestamp"
-	},
-	date: {
-		pslType: "DateTime",
-		attributeName: "db.Date"
-	},
-	time: {
-		pslType: "DateTime",
-		attributeName: "db.Time"
-	},
-	"time without time zone": {
-		pslType: "DateTime",
-		attributeName: "db.Time"
-	},
-	timetz: {
-		pslType: "DateTime",
-		attributeName: "db.Timetz"
-	},
-	"time with time zone": {
-		pslType: "DateTime",
-		attributeName: "db.Timetz"
-	},
-	json: {
-		pslType: "Json",
-		attributeName: "db.Json"
-	}
-};
-const PARAMETERIZED_NATIVE_TYPES = {
-	"character varying": {
-		pslType: "String",
-		attributeName: "db.VarChar"
-	},
-	character: {
-		pslType: "String",
-		attributeName: "db.Char"
-	},
-	char: {
-		pslType: "String",
-		attributeName: "db.Char"
-	},
-	varchar: {
-		pslType: "String",
-		attributeName: "db.VarChar"
-	},
-	numeric: {
-		pslType: "Decimal",
-		attributeName: "db.Numeric"
-	},
-	timestamp: {
-		pslType: "DateTime",
-		attributeName: "db.Timestamp"
-	},
-	timestamptz: {
-		pslType: "DateTime",
-		attributeName: "db.Timestamptz"
-	},
-	time: {
-		pslType: "DateTime",
-		attributeName: "db.Time"
-	},
-	timetz: {
-		pslType: "DateTime",
-		attributeName: "db.Timetz"
-	}
-};
-const PARAMETERIZED_TYPE_PATTERN = /^(.+?)\((.+)\)$/;
-function getOwnMappingValue(map, key) {
-	return Object.hasOwn(map, key) ? map[key] : void 0;
-}
-function getOwnRecordValue(map, key) {
-	return Object.hasOwn(map, key) ? map[key] : void 0;
-}
-function createNativeTypeAttribute(name, args) {
-	return args && args.length > 0 ? {
-		name,
-		args
-	} : { name };
-}
-function splitTypeParameterList(params) {
-	return params.split(",").map((part) => part.trim()).filter((part) => part.length > 0);
-}
-function createPostgresTypeMap(enumTypeNames) {
-	return { resolve(nativeType) {
-		if (enumTypeNames?.has(nativeType)) return {
-			pslType: nativeType,
-			nativeType
-		};
-		const paramMatch = nativeType.match(PARAMETERIZED_TYPE_PATTERN);
-		if (paramMatch) {
-			const [, baseType = nativeType, params = ""] = paramMatch;
-			const template = getOwnRecordValue(PARAMETERIZED_NATIVE_TYPES, baseType);
-			if (template) return {
-				pslType: template.pslType,
-				nativeType,
-				typeParams: {
-					baseType,
-					params
-				},
-				nativeTypeAttribute: createNativeTypeAttribute(template.attributeName, splitTypeParameterList(params))
-			};
-		}
-		const preservedType = getOwnRecordValue(PRESERVED_NATIVE_TYPES, nativeType);
-		if (preservedType) return {
-			pslType: preservedType.pslType,
-			nativeType,
-			nativeTypeAttribute: createNativeTypeAttribute(preservedType.attributeName)
-		};
-		const pslType = getOwnMappingValue(POSTGRES_TO_PSL, nativeType);
-		if (pslType) return {
-			pslType,
-			nativeType
-		};
-		return {
-			unsupported: true,
-			nativeType
-		};
-	} };
-}
-function extractEnumInfo(annotations) {
-	const nativeEnumTypeNames = (annotations?.["pg"])?.["nativeEnumTypeNames"];
-	const typeNames = /* @__PURE__ */ new Set();
-	const definitions = /* @__PURE__ */ new Map();
-	if (Array.isArray(nativeEnumTypeNames)) {
-		for (const name of nativeEnumTypeNames) if (typeof name === "string") typeNames.add(name);
-	}
-	return {
-		typeNames,
-		definitions
-	};
-}
-//#endregion
-//#region src/core/psl-contract-infer/raw-default-parser.ts
-const NEXTVAL_PATTERN = /^nextval\s*\(/i;
-const NOW_FUNCTION_PATTERN = /^(now\s*\(\s*\)|CURRENT_TIMESTAMP)$/i;
-const CLOCK_TIMESTAMP_PATTERN = /^clock_timestamp\s*\(\s*\)$/i;
-const TIMESTAMP_CAST_SUFFIX = /::timestamp(?:tz|\s+(?:with|without)\s+time\s+zone)?$/i;
-const TEXT_CAST_SUFFIX = /::text$/i;
-const NOW_LITERAL_PATTERN = /^'now'$/i;
-const UUID_PATTERN = /^gen_random_uuid\s*\(\s*\)$/i;
-const UUID_OSSP_PATTERN = /^uuid_generate_v4\s*\(\s*\)$/i;
-const NULL_PATTERN = /^NULL(?:::.+)?$/i;
-const TRUE_PATTERN = /^true$/i;
-const FALSE_PATTERN = /^false$/i;
-const NUMERIC_PATTERN = /^-?\d+(\.\d+)?$/;
-const JSON_CAST_SUFFIX = /::jsonb?$/i;
-const STRING_LITERAL_PATTERN = /^'((?:[^']|'')*)'(?:::(?:"[^"]+"|[\w\s]+)(?:\(\d+\))?)?$/;
-function canonicalizeTimestampDefault(expr) {
-	if (NOW_FUNCTION_PATTERN.test(expr)) return "now()";
-	if (CLOCK_TIMESTAMP_PATTERN.test(expr)) return "clock_timestamp()";
-	if (!TIMESTAMP_CAST_SUFFIX.test(expr)) return void 0;
-	let inner = expr.replace(TIMESTAMP_CAST_SUFFIX, "").trim();
-	if (inner.startsWith("(") && inner.endsWith(")")) inner = inner.slice(1, -1).trim();
-	if (NOW_FUNCTION_PATTERN.test(inner)) return "now()";
-	if (CLOCK_TIMESTAMP_PATTERN.test(inner)) return "clock_timestamp()";
-	inner = inner.replace(TEXT_CAST_SUFFIX, "").trim();
-	if (NOW_LITERAL_PATTERN.test(inner)) return "now()";
-}
-function parseRawDefault(rawDefault, nativeType) {
-	const trimmed = rawDefault.trim();
-	const normalizedType = nativeType?.toLowerCase();
-	if (NEXTVAL_PATTERN.test(trimmed)) return {
-		kind: "function",
-		expression: "autoincrement()"
-	};
-	const canonicalTimestamp = canonicalizeTimestampDefault(trimmed);
-	if (canonicalTimestamp) return {
-		kind: "function",
-		expression: canonicalTimestamp
-	};
-	if (UUID_PATTERN.test(trimmed) || UUID_OSSP_PATTERN.test(trimmed)) return {
-		kind: "function",
-		expression: "gen_random_uuid()"
-	};
-	if (NULL_PATTERN.test(trimmed)) return {
-		kind: "literal",
-		value: null
-	};
-	if (TRUE_PATTERN.test(trimmed)) return {
-		kind: "literal",
-		value: true
-	};
-	if (FALSE_PATTERN.test(trimmed)) return {
-		kind: "literal",
-		value: false
-	};
-	if (NUMERIC_PATTERN.test(trimmed)) return {
-		kind: "literal",
-		value: Number(trimmed)
-	};
-	const stringMatch = trimmed.match(STRING_LITERAL_PATTERN);
-	if (stringMatch?.[1] !== void 0) {
-		const unescaped = stringMatch[1].replace(/''/g, "'");
-		if (normalizedType === "json" || normalizedType === "jsonb") {
-			if (JSON_CAST_SUFFIX.test(trimmed)) return {
-				kind: "function",
-				expression: trimmed
-			};
-			try {
-				return {
-					kind: "literal",
-					value: JSON.parse(unescaped)
-				};
-			} catch {}
-		}
-		return {
-			kind: "literal",
-			value: unescaped
-		};
-	}
-	return {
-		kind: "function",
-		expression: trimmed
-	};
-}
-//#endregion
-//#region src/core/psl-contract-infer/relation-inference.ts
-const DEFAULT_ON_DELETE = "noAction";
-const DEFAULT_ON_UPDATE = "noAction";
-const REFERENTIAL_ACTION_PSL = {
-	noAction: "NoAction",
-	restrict: "Restrict",
-	cascade: "Cascade",
-	setNull: "SetNull",
-	setDefault: "SetDefault"
-};
-function inferRelations(tables, modelNameMap) {
-	const relationsByTable = /* @__PURE__ */ new Map();
-	const fkCountByPair = /* @__PURE__ */ new Map();
-	for (const table of Object.values(tables)) for (const fk of table.foreignKeys) {
-		const pairKey = `${table.name}→${fk.referencedTable}`;
-		fkCountByPair.set(pairKey, (fkCountByPair.get(pairKey) ?? 0) + 1);
-	}
-	const usedFieldNames = /* @__PURE__ */ new Map();
-	for (const table of Object.values(tables)) {
-		const names = /* @__PURE__ */ new Set();
-		for (const col of Object.values(table.columns)) names.add(col.name);
-		usedFieldNames.set(table.name, names);
-	}
-	for (const table of Object.values(tables)) for (const fk of table.foreignKeys) {
-		const childTableName = table.name;
-		const parentTableName = fk.referencedTable;
-		const childUsed = usedFieldNames.get(childTableName);
-		const childModelName = modelNameMap.get(childTableName) ?? childTableName;
-		const parentModelName = modelNameMap.get(parentTableName) ?? parentTableName;
-		const pairKey = `${childTableName}→${parentTableName}`;
-		const isSelfRelation = childTableName === parentTableName;
-		const needsRelationName = fkCountByPair.get(pairKey) > 1 || isSelfRelation;
-		const isOneToOne = detectOneToOne(fk, table);
-		const childRelFieldName = resolveUniqueFieldName(deriveRelationFieldName(fk.columns, parentTableName), childUsed, parentModelName);
-		const relationName = needsRelationName ? deriveRelationName(fk, childRelFieldName, parentModelName, isSelfRelation) : void 0;
-		addRelationField(relationsByTable, childTableName, buildChildRelationField(childRelFieldName, parentModelName, fk, fk.columns.some((columnName) => table.columns[columnName]?.nullable ?? false), relationName));
-		childUsed.add(childRelFieldName);
-		const parentUsed = usedFieldNames.get(parentTableName) ?? /* @__PURE__ */ new Set();
-		usedFieldNames.set(parentTableName, parentUsed);
-		const backRelFieldName = resolveUniqueFieldName(deriveBackRelationFieldName(childModelName, isOneToOne), parentUsed, childModelName);
-		addRelationField(relationsByTable, parentTableName, {
-			fieldName: backRelFieldName,
-			typeName: childModelName,
-			optional: isOneToOne,
-			list: !isOneToOne,
-			relationName
-		});
-		parentUsed.add(backRelFieldName);
-	}
-	return { relationsByTable };
-}
-function detectOneToOne(fk, table) {
-	const fkCols = [...fk.columns].sort();
-	if (table.primaryKey) {
-		const pkCols = [...table.primaryKey.columns].sort();
-		if (pkCols.length === fkCols.length && pkCols.every((c, i) => c === fkCols[i])) return true;
-	}
-	for (const unique of table.uniques) {
-		const uniqueCols = [...unique.columns].sort();
-		if (uniqueCols.length === fkCols.length && uniqueCols.every((c, i) => c === fkCols[i])) return true;
-	}
-	return false;
-}
-function deriveRelationName(fk, childRelationFieldName, parentModelName, isSelfRelation) {
-	if (fk.name) return fk.name;
-	if (isSelfRelation) return `${childRelationFieldName.charAt(0).toUpperCase() + childRelationFieldName.slice(1)}${pluralize(parentModelName)}`;
-	return fk.columns.join("_");
-}
-function buildChildRelationField(fieldName, parentModelName, fk, optional, relationName) {
-	const onDelete = fk.onDelete && fk.onDelete !== DEFAULT_ON_DELETE ? fk.onDelete : void 0;
-	const onUpdate = fk.onUpdate && fk.onUpdate !== DEFAULT_ON_UPDATE ? fk.onUpdate : void 0;
-	return {
-		fieldName,
-		typeName: parentModelName,
-		referencedTableName: fk.referencedTable,
-		optional,
-		list: false,
-		relationName,
-		fkName: fk.name,
-		fields: fk.columns,
-		references: fk.referencedColumns,
-		onDelete: onDelete ? REFERENTIAL_ACTION_PSL[onDelete] : void 0,
-		onUpdate: onUpdate ? REFERENTIAL_ACTION_PSL[onUpdate] : void 0
-	};
-}
-function resolveUniqueFieldName(desired, usedNames, fallbackSuffix) {
-	if (!usedNames.has(desired)) return desired;
-	const withSuffix = `${desired}${fallbackSuffix}`;
-	if (!usedNames.has(withSuffix)) return withSuffix;
-	let counter = 2;
-	while (usedNames.has(`${desired}${counter}`)) counter++;
-	return `${desired}${counter}`;
-}
-function addRelationField(map, tableName, field) {
-	const existing = map.get(tableName);
-	if (existing) existing.push(field);
-	else map.set(tableName, [field]);
-}
-//#endregion
-//#region src/core/psl-contract-infer/sql-schema-ir-to-psl-ast.ts
-const SYNTHETIC_SPAN = {
-	start: {
-		offset: 0,
-		line: 1,
-		column: 1
-	},
-	end: {
-		offset: 0,
-		line: 1,
-		column: 1
-	}
-};
-const PSL_SCALAR_TYPE_NAMES = new Set([
-	"String",
-	"Boolean",
-	"Int",
-	"BigInt",
-	"Float",
-	"Decimal",
-	"DateTime",
-	"Json",
-	"Bytes"
-]);
-/**
-* Converts a SQL schema IR into a PSL AST suitable for `printPsl`.
-*
-* This function owns all SQL-specific concerns: native type mapping (Postgres),
-* relation inference from foreign keys, enum extraction, and raw default parsing.
-* The output is a fully-formed `PslDocumentAst` with synthetic spans.
-*/
-function sqlSchemaIrToPslAst(schemaIR) {
-	const enumInfo = extractEnumInfo(schemaIR.annotations);
-	if (enumInfo.typeNames.size > 0) {
-		const names = [...enumInfo.typeNames].join(", ");
-		throw new Error(`contract infer: the database contains native Postgres enum type(s): ${names}. Native Postgres enums (CREATE TYPE … AS ENUM) are not adoptable by contract infer. Drop the native type and replace each column with a text column carrying a CHECK constraint, then re-run contract infer. The domain enum (enum Name { @@type("pg/text@1") … }) authoring surface generates the required check automatically.`);
-	}
-	return buildPslDocumentAst(schemaIR, {
-		typeMap: createPostgresTypeMap(/* @__PURE__ */ new Set()),
-		defaultMapping: createPostgresDefaultMapping(),
-		parseRawDefault
-	});
-}
-function buildPslDocumentAst(schemaIR, options) {
-	const { typeMap, defaultMapping, parseRawDefault: rawDefaultParser } = options;
-	const modelNames = buildTopLevelNameMap(Object.keys(schemaIR.tables), toModelName, "model", "table");
-	const modelNameMap = new Map([...modelNames].map(([tableName, result]) => [tableName, result.name]));
-	const reservedNamedTypeNames = createReservedNamedTypeNames(modelNames);
-	const fieldNamesByTable = buildFieldNamesByTable(schemaIR.tables);
-	const { relationsByTable } = inferRelations(schemaIR.tables, modelNameMap);
-	const namedTypes = seedNamedTypeRegistry(schemaIR, typeMap, /* @__PURE__ */ new Map(), reservedNamedTypeNames);
-	const models = [];
-	for (const table of Object.values(schemaIR.tables)) models.push(buildModel(table, typeMap, /* @__PURE__ */ new Map(), fieldNamesByTable, namedTypes, defaultMapping, rawDefaultParser, relationsByTable.get(table.name) ?? []));
-	const sortedModels = topologicalSort(models, schemaIR.tables, modelNameMap);
-	const namedTypeEntries = [...namedTypes.entriesByKey.values()].sort((a, b) => a.name.localeCompare(b.name));
-	const types = namedTypeEntries.length > 0 ? {
-		kind: "types",
-		declarations: namedTypeEntries.map(buildNamedTypeDeclaration),
-		span: SYNTHETIC_SPAN
-	} : void 0;
-	return {
-		kind: "document",
-		sourceId: "<sql-schema-ir>",
-		namespaces: [makePslNamespace({
-			kind: "namespace",
-			name: UNSPECIFIED_PSL_NAMESPACE_ID,
-			entries: makePslNamespaceEntries(sortedModels, [], []),
-			span: SYNTHETIC_SPAN
-		})],
-		...types ? { types } : {},
-		span: SYNTHETIC_SPAN
-	};
-}
-function buildModel(table, typeMap, enumNameMap, fieldNamesByTable, namedTypes, defaultMapping, rawDefaultParser, relationFields) {
-	const { name: modelName, map: mapName } = toModelName(table.name);
-	const fieldNameMap = fieldNamesByTable.get(table.name);
-	const pkColumns = new Set(table.primaryKey?.columns ?? []);
-	const isSinglePk = pkColumns.size === 1;
-	const singlePkConstraintName = isSinglePk ? table.primaryKey?.name : void 0;
-	const uniqueColumns = /* @__PURE__ */ new Map();
-	for (const unique of table.uniques) if (unique.columns.length === 1) {
-		const [columnName = ""] = unique.columns;
-		const existingConstraintName = uniqueColumns.get(columnName);
-		if (!uniqueColumns.has(columnName) || existingConstraintName === void 0 && unique.name) uniqueColumns.set(columnName, unique.name);
-	}
-	const fields = [];
-	for (const column of Object.values(table.columns)) fields.push(buildScalarField(column, table, typeMap, enumNameMap, fieldNameMap, namedTypes, defaultMapping, rawDefaultParser, pkColumns, isSinglePk, singlePkConstraintName, uniqueColumns));
-	const usedFieldNames = new Set(fields.map((field) => field.name));
-	for (const rel of relationFields) fields.push(buildRelationField(rel, table.name, fieldNamesByTable, usedFieldNames));
-	const modelAttributes = [];
-	if (table.primaryKey && table.primaryKey.columns.length > 1) {
-		const pkFieldNames = table.primaryKey.columns.map((columnName) => resolveColumnFieldName(fieldNamesByTable, table.name, columnName));
-		modelAttributes.push(buildModelConstraintAttribute("id", pkFieldNames, table.primaryKey.name));
-	}
-	for (const unique of table.uniques) if (unique.columns.length > 1) {
-		const uniqueFieldNames = unique.columns.map((columnName) => resolveColumnFieldName(fieldNamesByTable, table.name, columnName));
-		modelAttributes.push(buildModelConstraintAttribute("unique", uniqueFieldNames, unique.name));
-	}
-	for (const index of table.indexes) if (!index.unique) {
-		const indexFieldNames = index.columns.map((columnName) => resolveColumnFieldName(fieldNamesByTable, table.name, columnName));
-		modelAttributes.push(buildModelConstraintAttribute("index", indexFieldNames, index.name));
-	}
-	if (mapName) modelAttributes.push(buildMapAttribute("model", mapName));
-	const comment = table.primaryKey ? void 0 : "// WARNING: This table has no primary key in the database";
-	return {
-		kind: "model",
-		name: modelName,
-		fields,
-		attributes: modelAttributes,
-		span: SYNTHETIC_SPAN,
-		...comment !== void 0 ? { comment } : {}
-	};
-}
-function buildScalarField(column, table, typeMap, enumNameMap, fieldNameMap, namedTypes, defaultMapping, rawDefaultParser, pkColumns, isSinglePk, singlePkConstraintName, uniqueColumns) {
-	const resolvedField = fieldNameMap?.get(column.name);
-	const fieldName = resolvedField?.fieldName ?? toFieldName(column.name).name;
-	const fieldMap = resolvedField?.fieldMap;
-	const resolution = typeMap.resolve(column.nativeType, table.annotations);
-	if ("unsupported" in resolution) {
-		const attrs = [];
-		if (fieldMap !== void 0) attrs.push(buildMapAttribute("field", fieldMap));
-		return {
-			kind: "field",
-			name: fieldName,
-			typeName: `Unsupported("${escapePslString(resolution.nativeType)}")`,
-			optional: column.nullable,
-			list: false,
-			attributes: attrs,
-			span: SYNTHETIC_SPAN
-		};
-	}
-	let typeName = resolution.pslType;
-	const enumPslName = enumNameMap.get(column.nativeType);
-	if (enumPslName) typeName = enumPslName;
-	if (resolution.nativeTypeAttribute && !enumPslName) typeName = resolveNamedTypeName(namedTypes, resolution);
-	const attributes = [];
-	const isId = isSinglePk && pkColumns.has(column.name);
-	if (isId) attributes.push(buildSimpleConstraintFieldAttribute("id", singlePkConstraintName));
-	if (column.default !== void 0) {
-		const parsed = parseColumnDefault(column.default, column.nativeType, rawDefaultParser);
-		if (parsed) {
-			const result = mapDefault(parsed, defaultMapping);
-			if ("attribute" in result) attributes.push(parseDefaultAttributeString(result.attribute));
-		}
-	}
-	if (uniqueColumns.has(column.name) && !isId) {
-		const uniqueConstraintName = uniqueColumns.get(column.name);
-		attributes.push(buildSimpleConstraintFieldAttribute("unique", uniqueConstraintName));
-	}
-	if (fieldMap !== void 0) attributes.push(buildMapAttribute("field", fieldMap));
-	return {
-		kind: "field",
-		name: fieldName,
-		typeName,
-		optional: column.nullable,
-		list: false,
-		attributes,
-		span: SYNTHETIC_SPAN
-	};
-}
-function buildRelationField(rel, hostTableName, fieldNamesByTable, usedFieldNames) {
-	const fieldName = createUniqueFieldName(rel.fieldName, usedFieldNames);
-	usedFieldNames.add(fieldName);
-	const args = [];
-	if (rel.fields && rel.references) {
-		if (rel.relationName) args.push(namedArg("name", `"${escapePslString(rel.relationName)}"`));
-		args.push(namedArg("fields", `[${rel.fields.map((columnName) => resolveColumnFieldName(fieldNamesByTable, hostTableName, columnName)).join(", ")}]`));
-		args.push(namedArg("references", `[${rel.references.map((columnName) => resolveColumnFieldName(fieldNamesByTable, rel.referencedTableName ?? "", columnName)).join(", ")}]`));
-		if (rel.onDelete) args.push(namedArg("onDelete", rel.onDelete));
-		if (rel.onUpdate) args.push(namedArg("onUpdate", rel.onUpdate));
-		if (rel.fkName) args.push(namedArg("map", `"${escapePslString(rel.fkName)}"`));
-	} else if (rel.relationName) args.push(namedArg("name", `"${escapePslString(rel.relationName)}"`));
-	const attrs = args.length > 0 ? [buildAttribute("field", "relation", args)] : [];
-	return {
-		kind: "field",
-		name: fieldName,
-		typeName: rel.typeName,
-		optional: rel.optional,
-		list: rel.list,
-		attributes: attrs,
-		span: SYNTHETIC_SPAN
-	};
-}
-function buildModelConstraintAttribute(name, fields, constraintName) {
-	const args = [positionalArg(`[${fields.join(", ")}]`)];
-	if (constraintName !== void 0) args.push(namedArg("map", `"${escapePslString(constraintName)}"`));
-	return buildAttribute("model", name, args);
-}
-function buildSimpleConstraintFieldAttribute(name, constraintName) {
-	if (constraintName === void 0) return buildAttribute("field", name, []);
-	return buildAttribute("field", name, [namedArg("map", `"${escapePslString(constraintName)}"`)]);
-}
-function parseDefaultAttributeString(attributeText) {
-	return buildAttribute("field", "default", [positionalArg(attributeText.replace(/^@default\(/, "").replace(/\)$/, ""))]);
-}
-function buildMapAttribute(target, mapName) {
-	return buildAttribute(target, "map", [positionalArg(`"${escapePslString(mapName)}"`)]);
-}
-function buildAttribute(target, name, args) {
-	return {
-		kind: "attribute",
-		target,
-		name,
-		args,
-		span: SYNTHETIC_SPAN
-	};
-}
-function positionalArg(value) {
-	return {
-		kind: "positional",
-		value,
-		span: SYNTHETIC_SPAN
-	};
-}
-function namedArg(name, value) {
-	return {
-		kind: "named",
-		name,
-		value,
-		span: SYNTHETIC_SPAN
-	};
-}
-function buildNamedTypeDeclaration(entry) {
-	const attribute = buildAttribute("namedType", entry.nativeTypeAttribute.name, (entry.nativeTypeAttribute.args ?? []).map(positionalArg));
-	return {
-		kind: "namedType",
-		name: entry.name,
-		baseType: entry.baseType,
-		attributes: [attribute],
-		span: SYNTHETIC_SPAN
-	};
-}
-function escapePslString(value) {
-	return value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\n/g, "\\n").replace(/\r/g, "\\r");
-}
-/**
-* Resolves a `SqlColumnIR.default` value into a normalized {@link ColumnDefault}.
-*
-* `SqlSchemaIR` types the column default as `string` (a raw database default
-* expression). Some legacy fixtures and tests still pass already-normalized
-* `ColumnDefault` objects in the same slot, so we accept either shape
-* defensively at runtime.
-*/
-function parseColumnDefault(value, nativeType, rawDefaultParser) {
-	if (typeof value === "string") return rawDefaultParser ? rawDefaultParser(value, nativeType) : void 0;
-	if (value !== null && typeof value === "object" && "kind" in value) return value;
-}
-function buildFieldNamesByTable(tables) {
-	const fieldNamesByTable = /* @__PURE__ */ new Map();
-	for (const table of Object.values(tables)) {
-		const assignmentOrder = [...Object.values(table.columns).map((column, index) => {
-			const { name, map } = toFieldName(column.name);
-			return {
-				columnName: column.name,
-				desiredFieldName: name,
-				fieldMap: map,
-				index
-			};
-		})].sort((left, right) => {
-			const mapComparison = Number(left.fieldMap !== void 0) - Number(right.fieldMap !== void 0);
-			if (mapComparison !== 0) return mapComparison;
-			return left.index - right.index;
-		});
-		const usedFieldNames = /* @__PURE__ */ new Set();
-		const tableFieldNames = /* @__PURE__ */ new Map();
-		for (const column of assignmentOrder) {
-			const fieldName = createUniqueFieldName(column.desiredFieldName, usedFieldNames);
-			usedFieldNames.add(fieldName);
-			tableFieldNames.set(column.columnName, {
-				fieldName,
-				fieldMap: column.fieldMap
-			});
-		}
-		fieldNamesByTable.set(table.name, tableFieldNames);
-	}
-	return fieldNamesByTable;
-}
-function resolveColumnFieldName(fieldNamesByTable, tableName, columnName) {
-	return fieldNamesByTable.get(tableName)?.get(columnName)?.fieldName ?? toFieldName(columnName).name;
-}
-function createUniqueFieldName(desiredName, usedFieldNames) {
-	if (!usedFieldNames.has(desiredName)) return desiredName;
-	let counter = 2;
-	while (usedFieldNames.has(`${desiredName}${counter}`)) counter++;
-	return `${desiredName}${counter}`;
-}
-function buildTopLevelNameMap(sources, normalize, kind, sourceKind) {
-	const results = /* @__PURE__ */ new Map();
-	const normalizedToSources = /* @__PURE__ */ new Map();
-	for (const source of sources) {
-		const normalized = normalize(source);
-		results.set(source, normalized);
-		normalizedToSources.set(normalized.name, [...normalizedToSources.get(normalized.name) ?? [], source]);
-	}
-	const duplicates = [...normalizedToSources.entries()].filter(([, conflictingSources]) => conflictingSources.length > 1);
-	if (duplicates.length > 0) {
-		const details = duplicates.map(([normalizedName, conflictingSources]) => `- ${kind} "${normalizedName}" from ${sourceKind}s ${conflictingSources.map((source) => `"${source}"`).join(", ")}`);
-		throw new Error(`PSL ${kind} name collisions detected:\n${details.join("\n")}`);
-	}
-	return results;
-}
-function createReservedNamedTypeNames(modelNames) {
-	const reservedNames = new Set(PSL_SCALAR_TYPE_NAMES);
-	for (const result of modelNames.values()) reservedNames.add(result.name);
-	return reservedNames;
-}
-function seedNamedTypeRegistry(schemaIR, typeMap, enumNameMap, reservedNames) {
-	const seeds = /* @__PURE__ */ new Map();
-	for (const tableName of Object.keys(schemaIR.tables).sort()) {
-		const table = schemaIR.tables[tableName];
-		if (!table) continue;
-		for (const columnName of Object.keys(table.columns).sort()) {
-			const column = table.columns[columnName];
-			if (!column) continue;
-			const resolution = typeMap.resolve(column.nativeType, table.annotations);
-			if ("unsupported" in resolution || enumNameMap.has(column.nativeType) || !resolution.nativeTypeAttribute) continue;
-			const signatureKey = createNamedTypeSignatureKey(resolution);
-			if (!seeds.has(signatureKey)) seeds.set(signatureKey, {
-				baseType: resolution.pslType,
-				desiredName: toNamedTypeName(column.name),
-				nativeTypeAttribute: resolution.nativeTypeAttribute
-			});
-		}
-	}
-	const registry = {
-		entriesByKey: /* @__PURE__ */ new Map(),
-		usedNames: new Set(reservedNames)
-	};
-	const sortedSeeds = [...seeds.entries()].sort((left, right) => {
-		const desiredNameComparison = left[1].desiredName.localeCompare(right[1].desiredName);
-		if (desiredNameComparison !== 0) return desiredNameComparison;
-		return left[0].localeCompare(right[0]);
-	});
-	for (const [signatureKey, seed] of sortedSeeds) {
-		const name = createUniqueFieldName(seed.desiredName, registry.usedNames);
-		registry.entriesByKey.set(signatureKey, {
-			name,
-			baseType: seed.baseType,
-			nativeTypeAttribute: seed.nativeTypeAttribute
-		});
-		registry.usedNames.add(name);
-	}
-	return registry;
-}
-function resolveNamedTypeName(registry, resolution) {
-	const key = createNamedTypeSignatureKey(resolution);
-	const existing = registry.entriesByKey.get(key);
-	if (existing) return existing.name;
-	throw new Error(`Named type registry was not seeded for native type "${resolution.nativeType}"`);
-}
-function createNamedTypeSignatureKey(resolution) {
-	return JSON.stringify({
-		baseType: resolution.pslType,
-		nativeTypeAttribute: resolution.nativeTypeAttribute ? {
-			name: resolution.nativeTypeAttribute.name,
-			args: resolution.nativeTypeAttribute.args ?? null
-		} : null
-	});
-}
-function topologicalSort(models, tables, modelNameMap) {
-	const modelByName = /* @__PURE__ */ new Map();
-	for (const model of models) modelByName.set(model.name, model);
-	const deps = /* @__PURE__ */ new Map();
-	const tableToModel = /* @__PURE__ */ new Map();
-	for (const tableName of Object.keys(tables)) {
-		const modelName = modelNameMap.get(tableName);
-		tableToModel.set(tableName, modelName);
-		deps.set(modelName, /* @__PURE__ */ new Set());
-	}
-	for (const [tableName, table] of Object.entries(tables)) {
-		const modelName = tableToModel.get(tableName);
-		for (const fk of table.foreignKeys) {
-			const refModelName = tableToModel.get(fk.referencedTable);
-			if (refModelName && refModelName !== modelName) deps.get(modelName).add(refModelName);
-		}
-	}
-	const result = [];
-	const visited = /* @__PURE__ */ new Set();
-	const visiting = /* @__PURE__ */ new Set();
-	const sortedNames = [...deps.keys()].sort();
-	function visit(name) {
-		if (visited.has(name)) return;
-		if (visiting.has(name)) return;
-		visiting.add(name);
-		const sortedDeps = [...deps.get(name)].sort();
-		for (const dep of sortedDeps) visit(dep);
-		visiting.delete(name);
-		visited.add(name);
-		result.push(modelByName.get(name));
-	}
-	for (const name of sortedNames) visit(name);
-	return result;
-}
-//#endregion
 //#region src/core/control-instance.ts
 function extractCodecTypeIdsFromContract(contract) {
 	const typeIds = /* @__PURE__ */ new Set();
@@ -1123,8 +209,13 @@ function createSqlFamilyInstance(stack) {
 	let controlAdapter;
 	const getControlAdapter = () => controlAdapter ??= adapter.create(stack);
 	const targetSerializer = target.contractSerializer;
-	const deserializeWithTargetSerializer = (contractJson) => {
-		return (targetSerializer ?? new SqlContractSerializer()).deserializeContract(contractJson);
+	const targetInferPslContract = blindCast(target).inferPslContract;
+	const verifyDatabaseSchema = blindCast(target).verifyDatabaseSchema;
+	if (!verifyDatabaseSchema) throw new Error(`SQL target "${target.targetId}" is missing the required verifyDatabaseSchema descriptor operation`);
+	const deserializeWithTargetSerializer = (contractOrJson) => {
+		const serializer = targetSerializer ?? new SqlContractSerializer();
+		const json = targetSerializer !== void 0 && !isPlainRecord(contractOrJson) ? targetSerializer.serializeContract(blindCast(contractOrJson)) : contractOrJson;
+		return serializer.deserializeContract(json);
 	};
 	return {
 		familyId: "sql",
@@ -1227,16 +318,40 @@ function createSqlFamilyInstance(stack) {
 		},
 		verifySchema(options) {
 			const contract = deserializeWithTargetSerializer(options.contract);
-			const controlAdapter = getControlAdapter();
-			return verifySqlSchema({
+			const sqlResult = verifyDatabaseSchema({
 				contract,
 				schema: options.schema,
 				strict: options.strict,
 				typeMetadataRegistry,
-				frameworkComponents: options.frameworkComponents,
-				...ifDefined("normalizeDefault", controlAdapter.normalizeDefault),
-				...ifDefined("normalizeNativeType", controlAdapter.normalizeNativeType)
+				frameworkComponents: options.frameworkComponents
 			});
+			const schemaDiffIssues = filterSchemaDiffIssues(sqlResult.schema.schemaDiffIssues, contract.defaultControlPolicy);
+			const relationalFails = sqlResult.schema.counts.fail;
+			if (schemaDiffIssues.length === 0) {
+				if (schemaDiffIssues === sqlResult.schema.schemaDiffIssues) return sqlResult;
+				return {
+					...sqlResult,
+					schema: {
+						...sqlResult.schema,
+						schemaDiffIssues
+					}
+				};
+			}
+			const totalFails = relationalFails + schemaDiffIssues.length;
+			return {
+				...sqlResult,
+				ok: false,
+				code: sqlResult.code ?? "PN-RUN-3010",
+				summary: `Database schema does not satisfy contract (${totalFails} failure${totalFails === 1 ? "" : "s"})`,
+				schema: {
+					...sqlResult.schema,
+					schemaDiffIssues,
+					counts: {
+						...sqlResult.schema.counts,
+						fail: totalFails
+					}
+				}
+			};
 		},
 		async sign(options) {
 			const { driver, contract: contractInput, contractPath, configPath } = options;
@@ -1326,7 +441,8 @@ function createSqlFamilyInstance(stack) {
 			return getControlAdapter().introspect(options.driver, options.contract);
 		},
 		inferPslContract(schemaIR) {
-			return sqlSchemaIrToPslAst(schemaIR);
+			if (!targetInferPslContract) throw new Error(`Target "${target.targetId}" does not support contract infer (no inferPslContract on its descriptor).`);
+			return targetInferPslContract(schemaIR);
 		},
 		lowerAst(ast, context) {
 			return getControlAdapter().lowerToExecuteRequest(ast, context);
@@ -1334,21 +450,25 @@ function createSqlFamilyInstance(stack) {
 		bootstrapControlTableQueries() {
 			return getControlAdapter().bootstrapControlTableQueries();
 		},
-		bootstrapSignMarkerQueries() {
-			return getControlAdapter().bootstrapSignMarkerQueries();
-		},
 		toOperationPreview(operations) {
 			return sqlOperationsToPreview(operations);
 		},
 		toSchemaView(schema) {
-			const tableNodes = Object.entries(schema.tables).map(([tableName, table]) => {
+			const root = blindCast(schema);
+			const namespaceEntries = root.namespaces !== void 0 ? Object.entries(root.namespaces).map(([namespaceKey, namespace]) => [namespaceKey, namespace.tables]) : [[void 0, root.tables ?? {}]];
+			const qualify = namespaceEntries.length > 1;
+			const tableNodes = namespaceEntries.flatMap(([namespaceKey, tables]) => Object.entries(tables).map(([tableName, table]) => [
+				qualify && namespaceKey !== void 0 ? `${namespaceKey}.${tableName}` : tableName,
+				tableName,
+				table
+			])).map(([displayName, tableName, table]) => {
 				const children = [];
 				const columnNodes = [];
 				for (const [columnName, column] of Object.entries(table.columns)) {
 					const label = `${columnName}: ${column.nativeType} (${column.nullable ? "nullable" : "not nullable"})`;
 					columnNodes.push(new SchemaTreeNode({
 						kind: "field",
-						id: `column-${tableName}-${columnName}`,
+						id: `column-${displayName}-${columnName}`,
 						label,
 						meta: {
 							nativeType: column.nativeType,
@@ -1359,7 +479,7 @@ function createSqlFamilyInstance(stack) {
 				}
 				if (columnNodes.length > 0) children.push(new SchemaTreeNode({
 					kind: "collection",
-					id: `columns-${tableName}`,
+					id: `columns-${displayName}`,
 					label: "columns",
 					children: columnNodes
 				}));
@@ -1367,7 +487,7 @@ function createSqlFamilyInstance(stack) {
 					const pkColumns = table.primaryKey.columns.join(", ");
 					children.push(new SchemaTreeNode({
 						kind: "index",
-						id: `primary-key-${tableName}`,
+						id: `primary-key-${displayName}`,
 						label: `primary key: ${pkColumns}`,
 						meta: {
 							columns: table.primaryKey.columns,
@@ -1380,7 +500,7 @@ function createSqlFamilyInstance(stack) {
 					const label = `unique ${name}`;
 					children.push(new SchemaTreeNode({
 						kind: "index",
-						id: `unique-${tableName}-${name}`,
+						id: `unique-${displayName}-${name}`,
 						label,
 						meta: {
 							columns: unique.columns,
@@ -1393,7 +513,7 @@ function createSqlFamilyInstance(stack) {
 					const label = index.unique ? `unique index ${name}` : `index ${name}`;
 					children.push(new SchemaTreeNode({
 						kind: "index",
-						id: `index-${tableName}-${name}`,
+						id: `index-${displayName}-${name}`,
 						label,
 						meta: {
 							columns: index.columns,
@@ -1414,8 +534,8 @@ function createSqlFamilyInstance(stack) {
 				}));
 				return new SchemaTreeNode({
 					kind: "entity",
-					id: `table-${tableName}`,
-					label: `table ${tableName}`,
+					id: `table-${displayName}`,
+					label: `table ${displayName}`,
 					...Object.keys(tableMeta).length > 0 ? { meta: tableMeta } : {},
 					...children.length > 0 ? { children } : {}
 				});
@@ -1429,6 +549,24 @@ function createSqlFamilyInstance(stack) {
 		}
 	};
 }
+/**
+* Filters the structural schema-diff issues (from `diffDatabaseSchema`) through
+* the contract's `defaultControlPolicy`. Issues whose outcome maps to a suppressed
+* category under the effective policy are removed. This mirrors the control-policy
+* filtering applied by `verifySqlSchema` for table/column-level findings.
+*
+* Outcome → category mapping:
+* - `'extra'`    → `'extraAuxiliary'`    (an extra auxiliary entity, e.g. an RLS policy)
+* - `'missing'`  → `'declaredMissing'`
+* - `'mismatch'` → `'declaredIncompatible'`
+*/
+function filterSchemaDiffIssues(issues, defaultControlPolicy) {
+	if (issues.length === 0) return issues;
+	const policy = effectiveControlPolicy(void 0, defaultControlPolicy);
+	return issues.filter((issue) => {
+		return dispositionForCategory(policy, issue.outcome === "extra" ? "extraAuxiliary" : issue.outcome === "missing" ? "declaredMissing" : "declaredIncompatible") !== "suppress";
+	});
+}
 //#endregion
 //#region src/core/control-descriptor.ts
 var SqlFamilyDescriptor = class {
@@ -1635,8 +773,8 @@ function planFieldEventOperations(options) {
 		for (const tableName of tableNames) {
 			const priorTableRaw = priorTables?.[tableName];
 			const newTableRaw = newTables?.[tableName];
-			const priorTable = priorTableRaw instanceof StorageTable ? priorTableRaw : void 0;
-			const newTable = newTableRaw instanceof StorageTable ? newTableRaw : void 0;
+			const priorTable = StorageTable.is(priorTableRaw) ? priorTableRaw : void 0;
+			const newTable = StorageTable.is(newTableRaw) ? newTableRaw : void 0;
 			const fieldNames = unionSorted(priorTable ? Object.keys(priorTable.columns) : [], newTable ? Object.keys(newTable.columns) : []);
 			for (const fieldName of fieldNames) {
 				const priorField = priorTable?.columns[fieldName];
@@ -1853,6 +991,6 @@ const INIT_ADDITIVE_POLICY = Object.freeze({ allowedOperationClasses: Object.fre
 //#region src/exports/control.ts
 var control_default = new SqlFamilyDescriptor();
 //#endregion
-export { INIT_ADDITIVE_POLICY, assembleAuthoringContributions, contractToSchemaIR, controlPolicyForCall, createMigrationPlan, control_default as default, detectDestructiveChanges, extractCodecControlHooks, partitionCallsByControlPolicy, partitionIssuesByControlPolicy, planFieldEventOperations, plannerFailure, plannerSuccess, resolveValueSetValues, runnerFailure, runnerSuccess, temporalAuthoringPresets, timestampNowControlDescriptor };
+export { INIT_ADDITIVE_POLICY, assembleAuthoringContributions, contractNamespaceToSchemaIR, contractToSchemaIR, controlPolicyForCall, createMigrationPlan, control_default as default, detectDestructiveChanges, extractCodecControlHooks, partitionCallsByControlPolicy, partitionIssuesByControlPolicy, planFieldEventOperations, plannerFailure, plannerSuccess, resolveValueSetValues, runnerFailure, runnerSuccess, temporalAuthoringPresets, timestampNowControlDescriptor };
 
 //# sourceMappingURL=control.mjs.map