@prisma/orm-family-sql 8.0.0-rc.17-dev.9 → 8.0.0-rc.17-dev.11

package/dist/{derived-checks-CfXjGvNH-CrXoMrPU.mjs → derived-checks-RB_lNgFJ-CHamqgFW.mjs}

@@ -15,6 +15,7 @@ import { t as deriveValueSetFromEntity } from "./value-set-derivation-hook-Di9JZ
 import { isStructuredError, structuredError } from "@prisma/orm-framework/utils/structured-error";
 import { ifDefined } from "@prisma/orm-framework/utils/defined";
 import { flushAuthoringWarnings, isAuthoringEntityTypeDescriptor } from "@prisma/orm-framework/components/authoring";
+import { compareCodeUnits } from "@prisma/orm-framework/contract/hashing-utils";
 import { UNBOUND_NAMESPACE_ID } from "@prisma/orm-framework/components/ir";
 import { codecForRef, enumRefusalOf } from "@prisma/orm-framework/components/codec";
 import { blindCast } from "@prisma/orm-framework/utils/casts";
@@ -26,7 +27,7 @@ import { resolveToOneRelationNullable } from "@prisma/orm-framework/contract-aut
 import { buildExecutionSection, computeProfileHash, computeStorageHash } from "@prisma/orm-framework/contract/hashing";
 import { invariant } from "@prisma/orm-framework/utils/assertions";
 import { applySpecifierDefaultControlPolicy } from "@prisma/orm-framework/contract/apply-specifier-default-control-policy";
-//#region ../../../2-sql/2-authoring/contract-ts/dist/derived-checks-CfXjGvNH.mjs
+//#region ../../../2-sql/2-authoring/contract-ts/dist/derived-checks-RB_lNgFJ.mjs
 function contractError(code, message, options) {
 	return structuredError(code, message, options);
 }
@@ -40,8 +41,44 @@ function storedAsListColumn(field) {
 function isValueObjectMember(field) {
 	return "valueObjectName" in field;
 }
-function toOneNullabilityContradictionMessage(location, contradiction) {
-	return contradiction === "declared-optional" ? `${location} is optional but every local field it joins on is required` : `${location} is required but a local field it joins on is nullable`;
+/** Describes one column, declared by a model's field or by a table node. */
+function describeColumn(column, site) {
+	return {
+		columnName: column.columnName,
+		descriptor: column.descriptor,
+		nullable: column.nullable,
+		many: column.many === true ? { elementNullable: column.elementNullable === true } : false,
+		default: column.default,
+		noCheck: column.noCheck,
+		enumTypeHandle: column.enumTypeHandle,
+		site
+	};
+}
+/** How an error message names the column: `Field "Model.field"` or `Column "table.column"`. */
+function columnSiteSubject(site) {
+	return site.kind === "field" ? `Field "${site.modelName}.${site.fieldName}"` : `Column "${site.tableName}.${site.columnName}"`;
+}
+/** The error metadata that locates the column. */
+function columnSiteMeta(site) {
+	return site.kind === "field" ? {
+		modelName: site.modelName,
+		fieldName: site.fieldName
+	} : {
+		namespaceId: site.namespaceId,
+		tableName: site.tableName,
+		columnName: site.columnName
+	};
+}
+/** How an error message names the owner: `model "User"` or `table "audit_rows" in namespace "public"`. */
+function referenceOwnerSubject(owner) {
+	return owner.kind === "model" ? `model "${owner.modelName}"` : `table "${owner.tableName}" in namespace "${owner.namespaceId}"`;
+}
+/** The error metadata that locates the owner. */
+function referenceOwnerMeta(owner) {
+	return owner.kind === "model" ? { sourceModel: owner.modelName } : {
+		sourceTable: owner.tableName,
+		sourceNamespaceId: owner.namespaceId
+	};
 }
 /**
 * The codec that encodes one column's default, built with the column's own `typeParams`, because a parameterized codec checks its params when it encodes and reads a default. Only a column has params; every other encode site takes the representative instance.
@@ -64,11 +101,10 @@ function encodeViaCodec(value, codec) {
 function defaultRefusal(site, cause, elementPosition) {
 	const subject = elementPosition === void 0 ? "default" : `default (element ${elementPosition})`;
 	const reason = cause instanceof Error ? cause.message : String(cause);
-	return contractError("CONTRACT.DEFAULT_INVALID", `Field "${site.modelName}.${site.fieldName}" has a ${subject} that its codec refuses: ${reason}`, {
+	return contractError("CONTRACT.DEFAULT_INVALID", `${columnSiteSubject(site)} has a ${subject} that its codec refuses: ${reason}`, {
 		cause,
 		meta: {
-			modelName: site.modelName,
-			fieldName: site.fieldName,
+			...columnSiteMeta(site),
 			codecId: site.codecId,
 			reason: "codec-refused-default",
 			...ifDefined("elementPosition", elementPosition)
@@ -85,9 +121,8 @@ function encodeDefaultValue(value, codec, site, elementPosition) {
 }
 function codecForDefault(codecLookup, resolveCodec, site) {
 	const codec = buildCodecForDefault(codecLookup, resolveCodec, site);
-	if (codec === void 0) throw contractError("CONTRACT.DEFAULT_INVALID", `Field "${site.modelName}.${site.fieldName}" has a default, but no pack in the contract declares its codec "${site.codecId}", so the default cannot be checked. List the pack that owns the codec in \`extensions\`.`, { meta: {
-		modelName: site.modelName,
-		fieldName: site.fieldName,
+	if (codec === void 0) throw contractError("CONTRACT.DEFAULT_INVALID", `${columnSiteSubject(site)} has a default, but no pack in the contract declares its codec "${site.codecId}", so the default cannot be checked. List the pack that owns the codec in \`extensions\`.`, { meta: {
+		...columnSiteMeta(site),
 		codecId: site.codecId,
 		reason: "codec-not-found"
 	} });
@@ -98,11 +133,10 @@ function buildCodecForDefault(codecLookup, resolveCodec, site) {
 		return resolveCodec(codecLookup);
 	} catch (cause) {
 		if (!isStructuredError(cause) || cause.code !== "RUNTIME.TYPE_PARAMS_INVALID") throw cause;
-		throw contractError("CONTRACT.ARGUMENT_INVALID", `Field "${site.modelName}.${site.fieldName}" has type parameters that its codec does not accept: ${cause.message}`, {
+		throw contractError("CONTRACT.ARGUMENT_INVALID", `${columnSiteSubject(site)} has type parameters that its codec does not accept: ${cause.message}`, {
 			cause,
 			meta: {
-				modelName: site.modelName,
-				fieldName: site.fieldName,
+				...columnSiteMeta(site),
 				codecId: site.codecId,
 				reason: "type-params-invalid"
 			}
@@ -119,9 +153,8 @@ function encodeColumnDefault(defaultInput, codecLookup, resolveCodec, site, many
 		value: blindCast(defaultInput.value)
 	};
 	if (many) {
-		if (!Array.isArray(defaultInput.value)) throw contractError("CONTRACT.DEFAULT_INVALID", `Field "${site.modelName}.${site.fieldName}" is a list field, so its default is an array; received ${typeof defaultInput.value}. Call .many() before .default().`, { meta: {
-			modelName: site.modelName,
-			fieldName: site.fieldName,
+		if (!Array.isArray(defaultInput.value)) throw contractError("CONTRACT.DEFAULT_INVALID", `${columnSiteSubject(site)} is a list field, so its default is an array; received ${typeof defaultInput.value}. Call .many() before .default().`, { meta: {
+			...columnSiteMeta(site),
 			codecId: site.codecId,
 			reason: "list-default-not-array"
 		} });
@@ -140,76 +173,6 @@ function encodeColumnDefault(defaultInput, codecLookup, resolveCodec, site, many
 		value: encodeDefaultValue(defaultInput.value, codecForDefault(codecLookup, resolveCodec, site), site)
 	};
 }
-function assertStorageSemantics(contract, indexTypeRegistry, codecLookup) {
-	const semanticErrors = validateStorageSemantics(contract.storage);
-	if (semanticErrors.length > 0) throw contractError("CONTRACT.VALIDATION_FAILED", `Contract semantic validation failed: ${semanticErrors.join("; ")}`, { meta: { errors: semanticErrors } });
-	validateIndexTypes(contract, indexTypeRegistry, (codecId) => codecLookup.descriptorFor(codecId)?.traits);
-}
-function assertKnownTargetModel(modelsByName, modelsByCoordinate, sourceModelName, targetModelName, targetNamespaceId, context) {
-	const targetModel = targetNamespaceId !== void 0 && targetNamespaceId.length > 0 ? modelsByCoordinate.get(`${targetNamespaceId}:${targetModelName}`) : modelsByName.get(targetModelName);
-	if (!targetModel) {
-		const qualified = targetNamespaceId !== void 0 && targetNamespaceId.length > 0 ? `${targetNamespaceId}.${targetModelName}` : targetModelName;
-		throw contractError("CONTRACT.MODEL_UNKNOWN", `${context} on model "${sourceModelName}" references unknown model "${qualified}"`, { meta: {
-			sourceModel: sourceModelName,
-			targetModel: qualified,
-			context
-		} });
-	}
-	return targetModel;
-}
-function assertTargetTableMatches(sourceModelName, targetModel, referencedTableName, context) {
-	if (targetModel.tableName !== referencedTableName) throw contractError("CONTRACT.TABLE_MISMATCH", `${context} on model "${sourceModelName}" references table "${referencedTableName}" but model "${targetModel.modelName}" maps to "${targetModel.tableName}"`, { meta: {
-		sourceModel: sourceModelName,
-		referencedTable: referencedTableName,
-		mappedTable: targetModel.tableName,
-		context
-	} });
-}
-/**
-* Resolves a deferred entity-ref column descriptor (e.g. a `pg.enum(handle)`
-* column) against the field's now-known owning namespace: attaches the
-* storage `valueSet` ref the collected entity's derived value-set is stored
-* under. `typeParams.typeName` stays bare here — schema
-* qualification (e.g. `auth.aal_level`) is a target concern applied in the
-* next step, `qualifyColumnDescriptor`. A descriptor with no `entityRef` (the
-* ordinary case) passes through unchanged.
-*/
-function resolveEntityRefDescriptor(descriptor, namespaceId) {
-	const entityRef = descriptor.entityRef;
-	if (entityRef === void 0) return descriptor;
-	return {
-		...descriptor,
-		valueSet: {
-			plane: "storage",
-			entityKind: "valueSet",
-			namespaceId,
-			entityName: entityRef.entityName
-		}
-	};
-}
-/**
-* Structural check for a target that contributes a `qualifyColumnType` hook
-* on its authoring contributions. Duck-typed (mirroring
-* `contract-psl`'s `hasColumnFromEntityHook`) so the SQL family stays blind
-* to the target's qualification logic and no framework/family interface has
-* to name the hook.
-*/
-function hasColumnTypeQualifier(authoring) {
-	return "qualifyColumnType" in authoring && typeof authoring.qualifyColumnType === "function";
-}
-/**
-* Structural check for a target that contributes a `renderCheckExpressions`
-* hook, duck-typed for the same reason {@link hasColumnTypeQualifier} is: the
-* SQL family stays blind to the target's predicate syntax.
-*/
-function hasCheckExpressionRenderer(authoring) {
-	return "renderCheckExpressions" in authoring && typeof authoring.renderCheckExpressions === "function";
-}
-function resolveCheckExpressionRenderer(target) {
-	const authoring = target.authoring;
-	if (authoring === void 0) return void 0;
-	return hasCheckExpressionRenderer(authoring) ? authoring.renderCheckExpressions : void 0;
-}
 /** Whether TypeScript gives the value a literal type: a primitive, or an array or plain object of them. */
 function hasLiteralType(value) {
 	if ([
@@ -311,149 +274,86 @@ function checkMemberValues(handle, codecLookup) {
 	return values;
 }
 /**
-* Resolves a field's authored `noCheck` kinds against its column shape:
-* the bare form (`[]`) becomes every kind the shape derives, and a named
-* kind that can never apply to the shape is an authoring error
-* (`CONTRACT.CHECK_OPTOUT_INVALID`). Returns the concrete kinds in
-* canonical ascending order — the only form the contract persists.
+* The refs of a field typed by an authored enum: the domain enum and its storage value set. Authored enums are registered in the default namespace, whatever namespace the field's model is in.
 */
-function resolveNoCheckKinds(input) {
-	const derivable = [];
-	if (input.many && !input.elementNullable) derivable.push("elementNotNull");
-	if (input.isDomainEnum) derivable.push("membership");
-	const subject = `Field "${input.modelName}.${input.fieldName}"`;
-	const meta = {
-		modelName: input.modelName,
-		fieldName: input.fieldName
+function enumValueSetRefs(enumHandle, defaultNamespaceId) {
+	if (enumHandle === void 0) return void 0;
+	const common = {
+		namespaceId: defaultNamespaceId,
+		entityName: enumHandle.enumName
 	};
-	if (input.kinds.length === 0) {
-		if (derivable.length === 0) throw contractError("CONTRACT.CHECK_OPTOUT_INVALID", `${subject}: noCheck() waives nothing — this column's shape derives no generated checks.`, { meta: {
-			...meta,
-			reason: "no-derivable-checks"
-		} });
-		return derivable;
-	}
-	const seen = /* @__PURE__ */ new Set();
-	for (const kind of input.kinds) {
-		if (seen.has(kind)) throw contractError("CONTRACT.CHECK_OPTOUT_INVALID", `${subject}: noCheck("${kind}") names the same kind twice.`, { meta: {
-			...meta,
-			kind,
-			reason: "duplicate-kind"
-		} });
-		seen.add(kind);
-		if (!derivable.includes(kind)) throw contractError("CONTRACT.CHECK_OPTOUT_INVALID", `${subject}: noCheck("${kind}") does not apply — ${kind === "membership" ? "membership checks are derived only from enumType() value sets" : "element-non-null checks are derived only for lists whose elements are semantically non-null"}.`, { meta: {
-			...meta,
-			kind,
-			reason: "inapplicable-kind"
-		} });
-	}
-	return [...input.kinds].sort();
-}
-/**
-* Names the target's rendered checks and lowers them into contract entities.
-*
-* Naming is composed family-side ({@link composeCheckWirePrefix}) rather than
-* by the target, and suffixed with the predicate's content hash. Composing
-* family-side is what makes the truncation safe — two prefixes that truncate
-* alike still differ in their hashes, and the family can see that the
-* (table, column, kind) triple they were built from is unique per table,
-* rather than having to assume something about SQL text it declares itself
-* unable to read.
-*/
-function lowerRenderedChecks(tableName, candidates) {
-	return candidates.map((candidate) => new CheckConstraint({
-		naming: {
-			kind: "wire",
-			prefix: composeCheckWirePrefix(tableName, candidate.columnName, candidate.kind),
-			hash: computeCheckContentHash(candidate.expression)
+	return {
+		domain: {
+			plane: "domain",
+			entityKind: "enum",
+			...common
 		},
-		expression: candidate.expression
-	}));
-}
-function resolveColumnTypeQualifier(target) {
-	const authoring = target.authoring;
-	if (authoring === void 0) return void 0;
-	return hasColumnTypeQualifier(authoring) ? authoring.qualifyColumnType : void 0;
+		storage: {
+			plane: "storage",
+			entityKind: "valueSet",
+			...common
+		}
+	};
 }
-/**
-* Applies the target's `qualifyColumnType` hook to a scalar column descriptor.
-* A descriptor whose codec the target leaves unchanged passes through untouched.
-*/
-function qualifyColumnDescriptor(descriptor, namespaceId, qualify) {
-	if (qualify === void 0) return descriptor;
-	const qualified = qualify({
-		codecId: descriptor.codecId,
-		...ifDefined("typeParams", descriptor.typeParams)
-	}, namespaceId);
-	if (qualified.typeParams === descriptor.typeParams) return descriptor;
+function buildDomainField(field, defaultNamespaceId, storageTypes) {
+	if (isValueObjectMember(field)) return {
+		type: {
+			kind: "valueObject",
+			name: field.valueObjectName
+		},
+		nullable: field.nullable,
+		many: field.many ? { elementNullable: field.elementNullable === true } : false
+	};
 	return {
-		...descriptor,
-		...ifDefined("typeParams", qualified.typeParams)
+		type: {
+			kind: "scalar",
+			codecId: field.descriptor.codecId,
+			...ifDefined("typeParams", resolvedTypeParams(field.descriptor, storageTypes))
+		},
+		nullable: field.nullable,
+		many: field.many ? { elementNullable: field.elementNullable === true } : false,
+		...ifDefined("valueSet", enumValueSetRefs(field.enumTypeHandle, defaultNamespaceId)?.domain)
 	};
 }
-/**
-* Records a deferred column's entity-ref into the namespace-scoped collection
-* accumulator (`namespaceId → entityKind → entityName`) — folded into the same
-* namespace assembly `deriveEntityValueSets`/`entries.<kind>` step as the
-* entities-channel attachments, so a column-collected entity gets its
-* value-set the same way an entities-channel one does.
-*
-* The same handle reused by many columns in one namespace is normal (a native
-* enum type backs any number of columns) and records the identical entity once.
-* Two *different* entity instances sharing a name+kind in one namespace is a
-* name collision — the emitted `entries.valueSet.<name>` could only reflect one
-* of them, silently mismatching the other column's type/cast. PSL hard-errors
-* on the equivalent (`PSL_DUPLICATE_DECLARATION`); the TS path rejects it too.
-*/
-function collectEntityFromColumn(collected, namespaceId, entityRef) {
-	const forNs = collected[namespaceId] ?? {};
-	const forKind = forNs[entityRef.entityKind] ?? {};
-	const existing = forKind[entityRef.entityName];
-	if (existing !== void 0 && existing !== entityRef.entity) throw contractError("CONTRACT.NAME_DUPLICATE", `buildSqlContractFromDefinition: two different "${entityRef.entityKind}" entities named "${entityRef.entityName}" in namespace "${namespaceId}" — pack-entity names must be unique per namespace.`, { meta: {
-		kind: entityRef.entityKind,
-		name: entityRef.entityName,
-		namespaceId
-	} });
-	forKind[entityRef.entityName] = entityRef.entity;
-	forNs[entityRef.entityKind] = forKind;
-	collected[namespaceId] = forNs;
+/** A declared namespace coordinate, where an omitted or empty one means the target's default namespace. */
+function namespaceIdOrDefault(namespaceId, defaultNamespaceId) {
+	return namespaceId !== void 0 && namespaceId.length > 0 ? namespaceId : defaultNamespaceId;
 }
-/**
-* Merges a namespace's entities-channel attachments (lowered from the
-* `entities` handle list, carried on `ContractDefinition.attachedEntities`)
-* with the entities collected from that namespace's deferred entity-ref
-* columns. A column-collected entity that shadows a *different* attached
-* entity of the same kind+name (or vice-versa) is the same name-collision bug
-* `collectEntityFromColumn` guards against across columns, so it is rejected
-* the same way — by entity identity, so the same handle attached and used by
-* a column does not throw.
-*/
-function mergeColumnAndAttachedEntities(namespaceId, attached, columnCollected) {
-	if (attached === void 0) return columnCollected;
-	if (columnCollected === void 0) return attached;
-	const kinds = /* @__PURE__ */ new Set([...Object.keys(attached), ...Object.keys(columnCollected)]);
-	const result = {};
-	for (const kind of kinds) {
-		const attachedForKind = attached[kind];
-		const columnForKind = columnCollected[kind];
-		for (const [name, entity] of Object.entries(columnForKind ?? {})) {
-			const existing = attachedForKind?.[name];
-			if (existing !== void 0 && existing !== entity) throw contractError("CONTRACT.NAME_DUPLICATE", `buildSqlContractFromDefinition: two different "${kind}" entities named "${name}" in namespace "${namespaceId}" — a column-referenced entity conflicts with an attached one; pack-entity names must be unique per namespace.`, { meta: {
-				kind,
-				name,
-				namespaceId
-			} });
-		}
-		result[kind] = {
-			...attachedForKind,
-			...columnForKind
-		};
+function assertKnownTargetModel(modelsByName, modelsByCoordinate, owner, targetModelName, targetNamespaceId, context) {
+	const targetModel = targetNamespaceId !== void 0 && targetNamespaceId.length > 0 ? modelsByCoordinate.get(`${targetNamespaceId}:${targetModelName}`) : modelsByName.get(targetModelName);
+	if (!targetModel) {
+		const qualified = targetNamespaceId !== void 0 && targetNamespaceId.length > 0 ? `${targetNamespaceId}.${targetModelName}` : targetModelName;
+		throw contractError("CONTRACT.MODEL_UNKNOWN", `${context} on ${referenceOwnerSubject(owner)} references unknown model "${qualified}"`, { meta: {
+			...referenceOwnerMeta(owner),
+			targetModel: qualified,
+			context
+		} });
 	}
-	return result;
+	return targetModel;
+}
+function assertTargetTableMatches(owner, targetModel, referencedTableName, context) {
+	if (targetModel.tableName !== referencedTableName) throw contractError("CONTRACT.TABLE_MISMATCH", `${context} on ${referenceOwnerSubject(owner)} references table "${referencedTableName}" but model "${targetModel.modelName}" maps to "${targetModel.tableName}"`, { meta: {
+		...referenceOwnerMeta(owner),
+		referencedTable: referencedTableName,
+		mappedTable: targetModel.tableName,
+		context
+	} });
 }
-function resolveModelNamespaceId(model, modelNameToNamespaceId, defaultNamespaceId) {
-	if (model.namespaceId !== void 0 && model.namespaceId.length > 0) return model.namespaceId;
-	return modelNameToNamespaceId.get(model.modelName) ?? defaultNamespaceId;
+function modelNamespaceId(model, defaultNamespaceId) {
+	return namespaceIdOrDefault(model.namespaceId, defaultNamespaceId);
+}
+function modelLookupsOf(definition) {
+	const defaultNamespaceId = definition.target.defaultNamespaceId;
+	const { models } = definition;
+	return {
+		defaultNamespaceId,
+		modelsByName: new Map(models.map((m) => [m.modelName, m])),
+		modelsByCoordinate: new Map(models.map((m) => [`${modelNamespaceId(m, defaultNamespaceId)}:${m.modelName}`, m])),
+		tableNamespaceByName: new Map(models.map((m) => [m.tableName, modelNamespaceId(m, defaultNamespaceId)]))
+	};
+}
+function toOneNullabilityContradictionMessage(location, contradiction) {
+	return contradiction === "declared-optional" ? `${location} is optional but every local field it joins on is required` : `${location} is required but a local field it joins on is nullable`;
 }
 function toOneRelationNullable(semanticModel, relation) {
 	const location = `Relation "${semanticModel.modelName}.${relation.fieldName}"`;
@@ -500,104 +400,404 @@ function targetColumnsForJunction(targetModel, fieldName) {
 		reason: "no-key-for-junction-target-columns"
 	} });
 }
-function validateColumnTypeParams(dataType, typeParams, site) {
-	try {
-		validateSqlTypeParams(dataType, dataTypeParams(dataType, typeParams));
-	} catch (cause) {
-		if (!isStructuredError(cause) || cause.code !== "CONTRACT.TYPE_PARAMS_INVALID") throw cause;
-		throw contractError("CONTRACT.TYPE_PARAMS_INVALID", `Field "${site.modelName}.${site.fieldName}" has type parameters that its data type does not accept: ${cause.message}`, {
-			cause,
-			meta: {
-				...cause.meta,
-				modelName: site.modelName,
-				fieldName: site.fieldName
-			}
-		});
+/** Lowers a model's relations. `columnToField` maps the model's columns to the fields that hold them. */
+function lowerRelations(semanticModel, columnToField, lookups) {
+	const { defaultNamespaceId } = lookups;
+	const modelRelations = {};
+	for (const relation of semanticModel.relations ?? []) {
+		if (relation.spaceId !== void 0) {
+			const targetNamespaceId = relation.namespaceId ?? defaultNamespaceId;
+			modelRelations[relation.fieldName] = {
+				to: crossRef(relation.toModel, targetNamespaceId, relation.spaceId),
+				cardinality: "N:1",
+				nullable: toOneRelationNullable(semanticModel, relation),
+				on: {
+					localFields: relation.on.parentColumns.map((col) => columnToField.get(col) ?? col),
+					targetFields: relation.on.childColumns
+				}
+			};
+			continue;
+		}
+		const owner = {
+			kind: "model",
+			modelName: semanticModel.modelName
+		};
+		const targetModel = assertKnownTargetModel(lookups.modelsByName, lookups.modelsByCoordinate, owner, relation.toModel, relation.toNamespaceId, "Relation");
+		invariant(relation.toTable !== void 0, `Relation "${semanticModel.modelName}.${relation.fieldName}" is local but carries no target table; only cross-space relations may leave it unset.`);
+		assertTargetTableMatches(owner, targetModel, relation.toTable, "Relation");
+		const targetColumnToField = new Map(targetModel.fields.map((f) => [f.columnName, f.fieldName]));
+		const to = crossRef(relation.toModel, relation.toNamespaceId !== void 0 && relation.toNamespaceId.length > 0 ? relation.toNamespaceId : modelNamespaceId(targetModel, defaultNamespaceId));
+		const on = {
+			localFields: relation.on.parentColumns.map((col) => columnToField.get(col) ?? col),
+			targetFields: relation.on.childColumns.map((col) => targetColumnToField.get(col) ?? col)
+		};
+		if (relation.cardinality === "N:M") {
+			if (!relation.through) throw contractError("CONTRACT.RELATION_INVALID", `Relation "${semanticModel.modelName}.${relation.fieldName}" with cardinality "N:M" requires through metadata`, { meta: {
+				modelName: semanticModel.modelName,
+				relationName: relation.fieldName,
+				reason: "many-to-many-missing-through"
+			} });
+			modelRelations[relation.fieldName] = {
+				to,
+				cardinality: "N:M",
+				on,
+				through: buildThroughDescriptor(relation.through, lookups.tableNamespaceByName, targetModel, semanticModel.modelName, relation.fieldName, defaultNamespaceId)
+			};
+		} else if (relation.cardinality === "1:N") modelRelations[relation.fieldName] = {
+			to,
+			cardinality: "1:N",
+			on
+		};
+		else modelRelations[relation.fieldName] = {
+			to,
+			cardinality: relation.cardinality,
+			nullable: toOneRelationNullable(semanticModel, relation),
+			on
+		};
 	}
+	return modelRelations;
 }
-function buildStorageColumn(field, enumRefs, modelName, storageTypes, lookups) {
-	const { codecLookup } = lookups;
-	const { descriptor } = field;
-	const codecId = descriptor.codecId;
-	const isListColumn = storedAsListColumn({
-		list: field.many === true,
-		typedByValueObject: isValueObjectMember(field)
-	});
-	const noCheck = isValueObjectMember(field) ? void 0 : field.noCheck;
-	const typeParams = resolvedTypeParams(descriptor, storageTypes);
-	const dataType = sqlDataTypeOfCodec(codecId, lookups);
-	validateColumnTypeParams(dataType, typeParams, {
-		modelName,
-		fieldName: field.fieldName
-	});
-	const encodedDefault = field.default !== void 0 ? encodeColumnDefault(field.default, codecLookup, (lookup) => columnCodec(codecId, typeParams, lookup), {
-		modelName,
-		fieldName: field.fieldName,
-		codecId
-	}, isListColumn, field.elementNullable === true) : void 0;
-	invariant(enumRefs === void 0 || descriptor.valueSet === void 0, `Field "${modelName}.${field.fieldName}" is typed by a domain enum and also carries a storage value set from its type constructor.`);
-	const valueSet = enumRefs?.storage ?? descriptor.valueSet;
+/** The key of a table among all tables of a contract: its namespace and its name. */
+function tableKey(namespaceId, tableName) {
+	return JSON.stringify([namespaceId, tableName]);
+}
+/** Resolves a foreign key's target. A cross-space key keeps its foreign space; a local key names either a model of this definition and that model's table, or a table a model or table node declares. */
+function resolveForeignKey(fk, sourceTable, context) {
+	const source = {
+		namespaceId: asNamespaceId(sourceTable.namespaceId),
+		tableName: sourceTable.tableName,
+		columns: fk.columns
+	};
+	const options = {
+		...applyFkDefaults({
+			...ifDefined("constraint", fk.constraint),
+			...ifDefined("index", fk.index)
+		}, context.foreignKeyDefaults),
+		...ifDefined("name", fk.name),
+		...ifDefined("onDelete", fk.onDelete),
+		...ifDefined("onUpdate", fk.onUpdate)
+	};
+	if (fk.references.spaceId !== void 0) return {
+		source,
+		target: {
+			namespaceId: asNamespaceId(fk.references.namespaceId ?? context.defaultNamespaceId),
+			tableName: fk.references.table,
+			columns: fk.references.columns,
+			spaceId: fk.references.spaceId
+		},
+		...options
+	};
+	const { references } = fk;
+	if (references.model === void 0) {
+		const namespaceId = namespaceIdOrDefault(references.namespaceId, context.defaultNamespaceId);
+		if (!context.declaredTables.has(tableKey(namespaceId, references.table))) throw contractError("CONTRACT.TABLE_UNKNOWN", `Foreign key on ${referenceOwnerSubject(sourceTable.owner)} references table "${references.table}" in namespace "${namespaceId}", which no model or table node declares. Declare the table with a model or a table node, or correct the name.`, { meta: {
+			...referenceOwnerMeta(sourceTable.owner),
+			referencedTable: references.table,
+			namespaceId
+		} });
+		return {
+			source,
+			target: {
+				namespaceId: asNamespaceId(namespaceId),
+				tableName: references.table,
+				columns: references.columns
+			},
+			...options
+		};
+	}
+	const targetModel = assertKnownTargetModel(context.modelsByName, context.modelsByCoordinate, sourceTable.owner, references.model, fk.references.namespaceId, "Foreign key");
+	assertTargetTableMatches(sourceTable.owner, targetModel, fk.references.table, "Foreign key");
 	return {
-		dataType: dataType.id,
-		codecId,
-		nullable: field.nullable,
-		many: isListColumn ? { elementNullable: field.elementNullable === true } : false,
-		...ifDefined("noCheck", noCheck && [...noCheck].sort()),
-		...ifDefined("typeParams", descriptor.typeParams),
-		...ifDefined("default", encodedDefault),
-		...ifDefined("typeRef", descriptor.typeRef),
-		...ifDefined("valueSet", valueSet)
+		source,
+		target: {
+			namespaceId: asNamespaceId(namespaceIdOrDefault(fk.references.namespaceId, modelNamespaceId(targetModel, context.defaultNamespaceId))),
+			tableName: fk.references.table,
+			columns: fk.references.columns
+		},
+		...options
 	};
 }
 /**
-* The refs of a field typed by an authored enum: the domain enum and its storage value set. Authored enums are registered in the default namespace, whatever namespace the field's model is in.
+* Resolves a deferred entity-ref column descriptor (e.g. a `pg.enum(handle)`
+* column) against the field's now-known owning namespace: attaches the
+* storage `valueSet` ref the collected entity's derived value-set is stored
+* under. `typeParams.typeName` stays bare here — schema
+* qualification (e.g. `auth.aal_level`) is a target concern applied in the
+* next step, `qualifyColumnDescriptor`. A descriptor with no `entityRef` (the
+* ordinary case) passes through unchanged.
 */
-function enumValueSetRefs(enumHandle, defaultNamespaceId) {
-	if (enumHandle === void 0) return void 0;
-	const common = {
-		namespaceId: defaultNamespaceId,
-		entityName: enumHandle.enumName
-	};
+function resolveEntityRefDescriptor(descriptor, namespaceId) {
+	const entityRef = descriptor.entityRef;
+	if (entityRef === void 0) return descriptor;
 	return {
-		domain: {
-			plane: "domain",
-			entityKind: "enum",
-			...common
-		},
-		storage: {
+		...descriptor,
+		valueSet: {
 			plane: "storage",
 			entityKind: "valueSet",
-			...common
+			namespaceId,
+			entityName: entityRef.entityName
 		}
 	};
 }
-function buildDomainField(field, defaultNamespaceId, storageTypes) {
-	if (isValueObjectMember(field)) return {
-		type: {
-			kind: "valueObject",
-			name: field.valueObjectName
-		},
-		nullable: field.nullable,
-		many: field.many ? { elementNullable: field.elementNullable === true } : false
+/**
+* Structural check for a target that contributes a `qualifyColumnType` hook
+* on its authoring contributions. Duck-typed (mirroring
+* `contract-psl`'s `hasColumnFromEntityHook`) so the SQL family stays blind
+* to the target's qualification logic and no framework/family interface has
+* to name the hook.
+*/
+function hasColumnTypeQualifier(authoring) {
+	return "qualifyColumnType" in authoring && typeof authoring.qualifyColumnType === "function";
+}
+/**
+* Structural check for a target that contributes a `renderCheckExpressions`
+* hook, duck-typed for the same reason {@link hasColumnTypeQualifier} is: the
+* SQL family stays blind to the target's predicate syntax.
+*/
+function hasCheckExpressionRenderer(authoring) {
+	return "renderCheckExpressions" in authoring && typeof authoring.renderCheckExpressions === "function";
+}
+function resolveCheckExpressionRenderer(target) {
+	const authoring = target.authoring;
+	if (authoring === void 0) return void 0;
+	return hasCheckExpressionRenderer(authoring) ? authoring.renderCheckExpressions : void 0;
+}
+function resolveColumnTypeQualifier(target) {
+	const authoring = target.authoring;
+	if (authoring === void 0) return void 0;
+	return hasColumnTypeQualifier(authoring) ? authoring.qualifyColumnType : void 0;
+}
+/**
+* Applies the target's `qualifyColumnType` hook to a scalar column descriptor.
+* A descriptor whose codec the target leaves unchanged passes through untouched.
+*/
+function qualifyColumnDescriptor(descriptor, namespaceId, qualify) {
+	if (qualify === void 0) return descriptor;
+	const qualified = qualify({
+		codecId: descriptor.codecId,
+		...ifDefined("typeParams", descriptor.typeParams)
+	}, namespaceId);
+	if (qualified.typeParams === descriptor.typeParams) return descriptor;
+	return {
+		...descriptor,
+		...ifDefined("typeParams", qualified.typeParams)
 	};
+}
+/**
+* A column's descriptor as its namespace makes it: a deferred entity ref gets its storage value set, and the target's `qualifyColumnType` hook qualifies the type for the namespace.
+*/
+function resolveColumnDescriptor(descriptor, namespaceId, qualify) {
+	return qualifyColumnDescriptor(resolveEntityRefDescriptor(descriptor, namespaceId), namespaceId, qualify);
+}
+/**
+* Converts one model into the storage it implies and its domain model. Other models are read only to resolve the references this one makes to them.
+*/
+function describeModel(model, context) {
+	const namespaceId = modelNamespaceId(model, context.defaultNamespaceId);
+	const { tableName } = model;
+	const fieldToColumn = {};
+	const domainFields = {};
+	const executionDefaults = [];
+	for (const field of model.fields) {
+		const executionDefault = executionDefaultOf(model.modelName, field);
+		fieldToColumn[field.fieldName] = field.columnName;
+		domainFields[field.fieldName] = buildDomainField(isValueObjectMember(field) ? field : {
+			...field,
+			descriptor: resolveColumnDescriptor(field.descriptor, namespaceId, context.qualifyColumnType)
+		}, context.defaultNamespaceId, context.storageTypes);
+		if (executionDefault) executionDefaults.push({
+			ref: {
+				namespace: namespaceId,
+				entry: tableName,
+				field: field.columnName
+			},
+			...ifDefined("onCreate", executionDefault.onCreate),
+			...ifDefined("onUpdate", executionDefault.onUpdate)
+		});
+	}
+	const storage = describeModelStorage(model, namespaceId, (model.foreignKeys ?? []).map((fk) => resolveForeignKey(fk, {
+		namespaceId,
+		tableName: model.tableName,
+		owner: {
+			kind: "model",
+			modelName: model.modelName
+		}
+	}, context)));
+	const storageFields = {};
+	for (const [fieldName, columnName] of Object.entries(fieldToColumn)) storageFields[fieldName] = { column: columnName };
+	const columnToField = new Map(Object.entries(fieldToColumn).map(([field, col]) => [col, field]));
 	return {
-		type: {
-			kind: "scalar",
-			codecId: field.descriptor.codecId,
-			...ifDefined("typeParams", resolvedTypeParams(field.descriptor, storageTypes))
-		},
+		storage,
+		domain: {
+			namespaceId,
+			modelName: model.modelName,
+			model: {
+				storage: {
+					table: tableName,
+					namespaceId,
+					fields: storageFields
+				},
+				fields: domainFields,
+				relations: lowerRelations(model, columnToField, context)
+			},
+			executionDefaults
+		}
+	};
+}
+/**
+* Single-table-inheritance variants share their base model's table: the variant's columns must already be on that table, and it has no table of its own. That leaves an authored check nowhere to attach, so it is refused here as a backstop; the PSL surface refuses it earlier, at interpretation, with a diagnostic that names the base model.
+*/
+function describeModelStorage(model, namespaceId, foreignKeys) {
+	const { tableName } = model;
+	const columns = model.fields.map((field) => describeFieldColumn(model.modelName, field));
+	if (model.sharesBaseTable) {
+		if (model.checks && model.checks.length > 0) throw contractError("CONTRACT.CHECK_ON_STI_VARIANT", `Model "${model.modelName}" declares a check constraint but shares its base model's storage table (single-table inheritance) and has no table of its own to declare it on. Declare the check on the base model instead.`, { meta: {
+			tableName,
+			modelName: model.modelName
+		} });
+		return {
+			kind: "baseTable",
+			modelName: model.modelName,
+			namespaceId,
+			tableName,
+			columns
+		};
+	}
+	return {
+		kind: "ownTable",
+		modelName: model.modelName,
+		table: {
+			namespaceId,
+			tableName,
+			columns,
+			control: model.control,
+			id: model.id,
+			uniques: model.uniques ?? [],
+			indexes: model.indexes ?? [],
+			checks: model.checks ?? [],
+			foreignKeys
+		}
+	};
+}
+function describeFieldColumn(modelName, field) {
+	const site = {
+		kind: "field",
+		modelName,
+		fieldName: field.fieldName
+	};
+	if (isValueObjectMember(field)) return describeColumn({
+		columnName: field.columnName,
+		descriptor: field.descriptor,
 		nullable: field.nullable,
-		many: field.many ? { elementNullable: field.elementNullable === true } : false,
-		...ifDefined("valueSet", enumValueSetRefs(field.enumTypeHandle, defaultNamespaceId)?.domain)
+		...ifDefined("default", field.default)
+	}, site);
+	return describeColumn(field, site);
+}
+/** The phases a generated default fills the field on, refused alongside a default or on an optional field. */
+function executionDefaultOf(modelName, field) {
+	const phases = field.executionDefaults?.onCreate || field.executionDefaults?.onUpdate ? field.executionDefaults : void 0;
+	if (phases === void 0) return void 0;
+	if (field.default !== void 0) throw contractError("CONTRACT.DEFAULT_INVALID", `Field "${modelName}.${field.fieldName}" cannot define both default and executionDefaults.`, { meta: {
+		modelName,
+		fieldName: field.fieldName,
+		reason: "default-and-executionDefaults"
+	} });
+	if (field.nullable) throw contractError("CONTRACT.DEFAULT_INVALID", `Field "${modelName}.${field.fieldName}" is filled on write by a generated default (a preset such as temporal.createdAt() or an id generator), so it cannot be optional; remove .optional().`, { meta: {
+		modelName,
+		fieldName: field.fieldName,
+		reason: "nullable-with-executionDefaults"
+	} });
+	return phases;
+}
+/** Describes a table node: its columns, and its foreign keys resolved against the definition's models and tables. */
+function describeTableNode(table, context) {
+	const namespaceId = namespaceIdOrDefault(table.namespaceId, context.defaultNamespaceId);
+	const { tableName } = table;
+	const owner = {
+		kind: "tableNode",
+		namespaceId,
+		tableName
+	};
+	return {
+		namespaceId,
+		tableName,
+		columns: table.columns.map((column) => describeColumn(column, {
+			kind: "tableNode",
+			namespaceId,
+			tableName,
+			columnName: column.columnName
+		})),
+		id: table.id,
+		uniques: table.uniques ?? [],
+		indexes: table.indexes ?? [],
+		checks: table.checks ?? [],
+		foreignKeys: (table.foreignKeys ?? []).map((fk) => resolveForeignKey(fk, {
+			namespaceId,
+			tableName,
+			owner
+		}, context)),
+		control: table.control
 	};
 }
-function collectStorageNamespaceCoordinateIds(definition) {
-	const ids = /* @__PURE__ */ new Set();
-	ids.add(definition.target.defaultNamespaceId);
-	for (const id of definition.namespaces ?? []) if (id.length > 0) ids.add(id);
-	for (const model of definition.models) if (model.namespaceId !== void 0 && model.namespaceId.length > 0) ids.add(model.namespaceId);
-	for (const id of Object.keys(definition.attachedEntities ?? {})) if (id.length > 0) ids.add(id);
-	return ids;
+/**
+* Records a deferred column's entity-ref into the namespace-scoped collection
+* accumulator (`namespaceId → entityKind → entityName`) — folded into the same
+* namespace assembly `deriveEntityValueSets`/`entries.<kind>` step as the
+* entities-channel attachments, so a column-collected entity gets its
+* value-set the same way an entities-channel one does.
+*
+* The same handle reused by many columns in one namespace is normal (a native
+* enum type backs any number of columns) and records the identical entity once.
+* Two *different* entity instances sharing a name+kind in one namespace is a
+* name collision — the emitted `entries.valueSet.<name>` could only reflect one
+* of them, silently mismatching the other column's type/cast. PSL hard-errors
+* on the equivalent (`PSL_DUPLICATE_DECLARATION`); the TS path rejects it too.
+*/
+function collectEntityFromColumn(collected, namespaceId, entityRef) {
+	const forNs = collected[namespaceId] ?? {};
+	const forKind = forNs[entityRef.entityKind] ?? {};
+	const existing = forKind[entityRef.entityName];
+	if (existing !== void 0 && existing !== entityRef.entity) throw contractError("CONTRACT.NAME_DUPLICATE", `buildSqlContractFromDefinition: two different "${entityRef.entityKind}" entities named "${entityRef.entityName}" in namespace "${namespaceId}" — pack-entity names must be unique per namespace.`, { meta: {
+		kind: entityRef.entityKind,
+		name: entityRef.entityName,
+		namespaceId
+	} });
+	forKind[entityRef.entityName] = entityRef.entity;
+	forNs[entityRef.entityKind] = forKind;
+	collected[namespaceId] = forNs;
+}
+/**
+* Merges a namespace's entities-channel attachments (lowered from the
+* `entities` handle list, carried on `ContractDefinition.attachedEntities`)
+* with the entities collected from that namespace's deferred entity-ref
+* columns. A column-collected entity that shadows a *different* attached
+* entity of the same kind+name (or vice-versa) is the same name-collision bug
+* `collectEntityFromColumn` guards against across columns, so it is rejected
+* the same way — by entity identity, so the same handle attached and used by
+* a column does not throw.
+*/
+function mergeColumnAndAttachedEntities(namespaceId, attached, columnCollected) {
+	if (attached === void 0) return columnCollected;
+	if (columnCollected === void 0) return attached;
+	const kinds = /* @__PURE__ */ new Set([...Object.keys(attached), ...Object.keys(columnCollected)]);
+	const result = {};
+	for (const kind of kinds) {
+		const attachedForKind = attached[kind];
+		const columnForKind = columnCollected[kind];
+		for (const [name, entity] of Object.entries(columnForKind ?? {})) {
+			const existing = attachedForKind?.[name];
+			if (existing !== void 0 && existing !== entity) throw contractError("CONTRACT.NAME_DUPLICATE", `buildSqlContractFromDefinition: two different "${kind}" entities named "${name}" in namespace "${namespaceId}" — a column-referenced entity conflicts with an attached one; pack-entity names must be unique per namespace.`, { meta: {
+				kind,
+				name,
+				namespaceId
+			} });
+		}
+		result[kind] = {
+			...attachedForKind,
+			...columnForKind
+		};
+	}
+	return result;
 }
 /**
 * Entry kinds the framework assembler itself manages (`table` from models,
@@ -681,15 +881,136 @@ function mergeNamespaceValueSets(namespaceId, enumValueSets, packValueSets) {
 		...packValueSets
 	};
 }
-function ensureUnboundNamespaceSlot(namespaces, createNamespace) {
-	if (Object.hasOwn(namespaces, UNBOUND_NAMESPACE_ID)) return namespaces;
-	const unbound = createNamespace({
-		id: UNBOUND_NAMESPACE_ID,
-		entries: { table: {} }
-	});
+/**
+* Resolves a field's authored `noCheck` kinds against its column shape:
+* the bare form (`[]`) becomes every kind the shape derives, and a named
+* kind that can never apply to the shape is an authoring error
+* (`CONTRACT.CHECK_OPTOUT_INVALID`). Returns the concrete kinds in
+* canonical ascending order — the only form the contract persists.
+*/
+function resolveNoCheckKinds(input) {
+	const derivable = [];
+	if (input.many && !input.elementNullable) derivable.push("elementNotNull");
+	if (input.isDomainEnum) derivable.push("membership");
+	const subject = columnSiteSubject(input.site);
+	const meta = columnSiteMeta(input.site);
+	if (input.kinds.length === 0) {
+		if (derivable.length === 0) throw contractError("CONTRACT.CHECK_OPTOUT_INVALID", `${subject}: noCheck() waives nothing — this column's shape derives no generated checks.`, { meta: {
+			...meta,
+			reason: "no-derivable-checks"
+		} });
+		return derivable;
+	}
+	const seen = /* @__PURE__ */ new Set();
+	for (const kind of input.kinds) {
+		if (seen.has(kind)) throw contractError("CONTRACT.CHECK_OPTOUT_INVALID", `${subject}: noCheck("${kind}") names the same kind twice.`, { meta: {
+			...meta,
+			kind,
+			reason: "duplicate-kind"
+		} });
+		seen.add(kind);
+		if (!derivable.includes(kind)) throw contractError("CONTRACT.CHECK_OPTOUT_INVALID", `${subject}: noCheck("${kind}") does not apply — ${kind === "membership" ? "membership checks are derived only from enumType() value sets" : "element-non-null checks are derived only for lists whose elements are semantically non-null"}.`, { meta: {
+			...meta,
+			kind,
+			reason: "inapplicable-kind"
+		} });
+	}
+	return [...input.kinds].sort();
+}
+/**
+* Names the target's rendered checks and lowers them into contract entities.
+*
+* Naming is composed family-side ({@link composeCheckWirePrefix}) rather than
+* by the target, and suffixed with the predicate's content hash. Composing
+* family-side is what makes the truncation safe — two prefixes that truncate
+* alike still differ in their hashes, and the family can see that the
+* (table, column, kind) triple they were built from is unique per table,
+* rather than having to assume something about SQL text it declares itself
+* unable to read.
+*/
+function lowerRenderedChecks(tableName, candidates) {
+	return candidates.map((candidate) => new CheckConstraint({
+		naming: {
+			kind: "wire",
+			prefix: composeCheckWirePrefix(tableName, candidate.columnName, candidate.kind),
+			hash: computeCheckContentHash(candidate.expression)
+		},
+		expression: candidate.expression
+	}));
+}
+function validateColumnTypeParams(dataType, typeParams, site) {
+	try {
+		validateSqlTypeParams(dataType, dataTypeParams(dataType, typeParams));
+	} catch (cause) {
+		if (!isStructuredError(cause) || cause.code !== "CONTRACT.TYPE_PARAMS_INVALID") throw cause;
+		throw contractError("CONTRACT.TYPE_PARAMS_INVALID", `${columnSiteSubject(site)} has type parameters that its data type does not accept: ${cause.message}`, {
+			cause,
+			meta: {
+				...cause.meta,
+				...columnSiteMeta(site)
+			}
+		});
+	}
+}
+/**
+* Lowers one column into its storage column and the enforcement checks its shape derives.
+*
+* A column whose type constructor refers to a pack entity (e.g. `pg.enum(handle)`) records that entity, and its descriptor is resolved against the column's namespace and handed to the target's `qualifyColumnType` hook. An opt-out from derived checks on a table that derives none is dropped, never persisted: the policy may also be stamped after the build by a specifier.
+*
+* Member values reach the check renderer only for a column typed by an `enumType()` handle: that column is a plain scalar with no native type of its own to enforce membership. A value set resolved by a type constructor binds the column to a native type that already enforces it.
+*/
+function lowerColumn(description, placement, context) {
+	const { site, many } = description;
+	const { codecLookup } = context.lookups;
+	const entityRef = description.descriptor.entityRef;
+	if (entityRef !== void 0) collectEntityFromColumn(context.collectedColumnEntities, placement.namespaceId, entityRef);
+	const descriptor = resolveColumnDescriptor(description.descriptor, placement.namespaceId, context.qualifyColumnType);
+	const elementNullable = many !== false && many.elementNullable;
+	const noCheck = description.noCheck !== void 0 && placement.derivesChecks ? resolveNoCheckKinds({
+		site,
+		kinds: description.noCheck,
+		many: many !== false,
+		elementNullable,
+		isDomainEnum: description.enumTypeHandle !== void 0
+	}) : void 0;
+	const codecId = descriptor.codecId;
+	const typeParams = resolvedTypeParams(descriptor, context.storageTypes);
+	const dataType = sqlDataTypeOfCodec(codecId, context.lookups);
+	validateColumnTypeParams(dataType, typeParams, site);
+	const encodedDefault = description.default !== void 0 ? encodeColumnDefault(description.default, codecLookup, (lookup) => columnCodec(codecId, typeParams, lookup), {
+		...site,
+		codecId
+	}, many !== false, elementNullable) : void 0;
+	const enumRefs = enumValueSetRefs(description.enumTypeHandle, context.defaultNamespaceId);
+	invariant(enumRefs === void 0 || descriptor.valueSet === void 0, `${columnSiteSubject(site)} is typed by a domain enum and also carries a storage value set from its type constructor.`);
+	const valueSet = enumRefs?.storage ?? descriptor.valueSet;
+	const column = {
+		dataType: dataType.id,
+		codecId,
+		nullable: description.nullable,
+		many,
+		...ifDefined("noCheck", noCheck && [...noCheck].sort()),
+		...ifDefined("typeParams", descriptor.typeParams),
+		...ifDefined("default", encodedDefault),
+		...ifDefined("typeRef", descriptor.typeRef),
+		...ifDefined("valueSet", valueSet)
+	};
+	const render = context.renderCheckExpressions;
+	if (render === void 0 || !placement.derivesChecks) return {
+		column,
+		derivedChecks: []
+	};
+	const { enumTypeHandle } = description;
+	const candidates = render({
+		tableName: placement.tableName,
+		columnName: description.columnName,
+		many: many !== false,
+		elementNullable,
+		memberValues: enumTypeHandle !== void 0 ? checkMemberValues(enumTypeHandle, codecLookup) : void 0
+	}).filter((candidate) => !(noCheck?.includes(candidate.kind) ?? false));
 	return {
-		[UNBOUND_NAMESPACE_ID]: unbound,
-		...namespaces
+		column,
+		derivedChecks: lowerRenderedChecks(placement.tableName, candidates)
 	};
 }
 const DERIVABLE_CHECK_KINDS = ["membership", "elementNotNull"];
@@ -703,6 +1024,249 @@ const DERIVABLE_CHECK_KINDS = ["membership", "elementNotNull"];
 function columnsProducingCheckPrefix(tableName, columnNames, prefix) {
 	return columnNames.filter((columnName) => DERIVABLE_CHECK_KINDS.some((kind) => composeCheckWirePrefix(tableName, columnName, kind) === prefix));
 }
+/**
+* Lowers one table: each of its columns, then its indexes, checks, primary key, uniques and foreign keys, with the backing indexes its foreign keys need.
+*
+* Checks are derived only for tables Prisma 8 owns: the contract describes an external schema, it does not prescribe enforcement for it. This reads the policy the source declares; a policy applied by a contract specifier lands after the build and is handled by `stripDerivedChecksFromNonManagedTables`. Authored checks are kept whatever the policy: they are the author's statement about a constraint they know exists.
+*/
+function lowerTable(table, context) {
+	const { tableName } = table;
+	const derivesChecks = effectiveControlPolicy(table.control, context.defaultControlPolicy) === "managed";
+	const placement = {
+		namespaceId: table.namespaceId,
+		tableName,
+		derivesChecks
+	};
+	const columns = {};
+	const checks = [];
+	for (const description of table.columns) {
+		const lowered = lowerColumn(description, placement, context);
+		columns[description.columnName] = lowered.column;
+		checks.push(...lowered.derivedChecks);
+	}
+	const uniques = table.uniques.map((u) => ({
+		columns: u.columns,
+		...ifDefined("name", u.name)
+	}));
+	const declaredIndexes = table.indexes.map((index) => ({
+		namedByUser: index.name !== void 0 || index.map !== void 0,
+		index: lowerAuthoredIndex(tableName, authoredIndexInput(index), context.warnings, context.indexTypeRegistry)
+	}));
+	checks.push(...lowerAuthoredChecks(tableName, Object.keys(columns), table.checks, context));
+	const primaryKey = table.id ? {
+		columns: table.id.columns,
+		...ifDefined("name", table.id.name)
+	} : void 0;
+	const { foreignKeys, indexes } = materializeForeignKeysAndIndexes({
+		tableName,
+		foreignKeys: table.foreignKeys,
+		declaredIndexes,
+		uniques,
+		primaryKey,
+		warnings: context.warnings,
+		indexTypes: context.indexTypeRegistry
+	});
+	return {
+		columns,
+		...ifDefined("control", table.control),
+		uniques,
+		indexes: indexes.map((i) => new Index(i)),
+		foreignKeys,
+		...primaryKey ? { primaryKey } : {},
+		...checks.length > 0 ? { checks: inCanonicalOrder(checks) } : {}
+	};
+}
+/**
+* The checks sorted by name in UTF-16 code-unit order, the order contract canonicalization gives them. The table's storage is then the same whichever declaration each column came from and in whatever order the columns were listed.
+*/
+function inCanonicalOrder(checks) {
+	return [...checks].sort((a, b) => compareCodeUnits(a.name, b.name));
+}
+function authoredIndexInput(index) {
+	return blindCast({
+		...ifDefined("columns", index.columns),
+		...ifDefined("expression", index.expression),
+		where: index.where,
+		unique: index.unique,
+		map: index.map,
+		name: index.name,
+		type: index.type,
+		options: index.options
+	});
+}
+/** Names the authored checks, and refuses one whose name could be taken for a derived check of a column of this table. */
+function lowerAuthoredChecks(tableName, tableColumnNames, authoredChecks, context) {
+	if (authoredChecks.length === 0) return [];
+	const reservedCheckPrefixes = derivedCheckPrefixes(tableName, tableColumnNames);
+	return authoredChecks.map((authoredCheck) => {
+		const lowered = lowerAuthoredCheck(tableName, authoredCheck, context.warnings);
+		if (lowered.naming.kind === "wire" && reservedCheckPrefixes.has(lowered.naming.prefix)) {
+			const collidingColumns = columnsProducingCheckPrefix(tableName, tableColumnNames, lowered.naming.prefix);
+			const columnList = collidingColumns.map((name) => `"${name}"`).join(", ");
+			throw contractError("CONTRACT.CHECK_NAME_RESERVED", `Check "${lowered.naming.prefix}" on table "${tableName}": this name's prefix matches the shape a derived enforcement check would use for column${collidingColumns.length === 1 ? "" : "s"} ${columnList} of this table, so it can't be told apart from one. Choose a different name.`, { meta: {
+				tableName,
+				prefix: lowered.naming.prefix,
+				collidingColumns
+			} });
+		}
+		return new CheckConstraint(lowered);
+	});
+}
+/** How a refusal names each table-level property. Typed by every key of {@link TableProperties}, so a new property cannot be left out of the check. */
+const tablePropertyLabels = {
+	id: "a primary key",
+	uniques: "unique constraints",
+	indexes: "indexes",
+	checks: "check constraints",
+	foreignKeys: "foreign keys",
+	control: "a control policy"
+};
+function isTableProperty(key) {
+	return Object.hasOwn(tablePropertyLabels, key);
+}
+/**
+* Collects the tables the models and table nodes describe, one per namespace and table name: the models' tables in model order, then the tables only table nodes declare.
+*
+* A table node for a table a model maps adds its columns to that table and nothing else, because the model owns the table's table-level properties. A table node for any other table is the whole table. A single-table variant adds nothing: each of its columns must already be on its base's table, which the base owns, and no table node may declare a column a variant's field maps. A variant whose table no model owns is not checked.
+*
+* Every table comes out with its foreign keys from exactly one declaration, a model or a table node, in the order that declaration lists them.
+*/
+function mergeTables(storages, tableNodes) {
+	const tables = /* @__PURE__ */ new Map();
+	const modelOfTable = /* @__PURE__ */ new Map();
+	for (const storage of storages) {
+		if (storage.kind !== "ownTable") continue;
+		const { table } = storage;
+		const key = tableKey(table.namespaceId, table.tableName);
+		if (tables.has(key)) throw contractError("CONTRACT.NAME_DUPLICATE", `buildSqlContractFromDefinition: duplicate table "${table.tableName}" in namespace "${table.namespaceId}".`, { meta: {
+			kind: "table",
+			name: table.tableName,
+			namespaceId: table.namespaceId
+		} });
+		tables.set(key, table);
+		modelOfTable.set(key, storage.modelName);
+	}
+	const variants = storages.filter((storage) => storage.kind === "baseTable");
+	const variantColumnSites = variantColumnSitesByTable(variants);
+	const tableNodeKeys = /* @__PURE__ */ new Set();
+	for (const tableNode of tableNodes) {
+		const key = tableKey(tableNode.namespaceId, tableNode.tableName);
+		if (tableNodeKeys.has(key)) throw contractError("CONTRACT.NAME_DUPLICATE", `Table "${tableNode.tableName}" in namespace "${tableNode.namespaceId}" is declared by two table nodes.`, { meta: {
+			kind: "table",
+			name: tableNode.tableName,
+			namespaceId: tableNode.namespaceId
+		} });
+		tableNodeKeys.add(key);
+		const columnSites = variantColumnSites.get(key) ?? /* @__PURE__ */ new Map();
+		const modelName = modelOfTable.get(key);
+		const modelled = tables.get(key);
+		if (modelName === void 0 || modelled === void 0) {
+			tables.set(key, {
+				...tableNode,
+				columns: withColumns([], tableNode, columnSites)
+			});
+			continue;
+		}
+		assertOnlyColumns(tableNode, modelName);
+		tables.set(key, {
+			...modelled,
+			columns: withColumns(modelled.columns, tableNode, columnSites)
+		});
+	}
+	for (const variant of variants) {
+		const table = tables.get(tableKey(variant.namespaceId, variant.tableName));
+		if (table !== void 0) assertVariantColumnsOnBaseTable(variant, table);
+	}
+	return [...tables.values()];
+}
+/** For each table, the variant field that maps each variant column; the first variant to map a column names it. */
+function variantColumnSitesByTable(variants) {
+	const sites = /* @__PURE__ */ new Map();
+	for (const variant of variants) {
+		const key = tableKey(variant.namespaceId, variant.tableName);
+		const byColumn = sites.get(key) ?? /* @__PURE__ */ new Map();
+		for (const column of variant.columns) if (!byColumn.has(column.columnName)) byColumn.set(column.columnName, column.site);
+		sites.set(key, byColumn);
+	}
+	return sites;
+}
+/**
+* The table's columns with the table node's columns added. A column some field already declares is refused, and the error names the field the author wrote: a single-table variant's field when a variant maps the column, even though the base table carries a copy of it.
+*/
+function withColumns(columns, tableNode, variantColumnSites) {
+	const sites = new Map(columns.map((column) => [column.columnName, column.site]));
+	for (const column of tableNode.columns) {
+		const earlier = variantColumnSites.get(column.columnName) ?? sites.get(column.columnName);
+		if (earlier !== void 0) {
+			const problem = earlier.kind === "field" ? `is declared by field "${earlier.modelName}.${earlier.fieldName}" and again by a table node` : "is listed twice by its table node";
+			throw contractError("CONTRACT.NAME_DUPLICATE", `Column "${column.columnName}" of table "${tableNode.tableName}" ${problem}.`, { meta: {
+				kind: "column",
+				name: column.columnName,
+				tableName: tableNode.tableName,
+				namespaceId: tableNode.namespaceId
+			} });
+		}
+		sites.set(column.columnName, column.site);
+	}
+	return [...columns, ...tableNode.columns];
+}
+function isStated(value) {
+	return Array.isArray(value) ? value.length > 0 : value !== void 0;
+}
+function assertOnlyColumns(tableNode, modelName) {
+	const property = Object.keys(tablePropertyLabels).filter(isTableProperty).find((name) => isStated(tableNode[name]));
+	if (property === void 0) return;
+	throw contractError("CONTRACT.TABLE_OWNED_BY_MODEL", `A table node for table "${tableNode.tableName}" states ${tablePropertyLabels[property]}, but model "${modelName}" maps that table and owns its table-level properties. A table node for a modelled table may only add columns.`, { meta: {
+		namespaceId: tableNode.namespaceId,
+		tableName: tableNode.tableName,
+		modelName,
+		property
+	} });
+}
+function assertVariantColumnsOnBaseTable(variant, table) {
+	const present = new Set(table.columns.map((column) => column.columnName));
+	const missing = variant.columns.find((column) => !present.has(column.columnName));
+	if (missing === void 0) return;
+	throw contractError("CONTRACT.VARIANT_COLUMN_NOT_ON_BASE_TABLE", `Model "${variant.modelName}" shares table "${variant.tableName}" with its base model (single-table inheritance), but its column "${missing.columnName}" is not on that table. The base model owns the table; declare the column there.`, { meta: {
+		modelName: variant.modelName,
+		namespaceId: variant.namespaceId,
+		tableName: variant.tableName,
+		columnName: missing.columnName
+	} });
+}
+function assertStorageSemantics(contract, indexTypeRegistry, codecLookup) {
+	const semanticErrors = validateStorageSemantics(contract.storage);
+	if (semanticErrors.length > 0) throw contractError("CONTRACT.VALIDATION_FAILED", `Contract semantic validation failed: ${semanticErrors.join("; ")}`, { meta: { errors: semanticErrors } });
+	validateIndexTypes(contract, indexTypeRegistry, (codecId) => codecLookup.descriptorFor(codecId)?.traits);
+}
+function collectStorageNamespaceCoordinateIds(definition) {
+	const defaultNamespaceId = definition.target.defaultNamespaceId;
+	const declared = [
+		...definition.namespaces ?? [],
+		...definition.models.map((model) => model.namespaceId),
+		...(definition.tables ?? []).map((table) => table.namespaceId),
+		...Object.keys(definition.attachedEntities ?? {})
+	];
+	return /* @__PURE__ */ new Set([defaultNamespaceId, ...declared.map((id) => namespaceIdOrDefault(id, defaultNamespaceId))]);
+}
+function ensureUnboundNamespaceSlot(namespaces, createNamespace) {
+	if (Object.hasOwn(namespaces, UNBOUND_NAMESPACE_ID)) return namespaces;
+	const unbound = createNamespace({
+		id: UNBOUND_NAMESPACE_ID,
+		entries: { table: {} }
+	});
+	return {
+		[UNBOUND_NAMESPACE_ID]: unbound,
+		...namespaces
+	};
+}
+function declaredTableKeys(definition) {
+	const defaultNamespaceId = definition.target.defaultNamespaceId;
+	return /* @__PURE__ */ new Set([...definition.models.map((model) => tableKey(modelNamespaceId(model, defaultNamespaceId), model.tableName)), ...(definition.tables ?? []).map((table) => tableKey(namespaceIdOrDefault(table.namespaceId, defaultNamespaceId), table.tableName))]);
+}
+/**
+* Builds the contract in two stages. First each model is converted on its own into the table it describes and its domain model, and each table node into the table it describes. Then the tables are merged, each is lowered, and the contract is assembled.
+*/
 function buildSqlContractFromDefinition(definition, codecLookup, dataTypeLookup) {
 	const lookups = {
 		codecLookup,
@@ -712,296 +1276,45 @@ function buildSqlContractFromDefinition(definition, codecLookup, dataTypeLookup)
 	const defaultNamespaceId = definition.target.defaultNamespaceId;
 	const indexTypeRegistry = indexTypeRegistryOf(definition.target, Object.values(definition.extensions ?? {}));
 	const qualifyColumnType = resolveColumnTypeQualifier(definition.target);
-	const renderCheckExpressions = resolveCheckExpressionRenderer(definition.target);
+	const storageTypes = definition.storageTypes ?? {};
 	const targetFamily = "sql";
-	const resolveNamespaceId = (m) => m.namespaceId !== void 0 && m.namespaceId.length > 0 ? m.namespaceId : defaultNamespaceId;
-	const modelsByName = new Map(definition.models.map((m) => [m.modelName, m]));
-	const tableNamespaceByName = new Map(definition.models.map((m) => [m.tableName, m.namespaceId !== void 0 && m.namespaceId.length > 0 ? m.namespaceId : defaultNamespaceId]));
-	const modelsByCoordinate = new Map(definition.models.map((m) => [`${resolveNamespaceId(m)}:${m.modelName}`, m]));
-	const tablesByNamespace = {};
+	const modelDescriptionContext = {
+		...modelLookupsOf(definition),
+		declaredTables: declaredTableKeys(definition),
+		foreignKeyDefaults: definition.foreignKeyDefaults,
+		storageTypes,
+		qualifyColumnType
+	};
+	const components = definition.models.map((model) => describeModel(model, modelDescriptionContext));
+	const tableNodes = (definition.tables ?? []).map((table) => describeTableNode(table, modelDescriptionContext));
 	const authoringWarnings = [...definition.warnings ?? []];
-	const modelNameToNamespaceId = /* @__PURE__ */ new Map();
-	const executionDefaults = [];
-	const modelsByNamespace = {};
 	const collectedColumnEntities = {};
-	const rootEntries = [];
-	for (const semanticModel of definition.models) {
-		const tableName = semanticModel.tableName;
-		const namespaceId = semanticModel.namespaceId !== void 0 && semanticModel.namespaceId.length > 0 ? semanticModel.namespaceId : defaultNamespaceId;
-		modelNameToNamespaceId.set(semanticModel.modelName, namespaceId);
-		if (!semanticModel.sharesBaseTable) rootEntries.push({
-			tableName,
-			namespaceId,
-			ref: crossRef(semanticModel.modelName, namespaceId)
-		});
-		const columns = {};
-		const fieldToColumn = {};
-		const domainFields = {};
-		const checksForTable = [];
-		const derivesChecks = effectiveControlPolicy(semanticModel.control, definition.defaultControlPolicy) === "managed";
-		for (const field of semanticModel.fields) {
-			const executionDefaultPhases = field.executionDefaults?.onCreate || field.executionDefaults?.onUpdate ? field.executionDefaults : void 0;
-			if (executionDefaultPhases) {
-				if (field.default !== void 0) throw contractError("CONTRACT.DEFAULT_INVALID", `Field "${semanticModel.modelName}.${field.fieldName}" cannot define both default and executionDefaults.`, { meta: {
-					modelName: semanticModel.modelName,
-					fieldName: field.fieldName,
-					reason: "default-and-executionDefaults"
-				} });
-				if (field.nullable) throw contractError("CONTRACT.DEFAULT_INVALID", `Field "${semanticModel.modelName}.${field.fieldName}" is filled on write by a generated default (a preset such as temporal.createdAt() or an id generator), so it cannot be optional; remove .optional().`, { meta: {
-					modelName: semanticModel.modelName,
-					fieldName: field.fieldName,
-					reason: "nullable-with-executionDefaults"
-				} });
-			}
-			const enumHandle = !isValueObjectMember(field) ? field.enumTypeHandle : void 0;
-			let resolvedField = field;
-			if (!isValueObjectMember(field)) {
-				let descriptor = field.descriptor;
-				const entityRef = descriptor.entityRef;
-				if (entityRef !== void 0) {
-					collectEntityFromColumn(collectedColumnEntities, namespaceId, entityRef);
-					descriptor = resolveEntityRefDescriptor(descriptor, namespaceId);
-				}
-				descriptor = qualifyColumnDescriptor(descriptor, namespaceId, qualifyColumnType);
-				if (descriptor !== field.descriptor) resolvedField = {
-					...field,
-					descriptor
-				};
-			}
-			if (!isValueObjectMember(resolvedField) && resolvedField.noCheck !== void 0) {
-				const { noCheck: authoredNoCheck, ...withoutNoCheck } = resolvedField;
-				resolvedField = derivesChecks ? {
-					...withoutNoCheck,
-					noCheck: resolveNoCheckKinds({
-						modelName: semanticModel.modelName,
-						fieldName: field.fieldName,
-						kinds: authoredNoCheck,
-						many: resolvedField.many === true,
-						elementNullable: resolvedField.elementNullable === true,
-						isDomainEnum: enumHandle !== void 0
-					})
-				} : withoutNoCheck;
-			}
-			const column = buildStorageColumn(resolvedField, enumValueSetRefs(enumHandle, defaultNamespaceId), semanticModel.modelName, definition.storageTypes ?? {}, lookups);
-			const columnMany = column.many ?? false;
-			columns[field.columnName] = column;
-			fieldToColumn[field.fieldName] = field.columnName;
-			if (renderCheckExpressions !== void 0 && derivesChecks) {
-				const waivedKinds = !isValueObjectMember(resolvedField) ? resolvedField.noCheck : void 0;
-				checksForTable.push(...lowerRenderedChecks(tableName, renderCheckExpressions({
-					tableName,
-					columnName: field.columnName,
-					many: columnMany !== false,
-					elementNullable: columnMany !== false && columnMany.elementNullable,
-					memberValues: enumHandle !== void 0 ? checkMemberValues(enumHandle, codecLookup) : void 0
-				}).filter((candidate) => !(waivedKinds?.includes(candidate.kind) ?? false))));
-			}
-			domainFields[field.fieldName] = buildDomainField(resolvedField, defaultNamespaceId, definition.storageTypes ?? {});
-			if (executionDefaultPhases) executionDefaults.push({
-				ref: {
-					namespace: namespaceId,
-					entry: tableName,
-					field: field.columnName
-				},
-				...ifDefined("onCreate", executionDefaultPhases.onCreate),
-				...ifDefined("onUpdate", executionDefaultPhases.onUpdate)
-			});
-		}
-		const authoringForeignKeys = (semanticModel.foreignKeys ?? []).map((fk) => {
-			if (fk.references.spaceId !== void 0) {
-				const targetNamespaceId = fk.references.namespaceId ?? defaultNamespaceId;
-				return {
-					source: {
-						namespaceId: asNamespaceId(namespaceId),
-						tableName,
-						columns: fk.columns
-					},
-					target: {
-						namespaceId: asNamespaceId(targetNamespaceId),
-						tableName: fk.references.table,
-						columns: fk.references.columns,
-						spaceId: fk.references.spaceId
-					},
-					...applyFkDefaults({
-						...ifDefined("constraint", fk.constraint),
-						...ifDefined("index", fk.index)
-					}, definition.foreignKeyDefaults),
-					...ifDefined("name", fk.name),
-					...ifDefined("onDelete", fk.onDelete),
-					...ifDefined("onUpdate", fk.onUpdate)
-				};
-			}
-			const targetModel = assertKnownTargetModel(modelsByName, modelsByCoordinate, semanticModel.modelName, fk.references.model, fk.references.namespaceId, "Foreign key");
-			assertTargetTableMatches(semanticModel.modelName, targetModel, fk.references.table, "Foreign key");
-			const targetNamespaceId = fk.references.namespaceId ?? (targetModel.namespaceId !== void 0 && targetModel.namespaceId.length > 0 ? targetModel.namespaceId : defaultNamespaceId);
-			return {
-				source: {
-					namespaceId: asNamespaceId(namespaceId),
-					tableName,
-					columns: fk.columns
-				},
-				target: {
-					namespaceId: asNamespaceId(targetNamespaceId),
-					tableName: fk.references.table,
-					columns: fk.references.columns
-				},
-				...applyFkDefaults({
-					...ifDefined("constraint", fk.constraint),
-					...ifDefined("index", fk.index)
-				}, definition.foreignKeyDefaults),
-				...ifDefined("name", fk.name),
-				...ifDefined("onDelete", fk.onDelete),
-				...ifDefined("onUpdate", fk.onUpdate)
-			};
-		});
-		if (semanticModel.sharesBaseTable && semanticModel.checks && semanticModel.checks.length > 0) throw contractError("CONTRACT.CHECK_ON_STI_VARIANT", `Model "${semanticModel.modelName}" declares a check constraint but shares its base model's storage table (single-table inheritance) and has no table of its own to declare it on. Declare the check on the base model instead.`, { meta: {
-			tableName,
-			modelName: semanticModel.modelName
-		} });
-		if (!semanticModel.sharesBaseTable) {
-			const uniques = (semanticModel.uniques ?? []).map((u) => ({
-				columns: u.columns,
-				...ifDefined("name", u.name)
-			}));
-			const declaredIndexes = (semanticModel.indexes ?? []).map((i) => ({
-				namedByUser: i.name !== void 0 || i.map !== void 0,
-				index: lowerAuthoredIndex(tableName, blindCast({
-					...ifDefined("columns", i.columns),
-					...ifDefined("expression", i.expression),
-					where: i.where,
-					unique: i.unique,
-					map: i.map,
-					name: i.name,
-					type: i.type,
-					options: i.options
-				}), authoringWarnings, indexTypeRegistry)
-			}));
-			if (semanticModel.checks !== void 0 && semanticModel.checks.length > 0) {
-				const tableColumnNames = Object.keys(columns);
-				const reservedCheckPrefixes = derivedCheckPrefixes(tableName, tableColumnNames);
-				for (const authoredCheck of semanticModel.checks) {
-					const lowered = lowerAuthoredCheck(tableName, authoredCheck, authoringWarnings);
-					if (lowered.naming.kind === "wire" && reservedCheckPrefixes.has(lowered.naming.prefix)) {
-						const collidingColumns = columnsProducingCheckPrefix(tableName, tableColumnNames, lowered.naming.prefix);
-						const columnList = collidingColumns.map((name) => `"${name}"`).join(", ");
-						throw contractError("CONTRACT.CHECK_NAME_RESERVED", `Check "${lowered.naming.prefix}" on table "${tableName}": this name's prefix matches the shape a derived enforcement check would use for column${collidingColumns.length === 1 ? "" : "s"} ${columnList} of this table, so it can't be told apart from one. Choose a different name.`, { meta: {
-							tableName,
-							prefix: lowered.naming.prefix,
-							collidingColumns
-						} });
-					}
-					checksForTable.push(new CheckConstraint(lowered));
-				}
-			}
-			const primaryKey = semanticModel.id ? {
-				columns: semanticModel.id.columns,
-				...ifDefined("name", semanticModel.id.name)
-			} : void 0;
-			const { foreignKeys, indexes } = materializeForeignKeysAndIndexes({
-				tableName,
-				foreignKeys: authoringForeignKeys,
-				declaredIndexes,
-				uniques,
-				primaryKey,
-				warnings: authoringWarnings,
-				indexTypes: indexTypeRegistry
-			});
-			const tableInput = {
-				columns,
-				...ifDefined("control", semanticModel.control),
-				uniques,
-				indexes: indexes.map((i) => new Index(i)),
-				foreignKeys,
-				...primaryKey ? { primaryKey } : {},
-				...checksForTable.length > 0 ? { checks: checksForTable } : {}
-			};
-			let nsTables = tablesByNamespace[namespaceId];
-			if (nsTables === void 0) {
-				nsTables = {};
-				tablesByNamespace[namespaceId] = nsTables;
-			}
-			if (nsTables[tableName] !== void 0) throw contractError("CONTRACT.NAME_DUPLICATE", `buildSqlContractFromDefinition: duplicate table "${tableName}" in namespace "${namespaceId}".`, { meta: {
-				kind: "table",
-				name: tableName,
-				namespaceId
-			} });
-			nsTables[tableName] = tableInput;
-		}
-		const storageFields = {};
-		for (const [fieldName, columnName] of Object.entries(fieldToColumn)) storageFields[fieldName] = { column: columnName };
-		const columnToField = new Map(Object.entries(fieldToColumn).map(([field, col]) => [col, field]));
-		const modelRelations = {};
-		for (const relation of semanticModel.relations ?? []) {
-			if (relation.spaceId !== void 0) {
-				const targetNamespaceId = relation.namespaceId ?? defaultNamespaceId;
-				modelRelations[relation.fieldName] = {
-					to: crossRef(relation.toModel, targetNamespaceId, relation.spaceId),
-					cardinality: "N:1",
-					nullable: toOneRelationNullable(semanticModel, relation),
-					on: {
-						localFields: relation.on.parentColumns.map((col) => columnToField.get(col) ?? col),
-						targetFields: relation.on.childColumns
-					}
-				};
-				continue;
-			}
-			const targetModel = assertKnownTargetModel(modelsByName, modelsByCoordinate, semanticModel.modelName, relation.toModel, relation.toNamespaceId, "Relation");
-			invariant(relation.toTable !== void 0, `Relation "${semanticModel.modelName}.${relation.fieldName}" is local but carries no target table; only cross-space relations may leave it unset.`);
-			assertTargetTableMatches(semanticModel.modelName, targetModel, relation.toTable, "Relation");
-			const targetColumnToField = new Map(targetModel.fields.map((f) => [f.columnName, f.fieldName]));
-			const to = crossRef(relation.toModel, relation.toNamespaceId !== void 0 && relation.toNamespaceId.length > 0 ? relation.toNamespaceId : resolveModelNamespaceId(targetModel, modelNameToNamespaceId, defaultNamespaceId));
-			const on = {
-				localFields: relation.on.parentColumns.map((col) => columnToField.get(col) ?? col),
-				targetFields: relation.on.childColumns.map((col) => targetColumnToField.get(col) ?? col)
-			};
-			if (relation.cardinality === "N:M") {
-				if (!relation.through) throw contractError("CONTRACT.RELATION_INVALID", `Relation "${semanticModel.modelName}.${relation.fieldName}" with cardinality "N:M" requires through metadata`, { meta: {
-					modelName: semanticModel.modelName,
-					relationName: relation.fieldName,
-					reason: "many-to-many-missing-through"
-				} });
-				modelRelations[relation.fieldName] = {
-					to,
-					cardinality: "N:M",
-					on,
-					through: buildThroughDescriptor(relation.through, tableNamespaceByName, targetModel, semanticModel.modelName, relation.fieldName, defaultNamespaceId)
-				};
-			} else if (relation.cardinality === "1:N") modelRelations[relation.fieldName] = {
-				to,
-				cardinality: "1:N",
-				on
-			};
-			else modelRelations[relation.fieldName] = {
-				to,
-				cardinality: relation.cardinality,
-				nullable: toOneRelationNullable(semanticModel, relation),
-				on
-			};
-		}
-		let namespaceModels = modelsByNamespace[namespaceId];
-		if (namespaceModels === void 0) {
-			namespaceModels = {};
-			modelsByNamespace[namespaceId] = namespaceModels;
-		}
-		namespaceModels[semanticModel.modelName] = {
-			storage: {
-				table: tableName,
-				namespaceId,
-				fields: storageFields
-			},
-			fields: domainFields,
-			relations: modelRelations
-		};
+	const tableLoweringContext = {
+		lookups,
+		storageTypes,
+		defaultNamespaceId,
+		qualifyColumnType,
+		renderCheckExpressions: resolveCheckExpressionRenderer(definition.target),
+		collectedColumnEntities,
+		defaultControlPolicy: definition.defaultControlPolicy,
+		indexTypeRegistry,
+		warnings: authoringWarnings
+	};
+	const tablesByNamespace = {};
+	for (const table of mergeTables(components.map((c) => c.storage), tableNodes)) {
+		const namespaceTables = tablesByNamespace[table.namespaceId] ?? {};
+		namespaceTables[table.tableName] = lowerTable(table, tableLoweringContext);
+		tablesByNamespace[table.namespaceId] = namespaceTables;
 	}
-	const rootTableNameCounts = /* @__PURE__ */ new Map();
-	for (const entry of rootEntries) rootTableNameCounts.set(entry.tableName, (rootTableNameCounts.get(entry.tableName) ?? 0) + 1);
-	const roots = {};
-	for (const entry of rootEntries) {
-		const key = (rootTableNameCounts.get(entry.tableName) ?? 0) > 1 ? `${entry.namespaceId}.${entry.tableName}` : entry.tableName;
-		roots[key] = entry.ref;
+	const executionDefaults = components.flatMap((c) => c.domain.executionDefaults);
+	const modelsByNamespace = {};
+	for (const { domain } of components) {
+		const namespaceModels = modelsByNamespace[domain.namespaceId] ?? {};
+		namespaceModels[domain.modelName] = domain.model;
+		modelsByNamespace[domain.namespaceId] = namespaceModels;
 	}
-	const rawStorageTypes = definition.storageTypes ?? {};
-	const documentTypes = Object.fromEntries(Object.entries(rawStorageTypes).map(([name, entry]) => [name, toStorageTypeInstance({
+	const roots = buildRoots(components);
+	const documentTypes = Object.fromEntries(Object.entries(storageTypes).map(([name, entry]) => [name, toStorageTypeInstance({
 		codecId: entry.codecId,
 		dataType: sqlDataTypeOfCodec(entry.codecId, lookups).id,
 		typeParams: entry.typeParams
@@ -1084,7 +1397,7 @@ function buildSqlContractFromDefinition(definition, codecLookup, dataTypeLookup)
 		targetFamily,
 		defaults: executionDefaults
 	});
-	const valueObjects = definition.valueObjects && definition.valueObjects.length > 0 ? Object.fromEntries(definition.valueObjects.map((vo) => [vo.name, { fields: Object.fromEntries(vo.fields.map((f) => [f.fieldName, buildDomainField(f, defaultNamespaceId, definition.storageTypes ?? {})])) }])) : void 0;
+	const valueObjects = definition.valueObjects && definition.valueObjects.length > 0 ? Object.fromEntries(definition.valueObjects.map((vo) => [vo.name, { fields: Object.fromEntries(vo.fields.map((f) => [f.fieldName, buildDomainField(f, defaultNamespaceId, storageTypes)])) }])) : void 0;
 	const domainNamespaceIds = new Set(Object.keys(modelsByNamespace));
 	if (domainNamespaceIds.size === 0) domainNamespaceIds.add(defaultNamespaceId);
 	if (valueObjects !== void 0) domainNamespaceIds.add(defaultNamespaceId);
@@ -1116,6 +1429,24 @@ function buildSqlContractFromDefinition(definition, codecLookup, dataTypeLookup)
 	return contract;
 }
 /**
+* Aggregate roots, one per model that owns a table, keyed by bare storage table name. When two models in different namespaces map to the same bare table name, the bare key would collide, so those entries fall back to a namespace-qualified key. Single-namespace contracts never collide and keep their bare keys.
+*/
+function buildRoots(components) {
+	const rootEntries = components.flatMap(({ storage, domain }) => storage.kind === "ownTable" ? [{
+		tableName: storage.table.tableName,
+		namespaceId: domain.namespaceId,
+		ref: crossRef(domain.modelName, domain.namespaceId)
+	}] : []);
+	const rootTableNameCounts = /* @__PURE__ */ new Map();
+	for (const entry of rootEntries) rootTableNameCounts.set(entry.tableName, (rootTableNameCounts.get(entry.tableName) ?? 0) + 1);
+	const roots = {};
+	for (const entry of rootEntries) {
+		const key = (rootTableNameCounts.get(entry.tableName) ?? 0) > 1 ? `${entry.namespaceId}.${entry.tableName}` : entry.tableName;
+		roots[key] = entry.ref;
+	}
+	return roots;
+}
+/**
 * The one step every SQL contract specifier funnels its loaded contract
 * through: stamp the specifier's default control policy, then strip derived
 * checks from every table the stamped policy leaves non-managed. Composing the
@@ -1250,4 +1581,4 @@ function withoutDerivedChecks(tableName, table, contractDefault) {
 //#endregion
 export { storedAsListColumn as a, isValueObjectMember as i, buildSqlContractFromDefinition as n, toOneNullabilityContradictionMessage as o, contractError as r, applySqlSpecifierControlPolicy as t };
 
-//# sourceMappingURL=derived-checks-CfXjGvNH-CrXoMrPU.mjs.map
+//# sourceMappingURL=derived-checks-RB_lNgFJ-CHamqgFW.mjs.map