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

package/dist/{schema-verify.d.mts → diff.d.mts}

@@ -1,9 +1,9 @@
-import { i as verifySqlSchema, n as NativeTypeNormalizer, r as VerifySqlSchemaOptions } from "./verify-sql-schema-B8uEjw2s.mjs";
+import { a as verifySqlSchemaTree, i as verifySqlSchema, n as NativeTypeNormalizer, r as VerifySqlSchemaOptions } from "./sql-schema-diff-6z36dZt6.mjs";
 import { ControlPolicy } from "@prisma-next/contract/types";
 import { SchemaIssue } from "@prisma-next/framework-components/control";
 import { SqlIndexIR, SqlUniqueIR } from "@prisma-next/sql-schema-ir/types";
 
-//#region src/core/schema-verify/verify-helpers.d.ts
+//#region src/core/diff/verify-helpers.d.ts
 /**
  * Compares two arrays of strings for equality (order-sensitive).
  */
@@ -35,5 +35,5 @@ declare function isUniqueConstraintSatisfied(uniques: readonly SqlUniqueIR[], in
  */
 declare function isIndexSatisfied(indexes: readonly SqlIndexIR[], uniques: readonly SqlUniqueIR[], columns: readonly string[]): boolean;
 //#endregion
-export { type NativeTypeNormalizer, type VerifySqlSchemaOptions, arraysEqual, isIndexSatisfied, isUniqueConstraintSatisfied, verifySqlSchema };
-//# sourceMappingURL=schema-verify.d.mts.map
+export { type NativeTypeNormalizer, type VerifySqlSchemaOptions, arraysEqual, isIndexSatisfied, isUniqueConstraintSatisfied, verifySqlSchema, verifySqlSchemaTree };
+//# sourceMappingURL=diff.d.mts.map

package/dist/diff.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff.d.mts","names":[],"sources":["../src/core/diff/verify-helpers.ts"],"mappings":";;;;;;;;;iBAgEgB,WAAA,CAAY,CAAA,qBAAsB,CAAoB;AA+BtE;;;;;;;;;;AAG4B;AAuB5B;AA1BA,iBAAgB,2BAAA,CACd,OAAA,WAAkB,WAAA,IAClB,OAAA,WAAkB,UAAU,IAC5B,OAAA;;;;;;;;;AA0B0B;;;;iBAHZ,gBAAA,CACd,OAAA,WAAkB,UAAA,IAClB,OAAA,WAAkB,WAAW,IAC7B,OAAA"}

package/dist/{verify-sql-schema-CEY7b78t.mjs → diff.mjs}

@@ -1,242 +1,12 @@
+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 { assertUniqueCodecOwner, dispositionForCategory } from "@prisma-next/framework-components/control";
+import { dispositionForCategory } from "@prisma-next/framework-components/control";
 import { UNBOUND_NAMESPACE_ID } from "@prisma-next/framework-components/ir";
-import { defaultIndexName } from "@prisma-next/sql-schema-ir/naming";
 import { ifDefined } from "@prisma-next/utils/defined";
-import { isStorageTable, isStorageTypeInstance } from "@prisma-next/sql-contract/types";
+import { StorageTable, isStorageTypeInstance } from "@prisma-next/sql-contract/types";
 import { canonicalStringify } from "@prisma-next/utils/canonical-stringify";
-//#region src/core/assembly.ts
-function hasCodecControlHooks(descriptor) {
-	if (typeof descriptor !== "object" || descriptor === null) return false;
-	const hooks = descriptor.types?.codecTypes?.controlPlaneHooks;
-	return hooks !== null && hooks !== void 0 && typeof hooks === "object";
-}
-function extractCodecControlHooks(descriptors) {
-	const hooks = /* @__PURE__ */ new Map();
-	const owners = /* @__PURE__ */ new Map();
-	for (const descriptor of descriptors) {
-		if (typeof descriptor !== "object" || descriptor === null) continue;
-		if (!hasCodecControlHooks(descriptor)) continue;
-		const controlPlaneHooks = descriptor.types.codecTypes.controlPlaneHooks;
-		for (const [codecId, hook] of Object.entries(controlPlaneHooks)) {
-			assertUniqueCodecOwner({
-				codecId,
-				owners,
-				descriptorId: descriptor.id,
-				entityLabel: "control hooks",
-				entityOwnershipLabel: "owner"
-			});
-			hooks.set(codecId, hook);
-			owners.set(codecId, descriptor.id);
-		}
-	}
-	return hooks;
-}
-//#endregion
-//#region src/core/migrations/contract-to-schema-ir.ts
-function convertColumn(name, column, storageTypes, expandNativeType, renderDefault) {
-	const resolved = resolveColumnTypeMetadata(column, storageTypes);
-	const baseNativeType = expandNativeType ? expandNativeType({
-		nativeType: resolved.nativeType,
-		codecId: resolved.codecId,
-		...ifDefined("typeParams", resolved.typeParams)
-	}) : resolved.nativeType;
-	return {
-		name,
-		nativeType: column.many ? `${baseNativeType}[]` : baseNativeType,
-		nullable: column.nullable,
-		...ifDefined("default", column.default != null && renderDefault ? renderDefault(column.default, column) : void 0)
-	};
-}
-function resolveColumnTypeMetadata(column, storageTypes) {
-	if (!column.typeRef) return column;
-	const referenced = storageTypes[column.typeRef];
-	if (!referenced) throw new Error(`Column references storage type "${column.typeRef}" but it is not defined in storage.types.`);
-	if (isStorageTypeInstance(referenced)) return {
-		codecId: referenced.codecId,
-		nativeType: referenced.nativeType,
-		typeParams: referenced.typeParams
-	};
-	throw new Error(`Storage type "${column.typeRef}" has an unknown polymorphic kind; expected a codec-typed StorageTypeInstance.`);
-}
-/**
-* Resolves a `ValueSetRef` to its permitted values from the contract storage.
-*
-* Throws when the referenced namespace or value-set is absent — this indicates
-* the contract was built incorrectly (the check and the value-set must be
-* co-emitted by the lowering step). Used by `convertCheck` (schema-IR
-* projection), `verifyCheckConstraints` (verification), and
-* `checkConstraintPlanCallStrategy` (migration planning) so all three agree on
-* the resolved values and the error behavior on a missing reference.
-*/
-function allStrings(values) {
-	return values.every((value) => typeof value === "string");
-}
-function resolveValueSetValues(ref, storage, contextLabel) {
-	const ns = storage.namespaces[ref.namespaceId];
-	if (!ns) throw new Error(`resolveValueSetValues: namespace "${ref.namespaceId}" not found in storage (${contextLabel})`);
-	const valueSet = ns.entries.valueSet?.[ref.entityName];
-	if (!valueSet) throw new Error(`resolveValueSetValues: value-set "${ref.entityName}" not found in namespace "${ref.namespaceId}" (${contextLabel})`);
-	const values = valueSet.values;
-	if (!allStrings(values)) throw new Error(`resolveValueSetValues: value-set "${ref.entityName}" in namespace "${ref.namespaceId}" has a non-string value; numeric-enum CHECK constraints are not yet supported (${contextLabel})`);
-	return values;
-}
-/**
-* Projects a `CheckConstraint` IR into an `SqlCheckConstraintIRInput` by
-* resolving the permitted values from the storage value-set it references.
-*
-* The `CheckConstraint.valueSet` ref points to
-* `storage.namespaces[namespaceId].entries.valueSet[name]`. The resolved
-* values are lifted directly from `StorageValueSet.values` so verification
-* compares value sets, not SQL predicate strings.
-*
-* Throws if the referenced namespace or value-set is absent — this
-* indicates the contract was built incorrectly (the check and the
-* value-set must be co-emitted by the lowering step).
-*/
-function convertCheck(check, storage) {
-	const permittedValues = resolveValueSetValues(check.valueSet, storage, `check "${check.name}"`);
-	return {
-		name: check.name,
-		column: check.column,
-		permittedValues
-	};
-}
-function convertUnique(unique) {
-	return {
-		columns: unique.columns,
-		...ifDefined("name", unique.name)
-	};
-}
-function convertIndex(index) {
-	return {
-		columns: index.columns,
-		unique: false,
-		...ifDefined("name", index.name)
-	};
-}
-function convertForeignKey(fk) {
-	return {
-		columns: fk.source.columns,
-		referencedTable: fk.target.tableName,
-		referencedSchema: fk.target.namespaceId,
-		referencedColumns: fk.target.columns,
-		...ifDefined("name", fk.name),
-		...ifDefined("onDelete", fk.onDelete),
-		...ifDefined("onUpdate", fk.onUpdate)
-	};
-}
-function convertTable(name, table, storageTypes, expandNativeType, renderDefault, storage) {
-	const columns = {};
-	for (const [colName, colDef] of Object.entries(table.columns)) columns[colName] = convertColumn(colName, colDef, storageTypes, expandNativeType, renderDefault);
-	const satisfiedIndexColumns = new Set([
-		...table.indexes.map((idx) => idx.columns.join(",")),
-		...table.uniques.map((unique) => unique.columns.join(",")),
-		...table.primaryKey ? [table.primaryKey.columns.join(",")] : []
-	]);
-	const fkBackingIndexes = [];
-	for (const fk of table.foreignKeys) {
-		if (fk.index === false) continue;
-		const key = fk.source.columns.join(",");
-		if (satisfiedIndexColumns.has(key)) continue;
-		fkBackingIndexes.push({
-			columns: fk.source.columns,
-			unique: false,
-			name: defaultIndexName(name, fk.source.columns)
-		});
-		satisfiedIndexColumns.add(key);
-	}
-	const checks = table.checks && table.checks.length > 0 ? table.checks.map((c) => convertCheck(c, storage)) : void 0;
-	return {
-		name,
-		columns,
-		...ifDefined("primaryKey", table.primaryKey),
-		foreignKeys: table.foreignKeys.filter((fk) => fk.constraint !== false).map(convertForeignKey),
-		uniques: table.uniques.map(convertUnique),
-		indexes: [...table.indexes.map(convertIndex), ...fkBackingIndexes],
-		...ifDefined("checks", checks)
-	};
-}
-/**
-* Detects destructive changes between two contract storages.
-*
-* The additive-only planner silently ignores removals (tables, columns).
-* This function detects those removals so callers can report them as conflicts
-* rather than silently producing an empty plan.
-*
-* Returns an empty array if no destructive changes are found.
-*/
-function detectDestructiveChanges(from, to) {
-	if (!from) return [];
-	const hasOwn = (value, key) => Object.hasOwn(value, key);
-	const conflicts = [];
-	const namespaceIds = [...new Set([...Object.keys(from.namespaces), ...Object.keys(to.namespaces)])].sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
-	for (const namespaceId of namespaceIds) {
-		const fromNs = from.namespaces[namespaceId];
-		const toNs = to.namespaces[namespaceId];
-		const fromTables = fromNs?.entries.table;
-		if (!fromTables) continue;
-		for (const tableName of Object.keys(fromTables)) {
-			const toTableRaw = toNs?.entries.table?.[tableName];
-			if (!isStorageTable(toTableRaw)) {
-				conflicts.push({
-					kind: "tableRemoved",
-					summary: `Table "${tableName}" was removed`
-				});
-				continue;
-			}
-			const toTable = toTableRaw;
-			const fromTableRaw = fromTables[tableName];
-			if (!isStorageTable(fromTableRaw)) continue;
-			const fromTable = fromTableRaw;
-			for (const columnName of Object.keys(fromTable.columns)) if (!hasOwn(toTable.columns, columnName)) conflicts.push({
-				kind: "columnRemoved",
-				summary: `Column "${tableName}"."${columnName}" was removed`
-			});
-		}
-	}
-	return conflicts;
-}
-/**
-* Converts a `Contract` to `SqlSchemaIR`.
-*
-* Reads `contract.storage` for tables and `contract.storage.types` for type
-* annotations. Storage-type annotations are written under
-* `options.annotationNamespace`.
-*
-* Drops codec metadata (`codecId`, `typeRef`) since the schema IR only represents
-* structural information. When `expandNativeType` is provided, parameterized types
-* are expanded (e.g. `character` + `{ length: 36 }` → `character(36)`) so the
-* resulting IR compares correctly against the "to" contract during planning.
-*
-* Returns an empty schema IR when `contract` is `null` (new project).
-*/
-function contractToSchemaIR(contract, options) {
-	if (options.annotationNamespace.length === 0) throw new Error("annotationNamespace must be a non-empty string");
-	if (!contract) return { tables: {} };
-	const storage = contract.storage;
-	const storageTypes = { ...storage.types ?? {} };
-	const tables = {};
-	for (const ns of Object.values(storage.namespaces)) for (const [tableName, tableDefRaw] of Object.entries(ns.entries.table ?? {})) {
-		if (!isStorageTable(tableDefRaw)) throw new Error(`contractToSchemaIR: expected StorageTable at namespaces.${ns.id}.entries.table.${tableName}`);
-		const tableDef = tableDefRaw;
-		if (tables[tableName] !== void 0) throw new Error(`contractToSchemaIR: duplicate SQL table name "${tableName}" across namespaces (ambiguous for flat SqlSchemaIR.tables).`);
-		tables[tableName] = convertTable(tableName, tableDef, storageTypes, options.expandNativeType, options.renderDefault, storage);
-	}
-	return {
-		tables,
-		...ifDefined("annotations", deriveAnnotations(storage, options.annotationNamespace, options.resolveEnumNamespaceSchema))
-	};
-}
-function deriveAnnotations(storage, annotationNamespace, _resolveEnumNamespaceSchema) {
-	const storageTypes = {};
-	for (const typeInstance of Object.values(storage.types ?? {})) if (isStorageTypeInstance(typeInstance)) storageTypes[typeInstance.nativeType] = typeInstance;
-	const envelope = { ...Object.keys(storageTypes).length > 0 ? { storageTypes } : {} };
-	if (Object.keys(envelope).length === 0) return void 0;
-	return { [annotationNamespace]: envelope };
-}
-//#endregion
-//#region src/core/schema-verify/verifier-disposition.ts
+//#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
@@ -276,7 +46,7 @@ function verifierDisposition(controlPolicy, issueKind) {
 	return dispositionForCategory(controlPolicy, classifySqlVerifierIssueKind(issueKind));
 }
 //#endregion
-//#region src/core/schema-verify/control-verify-emit.ts
+//#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
@@ -304,7 +74,7 @@ function emitIssueUnderControlPolicy(controlPolicy, issue, issues) {
 	return disposition;
 }
 //#endregion
-//#region src/core/schema-verify/verify-helpers.ts
+//#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() : [];
@@ -369,6 +139,7 @@ function verifyPrimaryKey(contractPK, schemaPK, tableName, namespaceId, tableCon
 	if (!schemaPK) {
 		const outcome = emitIssueUnderControlPolicy(tableControlPolicy, {
 			kind: "primary_key_mismatch",
+			reason: "not-equal",
 			table: tableName,
 			namespaceId,
 			expected: contractPK.columns.join(", "),
@@ -379,6 +150,7 @@ function verifyPrimaryKey(contractPK, schemaPK, tableName, namespaceId, tableCon
 	if (!arraysEqual(contractPK.columns, schemaPK.columns)) {
 		const outcome = emitIssueUnderControlPolicy(tableControlPolicy, {
 			kind: "primary_key_mismatch",
+			reason: "not-equal",
 			table: tableName,
 			namespaceId,
 			expected: contractPK.columns.join(", "),
@@ -406,6 +178,7 @@ function verifyForeignKeys(contractFKs, schemaFKs, tableName, namespaceId, table
 		});
 		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(", ")})`,
@@ -429,6 +202,7 @@ function verifyForeignKeys(contractFKs, schemaFKs, tableName, namespaceId, table
 				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(",")})`,
@@ -465,6 +239,7 @@ function verifyForeignKeys(contractFKs, schemaFKs, tableName, namespaceId, table
 			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(",")})`,
@@ -502,6 +277,7 @@ function verifyUniqueConstraints(contractUniques, schemaUniques, schemaIndexes,
 		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(", "),
@@ -532,6 +308,7 @@ 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",
+			reason: "not-expected",
 			table: tableName,
 			namespaceId,
 			indexOrConstraint: schemaUnique.name ?? `unique(${schemaUnique.columns.join(",")})`,
@@ -569,6 +346,7 @@ function verifyIndexes(contractIndexes, schemaIndexes, schemaUniques, tableName,
 		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(", "),
@@ -600,6 +378,7 @@ function verifyIndexes(contractIndexes, schemaIndexes, schemaUniques, tableName,
 		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(",")})`,
@@ -708,6 +487,7 @@ function verifyCheckConstraints(contractChecks, schemaChecks, tableName, namespa
 		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,
@@ -726,6 +506,7 @@ function verifyCheckConstraints(contractChecks, schemaChecks, tableName, namespa
 		}, issues, nodes);
 		else if (!valueSetsEqual(contractCheck.permittedValues, liveCheck.permittedValues)) emitIssueAndNodeUnderControlPolicy(tableControlPolicy, {
 			kind: "check_mismatch",
+			reason: "not-equal",
 			table: tableName,
 			namespaceId,
 			indexOrConstraint: contractCheck.name,
@@ -758,6 +539,7 @@ function verifyCheckConstraints(contractChecks, schemaChecks, tableName, namespa
 	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,
@@ -778,7 +560,20 @@ function verifyCheckConstraints(contractChecks, schemaChecks, tableName, namespa
 	return nodes;
 }
 //#endregion
-//#region src/core/schema-verify/verify-sql-schema.ts
+//#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.
 *
@@ -802,7 +597,8 @@ function verifySqlSchema(options) {
 		codecHooks,
 		storageTypes: contract.storage.types ?? {},
 		...ifDefined("normalizeDefault", normalizeDefault),
-		...ifDefined("normalizeNativeType", normalizeNativeType)
+		...ifDefined("normalizeNativeType", normalizeNativeType),
+		...ifDefined("restrictToNamespaceIds", options.restrictToNamespaceIds)
 	});
 	validateFrameworkComponentsForExtensions(contract, options.frameworkComponents);
 	const typeNodes = [];
@@ -893,17 +689,18 @@ function extractContractMetadata(contract) {
 	};
 }
 function verifySchemaTables(options) {
-	const { contract, schema, strict, typeMetadataRegistry, codecHooks, storageTypes, normalizeDefault, normalizeNativeType } = 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 ?? {})) {
-			if (!isStorageTable(contractTableRaw)) throw new Error(`verifySqlSchema: expected StorageTable at storage.namespaces.${namespaceId}.entries.table.${tableName}`);
+			StorageTable.assert(contractTableRaw, `storage.namespaces.${namespaceId}.entries.table.${tableName}`);
 			const contractTable = contractTableRaw;
 			const tableControlPolicy = effectiveControlPolicy(contractTable.control, contractDefaultControl);
 			const schemaTable = schemaTables[tableName];
@@ -911,6 +708,7 @@ function verifySchemaTables(options) {
 			if (!schemaTable) {
 				emitIssueAndNodeUnderControlPolicy(tableControlPolicy, {
 					kind: "missing_table",
+					reason: "not-found",
 					table: tableName,
 					namespaceId,
 					message: `Table "${tableName}" is missing from database`
@@ -949,6 +747,7 @@ function verifySchemaTables(options) {
 	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)`
 		}, {
@@ -960,7 +759,8 @@ function verifySchemaTables(options) {
 			message: `Extra table "${tableName}" found`,
 			expected: void 0,
 			actual: void 0,
-			children: []
+			children: [],
+			reason: "not-expected"
 		}, issues, rootChildren);
 	}
 	return {
@@ -1034,6 +834,7 @@ function verifyTableChildren(options) {
 		});
 	} 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)"
@@ -1078,6 +879,7 @@ function collectContractColumnNodes(options) {
 		if (!schemaColumn) {
 			emitIssueAndNodeUnderControlPolicy(tableControlPolicy, {
 				kind: "missing_column",
+				reason: "not-found",
 				table: tableName,
 				namespaceId,
 				column: columnName,
@@ -1118,6 +920,7 @@ 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,
@@ -1151,6 +954,7 @@ function verifyColumn(options) {
 	if (!(contractNativeType === schemaNativeType)) {
 		const issue = {
 			kind: "type_mismatch",
+			reason: "not-equal",
 			table: tableName,
 			namespaceId,
 			column: columnName,
@@ -1203,6 +1007,7 @@ function verifyColumn(options) {
 	if (contractColumn.nullable !== schemaColumn.nullable) {
 		const issue = {
 			kind: "nullability_mismatch",
+			reason: "not-equal",
 			table: tableName,
 			namespaceId,
 			column: columnName,
@@ -1232,6 +1037,7 @@ function verifyColumn(options) {
 			const defaultDescription = describeColumnDefault(contractColumn.default);
 			const issue = {
 				kind: "default_missing",
+				reason: "not-found",
 				table: tableName,
 				namespaceId,
 				column: columnName,
@@ -1259,6 +1065,7 @@ function verifyColumn(options) {
 			const actualDescription = schemaColumn.default;
 			const issue = {
 				kind: "default_mismatch",
+				reason: "not-equal",
 				table: tableName,
 				namespaceId,
 				column: columnName,
@@ -1286,6 +1093,7 @@ function verifyColumn(options) {
 	} else if (strict && schemaColumn.default) {
 		const issue = {
 			kind: "extra_default",
+			reason: "not-expected",
 			table: tableName,
 			namespaceId,
 			column: columnName,
@@ -1501,7 +1309,109 @@ function formatLiteralValue(value) {
 	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 { contractToSchemaIR as a, extractCodecControlHooks as c, isUniqueConstraintSatisfied as i, arraysEqual as n, detectDestructiveChanges as o, isIndexSatisfied as r, resolveValueSetValues as s, verifySqlSchema as t };
+export { arraysEqual, isIndexSatisfied, isUniqueConstraintSatisfied, verifySqlSchema, verifySqlSchemaTree };
 
-//# sourceMappingURL=verify-sql-schema-CEY7b78t.mjs.map
+//# sourceMappingURL=diff.mjs.map