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

package/dist/{interpreter-BMMGMTBa-CT5iKl13.mjs → interpreter-gs7fSAIb-DuqyTGAB.mjs}

@@ -2,7 +2,7 @@ import { n as isAuthoredIndexInput } from "./index-naming-Cj1Anq-T-w1JL7-EM.mjs"
 import { n as providesPslEntityPlacement } from "./entity-handle-lowering-hook-B3atrRKX.mjs";
 import { t as deriveValueSetFromEntity } from "./value-set-derivation-hook-Di9JZ0X7.mjs";
 import { n as buildSqlContractFromDefinition } from "./derived-checks-Bsrdb2Wk-D4UfM06W.mjs";
-import { a as findModelAttributeNode, c as lowerDefaultFunctionWithRegistry, i as findFieldAttributeNode, l as modelAttributeSpecsFrom, n as createSqlBinder, o as interpretFieldAttribute, r as fieldSpecContext, s as interpretModelAttribute, t as PSL_CHECK_ON_STI_VARIANT, u as sqlAttributeSpecs } from "./sql-attribute-specs-4YqT9Gt_-DkPyYEaE.mjs";
+import { a as getAttribute, c as interpretModelAttribute, d as modelAttributeSpecsFrom, f as sqlAttributeSpecs, i as formatDbAttributeMigrationMessage, l as lowerDefaultFunctionWithRegistry, n as createSqlBinder, o as getNamedArgument, p as storageName, r as fieldSpecContext, s as interpretFieldAttribute, t as PSL_CHECK_ON_STI_VARIANT, u as mapFieldNamesToColumns } from "./sql-attribute-specs-Bs9QDuS7-DmIRJUz9.mjs";
 import { t as defaultTableName } from "./default-table-name-BfFY8qYR-lHNcVmY5.mjs";
 import { isStructuredError, structuredError } from "@prisma/orm-framework/utils/structured-error";
 import { checkUncomposedNamespace, getAuthoringFieldPreset, hasRegisteredFieldNamespace, instantiateAuthoringEntityType, instantiateAuthoringTypeConstructor, isAuthoringEntityTypeDescriptor, isAuthoringModelAttributeDescriptor, isAuthoringTypeConstructorDescriptor, isDataTypeLoweringEntry, loweringEntryKey, validateAuthoringHelperArguments } from "@prisma/orm-framework/components/authoring";
@@ -11,48 +11,19 @@ import { InternalError } from "@prisma/orm-framework/utils/internal-error";
 import { crossRef } from "@prisma/orm-framework/contract/types";
 import { ifDefined } from "@prisma/orm-framework/utils/defined";
 import { blindCast } from "@prisma/orm-framework/utils/casts";
+import { NamespaceDeclarationAst } from "@prisma/orm-framework/psl-parser/syntax";
 import { resolveToOneRelationNullable } from "@prisma/orm-framework/contract-authoring";
 import { materializeCodec } from "@prisma/orm-framework/components/codec";
 import { assertDefined, invariant } from "@prisma/orm-framework/utils/assertions";
 import { describeTaggedLiteralFailure } from "@prisma/orm-framework/components/control";
 import { notOk, ok } from "@prisma/orm-framework/utils/result";
-import { createPslDiagnosticCollector, diagnosticSource, findBlockDescriptor, interpretExtensionBlocks, nodePslSpan } from "@prisma/orm-framework/psl-parser";
+import { createPslDiagnosticCollector, diagnosticSource, findBlockDescriptor, interpretExtensionBlocks, nodePslSpan, typeReferenceNode } from "@prisma/orm-framework/psl-parser";
 import { UNBOUND_PSL_NAMESPACE_NAME, UNSPECIFIED_PSL_NAMESPACE_ID } from "@prisma/orm-framework/components/psl-ast";
-import { claimedBlockKeywords, consumeInvalidFkPairing, enumMemberAttributeDiagnostics, fkRelationPairKey, instantiatePslFieldPreset, mapPslHelperArgs, reportUncomposedNamespace, reportUnknownFieldPreset, requiredOneToOneBackrelationDiagnostic, uncomposedNamespaceDiagnostic, unsupportedBlockDiagnostic } from "@prisma/orm-framework/psl-parser/interpret";
-//#region ../../../2-sql/2-authoring/contract-psl/dist/interpreter-BMMGMTBa.mjs
+import { claimedBlockKeywords, enumMemberAttributeDiagnostics, fkRelationPairKey, instantiatePslFieldPreset, mapPslHelperArgs, reportUncomposedNamespace, reportUnknownFieldPreset, requiredOneToOneBackrelationDiagnostic, uncomposedNamespaceDiagnostic, unsupportedBlockDiagnostic } from "@prisma/orm-framework/psl-parser/interpret";
+//#region ../../../2-sql/2-authoring/contract-psl/dist/interpreter-gs7fSAIb.mjs
 function contractError(code, message, options) {
 	return structuredError(code, message, options);
 }
-function getAttribute(attributes, name) {
-	return attributes?.find((attribute) => attribute.name === name);
-}
-function formatDbAttributeMigrationMessage(attribute) {
-	const renderedArguments = attribute.args.map((argument) => argument.kind === "named" && argument.name !== void 0 ? `${argument.name}: ${argument.value}` : argument.value).join(", ");
-	const argumentList = attribute.args.length === 0 ? "" : `(${renderedArguments})`;
-	const constructorName = attribute.name.slice(3);
-	return `@${attribute.name}${argumentList} is no longer supported; use ${constructorName}${argumentList} in type position`;
-}
-function getNamedArgument(attribute, name) {
-	const entry = attribute.args.find((arg) => arg.kind === "named" && arg.name === name);
-	if (entry?.kind !== "named") return;
-	return entry.value;
-}
-function mapFieldNamesToColumns(input) {
-	const columns = [];
-	for (const fieldName of input.fieldNames) {
-		const columnName = input.mapping.fieldColumns.get(fieldName);
-		if (!columnName) {
-			input.diagnostics.push({
-				code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
-				message: `${input.entityLabel} references unknown field "${input.modelName}.${fieldName}"`,
-				...input.source.at(input.span)
-			});
-			return;
-		}
-		columns.push(columnName);
-	}
-	return columns;
-}
 /** A `` json`...` `` body that is not a JSON document. */
 const PSL_INVALID_JSON_LITERAL = "PSL_INVALID_JSON_LITERAL";
 /** A written value the entry, a cast, or the column's codec refuses. */
@@ -397,6 +368,12 @@ function getAuthoringEntity(contributions, path) {
 	}
 	return current !== void 0 && isAuthoringEntityTypeDescriptor(current) ? current : void 0;
 }
+function replacesUnresolvedTypeVoice(typeName, composedExtensions, context) {
+	if (checkUncomposedNamespace(typeName, composedExtensions, context) !== void 0) return true;
+	const dotIndex = typeName.indexOf(".");
+	if (dotIndex <= 0 || dotIndex === typeName.length - 1) return false;
+	return hasRegisteredFieldNamespace(context.authoringContributions, typeName.slice(0, dotIndex));
+}
 function instantiatePslTypeConstructor(input) {
 	const helperPath = input.call.path.join(".");
 	const args = mapPslHelperArgs({
@@ -685,7 +662,7 @@ function lowerTaggedLiteral(literal, support, context, source) {
 	};
 }
 function lowerDefaultForField(input) {
-	const node = findFieldAttributeNode(input.field, "default");
+	const node = getAttribute(input.field.attributes, "default")?.node;
 	if (node === void 0) return {};
 	const source = diagnosticSource(input.sources, node.syntax);
 	const spec = sqlAttributeSpecs.field.default(fieldSpecContext({
@@ -860,7 +837,7 @@ function resolveColumnDescriptor(field, enumTypeDescriptors, namedTypeDescriptor
 }
 function lowerEnumDefaultForField(input) {
 	const { field, model, enumHandle, diagnostics } = input;
-	const node = findFieldAttributeNode(field, "default");
+	const node = getAttribute(field.attributes, "default")?.node;
 	if (node === void 0) return {};
 	if (enumHandle.enumMembers.length === 0) return {};
 	const interpreted = interpretFieldAttribute({
@@ -951,7 +928,7 @@ function describeUnsupportedSqlAttribute(input) {
 function extractFieldConstraintNames(input) {
 	const idAttribute = getAttribute(input.field.attributes, "id");
 	const uniqueAttribute = getAttribute(input.field.attributes, "unique");
-	const idNode = findFieldAttributeNode(input.field, "id");
+	const idNode = getAttribute(input.field.attributes, "id")?.node;
 	const idName = idNode === void 0 ? void 0 : interpretFieldAttribute({
 		node: idNode,
 		symbols: input.symbolTable,
@@ -962,7 +939,7 @@ function extractFieldConstraintNames(input) {
 		binder: input.binder,
 		diagnostics: input.diagnostics
 	})?.map;
-	const uniqueNode = findFieldAttributeNode(input.field, "unique");
+	const uniqueNode = getAttribute(input.field.attributes, "unique")?.node;
 	return {
 		idAttribute,
 		uniqueAttribute,
@@ -987,7 +964,7 @@ function extractFieldConstraintNames(input) {
 * the only form the definition tree carries.
 */
 function lowerNoCheckForField(input) {
-	const node = findFieldAttributeNode(input.field, "noCheck");
+	const node = getAttribute(input.field.attributes, "noCheck")?.node;
 	if (node === void 0) return void 0;
 	const interpreted = interpretFieldAttribute({
 		node,
@@ -1029,20 +1006,22 @@ function lowerNoCheckForField(input) {
 	return [...authored].sort();
 }
 function collectResolvedFields(input) {
-	const { model, symbolTable, mapping, enumTypeDescriptors, namedTypeDescriptors, modelNames, compositeTypeNames, composedExtensions, authoringContributions, binder, familyId, targetId, defaultFunctionRegistry, dataTypeSupport, generatorDescriptorById, diagnostics, sources, scalarColumnDescriptors, enumHandles, capabilities, namespaceId, namespaceExtensionEntities, codecLookup } = input;
+	const { model, symbolTable, enumTypeDescriptors, namedTypeDescriptors, composedExtensions, authoringContributions, binder, familyId, targetId, defaultFunctionRegistry, dataTypeSupport, generatorDescriptorById, diagnostics, sources, scalarColumnDescriptors, enumHandles, capabilities, namespaceId, namespaceExtensionEntities, codecLookup } = input;
 	const resolvedFields = [];
 	const valueObjectStorageTypeName = authoringContributions?.valueObjectStorageType;
 	const declaredControlPolicy = getAttribute(model.attributes, "control")?.args.find((arg) => arg.kind === "positional")?.value.trim();
 	const modelDerivesChecks = declaredControlPolicy === void 0 || declaredControlPolicy === "managed";
 	for (const field of Object.values(model.fields)) {
 		const source = diagnosticSource(sources, field.node.syntax);
-		const isModelField = modelNames.has(field.typeName);
+		const fieldTypeReference = typeReferenceNode(field);
+		const fieldTypeResolution = fieldTypeReference === void 0 ? void 0 : binder.symbolForNode(fieldTypeReference);
+		const isModelField = fieldTypeResolution?.kind === "model";
 		if (field.list && isModelField) continue;
 		const relationAttribute = getAttribute(field.attributes, "relation");
 		if (isModelField && relationAttribute) continue;
 		if (field.typeContractSpaceId !== void 0 && relationAttribute) continue;
 		if (isModelField) continue;
-		const isValueObjectField = compositeTypeNames.has(field.typeName);
+		const isValueObjectField = fieldTypeResolution?.kind === "compositeType";
 		const isListField = field.list;
 		let descriptor;
 		let scalarCodecId;
@@ -1076,7 +1055,7 @@ function collectResolvedFields(input) {
 			}
 			const resolved = resolveFieldTypeDescriptor(resolveInput);
 			if (!resolved.ok) {
-				if (!resolved.alreadyReported) diagnostics.push({
+				if (!resolved.alreadyReported && fieldTypeResolution?.kind !== "unresolved") diagnostics.push({
 					code: "PSL_UNSUPPORTED_FIELD_TYPE",
 					message: `Field "${model.name}.${field.name}" type "${field.typeName}" is not supported in SQL PSL provider v1`,
 					...source.at(field.span)
@@ -1096,7 +1075,7 @@ function collectResolvedFields(input) {
 		} else {
 			const resolved = resolveFieldTypeDescriptor(resolveInput);
 			if (!resolved.ok) {
-				if (!resolved.alreadyReported) diagnostics.push({
+				if (!resolved.alreadyReported && fieldTypeResolution?.kind !== "unresolved") diagnostics.push({
 					code: "PSL_UNSUPPORTED_FIELD_TYPE",
 					message: `Field "${model.name}.${field.name}" type "${field.typeName}" is not supported in SQL PSL provider v1`,
 					...source.at(field.span)
@@ -1179,7 +1158,7 @@ function collectResolvedFields(input) {
 			});
 			continue;
 		}
-		const mappedColumnName = mapping.fieldColumns.get(field.name) ?? field.name;
+		const mappedColumnName = storageName(field, input.physicalNames);
 		const { idAttribute, uniqueAttribute, idName, uniqueName } = extractFieldConstraintNames({
 			symbolTable: input.symbolTable,
 			model,
@@ -1244,42 +1223,6 @@ function collectResolvedFields(input) {
 	}
 	return resolvedFields;
 }
-function buildModelMappings(symbols, modelEntries, defaultNamespaceId, diagnostics, sources, binder) {
-	const result = /* @__PURE__ */ new Map();
-	for (const { model, namespaceId } of modelEntries) {
-		const mapNode = findModelAttributeNode(model, "map");
-		const tableName = mapNode === void 0 ? defaultTableName(model.name) : interpretModelAttribute({
-			node: mapNode,
-			symbols,
-			spec: sqlAttributeSpecs.model.map(),
-			model,
-			sources,
-			binder,
-			diagnostics
-		})?.name ?? defaultTableName(model.name);
-		const fieldColumns = /* @__PURE__ */ new Map();
-		for (const field of Object.values(model.fields)) {
-			const fieldMapNode = findFieldAttributeNode(field, "map");
-			const columnName = fieldMapNode === void 0 ? field.name : interpretFieldAttribute({
-				node: fieldMapNode,
-				symbols,
-				spec: sqlAttributeSpecs.field.map(),
-				model,
-				field,
-				binder,
-				sources,
-				diagnostics
-			})?.name ?? field.name;
-			fieldColumns.set(field.name, columnName);
-		}
-		result.set(modelCoordinateKey(namespaceId ?? defaultNamespaceId, model.name), {
-			model,
-			tableName,
-			fieldColumns
-		});
-	}
-	return result;
-}
 function validateNamedTypeAttributes(input) {
 	let hasUnsupportedNamedTypeAttribute = false;
 	for (const attribute of input.declaration.attributes) {
@@ -1424,11 +1367,14 @@ const REFERENTIAL_ACTION_MAP = {
 	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 = findFieldAttributeNode(input.field, "relation");
+	const node = getAttribute(input.field.attributes, "relation")?.node;
 	if (node === void 0) return void 0;
 	return interpretFieldAttribute({
 		symbols: input.symbols,
@@ -1454,7 +1400,7 @@ function indexFkRelations(input) {
 		if (!existing) modelRelations.set(relation.declaringModelName, current);
 		current.push({
 			fieldName: relation.declaringFieldName,
-			toModel: relation.targetModelName,
+			toModel: modelName(relation.targetModelName),
 			toTable: relation.targetTableName,
 			...ifDefined("toNamespaceId", relation.targetNamespaceId),
 			cardinality: "N:1",
@@ -1466,13 +1412,14 @@ function indexFkRelations(input) {
 				childColumns: relation.referencedColumns
 			}
 		});
-		const pairKey = fkRelationPairKey(relation.declaringModelName, relation.targetModelName);
-		const pairRelations = fkRelationsByPair.get(pairKey);
-		if (!pairRelations) {
-			fkRelationsByPair.set(pairKey, [relation]);
-			continue;
-		}
-		pairRelations.push(relation);
+		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,
@@ -1541,7 +1488,7 @@ function findJunctionFkPairs(input) {
 				if (childFk === parentFk || childFk.targetModelName !== input.candidate.targetModelName) continue;
 				if (!idColumns || !idColumnsAreExactlyFkPair(idColumns, parentFk.localColumns, childFk.localColumns)) {
 					nearMisses.push({
-						junctionModelName,
+						junctionModelName: modelName(junctionModelName),
 						reason: "id-not-fk-covering"
 					});
 					continue;
@@ -1549,7 +1496,7 @@ function findJunctionFkPairs(input) {
 				const orderedChildColumns = childColumnsInTargetIdOrder(childFk, targetIdColumns);
 				if (!orderedChildColumns) {
 					nearMisses.push({
-						junctionModelName,
+						junctionModelName: modelName(junctionModelName),
 						reason: "target-fk-not-id"
 					});
 					continue;
@@ -1569,21 +1516,22 @@ function findJunctionFkPairs(input) {
 }
 function junctionNearMissDiagnostic(candidate, nearMiss, sources) {
 	const source = diagnosticSource(sources, candidate.field.node.syntax);
-	const listField = `${candidate.modelName}.${candidate.field.name}`;
+	const listField = `${modelName(candidate.modelName)}.${candidate.field.name}`;
+	const targetModelName = modelName(candidate.targetModelName);
 	const data = {
 		listField,
 		junctionModel: nearMiss.junctionModelName,
-		targetModel: candidate.targetModelName
+		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 "${candidate.targetModelName}" does not reference "${candidate.targetModelName}"'s @id. The junction's target-side foreign key must reference "${candidate.targetModelName}"'s full @id columns for many-to-many recognition.`,
+		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 "${candidate.modelName}" and "${candidate.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.`,
+		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
 	};
@@ -1591,7 +1539,7 @@ function junctionNearMissDiagnostic(candidate, nearMiss, sources) {
 function manyToManyRelationNode(candidate, pair) {
 	return {
 		fieldName: candidate.field.name,
-		toModel: pair.childFk.targetModelName,
+		toModel: modelName(pair.childFk.targetModelName),
 		toTable: pair.childFk.targetTableName,
 		...ifDefined("toNamespaceId", pair.childFk.targetNamespaceId),
 		cardinality: "N:M",
@@ -1631,11 +1579,18 @@ function fkColumnsAreUnique(localColumns, uniqueColumnSets) {
 function applyBackrelationCandidates(input) {
 	for (const candidate of input.backrelationCandidates) {
 		const source = diagnosticSource(input.sources, candidate.field.node.syntax);
-		const pairKey = fkRelationPairKey(candidate.targetModelName, candidate.modelName);
-		const pairMatches = input.fkRelationsByPair.get(pairKey) ?? [];
+		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) {
-			if (consumeInvalidFkPairing(candidate, pairKey, input.invalidFkPairings)) continue;
+			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,
@@ -1650,7 +1605,7 @@ function applyBackrelationCandidates(input) {
 				if (junctionPairs.length > 1) {
 					input.diagnostics.push({
 						code: "PSL_AMBIGUOUS_BACKRELATION",
-						message: `Backrelation list field "${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 "${candidate.modelName}" to disambiguate.`,
+						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;
@@ -1663,7 +1618,7 @@ function applyBackrelationCandidates(input) {
 			}
 			input.diagnostics.push({
 				code: "PSL_ORPHANED_BACKRELATION",
-				message: `Backrelation field "${candidate.modelName}.${candidate.field.name}" has no matching FK-side relation on model "${candidate.targetModelName}". Add @relation(fields: [...], references: [...]) on the FK-side relation${candidate.isList ? " or use an explicit join model for many-to-many" : ""}.`,
+				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;
@@ -1671,7 +1626,7 @@ function applyBackrelationCandidates(input) {
 		if (matches.length > 1) {
 			input.diagnostics.push({
 				code: "PSL_AMBIGUOUS_BACKRELATION",
-				message: `Backrelation field "${candidate.modelName}.${candidate.field.name}" matches multiple FK-side relations on model "${candidate.targetModelName}". Add @relation(name: "...") (or @relation("...")) to both sides to disambiguate.`,
+				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;
@@ -1684,22 +1639,22 @@ function applyBackrelationCandidates(input) {
 			if (!fkColumnsAreUnique(matched.localColumns, uniqueColumnSets)) {
 				input.diagnostics.push({
 					code: "PSL_NON_UNIQUE_BACKRELATION",
-					message: `Backrelation field "${candidate.modelName}.${candidate.field.name}" is singular, but the matching FK on "${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.`,
+					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: candidate.modelName,
+			modelName: modelName(candidate.modelName),
 			field: candidate.field,
-			targetModelName: candidate.targetModelName,
+			targetModelName: modelName(candidate.targetModelName),
 			sources: input.sources,
 			recordNoun: "row"
 		}));
 		relationsForModel(input.modelRelations, candidate.modelName).push({
 			fieldName: candidate.field.name,
-			toModel: matched.declaringModelName,
+			toModel: modelName(matched.declaringModelName),
 			toTable: matched.declaringTableName,
 			...ifDefined("toNamespaceId", matched.declaringNamespaceId),
 			...candidate.isList ? { cardinality: "1:N" } : {
@@ -2023,19 +1978,17 @@ function relationNullabilityMismatchDiagnostic(modelName, relationAttribute, sou
 	};
 }
 function buildModelNodeFromPsl(input) {
-	const { model, mapping, diagnostics } = input;
+	const { model, diagnostics } = input;
 	const source = diagnosticSource(input.sources, model.node.syntax);
-	const tableName = mapping.tableName;
-	const modelNamespaceId = input.modelNamespaceIds.get(model.name);
+	const tableName = storageName(model, input.physicalNames);
+	const modelNamespaceId = input.namespaceId;
 	const namespaceExtensionEntitiesForModel = modelNamespaceId !== void 0 ? input.namespaceExtensionEntities?.get(modelNamespaceId) : void 0;
 	const resolvedFields = collectResolvedFields({
 		model,
+		physicalNames: input.physicalNames,
 		symbolTable: input.symbolTable,
-		mapping,
 		enumTypeDescriptors: input.enumTypeDescriptors,
 		namedTypeDescriptors: input.namedTypeDescriptors,
-		modelNames: input.modelNames,
-		compositeTypeNames: input.compositeTypeNames,
 		composedExtensions: input.composedExtensions,
 		authoringContributions: input.authoringContributions,
 		familyId: input.familyId,
@@ -2072,7 +2025,8 @@ function buildModelNodeFromPsl(input) {
 	const modelAttributeEntities = {};
 	const resultBackrelationCandidates = [];
 	for (const field of Object.values(model.fields)) {
-		if (!input.modelNames.has(field.typeName)) continue;
+		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({
@@ -2117,10 +2071,10 @@ function buildModelNodeFromPsl(input) {
 		}
 		if (!attributesValid) continue;
 		resultBackrelationCandidates.push({
-			modelName: model.name,
+			modelName: model,
 			tableName,
 			field,
-			targetModelName: field.typeName,
+			targetModelName: backrelationTarget,
 			isList: field.list,
 			...ifDefined("relationName", relationName)
 		});
@@ -2208,9 +2162,9 @@ function buildModelNodeFromPsl(input) {
 				continue;
 			}
 			const columnNames = mapFieldNamesToColumns({
-				modelName: model.name,
+				model,
+				physicalNames: input.physicalNames,
 				fieldNames,
-				mapping,
 				source,
 				diagnostics,
 				span: modelAttribute.span,
@@ -2238,9 +2192,9 @@ function buildModelNodeFromPsl(input) {
 			});
 			if (parsed === void 0) continue;
 			const columnNames = mapFieldNamesToColumns({
-				modelName: model.name,
+				model,
+				physicalNames: input.physicalNames,
 				fieldNames: parsed.fields,
-				mapping,
 				source,
 				diagnostics,
 				span: modelAttribute.span,
@@ -2269,9 +2223,9 @@ function buildModelNodeFromPsl(input) {
 			let columnNames;
 			if (parsed.fields !== void 0) {
 				const mapped = mapFieldNamesToColumns({
-					modelName: model.name,
+					model,
+					physicalNames: input.physicalNames,
 					fieldNames: parsed.fields,
-					mapping,
 					source,
 					diagnostics,
 					span: modelAttribute.span,
@@ -2358,7 +2312,10 @@ function buildModelNodeFromPsl(input) {
 				target: input.targetId,
 				modelName: model.name,
 				storageName: tableName,
-				fieldStorageName: (fieldName) => mapping.fieldColumns.get(fieldName),
+				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 ?? input.defaultNamespaceId,
 				sourceId: source.sources.sourceFileFor(source.node).filename,
@@ -2428,9 +2385,9 @@ function buildModelNodeFromPsl(input) {
 				continue;
 			}
 			const localColumns = mapFieldNamesToColumns({
-				modelName: model.name,
+				model,
+				physicalNames: input.physicalNames,
 				fieldNames: parsedRelation.fields,
-				mapping,
 				source,
 				diagnostics,
 				span: relationAttribute.relation.span,
@@ -2502,19 +2459,15 @@ function buildModelNodeFromPsl(input) {
 			continue;
 		}
 		const qualifiedTypeName = fieldTypeNamespaceId ? `${fieldTypeNamespaceId}.${fieldTypeName}` : fieldTypeName;
-		if (!input.modelNames.has(fieldTypeName)) {
+		const typeReference = typeReferenceNode(relationAttribute.field);
+		const targetResolution = typeReference === void 0 ? void 0 : input.binder.symbolForNode(typeReference);
+		if (targetResolution?.kind === "unresolved") continue;
+		const targetModel = targetResolution?.kind === "model" ? targetResolution.symbol : void 0;
+		if (targetModel === void 0) {
+			const foundKind = targetResolution === void 0 ? void 0 : relationTargetKindLabel(targetResolution);
 			diagnostics.push({
 				code: "PSL_INVALID_RELATION_TARGET",
-				message: `Relation field "${model.name}.${relationAttribute.field.name}" references unknown model "${qualifiedTypeName}"`,
-				...source.at(relationAttribute.field.span)
-			});
-			continue;
-		}
-		const normalizedQualifier = fieldTypeNamespaceId === void 0 ? void 0 : fieldTypeNamespaceId === UNBOUND_PSL_NAMESPACE_NAME ? UNBOUND_NAMESPACE_ID : fieldTypeNamespaceId;
-		if (normalizedQualifier !== void 0 && !input.modelMappingsByCoordinate.has(modelCoordinateKey(normalizedQualifier, fieldTypeName))) {
-			diagnostics.push({
-				code: "PSL_INVALID_RELATION_TARGET",
-				message: `Relation field "${model.name}.${relationAttribute.field.name}" references unknown model "${qualifiedTypeName}"`,
+				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;
@@ -2536,19 +2489,10 @@ function buildModelNodeFromPsl(input) {
 			});
 			continue;
 		}
-		const targetMapping = normalizedQualifier !== void 0 ? input.modelMappingsByCoordinate.get(modelCoordinateKey(normalizedQualifier, fieldTypeName)) : input.modelMappings.get(fieldTypeName);
-		if (!targetMapping) {
-			diagnostics.push({
-				code: "PSL_INVALID_RELATION_TARGET",
-				message: `Relation field "${model.name}.${relationAttribute.field.name}" references unknown model "${qualifiedTypeName}"`,
-				...source.at(relationAttribute.field.span)
-			});
-			continue;
-		}
 		const localColumns = mapFieldNamesToColumns({
-			modelName: model.name,
+			model,
+			physicalNames: input.physicalNames,
 			fieldNames: parsedRelation.fields,
-			mapping,
 			source,
 			diagnostics,
 			span: relationAttribute.relation.span,
@@ -2558,15 +2502,16 @@ function buildModelNodeFromPsl(input) {
 		if (relationNullabilityMismatch(relationAttribute.field, localColumns, resolvedFields)) {
 			diagnostics.push(relationNullabilityMismatchDiagnostic(model.name, relationAttribute, source));
 			resultInvalidFkPairings.push({
-				pairKey: fkRelationPairKey(model.name, targetMapping.model.name),
+				declaringModel: model,
+				targetModel,
 				...ifDefined("relationName", parsedRelation.name)
 			});
 			continue;
 		}
 		const referencedColumns = mapFieldNamesToColumns({
-			modelName: targetMapping.model.name,
+			model: targetModel,
+			physicalNames: input.physicalNames,
 			fieldNames: parsedRelation.references,
-			mapping: targetMapping,
 			source,
 			diagnostics,
 			span: relationAttribute.relation.span,
@@ -2583,12 +2528,16 @@ function buildModelNodeFromPsl(input) {
 		}
 		const onDelete = parsedRelation.onDelete ? normalizeReferentialAction(parsedRelation.onDelete) : void 0;
 		const onUpdate = parsedRelation.onUpdate ? normalizeReferentialAction(parsedRelation.onUpdate) : void 0;
-		const targetNamespaceId = normalizedQualifier !== void 0 ? normalizedQualifier : input.modelNamespaceIds.get(targetMapping.model.name);
+		const targetNamespaceId = resolveNamespaceIdForSqlTarget({
+			bucketName: targetModel.node.syntax.findAncestor(NamespaceDeclarationAst.cast)?.name()?.name() ?? UNSPECIFIED_PSL_NAMESPACE_ID,
+			targetId: input.targetId
+		});
+		const targetTableName = storageName(targetModel, input.physicalNames);
 		foreignKeyNodes.push({
 			columns: localColumns,
 			references: {
-				model: targetMapping.model.name,
-				table: targetMapping.tableName,
+				model: targetModel.name,
+				table: targetTableName,
 				columns: referencedColumns,
 				...ifDefined("namespaceId", targetNamespaceId)
 			},
@@ -2598,12 +2547,12 @@ function buildModelNodeFromPsl(input) {
 			...ifDefined("index", parsedRelation.index)
 		});
 		resultFkRelationMetadata.push({
-			declaringModelName: model.name,
+			declaringModelName: model,
 			declaringFieldName: relationAttribute.field.name,
 			declaringTableName: tableName,
-			...ifDefined("declaringNamespaceId", input.modelNamespaceIds.get(model.name)),
-			targetModelName: targetMapping.model.name,
-			targetTableName: targetMapping.tableName,
+			...ifDefined("declaringNamespaceId", modelNamespaceId),
+			targetModelName: targetModel,
+			targetTableName,
 			...ifDefined("targetNamespaceId", targetNamespaceId),
 			...ifDefined("relationName", parsedRelation.name),
 			nullable: relationAttribute.field.optional,
@@ -2645,17 +2594,18 @@ function buildModelNodeFromPsl(input) {
 	};
 }
 function buildValueObjects(input) {
-	const { compositeTypes, enumTypeDescriptors, namedTypeDescriptors, scalarColumnDescriptors, composedExtensions, familyId, targetId, authoringContributions, diagnostics, sources } = input;
+	const { compositeTypes, enumTypeDescriptors, namedTypeDescriptors, scalarColumnDescriptors, composedExtensions, familyId, targetId, authoringContributions, diagnostics, sources, binder } = input;
 	const valueObjects = {};
-	const compositeTypeNames = new Set(compositeTypes.map((ct) => ct.name));
 	for (const compositeType of compositeTypes) {
 		const fields = {};
 		for (const field of Object.values(compositeType.fields)) {
-			if (compositeTypeNames.has(field.typeName)) {
+			const fieldTypeReference = typeReferenceNode(field);
+			const fieldTypeResolution = fieldTypeReference === void 0 ? void 0 : binder.symbolForNode(fieldTypeReference);
+			if (fieldTypeResolution?.kind === "compositeType") {
 				const result = {
 					type: {
 						kind: "valueObject",
-						name: field.typeName
+						name: fieldTypeResolution.symbol.name
 					},
 					nullable: field.optional
 				};
@@ -2679,7 +2629,7 @@ function buildValueObjects(input) {
 				entityLabel: `Field "${compositeType.name}.${field.name}"`
 			});
 			if (!resolved.ok) {
-				if (!resolved.alreadyReported) diagnostics.push({
+				if (!resolved.alreadyReported && fieldTypeResolution?.kind !== "unresolved") diagnostics.push({
 					code: "PSL_UNSUPPORTED_FIELD_TYPE",
 					message: `Field "${compositeType.name}.${field.name}" type "${field.typeName}" is not supported`,
 					...diagnosticSource(sources, field.node.syntax).at(field.span)
@@ -2748,7 +2698,7 @@ function collectPolymorphismDeclarations(identities, symbols, sources, binder, d
 	const baseDeclarations = /* @__PURE__ */ new Map();
 	for (const { model, key } of identities.values()) {
 		const source = diagnosticSource(sources, model.node.syntax);
-		const discriminatorNode = findModelAttributeNode(model, "discriminator");
+		const discriminatorNode = getAttribute(model.attributes, "discriminator")?.node;
 		if (discriminatorNode !== void 0) {
 			const parsed = interpretModelAttribute({
 				node: discriminatorNode,
@@ -2768,13 +2718,14 @@ function collectPolymorphismDeclarations(identities, symbols, sources, binder, d
 					...source.at(span)
 				});
 				else discriminatorDeclarations.set(key, {
+					model,
 					fieldName: parsed.field,
 					span,
 					source
 				});
 			}
 		}
-		const baseNode = findModelAttributeNode(model, "base");
+		const baseNode = getAttribute(model.attributes, "base")?.node;
 		if (baseNode !== void 0) {
 			const parsed = interpretModelAttribute({
 				node: baseNode,
@@ -2789,6 +2740,7 @@ function collectPolymorphismDeclarations(identities, symbols, sources, binder, d
 				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`);
 				baseDeclarations.set(key, {
+					model,
 					source,
 					base,
 					value: parsed.value,
@@ -2802,7 +2754,7 @@ function collectPolymorphismDeclarations(identities, symbols, sources, binder, d
 		baseDeclarations
 	};
 }
-function resolvePolymorphism(models, discriminatorDeclarations, baseDeclarations, modelMappings, syntheticPkFieldsByVariant, stiBaseFieldsByBase, diagnostics) {
+function resolvePolymorphism(models, physicalNames, discriminatorDeclarations, baseDeclarations, syntheticPkFieldsByVariant, stiBaseFieldsByBase, diagnostics) {
 	let patched = models;
 	for (const [baseKey, fieldNames] of stiBaseFieldsByBase) {
 		const baseModel = patched[baseKey];
@@ -2813,7 +2765,7 @@ function resolvePolymorphism(models, discriminatorDeclarations, baseDeclarations
 		};
 	}
 	for (const [modelKey, decl] of discriminatorDeclarations) {
-		const modelName = modelMappings.get(modelKey)?.model.name;
+		const modelName = decl.model.name;
 		if (baseDeclarations.has(modelKey)) {
 			diagnostics.push({
 				code: "PSL_DISCRIMINATOR_AND_BASE",
@@ -2826,10 +2778,9 @@ function resolvePolymorphism(models, discriminatorDeclarations, baseDeclarations
 		if (!model) continue;
 		const variants = {};
 		const seenValues = /* @__PURE__ */ new Map();
-		for (const [variantKey, baseDecl] of baseDeclarations) {
+		for (const baseDecl of baseDeclarations.values()) {
 			if (baseDecl.base.key !== modelKey) continue;
-			const variantName = modelMappings.get(variantKey)?.model.name;
-			invariant(variantName !== void 0, `Variant "${variantKey}" is missing from the model mappings`);
+			const variantName = baseDecl.model.name;
 			const existingVariant = seenValues.get(baseDecl.value);
 			if (existingVariant) {
 				diagnostics.push({
@@ -2860,8 +2811,7 @@ function resolvePolymorphism(models, discriminatorDeclarations, baseDeclarations
 		};
 	}
 	for (const [variantKey, baseDecl] of baseDeclarations) {
-		const variantMapping = modelMappings.get(variantKey);
-		const variantName = variantMapping?.model.name;
+		const variantName = baseDecl.model.name;
 		const baseName = baseDecl.base.model.name;
 		if (!discriminatorDeclarations.has(baseDecl.base.key)) {
 			diagnostics.push({
@@ -2874,8 +2824,7 @@ function resolvePolymorphism(models, discriminatorDeclarations, baseDeclarations
 		if (discriminatorDeclarations.has(variantKey)) continue;
 		const variantModel = patched[variantKey];
 		if (!variantModel) continue;
-		const baseMapping = modelMappings.get(baseDecl.base.key);
-		const resolvedTable = variantMapping?.model.attributes.some((attr) => attr.name === "map") ?? false ? variantMapping?.tableName : baseMapping?.tableName;
+		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),
@@ -3041,12 +2990,30 @@ function stripStorageOnlyDomainFields(model, fieldNames) {
 		}
 	};
 }
-function voicedAsUncomposedNamespace(diagnostic, composedExtensions, context) {
+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 "named type";
+		case "block": return resolution.symbol.keyword;
+		case "namespace":
+		case "contributedNamespace": return "namespace";
+		case "contributedType": return "type";
+		default: return;
+	}
+}
+function replacedBySqlTypeVoice(diagnostic, composedExtensions, context) {
 	const data = diagnostic.data;
 	if (data?.["reference"] !== "type") return false;
+	if (data["constructorCall"] !== true) return false;
 	const name = data["name"];
 	if (typeof name !== "string") return false;
-	return checkUncomposedNamespace(name, composedExtensions, context) !== void 0;
+	return replacesUnresolvedTypeVoice(name, composedExtensions, context);
 }
 function interpretPslDocumentToSqlContract(input) {
 	if (!input.target) throw new InternalError("PSL interpretation requires an explicit target context from composition.");
@@ -3078,7 +3045,7 @@ function interpretPslDocumentToSqlContract(input) {
 			targetId: input.target.targetId
 		})
 	});
-	diagnostics.push(...binderDiagnostics.filter((diagnostic) => !voicedAsUncomposedNamespace(diagnostic, composedExtensionNames, {
+	diagnostics.push(...binderDiagnostics.filter((diagnostic) => !replacedBySqlTypeVoice(diagnostic, composedExtensionNames, {
 		familyId: "sql",
 		targetId: input.target.targetId,
 		authoringContributions: input.authoringContributions
@@ -3108,7 +3075,6 @@ function interpretPslDocumentToSqlContract(input) {
 	});
 	const models = [];
 	const modelEntries = [];
-	const modelNamespaceIds = /* @__PURE__ */ new Map();
 	const compositeTypes = [];
 	const collectScope = (bucketName, scopeModels, scopeCompositeTypes) => {
 		const resolvedNamespaceId = resolveNamespaceIdForSqlTarget({
@@ -3121,15 +3087,40 @@ function interpretPslDocumentToSqlContract(input) {
 				model,
 				namespaceId: resolvedNamespaceId
 			});
-			if (resolvedNamespaceId !== void 0) modelNamespaceIds.set(model.name, resolvedNamespaceId);
 		}
 		for (const compositeType of scopeCompositeTypes) compositeTypes.push(compositeType);
 	};
 	collectScope(UNSPECIFIED_PSL_NAMESPACE_ID, Object.values(topLevel.models), Object.values(topLevel.compositeTypes));
 	for (const namespace of namespaceSymbols) collectScope(namespace.name, Object.values(namespace.models), 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(),
+			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(),
+				model,
+				field,
+				sources: input.sources,
+				binder,
+				diagnostics
+			});
+			physicalNames.set(field, mapped?.name ?? field.name);
+		}
+	}
 	const defaultNamespaceId = input.target.defaultNamespaceId;
-	const modelNames = new Set(models.map((model) => model.name));
-	const compositeTypeNames = new Set(compositeTypes.map((ct) => ct.name));
 	const composedExtensions = new Set(input.composedExtensions ?? []);
 	const composedExtensionContracts = input.composedExtensionContracts;
 	const defaultFunctionRegistry = input.controlMutationDefaults?.defaultFunctionRegistry ?? /* @__PURE__ */ new Map();
@@ -3199,17 +3190,15 @@ function interpretPslDocumentToSqlContract(input) {
 		} },
 		warnings: authoringWarnings
 	};
-	const earlyModelMappingsByCoordinate = buildModelMappings(input.symbolTable, modelEntries, defaultNamespaceId, createPslDiagnosticCollector(input.sources), input.sources, binder);
-	const modelCoordinates = /* @__PURE__ */ new Map();
-	for (const entry of modelEntries) {
-		const nsId = entry.namespaceId ?? defaultNamespaceId;
-		const mapping = earlyModelMappingsByCoordinate.get(modelCoordinateKey(nsId, entry.model.name));
-		if (mapping !== void 0) modelCoordinates.set(entry.model, {
-			namespaceId: nsId,
-			tableName: mapping.tableName
-		});
-	}
-	const modelCoordinateOf = (model) => modelCoordinates.get(model);
+	const modelCoordinateOf = (model) => {
+		return {
+			namespaceId: resolveNamespaceIdForSqlTarget({
+				bucketName: model.node.syntax.findAncestor(NamespaceDeclarationAst.cast)?.name()?.name() ?? UNSPECIFIED_PSL_NAMESPACE_ID,
+				targetId: input.target.targetId
+			}) ?? defaultNamespaceId,
+			tableName: storageName(model, physicalNames)
+		};
+	};
 	const namespaceExtensionEntities = /* @__PURE__ */ new Map();
 	const fileExtensionEntityRows = (rows, blocks) => {
 		for (const row of rows) {
@@ -3272,10 +3261,7 @@ function interpretPslDocumentToSqlContract(input) {
 		diagnostics
 	});
 	const storageTypes = { ...namedTypeResult.storageTypes };
-	const modelMappingsByCoordinate = buildModelMappings(input.symbolTable, modelEntries, defaultNamespaceId, diagnostics, input.sources, binder);
-	const modelMappings = /* @__PURE__ */ new Map();
-	for (const mapping of modelMappingsByCoordinate.values()) modelMappings.set(mapping.model.name, mapping);
-	const modelNodes = [];
+	const modelNodes = /* @__PURE__ */ new Map();
 	const fkRelationMetadata = [];
 	const invalidFkPairings = [];
 	const backrelationCandidates = [];
@@ -3284,15 +3270,10 @@ function interpretPslDocumentToSqlContract(input) {
 	const modelAttributeEntitiesByNamespace = /* @__PURE__ */ new Map();
 	for (const { model, namespaceId } of modelEntries) {
 		const coordinate = modelCoordinateKey(namespaceId ?? defaultNamespaceId, model.name);
-		const mapping = modelMappingsByCoordinate.get(coordinate);
-		if (!mapping) continue;
 		const result = buildModelNodeFromPsl({
 			model,
-			mapping,
-			modelMappings,
-			modelMappingsByCoordinate,
-			modelNames,
-			compositeTypeNames,
+			physicalNames,
+			namespaceId,
 			enumTypeDescriptors: allEnumTypeDescriptors,
 			namedTypeDescriptors: namedTypeResult.namedTypeDescriptors,
 			composedExtensions,
@@ -3308,7 +3289,6 @@ function interpretPslDocumentToSqlContract(input) {
 			binder,
 			symbolTable: input.symbolTable,
 			diagnostics,
-			modelNamespaceIds,
 			...enumHandlesByName.size > 0 ? { enumHandles: enumHandlesByName } : {},
 			capabilities: input.capabilities,
 			...namespaceExtensionEntities.size > 0 ? { namespaceExtensionEntities } : {},
@@ -3318,7 +3298,7 @@ function interpretPslDocumentToSqlContract(input) {
 			defaultNamespaceId,
 			parsedBlocks
 		});
-		modelNodes.push(namespaceId !== void 0 ? {
+		modelNodes.set(model, namespaceId !== void 0 ? {
 			...result.modelNode,
 			namespaceId
 		} : result.modelNode);
@@ -3327,8 +3307,8 @@ function interpretPslDocumentToSqlContract(input) {
 		backrelationCandidates.push(...result.backrelationCandidates);
 		modelResolvedFields.set(coordinate, result.resolvedFields);
 		if (result.crossSpaceRelations.length > 0) {
-			const existing = crossSpaceRelationsByModel.get(model.name) ?? [];
-			crossSpaceRelationsByModel.set(model.name, [...existing, ...result.crossSpaceRelations]);
+			const existing = crossSpaceRelationsByModel.get(model) ?? [];
+			crossSpaceRelationsByModel.set(model, [...existing, ...result.crossSpaceRelations]);
 		}
 		if (Object.keys(result.modelAttributeEntities).length > 0) {
 			const nsKey = namespaceId ?? defaultNamespaceId;
@@ -3343,13 +3323,13 @@ function interpretPslDocumentToSqlContract(input) {
 	const { modelRelations, fkRelationsByPair, fkRelationsByDeclaringModel } = indexFkRelations({ fkRelationMetadata });
 	const modelIdColumns = /* @__PURE__ */ new Map();
 	const modelUniqueColumnSets = /* @__PURE__ */ new Map();
-	for (const modelNode of modelNodes) {
-		if (modelNode.id) modelIdColumns.set(modelNode.modelName, modelNode.id.columns);
+	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(modelNode.modelName, uniqueColumnSets);
+		modelUniqueColumnSets.set(model, uniqueColumnSets);
 	}
 	applyBackrelationCandidates({
 		backrelationCandidates,
@@ -3376,14 +3356,12 @@ function interpretPslDocumentToSqlContract(input) {
 		}];
 	})), input.symbolTable, input.sources, binder, diagnostics);
 	const stiVariantKeys = /* @__PURE__ */ new Set();
-	for (const variantKey of baseDeclarations.keys()) if (!(modelMappingsByCoordinate.get(variantKey)?.model.attributes.some((attr) => attr.name === "map") ?? false)) stiVariantKeys.add(variantKey);
+	for (const [variantKey, declaration] of baseDeclarations) if (!(getAttribute(declaration.model.attributes, "map") !== void 0)) stiVariantKeys.add(variantKey);
 	for (const variantKey of stiVariantKeys) {
-		const variantMapping = modelMappingsByCoordinate.get(variantKey);
-		if (variantMapping === void 0) continue;
-		const variantName = variantMapping.model.name;
 		const baseDecl = baseDeclarations.get(variantKey);
-		invariant(baseDecl !== void 0, `stiVariantKeys is derived from baseDeclarations.keys(), so "${variantName}" must have a base declaration`);
-		for (const attribute of variantMapping.model.node.attributes()) {
+		invariant(baseDecl !== void 0, `stiVariantKeys is derived from baseDeclarations.keys(), so "${variantKey}" must have a base declaration`);
+		const variantName = baseDecl.model.name;
+		for (const attribute of baseDecl.model.node.attributes()) {
 			if (attribute.name()?.isSimpleName("check") !== true) continue;
 			diagnostics.push({
 				code: PSL_CHECK_ON_STI_VARIANT,
@@ -3392,7 +3370,10 @@ function interpretPslDocumentToSqlContract(input) {
 			});
 		}
 	}
-	const { modelNodes: mtiLinkedModelNodes, syntheticPkFieldsByVariant } = materializeMtiVariantStorageLinks(modelNodes, baseDeclarations, stiVariantKeys, defaultNamespaceId);
+	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);
 	const valueObjects = buildValueObjects({
 		compositeTypes,
@@ -3445,10 +3426,7 @@ function interpretPslDocumentToSqlContract(input) {
 		...Object.keys(validEnumHandles).length > 0 ? { enums: validEnumHandles } : {},
 		...namespaceExtensionEntities.size > 0 ? { namespaces: [...namespaceExtensionEntities.keys()] } : {},
 		createNamespace: createNamespaceWithExtensions,
-		models: stiColumnModelNodes.map((model) => ({
-			...model,
-			...modelRelations.has(model.modelName) ? { relations: [...modelRelations.get(model.modelName) ?? []].sort((left, right) => compareStrings(left.fieldName, right.fieldName)) } : {}
-		}))
+		models: stiColumnModelNodes
 	}, input.codecLookup);
 	const modelsForPatch = {};
 	for (const [namespaceId, namespaceSlice] of Object.entries(contract.domain.namespaces)) for (const [modelName, model] of Object.entries(namespaceSlice.models)) {
@@ -3458,7 +3436,7 @@ function interpretPslDocumentToSqlContract(input) {
 	}
 	let patchedModels = patchModelDomainFields(modelsForPatch, modelResolvedFields);
 	const polyDiagnostics = createPslDiagnosticCollector(input.sources);
-	patchedModels = resolvePolymorphism(patchedModels, discriminatorDeclarations, baseDeclarations, modelMappingsByCoordinate, syntheticPkFieldsByVariant, stiBaseFieldsByBase, polyDiagnostics);
+	patchedModels = resolvePolymorphism(patchedModels, physicalNames, discriminatorDeclarations, baseDeclarations, syntheticPkFieldsByVariant, stiBaseFieldsByBase, polyDiagnostics);
 	if (polyDiagnostics.length > 0) return notOk({
 		summary: "PSL to SQL contract interpretation failed",
 		diagnostics: polyDiagnostics.toExternal()
@@ -3478,4 +3456,4 @@ function interpretPslDocumentToSqlContract(input) {
 //#endregion
 export { interpretPslDocumentToSqlContract as a, resolveFieldTypeDescriptor as c, indexFkRelations as i, buildEntityTypesByDiscriminator as n, normalizeReferentialAction as o, entryForTag as r, readDataTypeDefault as s, applyBackrelationCandidates as t };
 
-//# sourceMappingURL=interpreter-BMMGMTBa-CT5iKl13.mjs.map
+//# sourceMappingURL=interpreter-gs7fSAIb-DuqyTGAB.mjs.map