@prisma/orm-family-sql 8.0.0-rc.2-dev.3 → 8.0.0-rc.20

package/dist/interpreter-D5qk4B---CG0C7kdx.mjs

@@ -0,0 +1,2280 @@
+import { n as isAuthoredIndexInput } from "./index-naming-BOcJT1B3-mG8Fd6KN.mjs";
+import { u as sqlCodecColumnLength } from "./sql-data-type-D7M-YTTY-D2vRqDxn.mjs";
+import { n as providesPslEntityPlacement } from "./entity-handle-lowering-hook-BJZSlVVF.mjs";
+import "./foreign-key-materialization-BM59w_Xg.mjs";
+import { p as sqlTextFromStored } from "./sql-expression-CKgKznXS.mjs";
+import { t as deriveValueSetFromEntity } from "./value-set-derivation-hook-HVaxhALD.mjs";
+import { n as buildSqlContractFromDefinition } from "./derived-checks-D5HVRvqN-BJx1gwPA.mjs";
+import { i as mapFieldNamesToColumns, n as getAttribute, o as storageName, r as getNamedArgument, t as formatDbAttributeMigrationMessage } from "./psl-attribute-parsing-BCsFWsSp-BJ-wGlY6.mjs";
+import { _ as modelSpecContext, b as sqlAttributeSpecs, d as interpretModelAttribute, f as lowerEnumDefault, g as modelCoordinateKey, h as modelAttributeSpecsFrom, l as instantiatePslTypeConstructor, m as lowerTypeGenerators, n as collectResolvedFields, o as fieldSpecContext, p as lowerTypeDefault, r as contractError, s as getAuthoringEntity, t as PSL_CHECK_ON_STI_VARIANT, u as interpretFieldAttribute, y as resolveFieldTypeDescriptor } from "./psl-field-resolution-C5KQ7kzP-B0NwuRWV.mjs";
+import { t as defaultTableName } from "./default-table-name-BfFY8qYR-CWZFDX6v.mjs";
+import { isStructuredError } from "@prisma/orm-framework/utils/structured-error";
+import { ifDefined } from "@prisma/orm-framework/utils/defined";
+import { applyDiscriminatorRule, describeDiscriminatorRefusal, encodeEnumMembers, instantiateAuthoringEntityType, instantiateAuthoringTypeAlias, instantiateAuthoringTypeConstructor, isAuthoringEntityTypeDescriptor, isAuthoringModelAttributeDescriptor, resolveTypeAliasGenerators } from "@prisma/orm-framework/components/authoring";
+import { UNBOUND_NAMESPACE_ID } from "@prisma/orm-framework/components/ir";
+import { blindCast } from "@prisma/orm-framework/utils/casts";
+import { InternalError } from "@prisma/orm-framework/utils/internal-error";
+import { crossRef } from "@prisma/orm-framework/contract/types";
+import { NamespaceDeclarationAst } from "@prisma/orm-framework/psl-parser/syntax";
+import { resolveToOneRelationNullable } from "@prisma/orm-framework/contract-authoring";
+import { assertDefined, invariant } from "@prisma/orm-framework/utils/assertions";
+import { notOk, ok } from "@prisma/orm-framework/utils/result";
+import { contributedTypeAliasOf, createPslDiagnosticCollector, diagnosticSource, findBlockDescriptor, interpretExtensionBlocks, nodePslSpan, resolveTypeAliases, typeAliasAttributeNames, typeAliasSpecContext, typeReferenceNode } from "@prisma/orm-framework/psl-parser";
+import { claimedBlockKeywords, enumMemberAttributeDiagnostics, fkRelationPairKey, requiredOneToOneBackrelationDiagnostic, unsupportedBlockDiagnostic } from "@prisma/orm-framework/psl-parser/interpret";
+//#region ../../../2-sql-family/2-authoring/contract-psl/dist/interpreter-D5qk4B--.mjs
+function describeUnsupportedSqlAliasAttribute(attribute) {
+	return attribute.name.startsWith("db.") ? formatDbAttributeMigrationMessage(attribute) : void 0;
+}
+function aliasDescriptor(alias, input) {
+	const { base, symbol } = alias;
+	const source = diagnosticSource(input.sources, symbol.node.syntax);
+	if (base.kind === "typeConstructor") {
+		if (base.call === void 0) return instantiateAuthoringTypeConstructor(base.descriptor, []);
+		return instantiatePslTypeConstructor({
+			call: base.call,
+			descriptor: base.descriptor,
+			codecLookup: input.codecLookup,
+			diagnostics: input.diagnostics,
+			source,
+			entityLabel: `Type alias "${symbol.name}"`,
+			dataTypes: input.dataTypes
+		});
+	}
+	const descriptor = input.enumTypeDescriptors.get(base.symbol);
+	if (descriptor === void 0) input.diagnostics.push({
+		code: "PSL_UNSUPPORTED_NAMED_TYPE_BASE",
+		message: `Type alias "${symbol.name}" references unsupported base type "${alias.baseName}"`,
+		...source.at(symbol.span)
+	});
+	return descriptor;
+}
+/**
+* Resolves each `types {}` alias once: its column type, with the params inline, and its `@default`, `@onCreate` and `@onUpdate`, lowered for that column. A diagnostic about the alias is reported here, once, not at each field typed by it.
+*/
+function resolveNamedTypeDeclarations(input) {
+	const declared = resolveDeclaredTypeAliases(input);
+	const contributed = /* @__PURE__ */ new Map();
+	const resolveContributed = (alias) => {
+		const existing = contributed.get(alias.descriptor);
+		if (existing !== void 0) return existing;
+		const resolved = resolveContributedTypeAlias(alias, input);
+		contributed.set(alias.descriptor, resolved);
+		return resolved;
+	};
+	return {
+		get: (symbol) => declared.get(symbol),
+		ofResolution(resolution) {
+			if (resolution?.kind === "namedType") return declared.get(resolution.symbol);
+			const alias = contributedTypeAliasOf(resolution);
+			return alias === void 0 ? void 0 : resolveContributed(alias);
+		}
+	};
+}
+function resolveContributedTypeAlias(alias, input) {
+	const { type: descriptor } = instantiateAuthoringTypeAlias(alias.descriptor);
+	const executionDefaults = resolveTypeAliasGenerators({
+		path: alias.name,
+		descriptor: alias.descriptor,
+		generatorFunctions: input.generatorFunctions,
+		length: sqlCodecColumnLength(input.dataTypes, descriptor.codecId, descriptor.typeParams)
+	});
+	return {
+		alias,
+		name: alias.name,
+		attributes: [],
+		descriptor,
+		enumHandle: void 0,
+		defaultValue: void 0,
+		executionDefaults
+	};
+}
+function resolveDeclaredTypeAliases(input) {
+	const aliases = resolveTypeAliases({
+		declarations: input.declarations,
+		binder: input.binder,
+		sources: input.sources,
+		diagnostics: input.diagnostics,
+		authoringTypes: input.authoringTypes,
+		describeUnsupportedAttribute: describeUnsupportedSqlAliasAttribute
+	});
+	const resolved = /* @__PURE__ */ new Map();
+	for (const alias of aliases.values()) {
+		const descriptor = aliasDescriptor(alias, input);
+		if (descriptor === void 0) continue;
+		const owner = {
+			attributes: alias.attributes,
+			optional: false,
+			list: false,
+			elementOptional: false,
+			specContext: typeAliasSpecContext(alias, {
+				...input,
+				symbols: input.symbolTable
+			}),
+			loweringNames: {
+				modelName: "types",
+				fieldName: alias.symbol.name
+			}
+		};
+		const enumHandle = alias.base.kind === "block" ? input.enumHandles.get(alias.base.symbol) : void 0;
+		const lowering = {
+			...input,
+			owner
+		};
+		const { defaultValue } = enumHandle === void 0 ? lowerTypeDefault({
+			...lowering,
+			columnDescriptor: descriptor,
+			columnTypeParams: descriptor.typeParams,
+			isListColumn: false,
+			valueObjectDefault: void 0
+		}) : lowerEnumDefault({
+			...lowering,
+			enumHandle
+		});
+		const executionDefaults = lowerTypeGenerators({
+			...lowering,
+			columnDescriptor: descriptor,
+			columnTypeParams: descriptor.typeParams
+		});
+		resolved.set(alias.symbol, {
+			alias,
+			name: alias.symbol.name,
+			attributes: alias.attributes,
+			descriptor,
+			enumHandle,
+			defaultValue,
+			executionDefaults
+		});
+	}
+	return resolved;
+}
+const REFERENTIAL_ACTION_MAP = {
+	NoAction: "noAction",
+	Restrict: "restrict",
+	Cascade: "cascade",
+	SetNull: "setNull",
+	SetDefault: "setDefault",
+	noAction: "noAction",
+	restrict: "restrict",
+	cascade: "cascade",
+	setNull: "setNull",
+	setDefault: "setDefault"
+};
+function modelName(key) {
+	return typeof key === "string" ? key : key.name;
+}
+function normalizeReferentialAction(actionToken) {
+	return REFERENTIAL_ACTION_MAP[actionToken];
+}
+function interpretRelationAttribute(input) {
+	const node = getAttribute(input.field.attributes, "relation")?.node;
+	if (node === void 0) return void 0;
+	return interpretFieldAttribute({
+		symbols: input.symbols,
+		node,
+		spec: sqlAttributeSpecs.field.relation(input.specContext),
+		model: input.selfModel,
+		field: input.field,
+		sources: input.sources,
+		binder: input.binder,
+		diagnostics: input.diagnostics
+	});
+}
+function indexFkRelations(input) {
+	const modelRelations = /* @__PURE__ */ new Map();
+	const fkRelationsByPair = /* @__PURE__ */ new Map();
+	const fkRelationsByDeclaringModel = /* @__PURE__ */ new Map();
+	for (const relation of input.fkRelationMetadata) {
+		const declaringFkRelations = fkRelationsByDeclaringModel.get(relation.declaringModelName);
+		if (declaringFkRelations) declaringFkRelations.push(relation);
+		else fkRelationsByDeclaringModel.set(relation.declaringModelName, [relation]);
+		const existing = modelRelations.get(relation.declaringModelName);
+		const current = existing ?? [];
+		if (!existing) modelRelations.set(relation.declaringModelName, current);
+		current.push({
+			fieldName: relation.declaringFieldName,
+			toModel: modelName(relation.targetModelName),
+			toTable: relation.targetTableName,
+			...ifDefined("toNamespaceId", relation.targetNamespaceId),
+			cardinality: "N:1",
+			nullable: relation.nullable,
+			on: {
+				parentTable: relation.declaringTableName,
+				parentColumns: relation.localColumns,
+				childTable: relation.targetTableName,
+				childColumns: relation.referencedColumns
+			}
+		});
+		let targets = fkRelationsByPair.get(relation.declaringModelName);
+		if (!targets) {
+			targets = /* @__PURE__ */ new Map();
+			fkRelationsByPair.set(relation.declaringModelName, targets);
+		}
+		const pairRelations = targets.get(relation.targetModelName);
+		if (pairRelations) pairRelations.push(relation);
+		else targets.set(relation.targetModelName, [relation]);
+	}
+	return {
+		modelRelations,
+		fkRelationsByPair,
+		fkRelationsByDeclaringModel
+	};
+}
+function idColumnsAreExactlyFkPair(idColumns, parentColumns, childColumns) {
+	if (idColumns.length !== parentColumns.length + childColumns.length) return false;
+	const fkColumns = /* @__PURE__ */ new Set([...parentColumns, ...childColumns]);
+	if (fkColumns.size !== parentColumns.length + childColumns.length) return false;
+	return idColumns.every((column) => fkColumns.has(column));
+}
+/**
+* Reorders the child FK's junction columns into the target model's id-column
+* order. Returns undefined unless the FK references exactly the target's full
+* id, because downstream consumers pair `through.childColumns` positionally
+* against the target id columns — an FK referencing anything else (a non-id
+* unique, a partial id) would produce a silently wrong join.
+*/
+function childColumnsInTargetIdOrder(childFk, targetIdColumns) {
+	if (childFk.referencedColumns.length !== targetIdColumns.length) return;
+	const localByReferenced = /* @__PURE__ */ new Map();
+	for (const [index, referencedColumn] of childFk.referencedColumns.entries()) {
+		const localColumn = childFk.localColumns[index];
+		if (localColumn === void 0) return;
+		localByReferenced.set(referencedColumn, localColumn);
+	}
+	if (localByReferenced.size !== targetIdColumns.length) return;
+	const ordered = [];
+	for (const idColumn of targetIdColumns) {
+		const localColumn = localByReferenced.get(idColumn);
+		if (localColumn === void 0) return;
+		ordered.push(localColumn);
+	}
+	return ordered;
+}
+/**
+* Finds explicit junction models that connect a bare backrelation list field
+* to its target model: a model whose composite id columns are exactly the FK
+* columns of one relation back to the candidate's model (the parent side) and
+* one relation to the candidate's target model (the child side). The child
+* FK must reference exactly the target model's id columns; its junction
+* columns are carried in target-id order on the pair. A relation name on the
+* list field pins the parent-side FK relation, which is how self-referential
+* many-to-many sides are disambiguated.
+*
+* Alongside the recognised pairs, returns junction-shaped near-misses (models
+* that link both sides but were declined) so the caller can emit a
+* junction-specific diagnostic instead of the generic orphaned-list message.
+*/
+function findJunctionFkPairs(input) {
+	const targetIdColumns = input.modelIdColumns.get(input.candidate.targetModelName);
+	if (!targetIdColumns || targetIdColumns.length === 0) return {
+		pairs: [],
+		nearMisses: []
+	};
+	const pairs = [];
+	const nearMisses = [];
+	for (const [junctionModelName, junctionFks] of input.fkRelationsByDeclaringModel) {
+		const idColumns = input.modelIdColumns.get(junctionModelName);
+		for (const parentFk of junctionFks) {
+			if (parentFk.targetModelName !== input.candidate.modelName) continue;
+			if (input.candidate.relationName !== void 0 && parentFk.relationName !== input.candidate.relationName) continue;
+			for (const childFk of junctionFks) {
+				if (childFk === parentFk || childFk.targetModelName !== input.candidate.targetModelName) continue;
+				if (!idColumns || !idColumnsAreExactlyFkPair(idColumns, parentFk.localColumns, childFk.localColumns)) {
+					nearMisses.push({
+						junctionModelName: modelName(junctionModelName),
+						reason: "id-not-fk-covering"
+					});
+					continue;
+				}
+				const orderedChildColumns = childColumnsInTargetIdOrder(childFk, targetIdColumns);
+				if (!orderedChildColumns) {
+					nearMisses.push({
+						junctionModelName: modelName(junctionModelName),
+						reason: "target-fk-not-id"
+					});
+					continue;
+				}
+				pairs.push({
+					parentFk,
+					childFk,
+					childColumnsInTargetIdOrder: orderedChildColumns
+				});
+			}
+		}
+	}
+	return {
+		pairs,
+		nearMisses
+	};
+}
+function junctionNearMissDiagnostic(candidate, nearMiss, sources) {
+	const source = diagnosticSource(sources, candidate.field.node.syntax);
+	const listField = `${modelName(candidate.modelName)}.${candidate.field.name}`;
+	const targetModelName = modelName(candidate.targetModelName);
+	const data = {
+		listField,
+		junctionModel: nearMiss.junctionModelName,
+		targetModel: targetModelName
+	};
+	if (nearMiss.reason === "target-fk-not-id") return {
+		code: "PSL_JUNCTION_TARGET_FK_NOT_ID",
+		message: `Backrelation list field "${listField}" found junction model "${nearMiss.junctionModelName}", but its foreign key to "${targetModelName}" does not reference "${targetModelName}"'s @id. The junction's target-side foreign key must reference "${targetModelName}"'s full @id columns for many-to-many recognition.`,
+		...source.at(candidate.field.span),
+		data
+	};
+	return {
+		code: "PSL_JUNCTION_ID_NOT_FK_COVERING",
+		message: `Backrelation list field "${listField}" found junction-shaped model "${nearMiss.junctionModelName}" linking "${modelName(candidate.modelName)}" and "${targetModelName}", but its id does not cover exactly its foreign-key columns. Declare @@id([...]) on "${nearMiss.junctionModelName}" listing exactly the two foreign-key columns for many-to-many recognition.`,
+		...source.at(candidate.field.span),
+		data
+	};
+}
+function manyToManyRelationNode(candidate, pair) {
+	return {
+		fieldName: candidate.field.name,
+		toModel: modelName(pair.childFk.targetModelName),
+		toTable: pair.childFk.targetTableName,
+		...ifDefined("toNamespaceId", pair.childFk.targetNamespaceId),
+		cardinality: "N:M",
+		on: {
+			parentTable: candidate.tableName,
+			parentColumns: pair.parentFk.referencedColumns,
+			childTable: pair.parentFk.declaringTableName,
+			childColumns: pair.parentFk.localColumns
+		},
+		through: {
+			table: pair.parentFk.declaringTableName,
+			...ifDefined("namespaceId", pair.parentFk.declaringNamespaceId),
+			parentColumns: pair.parentFk.localColumns,
+			childColumns: pair.childColumnsInTargetIdOrder
+		}
+	};
+}
+function relationsForModel(modelRelations, modelName) {
+	const existing = modelRelations.get(modelName);
+	if (existing) return existing;
+	const created = [];
+	modelRelations.set(modelName, created);
+	return created;
+}
+/**
+* A set of columns is unique when it exactly matches one of the model's unique
+* column sets — its primary key, any single- or multi-column `@unique` /
+* `@@unique` constraint, or a unique index over plain columns with no `where`
+* clause. Set equality (not subset) is required: a singular back-relation means
+* at most one child per parent, which a unique constraint covering exactly the
+* FK columns guarantees.
+*/
+function fkColumnsAreUnique(localColumns, uniqueColumnSets) {
+	const local = new Set(localColumns);
+	return uniqueColumnSets.some((columns) => columns.length === local.size && columns.every((column) => local.has(column)));
+}
+function applyBackrelationCandidates(input) {
+	for (const candidate of input.backrelationCandidates) {
+		const source = diagnosticSource(input.sources, candidate.field.node.syntax);
+		const pairMatches = input.fkRelationsByPair.get(candidate.targetModelName)?.get(candidate.modelName) ?? [];
+		const matches = candidate.relationName ? pairMatches.filter((relation) => relation.relationName === candidate.relationName) : [...pairMatches];
+		if (matches.length === 0) {
+			const invalidIndex = input.invalidFkPairings.findIndex((pairing) => {
+				if (pairing.relationName !== candidate.relationName) return false;
+				if ("pairKey" in pairing) return typeof candidate.targetModelName === "string" && typeof candidate.modelName === "string" && pairing.pairKey === fkRelationPairKey(candidate.targetModelName, candidate.modelName);
+				return pairing.declaringModel === candidate.targetModelName && pairing.targetModel === candidate.modelName;
+			});
+			if (invalidIndex !== -1) {
+				input.invalidFkPairings.splice(invalidIndex, 1);
+				continue;
+			}
+			if (candidate.isList) {
+				const { pairs: junctionPairs, nearMisses } = findJunctionFkPairs({
+					candidate,
+					fkRelationsByDeclaringModel: input.fkRelationsByDeclaringModel,
+					modelIdColumns: input.modelIdColumns
+				});
+				const junctionPair = junctionPairs[0];
+				if (junctionPairs.length === 1 && junctionPair) {
+					relationsForModel(input.modelRelations, candidate.modelName).push(manyToManyRelationNode(candidate, junctionPair));
+					continue;
+				}
+				if (junctionPairs.length > 1) {
+					input.diagnostics.push({
+						code: "PSL_AMBIGUOUS_BACKRELATION",
+						message: `Backrelation list field "${modelName(candidate.modelName)}.${candidate.field.name}" matches multiple junction FK pairs for a many-to-many relation. Add @relation(name: "...") (or @relation("...")) to the list field and the junction FK-side relation pointing back at "${modelName(candidate.modelName)}" to disambiguate.`,
+						...source.at(candidate.field.span)
+					});
+					continue;
+				}
+				const nearMiss = nearMisses[0];
+				if (nearMiss) {
+					input.diagnostics.push(junctionNearMissDiagnostic(candidate, nearMiss, input.sources));
+					continue;
+				}
+			}
+			input.diagnostics.push({
+				code: "PSL_ORPHANED_BACKRELATION",
+				message: `Backrelation field "${modelName(candidate.modelName)}.${candidate.field.name}" has no matching FK-side relation on model "${modelName(candidate.targetModelName)}". Add @relation(fields: [...], references: [...]) on the FK-side relation${candidate.isList ? " or use an explicit join model for many-to-many" : ""}.`,
+				...source.at(candidate.field.span)
+			});
+			continue;
+		}
+		if (matches.length > 1) {
+			input.diagnostics.push({
+				code: "PSL_AMBIGUOUS_BACKRELATION",
+				message: `Backrelation field "${modelName(candidate.modelName)}.${candidate.field.name}" matches multiple FK-side relations on model "${modelName(candidate.targetModelName)}". Add @relation(name: "...") (or @relation("...")) to both sides to disambiguate.`,
+				...source.at(candidate.field.span)
+			});
+			continue;
+		}
+		invariant(matches.length === 1, "Backrelation matching requires exactly one match");
+		const matched = matches[0];
+		assertDefined(matched, "Backrelation matching requires a defined relation match");
+		if (!candidate.isList) {
+			const uniqueColumnSets = input.modelUniqueColumnSets.get(matched.declaringModelName) ?? [];
+			if (!fkColumnsAreUnique(matched.localColumns, uniqueColumnSets)) {
+				input.diagnostics.push({
+					code: "PSL_NON_UNIQUE_BACKRELATION",
+					message: `Backrelation field "${modelName(candidate.modelName)}.${candidate.field.name}" is singular, but the matching FK on "${modelName(matched.declaringModelName)}" (fields ${matched.localColumns.map((column) => `"${column}"`).join(", ")}) is not unique. A singular back-relation implies at most one related row; add @unique (or @@unique([...])) to the FK fields, or make "${candidate.field.name}" a list.`,
+					...source.at(candidate.field.span)
+				});
+				continue;
+			}
+		}
+		if (!candidate.isList && !candidate.field.optional) input.diagnostics.push(requiredOneToOneBackrelationDiagnostic({
+			modelName: modelName(candidate.modelName),
+			field: candidate.field,
+			targetModelName: modelName(candidate.targetModelName),
+			sources: input.sources,
+			recordNoun: "row"
+		}));
+		relationsForModel(input.modelRelations, candidate.modelName).push({
+			fieldName: candidate.field.name,
+			toModel: modelName(matched.declaringModelName),
+			toTable: matched.declaringTableName,
+			...ifDefined("toNamespaceId", matched.declaringNamespaceId),
+			...candidate.isList ? { cardinality: "1:N" } : {
+				cardinality: "1:1",
+				nullable: true
+			},
+			on: {
+				parentTable: candidate.tableName,
+				parentColumns: matched.referencedColumns,
+				childTable: matched.declaringTableName,
+				childColumns: matched.localColumns
+			}
+		});
+	}
+}
+function validateBackrelationFieldAttributes(input) {
+	const source = diagnosticSource(input.sources, input.field.node.syntax);
+	let valid = true;
+	for (const attribute of input.field.attributes) {
+		if (attribute.name === "relation") continue;
+		input.diagnostics.push({
+			code: "PSL_UNSUPPORTED_FIELD_ATTRIBUTE",
+			message: `Field "${input.modelName}.${input.field.name}" uses unsupported attribute "@${attribute.name}"`,
+			...source.at(attribute.span)
+		});
+		valid = false;
+	}
+	return valid;
+}
+function buildComposedExtensionPackRefs(target, extensionIds, extensionPackRefs = []) {
+	if (extensionIds.length === 0) return;
+	const extensionPackRefById = new Map(extensionPackRefs.map((packRef) => [packRef.id, packRef]));
+	return Object.fromEntries(extensionIds.map((extensionId) => [extensionId, extensionPackRefById.get(extensionId) ?? {
+		kind: "extension",
+		id: extensionId,
+		familyId: target.familyId,
+		targetId: target.targetId,
+		version: "0.0.1"
+	}]));
+}
+function compareStrings(left, right) {
+	if (left < right) return -1;
+	if (left > right) return 1;
+	return 0;
+}
+function declarationsHoldingModels(namespace) {
+	const declarations = /* @__PURE__ */ new Set();
+	for (const model of Object.values(namespace.models)) {
+		const written = model.node.syntax.findAncestor(NamespaceDeclarationAst.cast);
+		if (written !== void 0) declarations.add(written.syntax);
+	}
+	return declarations;
+}
+function validateNamespaceBlocksForSqlTarget(input) {
+	if (input.target.supportsNamespaces === false) {
+		const targetName = input.target.displayName ?? input.target.targetId;
+		for (const namespace of input.namespaces) for (const { node, span } of namespace.declarations) input.diagnostics.push({
+			code: "PSL_UNSUPPORTED_NAMESPACE_BLOCK",
+			message: `${targetName} does not support \`namespace ${node.name()?.name() ?? namespace.name} { … }\` blocks (declare models at the document top level instead).`,
+			...diagnosticSource(input.sources, node.syntax).at(span)
+		});
+		return;
+	}
+	const unboundNamespace = input.namespaces.find((namespace) => namespace.id === UNBOUND_NAMESPACE_ID && Object.keys(namespace.models).length > 0);
+	const hasSibling = input.namespaces.some((namespace) => namespace.id !== UNBOUND_NAMESPACE_ID && namespace.declarations.length > 0);
+	if (unboundNamespace !== void 0 && hasSibling) {
+		const holdingModels = declarationsHoldingModels(unboundNamespace);
+		for (const { node, span } of unboundNamespace.declarations) {
+			if (!holdingModels.has(node.syntax)) continue;
+			input.diagnostics.push({
+				code: "PSL_RESERVED_NAMESPACE_NAME",
+				message: "Namespace \"unbound\" is reserved for the late-binding sentinel mapping; a `namespace unbound { … }` containing models cannot appear alongside other named namespace blocks. Use `namespace unbound { … }` alone (no sibling named namespaces) for late-binding multi-tenant contracts.",
+				...diagnosticSource(input.sources, node.syntax).at(span)
+			});
+		}
+	}
+}
+/**
+* Walks the flat `entityTypes` namespace tree in `authoringContributions` and
+* returns a map from discriminator string to the matching descriptor. The
+* interpreter uses this to dispatch parsed extension blocks to their factory
+* without naming any specific discriminator value (generic, by-discriminator).
+*/
+function buildEntityTypesByDiscriminator(contributions) {
+	const result = /* @__PURE__ */ new Map();
+	const namespace = contributions?.entityTypes;
+	if (namespace === void 0) return result;
+	const walk = (node) => {
+		for (const value of Object.values(node)) if (isAuthoringEntityTypeDescriptor(value)) result.set(value.discriminator, value);
+		else if (typeof value === "object" && value !== null) walk(value);
+	};
+	walk(namespace);
+	return result;
+}
+/**
+* The `PSL_DUPLICATE_ATTRIBUTE` diagnostic for a model attribute declared
+* more than once on one model. Shared by the built-in `@@control` path and
+* the contributed-model-attribute path so the code and wording stay in one
+* place. `name` is the bare attribute name (`control`, `rls`, …).
+*/
+function duplicateModelAttributeDiagnostic(input) {
+	return {
+		code: "PSL_DUPLICATE_ATTRIBUTE",
+		message: `\`@@${input.name}\` declared more than once on model "${input.modelName}".`,
+		...input.source.at(input.span)
+	};
+}
+function isResolvedModelReference(value) {
+	if (typeof value !== "object" || value === null || !("declaration" in value)) return false;
+	const declaration = value.declaration;
+	return typeof declaration === "object" && declaration !== null && "kind" in declaration && declaration.kind === "model";
+}
+function validateBlockModelAttributeRequirements(input) {
+	for (const [blockSymbol, envelope] of input.parsedBlocks) {
+		const requirement = findBlockDescriptor(input.pslBlockDescriptors, blockSymbol.keyword)?.requiresModelAttribute;
+		if (requirement === void 0) continue;
+		const target = envelope.values[requirement.parameter];
+		if (!isResolvedModelReference(target)) continue;
+		const model = target.declaration;
+		if (model.attributes.some((attribute) => attribute.name === requirement.attribute)) continue;
+		input.diagnostics.push({
+			code: "PSL_EXTENSION_TARGET_MODEL_MISSING_ATTRIBUTE",
+			message: `\`${blockSymbol.keyword}\` block "${envelope.name}" targets model "${model.name}", which does not declare \`@@${requirement.attribute}\`. Add \`@@${requirement.attribute}\` to model "${model.name}".`,
+			...diagnosticSource(input.sources, blockSymbol.node.syntax).at(envelope.parameterSpans[requirement.parameter] ?? envelope.span)
+		});
+	}
+}
+/**
+* Walks the flat `modelAttributes` namespace tree in `authoringContributions`
+* and returns a map from bare `@@` attribute name to the matching
+* descriptor. The model-attribute loop in `buildModelNodeFromPsl` uses this
+* to dispatch a contributed attribute without naming any specific attribute.
+*/
+function buildModelAttributesByName(contributions) {
+	const result = /* @__PURE__ */ new Map();
+	const namespace = contributions?.modelAttributes;
+	if (namespace === void 0) return result;
+	const walk = (node) => {
+		for (const value of Object.values(node)) if (isAuthoringModelAttributeDescriptor(value)) result.set(value.attribute, value);
+		else if (typeof value === "object" && value !== null) walk(value);
+	};
+	walk(namespace);
+	return result;
+}
+/**
+* This pass is intentionally generic: no discriminator value is named here.
+* The factory (registered by the target pack) owns all block-specific logic.
+*/
+function lowerExtensionBlocksForNamespace(blocks, ownerNamespaceId, entityTypesByDiscriminator, entityContext, parsedBlocks, modelCoordinateOf, sources) {
+	const rows = [];
+	for (const blockSymbol of Object.values(blocks)) {
+		const envelope = parsedBlocks.get(blockSymbol);
+		if (envelope === void 0) continue;
+		const descriptor = entityTypesByDiscriminator.get(envelope.kind);
+		if (descriptor === void 0) continue;
+		let resolvedModelRefs;
+		for (const [paramName, value] of Object.entries(envelope.values)) {
+			if (!isResolvedModelReference(value)) continue;
+			const coordinate = modelCoordinateOf(value.declaration);
+			invariant(coordinate !== void 0, `model mappings cover every collected model; \`${envelope.keyword}\` block "${envelope.name}" selected model "${value.declaration.name}" in \`${paramName}\` without a storage coordinate`);
+			resolvedModelRefs = {
+				...resolvedModelRefs ?? {},
+				[paramName]: coordinate
+			};
+		}
+		const annotatedBlock = {
+			...envelope,
+			namespaceId: ownerNamespaceId,
+			...resolvedModelRefs !== void 0 ? { resolvedModelRefs } : {}
+		};
+		const entity = instantiateAuthoringEntityType(descriptor.discriminator, descriptor, [annotatedBlock], {
+			...entityContext,
+			sourceId: sources.sourceFileFor(blockSymbol.node.syntax).filename
+		});
+		if (entity === void 0) continue;
+		const namespaceId = providesPslEntityPlacement(descriptor.output) ? descriptor.output.pslPlacement(entity).namespaceId : ownerNamespaceId;
+		rows.push({
+			namespaceId,
+			entityKind: descriptor.discriminator,
+			key: envelope.name,
+			entity
+		});
+		const derivedValueSet = deriveValueSetFromEntity(descriptor.output, entity);
+		if (derivedValueSet !== void 0) rows.push({
+			namespaceId,
+			entityKind: "valueSet",
+			key: envelope.name,
+			entity: derivedValueSet
+		});
+	}
+	return rows;
+}
+function processEnumDeclarations(input) {
+	const enumHandles = /* @__PURE__ */ new Map();
+	const enumTypeDescriptors = /* @__PURE__ */ new Map();
+	if (input.enumBlocks.length === 0) return {
+		enumHandles,
+		enumTypeDescriptors
+	};
+	const enumDescriptor = getAuthoringEntity(input.authoringContributions, ["enum"]);
+	if (!enumDescriptor) {
+		for (const symbol of input.enumBlocks) input.diagnostics.push({
+			code: "PSL_ENUM_MISSING_FACTORY",
+			message: `enum "${symbol.name}" requires an "enum" entityType factory in the active authoring contributions`,
+			...diagnosticSource(input.source.sources, symbol.node.syntax).at(symbol.span)
+		});
+		return {
+			enumHandles,
+			enumTypeDescriptors
+		};
+	}
+	for (const symbol of input.enumBlocks) {
+		const envelope = input.parsedBlocks.get(symbol);
+		input.diagnostics.push(...enumMemberAttributeDiagnostics(symbol, input.source.sources));
+		if (envelope === void 0) continue;
+		const handle = instantiateAuthoringEntityType("enum", enumDescriptor, [envelope], {
+			...input.entityContext,
+			sourceId: input.source.sources.sourceFileFor(symbol.node.syntax).filename
+		});
+		if (handle === void 0 || handle === null) continue;
+		enumHandles.set(symbol, handle);
+		enumTypeDescriptors.set(symbol, { codecId: handle.codecId });
+	}
+	return {
+		enumHandles,
+		enumTypeDescriptors
+	};
+}
+/**
+* The owning side of a relation is the one that declares `fields`/`references` on its
+* `@relation` attribute — those name the FK columns. A singular model-typed field whose
+* `@relation` carries only a name (or nothing at all) is the back side: infer prints exactly
+* that shape for a 1:1 back-relation whenever the FK needs disambiguating (two FKs between the
+* same table pair, or a self-referencing unique FK). Checking for the attribute's mere presence
+* would misclassify that back side as the owning side.
+*/
+function relationAttributeDeclaresOwningSide(relationAttribute) {
+	return getNamedArgument(relationAttribute, "fields") !== void 0 || getNamedArgument(relationAttribute, "references") !== void 0;
+}
+function relationNullabilityMismatch(relationField, localColumns, resolvedFields) {
+	return resolveToOneRelationNullable({
+		declaredNullable: relationField.optional,
+		localFieldNullability: resolvedFields.filter((resolvedField) => localColumns.includes(resolvedField.columnName)).map((resolvedField) => resolvedField.nullable),
+		ownsReference: true
+	}).contradiction !== void 0;
+}
+function relationNullabilityMismatchDiagnostic(modelName, relationAttribute, source) {
+	const fieldLabel = `Relation field "${modelName}.${relationAttribute.field.name}"`;
+	return {
+		code: "PSL_RELATION_NULLABILITY_MISMATCH",
+		message: relationAttribute.field.optional ? `${fieldLabel} is optional but every field in @relation(fields: [...]) is required. Make one of those fields optional with "?" or remove "?" from "${relationAttribute.field.name}".` : `${fieldLabel} is required but a field in @relation(fields: [...]) is optional. Add "?" to "${relationAttribute.field.name}" or make those fields required.`,
+		...source.at(relationAttribute.field.span)
+	};
+}
+function buildModelNodeFromPsl(input) {
+	const { model, diagnostics } = input;
+	const source = diagnosticSource(input.sources, model.node.syntax);
+	const tableName = storageName(model, input.physicalNames);
+	const specContext = modelSpecContext({
+		symbols: input.symbolTable,
+		model,
+		defaultFunctionRegistry: input.defaultFunctionRegistry,
+		generatorFunctions: input.generatorFunctions,
+		dataTypes: input.dataTypes
+	});
+	const modelNamespaceId = input.namespaceId;
+	const resolvedFields = collectResolvedFields({
+		model,
+		physicalNames: input.physicalNames,
+		symbolTable: input.symbolTable,
+		enumTypeDescriptors: input.enumTypeDescriptors,
+		typeAliases: input.typeAliases,
+		valueObjectTypes: input.valueObjectTypes,
+		authoringContributions: input.authoringContributions,
+		targetId: input.targetId,
+		defaultFunctionRegistry: input.defaultFunctionRegistry,
+		generatorFunctions: input.generatorFunctions,
+		dataTypes: input.dataTypes,
+		diagnostics,
+		sources: input.sources,
+		binder: input.binder,
+		scalarColumnDescriptors: input.scalarColumnDescriptors,
+		enumHandles: input.enumHandles,
+		capabilities: input.capabilities,
+		namespaceId: modelNamespaceId,
+		...ifDefined("namespaceExtensionEntities", input.namespaceExtensionEntities),
+		codecLookup: input.codecLookup
+	});
+	const inlineIdFields = resolvedFields.filter((field) => field.isId);
+	if (inlineIdFields.length > 1) diagnostics.push({
+		code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
+		message: `Model "${model.name}" cannot declare inline @id on multiple fields; use model-level @@id([...]) for composite identity`,
+		...source.at(model.span)
+	});
+	const singleInlineIdField = inlineIdFields.length === 1 ? inlineIdFields[0] : void 0;
+	let primaryKey = singleInlineIdField ? {
+		columns: [singleInlineIdField.columnName],
+		...ifDefined("name", singleInlineIdField.idName)
+	} : void 0;
+	const hasInlinePrimaryKey = primaryKey !== void 0;
+	let blockPrimaryKeyDeclared = false;
+	let controlPolicyDeclared = false;
+	let controlPolicy;
+	const declaredContributedModelAttributes = /* @__PURE__ */ new Set();
+	const modelAttributeEntities = {};
+	const resultBackrelationCandidates = [];
+	for (const field of Object.values(model.fields)) {
+		const backrelationTarget = backrelationTargetSymbol(field, input.binder);
+		if (backrelationTarget === void 0) continue;
+		const relationAttribute = getAttribute(field.attributes, "relation");
+		if (!field.list && relationAttribute && relationAttributeDeclaresOwningSide(relationAttribute)) continue;
+		const attributesValid = validateBackrelationFieldAttributes({
+			modelName: model.name,
+			field,
+			sources: input.sources,
+			binder: input.binder,
+			diagnostics
+		});
+		let relationName;
+		if (relationAttribute) {
+			const parsedRelation = interpretRelationAttribute({
+				selfModel: model,
+				field,
+				specContext: fieldSpecContext({
+					...specContext,
+					field,
+					binder: input.binder
+				}),
+				symbols: input.symbolTable,
+				sources: input.sources,
+				binder: input.binder,
+				diagnostics
+			});
+			if (!parsedRelation) continue;
+			if (parsedRelation.fields || parsedRelation.references) {
+				diagnostics.push({
+					code: "PSL_INVALID_RELATION_ATTRIBUTE",
+					message: `Backrelation list field "${model.name}.${field.name}" cannot declare fields/references; define them on the FK-side relation field`,
+					...source.at(relationAttribute.span)
+				});
+				continue;
+			}
+			if (parsedRelation.onDelete || parsedRelation.onUpdate || parsedRelation.index !== void 0) {
+				diagnostics.push({
+					code: "PSL_INVALID_RELATION_ATTRIBUTE",
+					message: `Backrelation list field "${model.name}.${field.name}" cannot declare onDelete/onUpdate/index; define them on the FK-side relation field`,
+					...source.at(relationAttribute.span)
+				});
+				continue;
+			}
+			relationName = parsedRelation.name;
+		}
+		if (!attributesValid) continue;
+		resultBackrelationCandidates.push({
+			modelName: model,
+			tableName,
+			field,
+			targetModelName: backrelationTarget,
+			isList: field.list,
+			...ifDefined("relationName", relationName)
+		});
+	}
+	const relationAttributes = Object.values(model.fields).map((field) => ({
+		field,
+		relation: getAttribute(field.attributes, "relation")
+	})).filter((entry) => Boolean(entry.relation));
+	const uniqueConstraints = resolvedFields.filter((field) => field.isUnique).map((field) => ({
+		columns: [field.columnName],
+		...ifDefined("name", field.uniqueName)
+	}));
+	const indexNodes = [];
+	const checkNodes = [];
+	const foreignKeyNodes = [];
+	for (const modelAttribute of model.attributes) {
+		if (!Object.hasOwn(sqlAttributeSpecs.model, modelAttribute.name) && !input.modelAttributesByName.has(modelAttribute.name)) continue;
+		if (modelAttribute.name === "map") continue;
+		if (modelAttribute.name === "discriminator" || modelAttribute.name === "base") continue;
+		if (modelAttribute.name === "control") {
+			if (controlPolicyDeclared) {
+				diagnostics.push(duplicateModelAttributeDiagnostic({
+					name: "control",
+					modelName: model.name,
+					source,
+					span: modelAttribute.span
+				}));
+				continue;
+			}
+			controlPolicyDeclared = true;
+			const node = modelAttribute.node;
+			const parsed = interpretModelAttribute({
+				node,
+				spec: sqlAttributeSpecs.model.control(specContext),
+				model,
+				symbols: input.symbolTable,
+				sources: input.sources,
+				binder: input.binder,
+				diagnostics
+			});
+			if (parsed !== void 0) controlPolicy = parsed.policy;
+			continue;
+		}
+		const attributeLabel = `Model "${model.name}" @@${modelAttribute.name}`;
+		if (modelAttribute.name === "id") {
+			if (blockPrimaryKeyDeclared) {
+				diagnostics.push({
+					code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
+					message: `Model "${model.name}" declares @@id more than once`,
+					...source.at(modelAttribute.span)
+				});
+				continue;
+			}
+			if (hasInlinePrimaryKey) {
+				diagnostics.push({
+					code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
+					message: `Model "${model.name}" cannot declare both field-level @id and model-level @@id`,
+					...source.at(modelAttribute.span)
+				});
+				blockPrimaryKeyDeclared = true;
+				continue;
+			}
+			const node = modelAttribute.node;
+			const parsed = interpretModelAttribute({
+				node,
+				spec: sqlAttributeSpecs.model.id(specContext),
+				model,
+				symbols: input.symbolTable,
+				sources: input.sources,
+				binder: input.binder,
+				diagnostics
+			});
+			if (parsed === void 0) continue;
+			const fieldNames = parsed.fields;
+			const nullableFieldName = fieldNames.find((name) => model.fields[name]?.optional === true);
+			if (nullableFieldName !== void 0) {
+				diagnostics.push({
+					code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
+					message: `${attributeLabel} cannot include optional field "${nullableFieldName}"; primary key columns must be NOT NULL`,
+					...source.at(modelAttribute.span)
+				});
+				continue;
+			}
+			const columnNames = mapFieldNamesToColumns({
+				model,
+				physicalNames: input.physicalNames,
+				fieldNames,
+				source,
+				diagnostics,
+				span: modelAttribute.span,
+				entityLabel: attributeLabel
+			});
+			if (!columnNames) continue;
+			primaryKey = {
+				columns: columnNames,
+				...ifDefined("name", parsed.map)
+			};
+			blockPrimaryKeyDeclared = true;
+			continue;
+		}
+		if (modelAttribute.name === "unique") {
+			const node = modelAttribute.node;
+			const parsed = interpretModelAttribute({
+				node,
+				spec: sqlAttributeSpecs.model.unique(specContext),
+				model,
+				symbols: input.symbolTable,
+				sources: input.sources,
+				binder: input.binder,
+				diagnostics
+			});
+			if (parsed === void 0) continue;
+			const columnNames = mapFieldNamesToColumns({
+				model,
+				physicalNames: input.physicalNames,
+				fieldNames: parsed.fields,
+				source,
+				diagnostics,
+				span: modelAttribute.span,
+				entityLabel: attributeLabel
+			});
+			if (!columnNames) continue;
+			uniqueConstraints.push({
+				columns: columnNames,
+				...ifDefined("name", parsed.map)
+			});
+			continue;
+		}
+		if (modelAttribute.name === "index") {
+			const node = modelAttribute.node;
+			const parsed = interpretModelAttribute({
+				node,
+				spec: sqlAttributeSpecs.model.index(specContext),
+				model,
+				symbols: input.symbolTable,
+				sources: input.sources,
+				binder: input.binder,
+				diagnostics
+			});
+			if (parsed === void 0) continue;
+			let columnNames;
+			if (parsed.fields !== void 0) {
+				const mapped = mapFieldNamesToColumns({
+					model,
+					physicalNames: input.physicalNames,
+					fieldNames: parsed.fields,
+					source,
+					diagnostics,
+					span: modelAttribute.span,
+					entityLabel: attributeLabel
+				});
+				if (!mapped) continue;
+				columnNames = mapped;
+			}
+			indexNodes.push(blindCast({
+				...ifDefined("columns", columnNames),
+				...ifDefined("expression", parsed.expression === void 0 ? void 0 : sqlTextFromStored(parsed.expression.value.value)),
+				where: parsed.where === void 0 ? void 0 : sqlTextFromStored(parsed.where.value.value),
+				unique: parsed.unique,
+				name: parsed.name,
+				map: parsed.map,
+				type: parsed.type,
+				options: parsed.options
+			}));
+			continue;
+		}
+		if (modelAttribute.name === "check") {
+			const node = modelAttribute.node;
+			if (input.capabilities["sql"]?.["checkConstraint"] !== true) {
+				diagnostics.push({
+					code: "PSL_CHECK_UNSUPPORTED_TARGET",
+					message: `Model "${model.name}" declares "@@check", but target "${input.targetId}" does not support check constraints (the adapter does not report the "checkConstraint" capability). Remove the check or author it against a target that supports check constraints.`,
+					...source.at(modelAttribute.span)
+				});
+				continue;
+			}
+			const parsed = interpretModelAttribute({
+				node,
+				spec: sqlAttributeSpecs.model.check(specContext),
+				model,
+				symbols: input.symbolTable,
+				sources: input.sources,
+				binder: input.binder,
+				diagnostics
+			});
+			if (parsed === void 0) continue;
+			checkNodes.push({
+				expression: sqlTextFromStored(parsed.expression.value.value),
+				name: parsed.name,
+				map: parsed.map
+			});
+			continue;
+		}
+		const contributedModelAttribute = input.modelAttributesByName.get(modelAttribute.name);
+		if (contributedModelAttribute !== void 0) {
+			if (contributedModelAttribute.repeatable !== true && declaredContributedModelAttributes.has(modelAttribute.name)) {
+				diagnostics.push(duplicateModelAttributeDiagnostic({
+					name: modelAttribute.name,
+					modelName: model.name,
+					source,
+					span: modelAttribute.span
+				}));
+				continue;
+			}
+			declaredContributedModelAttributes.add(modelAttribute.name);
+			const node = modelAttribute.node;
+			const specFactory = input.contributedModelAttributeSpecs[contributedModelAttribute.attribute];
+			if (specFactory === void 0) continue;
+			const parsed = interpretModelAttribute({
+				node,
+				spec: specFactory(specContext),
+				model,
+				symbols: input.symbolTable,
+				sources: input.sources,
+				binder: input.binder,
+				diagnostics
+			});
+			if (parsed === void 0) continue;
+			const lowered = blindCast(contributedModelAttribute.lower)(parsed, {
+				family: input.familyId,
+				target: input.targetId,
+				codecLookup: input.codecLookup,
+				dataTypes: input.dataTypes,
+				modelName: model.name,
+				storageName: tableName,
+				fieldStorageName: (fieldName) => {
+					const field = model.fields[fieldName];
+					return field === void 0 ? void 0 : storageName(field, input.physicalNames);
+				},
+				fieldCodecId: (fieldName) => resolvedFields.find((resolved) => resolved.field.name === fieldName)?.descriptor.codecId,
+				namespaceId: modelNamespaceId,
+				sourceId: source.sources.sourceFileFor(source.node).filename,
+				diagnostics: { push: (d) => {
+					diagnostics.pushExternal(blindCast(d));
+				} }
+			});
+			if (lowered === void 0) continue;
+			if ("index" in lowered) {
+				if (!isAuthoredIndexInput(lowered.index)) throw contractError("CONTRACT.PACK_CONTRIBUTION_INVALID", `model attribute "@@${modelAttribute.name}" on model "${model.name}" lowered to a malformed index. A contributed attribute that returns { index } must return an authored-index input: exactly one of a columns list or an expression, plus explicit where/unique/name/map and a type-with-options pair.`, { meta: {
+					attribute: modelAttribute.name,
+					modelName: model.name
+				} });
+				indexNodes.push(lowered.index);
+				continue;
+			}
+			const slot = modelAttributeEntities[contributedModelAttribute.attribute] ?? {};
+			modelAttributeEntities[contributedModelAttribute.attribute] = slot;
+			slot[lowered.key] = lowered.entity;
+			continue;
+		}
+		throw new InternalError(`Model attribute "@@${modelAttribute.name}" is registered but has no interpreter branch`);
+	}
+	const resultFkRelationMetadata = [];
+	const relationIndexLocations = [];
+	const resultInvalidFkPairings = [];
+	const resultCrossSpaceRelations = [];
+	for (const relationAttribute of relationAttributes) {
+		const { typeName: fieldTypeName, typeNamespaceId: fieldTypeNamespaceId, typeContractSpaceId: fieldTypeContractSpaceId } = relationAttribute.field;
+		if (relationAttribute.field.list) {
+			if (fieldTypeContractSpaceId !== void 0) diagnostics.push({
+				code: "PSL_UNSUPPORTED_CROSS_SPACE_LIST",
+				message: `Relation field "${model.name}.${relationAttribute.field.name}" is a cross-space list relation (type "${fieldTypeContractSpaceId}:${fieldTypeNamespaceId !== void 0 ? `${fieldTypeNamespaceId}.` : ""}${fieldTypeName}[]"). Cross-space relations must be singular in v0.1 — list cross-space relations are not supported.`,
+				...source.at(relationAttribute.field.span)
+			});
+			continue;
+		}
+		if (!relationAttributeDeclaresOwningSide(relationAttribute.relation)) continue;
+		if (fieldTypeContractSpaceId !== void 0) {
+			const extContractForSpace = input.composedExtensionContracts.get(fieldTypeContractSpaceId);
+			if (extContractForSpace === void 0) {
+				diagnostics.push({
+					code: "PSL_UNKNOWN_CONTRACT_SPACE",
+					message: `Relation field "${model.name}.${relationAttribute.field.name}" references contract space "${fieldTypeContractSpaceId}" which is not declared in extensions. Add "${fieldTypeContractSpaceId}" to extensions in prisma.config.ts.`,
+					...source.at(relationAttribute.field.span),
+					data: {
+						space: fieldTypeContractSpaceId,
+						suggestedPack: fieldTypeContractSpaceId
+					}
+				});
+				continue;
+			}
+			const parsedRelation = interpretRelationAttribute({
+				selfModel: model,
+				field: relationAttribute.field,
+				specContext: fieldSpecContext({
+					...specContext,
+					field: relationAttribute.field,
+					binder: input.binder
+				}),
+				symbols: input.symbolTable,
+				sources: input.sources,
+				binder: input.binder,
+				diagnostics
+			});
+			if (!parsedRelation) continue;
+			if (!parsedRelation.fields || !parsedRelation.references) {
+				diagnostics.push({
+					code: "PSL_INVALID_RELATION_ATTRIBUTE",
+					message: `Relation field "${model.name}.${relationAttribute.field.name}" requires fields and references arguments`,
+					...source.at(relationAttribute.relation.span)
+				});
+				continue;
+			}
+			const localColumns = mapFieldNamesToColumns({
+				model,
+				physicalNames: input.physicalNames,
+				fieldNames: parsedRelation.fields,
+				source,
+				diagnostics,
+				span: relationAttribute.relation.span,
+				entityLabel: `Relation field "${model.name}.${relationAttribute.field.name}"`
+			});
+			if (!localColumns) continue;
+			if (relationNullabilityMismatch(relationAttribute.field, localColumns, resolvedFields)) {
+				diagnostics.push(relationNullabilityMismatchDiagnostic(model.name, relationAttribute, source));
+				continue;
+			}
+			const referencedColumns = parsedRelation.references;
+			if (localColumns.length !== referencedColumns.length) {
+				diagnostics.push({
+					code: "PSL_INVALID_RELATION_ATTRIBUTE",
+					message: `Relation field "${model.name}.${relationAttribute.field.name}" must provide the same number of fields and references`,
+					...source.at(relationAttribute.relation.span)
+				});
+				continue;
+			}
+			const onDelete = parsedRelation.onDelete ? normalizeReferentialAction(parsedRelation.onDelete) : void 0;
+			const onUpdate = parsedRelation.onUpdate ? normalizeReferentialAction(parsedRelation.onUpdate) : void 0;
+			const crossTargetNamespaceId = fieldTypeNamespaceId ?? UNBOUND_NAMESPACE_ID;
+			const extContract = extContractForSpace;
+			const resolvedTable = extContract.domain.namespaces[crossTargetNamespaceId]?.models[fieldTypeName]?.storage["table"];
+			if (typeof resolvedTable !== "string") {
+				const availableModels = Object.keys(extContract.domain.namespaces[crossTargetNamespaceId]?.models ?? {}).join(", ") || "(none)";
+				diagnostics.push({
+					code: "PSL_UNKNOWN_CROSS_SPACE_TARGET",
+					message: `Relation field "${model.name}.${relationAttribute.field.name}" references model "${fieldTypeName}" in namespace "${crossTargetNamespaceId}" of space "${fieldTypeContractSpaceId}", but that model was not found in the extension contract. Available models: ${availableModels}`,
+					...source.at(relationAttribute.field.span),
+					data: {
+						space: fieldTypeContractSpaceId,
+						namespace: crossTargetNamespaceId,
+						model: fieldTypeName
+					}
+				});
+				continue;
+			}
+			const crossTargetTableName = resolvedTable;
+			foreignKeyNodes.push({
+				columns: localColumns,
+				references: {
+					model: fieldTypeName,
+					table: crossTargetTableName,
+					columns: referencedColumns,
+					namespaceId: crossTargetNamespaceId,
+					spaceId: fieldTypeContractSpaceId
+				},
+				...ifDefined("name", parsedRelation.map),
+				...ifDefined("onDelete", onDelete),
+				...ifDefined("onUpdate", onUpdate),
+				...ifDefined("index", parsedRelation.index)
+			});
+			if (typeof parsedRelation.index === "string") relationIndexLocations.push({
+				namespaceId: modelNamespaceId,
+				tableName,
+				columns: localColumns,
+				index: parsedRelation.index,
+				location: source.at(relationAttribute.relation.span)
+			});
+			resultCrossSpaceRelations.push({
+				fieldName: relationAttribute.field.name,
+				toModel: fieldTypeName,
+				toTable: crossTargetTableName,
+				cardinality: "N:1",
+				nullable: relationAttribute.field.optional,
+				spaceId: fieldTypeContractSpaceId,
+				namespaceId: crossTargetNamespaceId,
+				on: {
+					parentTable: tableName,
+					parentColumns: localColumns,
+					childTable: crossTargetTableName,
+					childColumns: referencedColumns
+				}
+			});
+			continue;
+		}
+		const qualifiedTypeName = fieldTypeNamespaceId ? `${fieldTypeNamespaceId}.${fieldTypeName}` : fieldTypeName;
+		const typeReference = typeReferenceNode(relationAttribute.field);
+		const targetResolution = typeReference === void 0 ? void 0 : input.binder.symbolForNode(typeReference);
+		if (targetResolution?.kind === "unresolved") continue;
+		if (targetResolution?.kind !== "model") {
+			const foundKind = targetResolution === void 0 ? void 0 : relationTargetKindLabel(targetResolution);
+			diagnostics.push({
+				code: "PSL_INVALID_RELATION_TARGET",
+				message: foundKind === void 0 ? `Relation field "${model.name}.${relationAttribute.field.name}" references unknown model "${qualifiedTypeName}"` : `Relation field "${model.name}.${relationAttribute.field.name}" references ${foundKind} "${qualifiedTypeName}"; a relation target must be a model`,
+				...source.at(relationAttribute.field.span)
+			});
+			continue;
+		}
+		const targetModel = targetResolution.symbol;
+		const targetNamespaceId = targetResolution.namespace.id;
+		const parsedRelation = interpretRelationAttribute({
+			selfModel: model,
+			field: relationAttribute.field,
+			specContext: fieldSpecContext({
+				...specContext,
+				field: relationAttribute.field,
+				binder: input.binder
+			}),
+			symbols: input.symbolTable,
+			sources: input.sources,
+			binder: input.binder,
+			diagnostics
+		});
+		if (!parsedRelation) continue;
+		if (!parsedRelation.fields || !parsedRelation.references) {
+			diagnostics.push({
+				code: "PSL_INVALID_RELATION_ATTRIBUTE",
+				message: `Relation field "${model.name}.${relationAttribute.field.name}" requires fields and references arguments`,
+				...source.at(relationAttribute.relation.span)
+			});
+			continue;
+		}
+		const localColumns = mapFieldNamesToColumns({
+			model,
+			physicalNames: input.physicalNames,
+			fieldNames: parsedRelation.fields,
+			source,
+			diagnostics,
+			span: relationAttribute.relation.span,
+			entityLabel: `Relation field "${model.name}.${relationAttribute.field.name}"`
+		});
+		if (!localColumns) continue;
+		if (relationNullabilityMismatch(relationAttribute.field, localColumns, resolvedFields)) {
+			diagnostics.push(relationNullabilityMismatchDiagnostic(model.name, relationAttribute, source));
+			resultInvalidFkPairings.push({
+				declaringModel: model,
+				targetModel,
+				...ifDefined("relationName", parsedRelation.name)
+			});
+			continue;
+		}
+		const referencedColumns = mapFieldNamesToColumns({
+			model: targetModel,
+			physicalNames: input.physicalNames,
+			fieldNames: parsedRelation.references,
+			source,
+			diagnostics,
+			span: relationAttribute.relation.span,
+			entityLabel: `Relation field "${model.name}.${relationAttribute.field.name}"`
+		});
+		if (!referencedColumns) continue;
+		if (localColumns.length !== referencedColumns.length) {
+			diagnostics.push({
+				code: "PSL_INVALID_RELATION_ATTRIBUTE",
+				message: `Relation field "${model.name}.${relationAttribute.field.name}" must provide the same number of fields and references`,
+				...source.at(relationAttribute.relation.span)
+			});
+			continue;
+		}
+		const onDelete = parsedRelation.onDelete ? normalizeReferentialAction(parsedRelation.onDelete) : void 0;
+		const onUpdate = parsedRelation.onUpdate ? normalizeReferentialAction(parsedRelation.onUpdate) : void 0;
+		const targetTableName = storageName(targetModel, input.physicalNames);
+		foreignKeyNodes.push({
+			columns: localColumns,
+			references: {
+				model: targetModel.name,
+				table: targetTableName,
+				columns: referencedColumns,
+				namespaceId: targetNamespaceId
+			},
+			...ifDefined("name", parsedRelation.map),
+			...ifDefined("onDelete", onDelete),
+			...ifDefined("onUpdate", onUpdate),
+			...ifDefined("index", parsedRelation.index)
+		});
+		if (typeof parsedRelation.index === "string") relationIndexLocations.push({
+			namespaceId: modelNamespaceId,
+			tableName,
+			columns: localColumns,
+			index: parsedRelation.index,
+			location: source.at(relationAttribute.relation.span)
+		});
+		resultFkRelationMetadata.push({
+			declaringModelName: model,
+			declaringFieldName: relationAttribute.field.name,
+			declaringTableName: tableName,
+			...ifDefined("declaringNamespaceId", modelNamespaceId),
+			targetModelName: targetModel,
+			targetTableName,
+			...ifDefined("targetNamespaceId", targetNamespaceId),
+			...ifDefined("relationName", parsedRelation.name),
+			nullable: relationAttribute.field.optional,
+			localColumns,
+			referencedColumns
+		});
+	}
+	return {
+		modelNode: {
+			modelName: model.name,
+			tableName,
+			fields: resolvedFields.map((resolvedField) => {
+				const common = {
+					fieldName: resolvedField.field.name,
+					columnName: resolvedField.columnName,
+					descriptor: resolvedField.descriptor,
+					nullable: resolvedField.nullable,
+					...ifDefined("many", resolvedField.many),
+					...ifDefined("elementNullable", resolvedField.many ? resolvedField.elementNullable === true : void 0),
+					...ifDefined("default", resolvedField.defaultValue),
+					...ifDefined("executionDefaults", resolvedField.executionDefaults)
+				};
+				if (resolvedField.valueObjectTypeName !== void 0) return {
+					...common,
+					valueObjectName: resolvedField.valueObjectTypeName
+				};
+				return {
+					...common,
+					...ifDefined("enumTypeHandle", resolvedField.enumTypeHandle)
+				};
+			}),
+			...ifDefined("id", primaryKey),
+			...uniqueConstraints.length > 0 ? { uniques: uniqueConstraints } : {},
+			...indexNodes.length > 0 ? { indexes: indexNodes } : {},
+			...checkNodes.length > 0 ? { checks: checkNodes } : {},
+			...foreignKeyNodes.length > 0 ? { foreignKeys: foreignKeyNodes } : {},
+			...ifDefined("control", controlPolicy)
+		},
+		fkRelationMetadata: resultFkRelationMetadata,
+		relationIndexLocations,
+		invalidFkPairings: resultInvalidFkPairings,
+		crossSpaceRelations: resultCrossSpaceRelations,
+		backrelationCandidates: resultBackrelationCandidates,
+		modelAttributeEntities
+	};
+}
+function buildValueObjectNodes(input) {
+	const { compositeTypes, enumHandles, diagnostics, sources, binder } = input;
+	return compositeTypes.map((compositeType) => {
+		for (const attribute of compositeType.attributes) diagnostics.push({
+			code: "PSL_UNSUPPORTED_COMPOSITE_TYPE_ATTRIBUTE",
+			message: `Composite type "${compositeType.name}" uses attribute "@@${attribute.name}", which a composite type does not take`,
+			...diagnosticSource(sources, compositeType.node.syntax).at(attribute.span)
+		});
+		const fields = [];
+		for (const field of Object.values(compositeType.fields)) {
+			for (const attribute of field.attributes) diagnostics.push({
+				code: "PSL_UNSUPPORTED_FIELD_ATTRIBUTE",
+				message: `Member "${field.name}" of composite type "${compositeType.name}" uses attribute "@${attribute.name}", which a composite type member does not take`,
+				...diagnosticSource(sources, field.node.syntax).at(attribute.span)
+			});
+			const common = {
+				fieldName: field.name,
+				nullable: field.optional,
+				...ifDefined("many", field.list ? true : void 0),
+				...ifDefined("elementNullable", field.list ? field.elementOptional : void 0)
+			};
+			const fieldTypeReference = typeReferenceNode(field);
+			const fieldTypeResolution = fieldTypeReference === void 0 ? void 0 : binder.symbolForNode(fieldTypeReference);
+			if (fieldTypeResolution?.kind === "compositeType") {
+				fields.push({
+					...common,
+					valueObjectName: fieldTypeResolution.symbol.name
+				});
+				continue;
+			}
+			const resolved = resolveFieldTypeDescriptor({
+				field,
+				resolution: fieldTypeResolution,
+				enumTypeDescriptors: input.enumTypeDescriptors,
+				typeAliases: input.typeAliases,
+				diagnostics,
+				sources,
+				entityLabel: `Field "${compositeType.name}.${field.name}"`,
+				namespaceId: input.defaultNamespaceId,
+				namespaceExtensionEntities: input.namespaceExtensionEntities,
+				binder,
+				codecLookup: input.codecLookup,
+				dataTypes: input.dataTypes
+			});
+			if (!resolved.ok) continue;
+			const { descriptor } = resolved;
+			if (descriptor.valueSet !== void 0) {
+				diagnostics.push({
+					code: "PSL_UNSUPPORTED_FIELD_TYPE",
+					message: `Field "${compositeType.name}.${field.name}" is typed by the storage enum "${descriptor.valueSet.entityName}", which a composite type member cannot use: a member has no column to store it in. Use a PSL enum instead.`,
+					...diagnosticSource(sources, field.node.syntax).at(field.span)
+				});
+				continue;
+			}
+			const typeAlias = input.typeAliases.ofResolution(fieldTypeResolution);
+			for (const attribute of typeAlias === void 0 ? [] : typeAliasAttributeNames(typeAlias.alias)) diagnostics.push({
+				code: "PSL_UNSUPPORTED_FIELD_ATTRIBUTE",
+				message: `Member "${field.name}" of composite type "${compositeType.name}" is typed by the type alias "${field.typeName}", which carries "@${attribute}", an attribute a composite type member does not take`,
+				...diagnosticSource(sources, field.node.syntax).at(field.span)
+			});
+			fields.push({
+				...common,
+				descriptor: {
+					codecId: descriptor.codecId,
+					...ifDefined("typeParams", descriptor.typeParams)
+				},
+				...ifDefined("enumTypeHandle", fieldTypeResolution?.kind === "block" ? enumHandles.get(fieldTypeResolution.symbol) : typeAlias?.enumHandle)
+			});
+		}
+		return {
+			name: compositeType.name,
+			fields
+		};
+	});
+}
+function collectPolymorphismDeclarations(identities, symbols, sources, binder, specContextFor, discriminatorFieldOf, codecLookup, dataTypes, diagnostics) {
+	const pendingDiscriminators = /* @__PURE__ */ new Map();
+	const pendingBaseDeclarations = /* @__PURE__ */ new Map();
+	const reported = { discriminators: /* @__PURE__ */ new Set() };
+	for (const { model, namespaceId, key } of identities.values()) {
+		const source = diagnosticSource(sources, model.node.syntax);
+		const discriminatorNode = getAttribute(model.attributes, "discriminator")?.node;
+		if (discriminatorNode !== void 0) {
+			const parsed = interpretModelAttribute({
+				node: discriminatorNode,
+				symbols,
+				spec: sqlAttributeSpecs.model.discriminator(specContextFor(model)),
+				model,
+				sources,
+				binder,
+				diagnostics
+			});
+			if (parsed !== void 0) pendingDiscriminators.set(key, {
+				declaration: {
+					model,
+					fieldName: parsed.field,
+					span: nodePslSpan(discriminatorNode.syntax, sources),
+					source
+				},
+				field: discriminatorFieldOf(model, parsed.field)
+			});
+			else reported.discriminators.add(key);
+		}
+		const baseNode = getAttribute(model.attributes, "base")?.node;
+		if (baseNode !== void 0) {
+			const parsed = interpretModelAttribute({
+				node: baseNode,
+				symbols,
+				spec: sqlAttributeSpecs.model.base(specContextFor(model)),
+				model,
+				sources,
+				binder,
+				diagnostics
+			});
+			if (parsed !== void 0) {
+				const base = identities.get(parsed.base.declaration);
+				invariant(base !== void 0, `Resolved base model "${parsed.base.declaration.name}" is missing from the collected model identities`);
+				pendingBaseDeclarations.set(key, {
+					model,
+					namespaceId,
+					source,
+					base,
+					written: parsed.value,
+					span: nodePslSpan(baseNode.syntax, sources)
+				});
+			}
+		}
+	}
+	const discriminatorDeclarations = /* @__PURE__ */ new Map();
+	const values = /* @__PURE__ */ new Map();
+	for (const [baseKey, { declaration, field }] of pendingDiscriminators) {
+		const accepted = acceptedDiscriminator(declaration, field, [...pendingBaseDeclarations].filter(([, base]) => base.base.key === baseKey), {
+			codecLookup,
+			dataTypes,
+			diagnostics
+		});
+		if (accepted === void 0) {
+			reported.discriminators.add(baseKey);
+			continue;
+		}
+		discriminatorDeclarations.set(baseKey, declaration);
+		for (const [variantKey, value] of accepted) values.set(variantKey, value);
+	}
+	const baseDeclarations = /* @__PURE__ */ new Map();
+	for (const [key, { model, namespaceId, source, base, span }] of pendingBaseDeclarations) baseDeclarations.set(key, {
+		model,
+		namespaceId,
+		source,
+		base,
+		span,
+		value: values.get(key)
+	});
+	return {
+		discriminatorDeclarations,
+		baseDeclarations,
+		reported
+	};
+}
+/**
+* The stored discriminator value of each variant, by the variant's key, when the discriminator rule accepts the field; `undefined` when it refuses the field. A refusal is reported at the `@@discriminator` attribute or at the `@@base` value it is about.
+*/
+function acceptedDiscriminator(declaration, discriminatorField, bases, input) {
+	const { model, fieldName } = declaration;
+	const baseByKey = new Map(bases);
+	const decision = applyDiscriminatorRule({
+		field: discriminatorField.field,
+		variants: bases.map(([key, base]) => ({
+			key,
+			written: writtenBaseValue(base)
+		})),
+		subject: `Field "${model.name}.${fieldName}"`,
+		codecLookup: input.codecLookup,
+		dataTypes: input.dataTypes
+	});
+	const baseOf = (variantKey) => {
+		const base = baseByKey.get(variantKey);
+		invariant(base !== void 0, "A refused @@base value belongs to a collected variant");
+		return base;
+	};
+	const subject = {
+		modelName: model.name,
+		fieldName,
+		typeName: model.fields[fieldName]?.typeName ?? fieldName,
+		enumName: discriminatorField.enumName,
+		variantName: (variantKey) => baseOf(variantKey).model.name
+	};
+	for (const refusal of decision.fieldRefusals) input.diagnostics.push({
+		code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
+		message: describeDiscriminatorRefusal(refusal, subject),
+		...declaration.source.at(declaration.span)
+	});
+	if (decision.fieldRefusals.length > 0) return void 0;
+	for (const refusal of decision.variantRefusals) {
+		const base = baseOf(refusal.key);
+		input.diagnostics.push({
+			...refusal.kind === "unreadable" ? refusal.refusal : {
+				code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
+				message: describeDiscriminatorRefusal(refusal, subject)
+			},
+			...base.source.at(base.written.span)
+		});
+	}
+	return decision.values;
+}
+/** A `@@base` value as it is written; the grammar reads only a quoted string there. */
+function writtenBaseValue(base) {
+	if (base.written.written === void 0) throw new InternalError("A @@base value is a quoted string, never a tagged literal.");
+	return base.written.written;
+}
+function modelLabel(namespaceId, modelName, qualified) {
+	return qualified ? `${namespaceId}.${modelName}` : modelName;
+}
+function resolvePolymorphism(models, physicalNames, discriminatorDeclarations, baseDeclarations, reported, syntheticPkFieldsByVariant, stiBaseFieldsByBase, diagnostics) {
+	let patched = models;
+	for (const [baseKey, fieldNames] of stiBaseFieldsByBase) {
+		const baseModel = patched[baseKey];
+		if (!baseModel || fieldNames.length === 0) continue;
+		patched = {
+			...patched,
+			[baseKey]: stripStorageOnlyDomainFields(baseModel, fieldNames)
+		};
+	}
+	for (const [modelKey, decl] of discriminatorDeclarations) {
+		const modelName = decl.model.name;
+		if (baseDeclarations.has(modelKey)) {
+			diagnostics.push({
+				code: "PSL_DISCRIMINATOR_AND_BASE",
+				message: `Model "${modelName}" cannot have both @@discriminator and @@base`,
+				...decl.source.at(decl.span)
+			});
+			continue;
+		}
+		const model = patched[modelKey];
+		if (!model) continue;
+		const variants = {};
+		for (const baseDecl of baseDeclarations.values()) {
+			if (baseDecl.base.key !== modelKey || baseDecl.value === void 0) continue;
+			const variantName = baseDecl.model.name;
+			const existingVariant = variants[baseDecl.value];
+			if (existingVariant) {
+				const qualified = existingVariant.namespace !== baseDecl.base.namespaceId || baseDecl.namespaceId !== baseDecl.base.namespaceId;
+				diagnostics.push({
+					code: "PSL_DUPLICATE_DISCRIMINATOR_VALUE",
+					message: `Discriminator value "${baseDecl.value}" is used by both "${modelLabel(existingVariant.namespace, existingVariant.model, qualified)}" and "${modelLabel(baseDecl.namespaceId, variantName, qualified)}" on base model "${modelLabel(baseDecl.base.namespaceId, modelName, qualified)}"`,
+					...baseDecl.source.at(baseDecl.span)
+				});
+				continue;
+			}
+			variants[baseDecl.value] = crossRef(variantName, baseDecl.namespaceId);
+		}
+		if (Object.keys(variants).length === 0) {
+			if ([...baseDeclarations.values()].some((baseDecl) => baseDecl.base.key === modelKey && baseDecl.value === void 0)) continue;
+			diagnostics.push({
+				code: "PSL_ORPHANED_DISCRIMINATOR",
+				message: `Model "${modelName}" has @@discriminator but no variant models declare @@base(${modelName}, ...)`,
+				...decl.source.at(decl.span)
+			});
+			continue;
+		}
+		patched = {
+			...patched,
+			[modelKey]: {
+				...model,
+				discriminator: { field: decl.fieldName },
+				variants
+			}
+		};
+	}
+	for (const [variantKey, baseDecl] of baseDeclarations) {
+		const baseName = baseDecl.base.model.name;
+		if (!discriminatorDeclarations.has(baseDecl.base.key)) {
+			if (reported.discriminators.has(baseDecl.base.key)) continue;
+			const qualified = baseDecl.namespaceId !== baseDecl.base.namespaceId;
+			const variantLabel = modelLabel(baseDecl.namespaceId, baseDecl.model.name, qualified);
+			const baseLabel = modelLabel(baseDecl.base.namespaceId, baseName, qualified);
+			diagnostics.push({
+				code: "PSL_ORPHANED_BASE",
+				message: `Model "${variantLabel}" declares @@base(${baseLabel}, ...) but "${baseLabel}" has no @@discriminator`,
+				...baseDecl.source.at(baseDecl.span)
+			});
+			continue;
+		}
+		if (discriminatorDeclarations.has(variantKey)) continue;
+		const variantModel = patched[variantKey];
+		if (!variantModel) continue;
+		const resolvedTable = storageName(getAttribute(baseDecl.model.attributes, "map") !== void 0 ? baseDecl.model : baseDecl.base.model, physicalNames);
+		const patchedVariant = {
+			...variantModel,
+			base: crossRef(baseName, baseDecl.base.namespaceId),
+			...resolvedTable ? { storage: {
+				...variantModel.storage,
+				table: resolvedTable
+			} } : {}
+		};
+		patched = {
+			...patched,
+			[variantKey]: stripStorageOnlyDomainFields(patchedVariant, syntheticPkFieldsByVariant.get(variantKey) ?? [])
+		};
+	}
+	return patched;
+}
+/**
+* Multi-table-inheritance variants (`@@base` + their own `@@map`) live in a
+* separate table from their base. The ORM joins that table to the base on the
+* shared primary key (`base.id = variant.id`), so the variant storage table
+* must carry the base PK column even though the variant domain model declares
+* only its own fields. This enriches each MTI variant's `ModelNode` with that
+* link column, a primary key on it, and a FK back to the base table.
+*
+* The link column is reported back per variant in `syntheticPkFieldsByVariant`
+* so the domain-model patch can drop it again — keeping the variant's domain
+* surface thin (its create/read inputs don't gain a redundant `id`) while the
+* storage table stays joinable. Single-table-inheritance variants (no own
+* table) are left untouched.
+*/
+function materializeMtiVariantStorageLinks(modelNodes, baseDeclarations, stiVariantKeys, defaultNamespaceId) {
+	const keyOf = (node) => modelCoordinateKey(node.namespaceId ?? defaultNamespaceId, node.modelName);
+	const nodeByModel = new Map(modelNodes.map((node) => [keyOf(node), node]));
+	const syntheticPkFieldsByVariant = /* @__PURE__ */ new Map();
+	return {
+		modelNodes: modelNodes.map((node) => {
+			const variantKey = keyOf(node);
+			const baseDecl = baseDeclarations.get(variantKey);
+			if (!baseDecl) return node;
+			const baseNode = nodeByModel.get(baseDecl.base.key);
+			if (!baseNode) return node;
+			if (stiVariantKeys.has(variantKey)) return node;
+			const basePrimaryKey = baseNode.id;
+			if (!basePrimaryKey || basePrimaryKey.columns.length === 0) return node;
+			const existingColumns = new Set(node.fields.map((field) => field.columnName));
+			const linkFields = [];
+			for (const pkColumn of basePrimaryKey.columns) {
+				if (existingColumns.has(pkColumn)) continue;
+				const baseField = baseNode.fields.find((field) => field.columnName === pkColumn);
+				if (!baseField) continue;
+				linkFields.push({
+					fieldName: baseField.fieldName,
+					columnName: pkColumn,
+					descriptor: baseField.descriptor,
+					nullable: false,
+					many: false
+				});
+			}
+			if (linkFields.length === 0) return node;
+			syntheticPkFieldsByVariant.set(variantKey, linkFields.map((field) => field.fieldName));
+			const foreignKey = {
+				columns: basePrimaryKey.columns,
+				references: {
+					model: baseNode.modelName,
+					table: baseNode.tableName,
+					columns: basePrimaryKey.columns,
+					...ifDefined("namespaceId", baseNode.namespaceId)
+				},
+				constraint: true,
+				onDelete: "cascade"
+			};
+			return {
+				...node,
+				fields: [...linkFields, ...node.fields],
+				id: { columns: basePrimaryKey.columns },
+				foreignKeys: [...node.foreignKeys ?? [], foreignKey]
+			};
+		}),
+		syntheticPkFieldsByVariant
+	};
+}
+/**
+* Single-table-inheritance variants (`@@base` with no own `@@map`) share the
+* base table: `resolvePolymorphism` points the variant's `storage.table` at the
+* base, and the ORM reads variant-declared fields straight off the base table.
+* For that to validate and round-trip, the base storage table must physically
+* carry every STI variant's declared columns. This enriches the base
+* `ModelNode` with those columns.
+*
+* The materialised columns are always nullable in storage: the base table hosts
+* every variant's rows, so a column a variant declares as required is still
+* NULL on sibling-variant rows. The variant's domain field keeps its declared
+* nullability — required-in-domain / nullable-in-storage is the intended STI
+* shape.
+*
+* Collisions (two variants declaring the same column, or a variant column name
+* clashing with a base column) are resolved skip-if-exists here, mirroring the
+* MTI link guard; surfacing them as diagnostics is tracked separately
+* (TML-2827).
+*/
+function materializeStiVariantStorageColumns(modelNodes, baseDeclarations, stiVariantKeys, defaultNamespaceId) {
+	if (stiVariantKeys.size === 0) return {
+		modelNodes: [...modelNodes],
+		stiBaseFieldsByBase: /* @__PURE__ */ new Map()
+	};
+	const keyOf = (node) => modelCoordinateKey(node.namespaceId ?? defaultNamespaceId, node.modelName);
+	const nodeByModel = new Map(modelNodes.map((node) => [keyOf(node), node]));
+	const stiColumnsByBase = /* @__PURE__ */ new Map();
+	for (const variantKey of stiVariantKeys) {
+		const variantNode = nodeByModel.get(variantKey);
+		const baseDecl = baseDeclarations.get(variantKey);
+		if (!variantNode || !baseDecl) continue;
+		const baseNode = nodeByModel.get(baseDecl.base.key);
+		if (!baseNode) continue;
+		const baseColumns = new Set(baseNode.fields.map((field) => field.columnName));
+		const claimed = stiColumnsByBase.get(baseDecl.base.key) ?? [];
+		const claimedColumns = new Set(claimed.map((field) => field.columnName));
+		for (const field of variantNode.fields) {
+			if (baseColumns.has(field.columnName) || claimedColumns.has(field.columnName)) continue;
+			claimedColumns.add(field.columnName);
+			claimed.push({
+				...field,
+				nullable: true
+			});
+		}
+		stiColumnsByBase.set(baseDecl.base.key, claimed);
+	}
+	const stiBaseFieldsByBase = /* @__PURE__ */ new Map();
+	for (const [baseName, columns] of stiColumnsByBase) stiBaseFieldsByBase.set(baseName, columns.map((field) => field.fieldName));
+	return {
+		modelNodes: modelNodes.map((node) => {
+			if (stiVariantKeys.has(keyOf(node))) return {
+				...node,
+				sharesBaseTable: true
+			};
+			const stiColumns = stiColumnsByBase.get(keyOf(node));
+			if (!stiColumns || stiColumns.length === 0) return node;
+			return {
+				...node,
+				fields: [...node.fields, ...stiColumns]
+			};
+		}),
+		stiBaseFieldsByBase
+	};
+}
+/**
+* Drop the storage-only link fields (added by
+* {@link materializeMtiVariantStorageLinks}) from a variant's domain model, so
+* the domain surface stays thin while the storage table keeps the link column.
+*/
+function stripStorageOnlyDomainFields(model, fieldNames) {
+	if (fieldNames.length === 0) return model;
+	const fields = { ...model.fields };
+	for (const name of fieldNames) delete fields[name];
+	const storage = blindCast(model.storage);
+	const storageFields = { ...storage.fields };
+	for (const name of fieldNames) delete storageFields[name];
+	return {
+		...model,
+		fields,
+		storage: {
+			...storage,
+			fields: storageFields
+		}
+	};
+}
+function backrelationTargetSymbol(field, binder) {
+	const typeReference = typeReferenceNode(field);
+	if (typeReference === void 0) return void 0;
+	const resolution = binder.symbolForNode(typeReference);
+	return resolution?.kind === "model" ? resolution.symbol : void 0;
+}
+function relationTargetKindLabel(resolution) {
+	switch (resolution.kind) {
+		case "compositeType": return "composite type";
+		case "namedType": return "type alias";
+		case "block": return resolution.symbol.keyword;
+		case "namespace":
+		case "contributedNamespace": return "namespace";
+		case "contributedType": return "type";
+		default: return;
+	}
+}
+/**
+* The relation a refusal of `index: "<name>"` belongs to, and the message to report there; `undefined` for every other error.
+*/
+function relationIndexRefusal(error, locations) {
+	if (!isStructuredError(error) || error.meta?.["reason"] !== "foreign-key-index-unresolved") return;
+	const { namespaceId, tableName, columns, index } = error.meta ?? {};
+	const at = locations.find((candidate) => candidate.namespaceId === namespaceId && candidate.tableName === tableName && candidate.index === index && Array.isArray(columns) && candidate.columns.length === columns.length && candidate.columns.every((column, position) => column === columns[position]));
+	if (at === void 0) return void 0;
+	return {
+		at,
+		message: error.fix === void 0 ? error.message : `${error.message} ${error.fix}`
+	};
+}
+function interpretPslDocumentToSqlContract(input) {
+	if (!input.target) throw new InternalError("PSL interpretation requires an explicit target context from composition.");
+	if (!input.scalarColumnDescriptors) throw new InternalError("PSL interpretation requires composed scalar type descriptors.");
+	const [anchorDocument] = input.documents;
+	assertDefined(anchorDocument, "interpretPslDocumentToSqlContract requires at least one document");
+	const source = diagnosticSource(input.sources, anchorDocument.syntax);
+	const diagnostics = createPslDiagnosticCollector(input.sources);
+	const modelAttributesByName = buildModelAttributesByName(input.authoringContributions);
+	const contributedModelSpecs = modelAttributeSpecsFrom(modelAttributesByName);
+	const composedPslBlockDescriptors = input.authoringContributions?.pslBlockDescriptors ?? {};
+	const { binder, dataTypes } = input;
+	const defaultFunctionRegistry = input.controlMutationDefaults?.defaultFunctionRegistry ?? /* @__PURE__ */ new Map();
+	const { generatorFunctions } = input;
+	const specContextFor = (model) => modelSpecContext({
+		symbols: input.symbolTable,
+		model,
+		defaultFunctionRegistry,
+		generatorFunctions,
+		dataTypes
+	});
+	const namespaceSymbols = Object.values(input.symbolTable.namespaces);
+	validateNamespaceBlocksForSqlTarget({
+		namespaces: namespaceSymbols,
+		target: input.target,
+		source,
+		sources: input.sources,
+		binder,
+		diagnostics
+	});
+	const { parsedBlocks, diagnostics: blockDiagnostics } = interpretExtensionBlocks({
+		symbolTable: input.symbolTable,
+		sources: input.sources,
+		pslBlockDescriptors: composedPslBlockDescriptors,
+		binder,
+		dataTypes
+	});
+	diagnostics.push(...blockDiagnostics);
+	validateBlockModelAttributeRequirements({
+		parsedBlocks,
+		pslBlockDescriptors: composedPslBlockDescriptors,
+		sources: input.sources,
+		diagnostics
+	});
+	const models = [];
+	const modelEntries = [];
+	const compositeTypes = [];
+	for (const namespace of namespaceSymbols) {
+		for (const model of Object.values(namespace.models)) {
+			models.push(model);
+			modelEntries.push({
+				model,
+				namespaceId: namespace.id
+			});
+		}
+		compositeTypes.push(...Object.values(namespace.compositeTypes));
+	}
+	const physicalNames = /* @__PURE__ */ new Map();
+	for (const model of models) {
+		const mapNode = getAttribute(model.attributes, "map")?.node;
+		const mapped = mapNode === void 0 ? void 0 : interpretModelAttribute({
+			node: mapNode,
+			symbols: input.symbolTable,
+			spec: sqlAttributeSpecs.model.map(specContextFor(model)),
+			model,
+			sources: input.sources,
+			binder,
+			diagnostics
+		});
+		physicalNames.set(model, mapped?.name ?? defaultTableName(model.name));
+		for (const field of Object.values(model.fields)) {
+			const mapNode = getAttribute(field.attributes, "map")?.node;
+			const mapped = mapNode === void 0 ? void 0 : interpretFieldAttribute({
+				node: mapNode,
+				symbols: input.symbolTable,
+				spec: sqlAttributeSpecs.field.map(fieldSpecContext({
+					...specContextFor(model),
+					field,
+					binder
+				})),
+				model,
+				field,
+				sources: input.sources,
+				binder,
+				diagnostics
+			});
+			physicalNames.set(field, mapped?.name ?? field.name);
+		}
+	}
+	const defaultNamespaceId = input.symbolTable.defaultNamespace.id;
+	const composedExtensions = new Set(input.composedExtensions ?? []);
+	const composedExtensionContracts = input.composedExtensionContracts;
+	const isEnumBlock = (block) => block.keyword === "enum";
+	const legitimateBlockKeywords = claimedBlockKeywords(input.authoringContributions?.pslBlockDescriptors);
+	const reportUnsupportedTopLevelBlock = (block) => {
+		diagnostics.push(unsupportedBlockDiagnostic(block, input.sources));
+	};
+	const topLevelEnums = [];
+	const extensionBlocksByNamespace = /* @__PURE__ */ new Map();
+	for (const namespace of namespaceSymbols) {
+		const extensionBlocks = {};
+		extensionBlocksByNamespace.set(namespace, extensionBlocks);
+		for (const [blockName, block] of Object.entries(namespace.blocks)) {
+			const writtenNamespace = block.node.syntax.findAncestor(NamespaceDeclarationAst.cast);
+			if (writtenNamespace === void 0) {
+				if (!legitimateBlockKeywords.has(block.keyword)) reportUnsupportedTopLevelBlock(block);
+				else if (isEnumBlock(block)) topLevelEnums.push(block);
+				else extensionBlocks[blockName] = block;
+				continue;
+			}
+			extensionBlocks[blockName] = block;
+			if (isEnumBlock(block)) {
+				diagnostics.push({
+					code: "PSL_ENUM_NAMESPACE_NOT_SUPPORTED",
+					message: `enum "${block.name}" inside namespace "${writtenNamespace.name()?.name() ?? namespace.name}" is not supported; declare enum at the top level`,
+					...diagnosticSource(input.sources, block.node.syntax).at(nodePslSpan(block.node.syntax, input.sources))
+				});
+				continue;
+			}
+			if (!legitimateBlockKeywords.has(block.keyword)) reportUnsupportedTopLevelBlock(block);
+		}
+	}
+	const enumResult = processEnumDeclarations({
+		enumBlocks: topLevelEnums,
+		parsedBlocks,
+		source,
+		authoringContributions: input.authoringContributions,
+		entityContext: {
+			family: input.target.familyId,
+			target: input.target.targetId,
+			codecLookup: input.codecLookup,
+			dataTypes: input.dataTypes,
+			sourceId: source.sources.sourceFileFor(source.node).filename,
+			diagnostics: { push: (d) => {
+				diagnostics.pushExternal(blindCast(d));
+			} },
+			...ifDefined("enumInferenceCodecs", input.enumInferenceCodecs)
+		},
+		diagnostics
+	});
+	const allEnumTypeDescriptors = enumResult.enumTypeDescriptors;
+	const enumHandles = enumResult.enumHandles;
+	const validEnumHandles = Object.fromEntries(Array.from(enumHandles, ([symbol, handle]) => [symbol.name, handle]));
+	const entityTypesByDiscriminator = buildEntityTypesByDiscriminator(input.authoringContributions);
+	const authoringWarnings = [];
+	const extensionEntityContext = {
+		family: input.target.familyId,
+		target: input.target.targetId,
+		...ifDefined("enumInferenceCodecs", input.enumInferenceCodecs),
+		codecLookup: input.codecLookup,
+		dataTypes: input.dataTypes,
+		sourceId: source.sources.sourceFileFor(source.node).filename,
+		diagnostics: { push: (d) => {
+			diagnostics.pushExternal(blindCast(d));
+		} },
+		warnings: authoringWarnings
+	};
+	const namespaceIdByModel = new Map(modelEntries.map(({ model, namespaceId }) => [model, namespaceId]));
+	const modelCoordinateOf = (model) => {
+		const namespaceId = namespaceIdByModel.get(model);
+		return namespaceId === void 0 ? void 0 : {
+			namespaceId,
+			tableName: storageName(model, physicalNames)
+		};
+	};
+	const namespaceExtensionEntities = /* @__PURE__ */ new Map();
+	const fileExtensionEntityRows = (rows, blocks) => {
+		for (const row of rows) {
+			let entities = namespaceExtensionEntities.get(row.namespaceId);
+			if (entities === void 0) {
+				entities = {};
+				namespaceExtensionEntities.set(row.namespaceId, entities);
+			}
+			const slot = entities[row.entityKind] ?? {};
+			entities[row.entityKind] = slot;
+			if (Object.hasOwn(slot, row.key)) {
+				const block = Object.values(blocks).find((candidate) => candidate.name === row.key);
+				invariant(block !== void 0, "Lowered entity has an owning block");
+				diagnostics.pushUnlocated({
+					code: "PSL_DUPLICATE_EXTENSION_ENTITY",
+					message: `entries slot "${row.entityKind}" in namespace "${row.namespaceId}": entity "${row.key}" is declared more than once in the same namespace.`,
+					...diagnosticSource(input.sources, block.node.syntax).at()
+				});
+				continue;
+			}
+			slot[row.key] = row.entity;
+		}
+	};
+	for (const [namespace, extensionBlocks] of extensionBlocksByNamespace) fileExtensionEntityRows(lowerExtensionBlocksForNamespace(extensionBlocks, namespace.id, entityTypesByDiscriminator, extensionEntityContext, parsedBlocks, modelCoordinateOf, input.sources), extensionBlocks);
+	const defaultNsExtensionValueSets = namespaceExtensionEntities.get(defaultNamespaceId)?.["valueSet"];
+	if (defaultNsExtensionValueSets !== void 0) {
+		for (const name of Object.keys(defaultNsExtensionValueSets)) if (Object.hasOwn(validEnumHandles, name)) {
+			const enumSymbol = input.symbolTable.defaultNamespace.blocks[name];
+			invariant(enumSymbol !== void 0, "Domain enum has an owning block");
+			diagnostics.pushUnlocated({
+				code: "PSL_VALUE_SET_NAME_COLLISION",
+				message: `namespace "${defaultNamespaceId}": name "${name}" is declared both as a domain enum and as an extension entity that derives a value-set; rename one`,
+				...diagnosticSource(input.sources, enumSymbol.node.syntax).at()
+			});
+		}
+	}
+	const typeAliases = resolveNamedTypeDeclarations({
+		declarations: Object.values(input.symbolTable.namedTypes),
+		sources: input.sources,
+		symbolTable: input.symbolTable,
+		binder,
+		enumTypeDescriptors: allEnumTypeDescriptors,
+		enumHandles,
+		codecLookup: input.codecLookup,
+		defaultFunctionRegistry,
+		generatorFunctions,
+		dataTypes,
+		diagnostics,
+		authoringTypes: input.authoringContributions?.type
+	});
+	const modelNodes = /* @__PURE__ */ new Map();
+	const fkRelationMetadata = [];
+	const relationIndexLocations = [];
+	const invalidFkPairings = [];
+	const backrelationCandidates = [];
+	const crossSpaceRelationsByModel = /* @__PURE__ */ new Map();
+	const modelAttributeEntitiesByNamespace = /* @__PURE__ */ new Map();
+	const valueObjects = buildValueObjectNodes({
+		compositeTypes,
+		enumTypeDescriptors: allEnumTypeDescriptors,
+		enumHandles,
+		typeAliases,
+		diagnostics,
+		sources: input.sources,
+		defaultNamespaceId,
+		namespaceExtensionEntities,
+		codecLookup: input.codecLookup,
+		dataTypes: input.dataTypes,
+		binder
+	});
+	const valueObjectTypes = {
+		nodes: new Map(valueObjects.map((valueObject) => [valueObject.name, valueObject])),
+		declaredMembers: new Map(compositeTypes.map((compositeType) => [compositeType.name, new Set(Object.keys(compositeType.fields))]))
+	};
+	for (const { model, namespaceId } of modelEntries) {
+		const result = buildModelNodeFromPsl({
+			model,
+			physicalNames,
+			namespaceId,
+			valueObjectTypes,
+			enumTypeDescriptors: allEnumTypeDescriptors,
+			typeAliases,
+			composedExtensionContracts,
+			familyId: input.target.familyId,
+			targetId: input.target.targetId,
+			authoringContributions: input.authoringContributions,
+			defaultFunctionRegistry,
+			generatorFunctions,
+			dataTypes,
+			scalarColumnDescriptors: input.scalarColumnDescriptors,
+			sources: input.sources,
+			binder,
+			symbolTable: input.symbolTable,
+			diagnostics,
+			enumHandles,
+			capabilities: input.capabilities,
+			...namespaceExtensionEntities.size > 0 ? { namespaceExtensionEntities } : {},
+			codecLookup: input.codecLookup,
+			modelAttributesByName,
+			contributedModelAttributeSpecs: contributedModelSpecs,
+			parsedBlocks
+		});
+		modelNodes.set(model, {
+			...result.modelNode,
+			namespaceId
+		});
+		fkRelationMetadata.push(...result.fkRelationMetadata);
+		relationIndexLocations.push(...result.relationIndexLocations);
+		invalidFkPairings.push(...result.invalidFkPairings);
+		backrelationCandidates.push(...result.backrelationCandidates);
+		if (result.crossSpaceRelations.length > 0) {
+			const existing = crossSpaceRelationsByModel.get(model) ?? [];
+			crossSpaceRelationsByModel.set(model, [...existing, ...result.crossSpaceRelations]);
+		}
+		if (Object.keys(result.modelAttributeEntities).length > 0) {
+			const existingByAttribute = modelAttributeEntitiesByNamespace.get(namespaceId) ?? {};
+			for (const [attribute, keyed] of Object.entries(result.modelAttributeEntities)) existingByAttribute[attribute] = {
+				...existingByAttribute[attribute] ?? {},
+				...keyed
+			};
+			modelAttributeEntitiesByNamespace.set(namespaceId, existingByAttribute);
+		}
+	}
+	const { modelRelations, fkRelationsByPair, fkRelationsByDeclaringModel } = indexFkRelations({ fkRelationMetadata });
+	const modelIdColumns = /* @__PURE__ */ new Map();
+	const modelUniqueColumnSets = /* @__PURE__ */ new Map();
+	for (const [model, modelNode] of modelNodes) {
+		if (modelNode.id) modelIdColumns.set(model, modelNode.id.columns);
+		const uniqueColumnSets = [];
+		if (modelNode.id) uniqueColumnSets.push(modelNode.id.columns);
+		for (const unique of modelNode.uniques ?? []) uniqueColumnSets.push(unique.columns);
+		for (const index of modelNode.indexes ?? []) if (index.unique === true && index.columns !== void 0 && index.where === void 0) uniqueColumnSets.push(index.columns);
+		modelUniqueColumnSets.set(model, uniqueColumnSets);
+	}
+	applyBackrelationCandidates({
+		backrelationCandidates,
+		fkRelationsByPair,
+		invalidFkPairings,
+		fkRelationsByDeclaringModel,
+		modelIdColumns,
+		modelUniqueColumnSets,
+		modelRelations,
+		diagnostics,
+		sources: input.sources
+	});
+	for (const [modelName, relations] of crossSpaceRelationsByModel) {
+		const existing = modelRelations.get(modelName);
+		if (existing) existing.push(...relations);
+		else modelRelations.set(modelName, [...relations]);
+	}
+	const modelIdentities = new Map(modelEntries.map(({ model, namespaceId }) => [model, {
+		model,
+		namespaceId,
+		key: modelCoordinateKey(namespaceId, model.name)
+	}]));
+	const discriminatorFieldOf = (model, fieldName) => {
+		const field = modelNodes.get(model)?.fields.find((node) => node.fieldName === fieldName);
+		if (field === void 0 || !("columnName" in field)) return {
+			field: {
+				ref: void 0,
+				nullable: false,
+				many: false,
+				enumMembers: void 0
+			},
+			enumName: void 0
+		};
+		const handle = "enumTypeHandle" in field ? field.enumTypeHandle : void 0;
+		const encoded = handle === void 0 ? void 0 : encodeEnumMembers(handle, input.codecLookup);
+		return {
+			field: {
+				ref: {
+					codecId: field.descriptor.codecId,
+					...ifDefined("typeParams", field.descriptor.typeParams === void 0 ? void 0 : blindCast(field.descriptor.typeParams))
+				},
+				nullable: field.nullable,
+				many: field.many === true,
+				enumMembers: encoded?.ok ? encoded.value.map(({ value }) => value) : void 0
+			},
+			enumName: handle?.enumName
+		};
+	};
+	const { discriminatorDeclarations, baseDeclarations, reported } = collectPolymorphismDeclarations(modelIdentities, input.symbolTable, input.sources, binder, specContextFor, discriminatorFieldOf, input.codecLookup, dataTypes, diagnostics);
+	const stiVariantKeys = /* @__PURE__ */ new Set();
+	for (const [variantKey, declaration] of baseDeclarations) if (!(getAttribute(declaration.model.attributes, "map") !== void 0)) stiVariantKeys.add(variantKey);
+	for (const variantKey of stiVariantKeys) {
+		const baseDecl = baseDeclarations.get(variantKey);
+		invariant(baseDecl !== void 0, `stiVariantKeys is derived from baseDeclarations.keys(), so "${variantKey}" must have a base declaration`);
+		const variantName = baseDecl.model.name;
+		if (baseDecl.namespaceId !== baseDecl.base.namespaceId) {
+			const variantLabel = modelLabel(baseDecl.namespaceId, variantName, true);
+			const baseLabel = modelLabel(baseDecl.base.namespaceId, baseDecl.base.model.name, true);
+			diagnostics.push({
+				code: "PSL_BASE_IN_OTHER_NAMESPACE_WITHOUT_MAP",
+				message: `Model "${variantLabel}" declares @@base(${baseLabel}, ...) without @@map, so it would share the table of "${baseLabel}", which belongs to namespace "${baseDecl.base.namespaceId}". Add @@map to give "${variantLabel}" its own table.`,
+				...baseDecl.source.at(baseDecl.span)
+			});
+		}
+		for (const attribute of baseDecl.model.attributes) {
+			if (attribute.node.name()?.isSimpleName("check") !== true) continue;
+			diagnostics.push({
+				code: PSL_CHECK_ON_STI_VARIANT,
+				message: `Model "${variantName}" declares "@@check", but it shares its base model "${baseDecl.base.model.name}"'s storage table (single-table inheritance via @@base) and has no table of its own to declare a check constraint on. Declare the check on "${baseDecl.base.model.name}" instead.`,
+				...diagnosticSource(input.sources, attribute.node.syntax).at(nodePslSpan(attribute.node.syntax, input.sources))
+			});
+		}
+	}
+	const { modelNodes: mtiLinkedModelNodes, syntheticPkFieldsByVariant } = materializeMtiVariantStorageLinks(Array.from(modelNodes, ([symbol, model]) => ({
+		...model,
+		...modelRelations.has(symbol) ? { relations: [...modelRelations.get(symbol) ?? []].sort((left, right) => compareStrings(left.fieldName, right.fieldName)) } : {}
+	})), baseDeclarations, stiVariantKeys, defaultNamespaceId);
+	const { modelNodes: stiColumnModelNodes, stiBaseFieldsByBase } = materializeStiVariantStorageColumns(mtiLinkedModelNodes, baseDeclarations, stiVariantKeys, defaultNamespaceId);
+	if (diagnostics.length > 0 || (input.seedDiagnostics?.length ?? 0) > 0) return notOk({
+		summary: "PSL to SQL contract interpretation failed",
+		diagnostics: [...input.seedDiagnostics ?? [], ...diagnostics.toExternal()]
+	});
+	const { createNamespace } = input;
+	const createNamespaceWithExtensions = (nsInput) => {
+		const entities = namespaceExtensionEntities.get(nsInput.id);
+		const attributeEntities = modelAttributeEntitiesByNamespace.get(nsInput.id);
+		if (entities === void 0 && attributeEntities === void 0) return createNamespace(nsInput);
+		if (attributeEntities !== void 0) {
+			for (const slot of Object.keys(attributeEntities)) if (Object.hasOwn(nsInput.entries, slot) || entities !== void 0 && slot in entities) throw contractError("CONTRACT.PACK_CONTRIBUTION_INVALID", `entries slot "${slot}" in namespace "${nsInput.id}" is contributed by both a model attribute and a block/base entry kind. A model-attribute entries key must be unique across the namespace's entry kinds.`, { meta: {
+				slot,
+				namespaceId: nsInput.id
+			} });
+		}
+		const mergedValueSet = {
+			...nsInput.entries["valueSet"],
+			...entities?.["valueSet"]
+		};
+		const extended = {
+			...nsInput,
+			entries: {
+				...nsInput.entries,
+				...entities,
+				...attributeEntities,
+				...Object.keys(mergedValueSet).length > 0 ? { valueSet: mergedValueSet } : {}
+			}
+		};
+		return createNamespace(extended);
+	};
+	let contract;
+	try {
+		contract = buildSqlContractFromDefinition({
+			target: input.target,
+			capabilities: input.capabilities,
+			warnings: authoringWarnings.length > 0 ? authoringWarnings : void 0,
+			...ifDefined("extensions", buildComposedExtensionPackRefs(input.target, [...composedExtensions].sort(compareStrings), input.composedExtensionPackRefs)),
+			...Object.keys(validEnumHandles).length > 0 ? { enums: validEnumHandles } : {},
+			...namespaceExtensionEntities.size > 0 ? { namespaces: [...namespaceExtensionEntities.keys()] } : {},
+			createNamespace: createNamespaceWithExtensions,
+			...ifDefined("valueObjects", valueObjects.length > 0 ? valueObjects : void 0),
+			models: stiColumnModelNodes
+		}, input.codecLookup, input.dataTypes.lookup);
+	} catch (error) {
+		const refusal = relationIndexRefusal(error, relationIndexLocations);
+		if (refusal === void 0) throw error;
+		diagnostics.push({
+			code: "PSL_INVALID_RELATION_ATTRIBUTE",
+			message: refusal.message,
+			...refusal.at.location
+		});
+		return notOk({
+			summary: "PSL to SQL contract interpretation failed",
+			diagnostics: diagnostics.toExternal()
+		});
+	}
+	const modelsByCoordinate = {};
+	for (const [namespaceId, namespaceSlice] of Object.entries(contract.domain.namespaces)) for (const [modelName, model] of Object.entries(namespaceSlice.models)) {
+		const coordinate = modelCoordinateKey(namespaceId, modelName);
+		invariant(!Object.hasOwn(modelsByCoordinate, coordinate), `symbol table guarantees coordinate uniqueness; duplicate model "${namespaceId}.${modelName}" reached interpretation`);
+		modelsByCoordinate[coordinate] = model;
+	}
+	const polyDiagnostics = createPslDiagnosticCollector(input.sources);
+	const polymorphicModels = resolvePolymorphism(modelsByCoordinate, physicalNames, discriminatorDeclarations, baseDeclarations, reported, syntheticPkFieldsByVariant, stiBaseFieldsByBase, polyDiagnostics);
+	if (polyDiagnostics.length > 0) return notOk({
+		summary: "PSL to SQL contract interpretation failed",
+		diagnostics: polyDiagnostics.toExternal()
+	});
+	const filteredRoots = Object.fromEntries(Object.entries(contract.roots).filter(([, crossReference]) => !baseDeclarations.has(modelCoordinateKey(crossReference.namespace, crossReference.model))));
+	return ok({
+		...contract,
+		roots: filteredRoots,
+		domain: { namespaces: Object.fromEntries(Object.entries(contract.domain.namespaces).map(([namespaceId, namespaceSlice]) => [namespaceId, {
+			models: Object.fromEntries(Object.entries(namespaceSlice.models).map(([modelName, model]) => [modelName, polymorphicModels[modelCoordinateKey(namespaceId, modelName)] ?? model])),
+			...ifDefined("enum", namespaceSlice.enum),
+			...ifDefined("valueObjects", namespaceSlice.valueObjects)
+		}])) }
+	});
+}
+//#endregion
+export { normalizeReferentialAction as a, interpretPslDocumentToSqlContract as i, buildEntityTypesByDiscriminator as n, indexFkRelations as r, applyBackrelationCandidates as t };
+
+//# sourceMappingURL=interpreter-D5qk4B---CG0C7kdx.mjs.map