@prisma/orm-family-sql 8.0.0-rc.11-dev.43 → 8.0.0-rc.11-dev.45

package/dist/{interpreter-DvKii7Bl-D8Ipte3f.mjs → interpreter-BIBwrA2w-DAiNN30m.mjs}

@@ -1,7 +1,7 @@
 import { n as isAuthoredIndexInput } from "./index-naming-Cj1Anq-T-w1JL7-EM.mjs";
 import { t as deriveValueSetFromEntity } from "./value-set-derivation-hook-Di9JZ0X7.mjs";
 import { n as buildSqlContractFromDefinition } from "./derived-checks-6WZKIUxH-B3Pd6QA5.mjs";
-import { a as interpretFieldAttribute, i as findModelAttributeNode, n as fieldSpecContext, o as interpretModelAttribute, r as findFieldAttributeNode, s as sqlAttributeSpecs, t as PSL_CHECK_ON_STI_VARIANT } from "./sql-attribute-specs-CQoOV2MU-DLD9uxC6.mjs";
+import { a as interpretFieldAttribute, i as findModelAttributeNode, n as fieldSpecContext, o as interpretModelAttribute, r as findFieldAttributeNode, s as sqlAttributeSpecs, t as PSL_CHECK_ON_STI_VARIANT } from "./sql-attribute-specs-BH0U6i1B-Ces5ZCvv.mjs";
 import { t as defaultTableName } from "./default-table-name-BfFY8qYR-lHNcVmY5.mjs";
 import { isStructuredError, structuredError } from "@prisma/orm-framework/utils/structured-error";
 import { hasRegisteredFieldNamespace, instantiateAuthoringEntityType, instantiateAuthoringFieldPreset, instantiateAuthoringTypeConstructor, isAuthoringEntityTypeDescriptor, isAuthoringFieldPresetDescriptor, isAuthoringModelAttributeDescriptor, isAuthoringPslBlockDescriptor, isAuthoringTypeConstructorDescriptor, isDataTypeLoweringEntry, loweringEntryKey, validateAuthoringHelperArguments } from "@prisma/orm-framework/components/authoring";
@@ -17,7 +17,7 @@ import { describeTaggedLiteralFailure } from "@prisma/orm-framework/components/c
 import { notOk, ok } from "@prisma/orm-framework/utils/result";
 import { createPslDiagnosticCollector, diagnosticSource, findBlockDescriptor, keywordPslSpan, nodePslSpan } from "@prisma/orm-framework/psl-parser";
 import { consumeInvalidFkPairing, fkRelationPairKey, requiredOneToOneBackrelationDiagnostic } from "@prisma/orm-framework/psl-parser/interpret";
-//#region ../../../2-sql/2-authoring/contract-psl/dist/interpreter-DvKii7Bl.mjs
+//#region ../../../2-sql/2-authoring/contract-psl/dist/interpreter-BIBwrA2w.mjs
 function contractError(code, message, options) {
 	return structuredError(code, message, options);
 }
@@ -1109,17 +1109,19 @@ function lowerDefaultForField(input) {
 	const node = findFieldAttributeNode(input.field, "default");
 	if (node === void 0) return {};
 	const source = diagnosticSource(input.sources, node.syntax);
+	const spec = sqlAttributeSpecs.field.default(fieldSpecContext({
+		symbols: input.symbolTable,
+		model: input.model,
+		field: input.field,
+		controlMutationDefaults: {
+			defaultFunctionRegistry: input.defaultFunctionRegistry,
+			dataTypeEntries: input.dataTypeSupport.entries
+		}
+	}));
 	const interpreted = interpretFieldAttribute({
+		symbols: input.symbolTable,
 		node,
-		spec: sqlAttributeSpecs.field.default(fieldSpecContext({
-			symbols: input.symbolTable,
-			model: input.model,
-			field: input.field,
-			controlMutationDefaults: {
-				defaultFunctionRegistry: input.defaultFunctionRegistry,
-				dataTypeEntries: input.dataTypeSupport.entries
-			}
-		})),
+		spec,
 		model: input.model,
 		field: input.field,
 		sources: input.sources,
@@ -1283,6 +1285,7 @@ function lowerEnumDefaultForField(input) {
 				dataTypeEntries: input.dataTypeSupport.entries
 			}
 		})),
+		symbols: input.symbolTable,
 		model,
 		field,
 		sources: input.sources,
@@ -1352,6 +1355,7 @@ function extractFieldConstraintNames(input) {
 	const idNode = findFieldAttributeNode(input.field, "id");
 	const idName = idNode === void 0 ? void 0 : interpretFieldAttribute({
 		node: idNode,
+		symbols: input.symbolTable,
 		spec: sqlAttributeSpecs.field.id(),
 		model: input.model,
 		field: input.field,
@@ -1365,6 +1369,7 @@ function extractFieldConstraintNames(input) {
 		idName,
 		uniqueName: uniqueNode === void 0 ? void 0 : interpretFieldAttribute({
 			node: uniqueNode,
+			symbols: input.symbolTable,
 			spec: sqlAttributeSpecs.field.unique(),
 			model: input.model,
 			field: input.field,
@@ -1386,6 +1391,7 @@ function lowerNoCheckForField(input) {
 	const interpreted = interpretFieldAttribute({
 		node,
 		spec: sqlAttributeSpecs.field.noCheck(),
+		symbols: input.symbolTable,
 		model: input.model,
 		field: input.field,
 		sources: input.sources,
@@ -1580,6 +1586,7 @@ function collectResolvedFields(input) {
 		}
 		const mappedColumnName = mapping.fieldColumns.get(field.name) ?? field.name;
 		const { idAttribute, uniqueAttribute, idName, uniqueName } = extractFieldConstraintNames({
+			symbolTable: input.symbolTable,
 			model,
 			field,
 			sources: input.sources,
@@ -1613,6 +1620,7 @@ function collectResolvedFields(input) {
 		const fieldExecutionDefaults = presetContributions?.executionDefaults ?? loweredDefault.executionDefaults;
 		const fieldDefaultValue = presetContributions?.default ?? loweredDefault.defaultValue;
 		const noCheckKinds = modelDerivesChecks ? lowerNoCheckForField({
+			symbolTable: input.symbolTable,
 			model,
 			field,
 			sources: input.sources,
@@ -1639,12 +1647,13 @@ function collectResolvedFields(input) {
 	}
 	return resolvedFields;
 }
-function buildModelMappings(modelEntries, defaultNamespaceId, diagnostics, sources) {
+function buildModelMappings(symbols, modelEntries, defaultNamespaceId, diagnostics, sources) {
 	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,
@@ -1655,6 +1664,7 @@ function buildModelMappings(modelEntries, defaultNamespaceId, diagnostics, sourc
 			const fieldMapNode = findFieldAttributeNode(field, "map");
 			const columnName = fieldMapNode === void 0 ? field.name : interpretFieldAttribute({
 				node: fieldMapNode,
+				symbols,
 				spec: sqlAttributeSpecs.field.map(),
 				model,
 				field,
@@ -1830,6 +1840,7 @@ function interpretRelationAttribute(input) {
 	const node = findFieldAttributeNode(input.field, "relation");
 	if (node === void 0) return void 0;
 	return interpretFieldAttribute({
+		symbols: input.symbols,
 		node,
 		spec: sqlAttributeSpecs.field.relation(),
 		model: input.selfModel,
@@ -2642,6 +2653,7 @@ function buildModelNodeFromPsl(input) {
 				node,
 				spec: sqlAttributeSpecs.model.control(),
 				model,
+				symbols: input.symbolTable,
 				sources: input.sources,
 				diagnostics
 			});
@@ -2673,6 +2685,7 @@ function buildModelNodeFromPsl(input) {
 				node,
 				spec: sqlAttributeSpecs.model.id(),
 				model,
+				symbols: input.symbolTable,
 				sources: input.sources,
 				diagnostics
 			});
@@ -2711,6 +2724,7 @@ function buildModelNodeFromPsl(input) {
 				node,
 				spec: sqlAttributeSpecs.model.unique(),
 				model,
+				symbols: input.symbolTable,
 				sources: input.sources,
 				diagnostics
 			});
@@ -2738,6 +2752,7 @@ function buildModelNodeFromPsl(input) {
 				node,
 				spec: sqlAttributeSpecs.model.index(),
 				model,
+				symbols: input.symbolTable,
 				sources: input.sources,
 				diagnostics
 			});
@@ -2783,6 +2798,7 @@ function buildModelNodeFromPsl(input) {
 				node,
 				spec: sqlAttributeSpecs.model.check(),
 				model,
+				symbols: input.symbolTable,
 				sources: input.sources,
 				diagnostics
 			});
@@ -2819,6 +2835,7 @@ function buildModelNodeFromPsl(input) {
 					}
 				}),
 				model,
+				symbols: input.symbolTable,
 				sources: input.sources,
 				diagnostics
 			});
@@ -3208,15 +3225,16 @@ function patchModelDomainFields(models, modelResolvedFields) {
 	}
 	return patched;
 }
-function collectPolymorphismDeclarations(models, sources, diagnostics) {
+function collectPolymorphismDeclarations(identities, symbols, sources, diagnostics) {
 	const discriminatorDeclarations = /* @__PURE__ */ new Map();
 	const baseDeclarations = /* @__PURE__ */ new Map();
-	for (const model of models) {
+	for (const { model, key } of identities.values()) {
 		const source = diagnosticSource(sources, model.node.syntax);
 		const discriminatorNode = findModelAttributeNode(model, "discriminator");
 		if (discriminatorNode !== void 0) {
 			const parsed = interpretModelAttribute({
 				node: discriminatorNode,
+				symbols,
 				spec: sqlAttributeSpecs.model.discriminator(),
 				model,
 				sources,
@@ -3230,7 +3248,7 @@ function collectPolymorphismDeclarations(models, sources, diagnostics) {
 					message: `Discriminator field "${parsed.field}" on model "${model.name}" must be of type String, but is "${discField.typeName}"`,
 					...source.at(span)
 				});
-				else discriminatorDeclarations.set(model.name, {
+				else discriminatorDeclarations.set(key, {
 					fieldName: parsed.field,
 					span,
 					source
@@ -3241,17 +3259,22 @@ function collectPolymorphismDeclarations(models, sources, diagnostics) {
 		if (baseNode !== void 0) {
 			const parsed = interpretModelAttribute({
 				node: baseNode,
+				symbols,
 				spec: sqlAttributeSpecs.model.base(),
 				model,
 				sources,
 				diagnostics
 			});
-			if (parsed !== void 0) baseDeclarations.set(model.name, {
-				source,
-				baseName: parsed.base,
-				value: parsed.value,
-				span: nodePslSpan(baseNode.syntax, sources)
-			});
+			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`);
+				baseDeclarations.set(key, {
+					source,
+					base,
+					value: parsed.value,
+					span: nodePslSpan(baseNode.syntax, sources)
+				});
+			}
 		}
 	}
 	return {
@@ -3259,11 +3282,9 @@ function collectPolymorphismDeclarations(models, sources, diagnostics) {
 		baseDeclarations
 	};
 }
-function resolvePolymorphism(models, discriminatorDeclarations, baseDeclarations, modelNames, modelMappings, modelNamespaceIds, defaultNamespaceId, syntheticPkFieldsByVariant, stiBaseFieldsByBase, diagnostics) {
+function resolvePolymorphism(models, discriminatorDeclarations, baseDeclarations, modelMappings, syntheticPkFieldsByVariant, stiBaseFieldsByBase, diagnostics) {
 	let patched = models;
-	const coordinateFor = (modelName) => modelCoordinateKey(modelNamespaceIds.get(modelName) ?? defaultNamespaceId, modelName);
-	for (const [baseName, fieldNames] of stiBaseFieldsByBase) {
-		const baseKey = coordinateFor(baseName);
+	for (const [baseKey, fieldNames] of stiBaseFieldsByBase) {
 		const baseModel = patched[baseKey];
 		if (!baseModel || fieldNames.length === 0) continue;
 		patched = {
@@ -3271,8 +3292,9 @@ function resolvePolymorphism(models, discriminatorDeclarations, baseDeclarations
 			[baseKey]: stripStorageOnlyDomainFields(baseModel, fieldNames)
 		};
 	}
-	for (const [modelName, decl] of discriminatorDeclarations) {
-		if (baseDeclarations.has(modelName)) {
+	for (const [modelKey, decl] of discriminatorDeclarations) {
+		const modelName = modelMappings.get(modelKey)?.model.name;
+		if (baseDeclarations.has(modelKey)) {
 			diagnostics.push({
 				code: "PSL_DISCRIMINATOR_AND_BASE",
 				message: `Model "${modelName}" cannot have both @@discriminator and @@base`,
@@ -3280,12 +3302,14 @@ function resolvePolymorphism(models, discriminatorDeclarations, baseDeclarations
 			});
 			continue;
 		}
-		const model = patched[coordinateFor(modelName)];
+		const model = patched[modelKey];
 		if (!model) continue;
 		const variants = {};
 		const seenValues = /* @__PURE__ */ new Map();
-		for (const [variantName, baseDecl] of baseDeclarations) {
-			if (baseDecl.baseName !== modelName) continue;
+		for (const [variantKey, baseDecl] of baseDeclarations) {
+			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 existingVariant = seenValues.get(baseDecl.value);
 			if (existingVariant) {
 				diagnostics.push({
@@ -3308,39 +3332,33 @@ function resolvePolymorphism(models, discriminatorDeclarations, baseDeclarations
 		}
 		patched = {
 			...patched,
-			[coordinateFor(modelName)]: {
+			[modelKey]: {
 				...model,
 				discriminator: { field: decl.fieldName },
 				variants
 			}
 		};
 	}
-	for (const [variantName, baseDecl] of baseDeclarations) {
-		if (!modelNames.has(baseDecl.baseName)) {
-			diagnostics.push({
-				code: "PSL_BASE_TARGET_NOT_FOUND",
-				message: `Model "${variantName}" @@base references non-existent model "${baseDecl.baseName}"`,
-				...baseDecl.source.at(baseDecl.span)
-			});
-			continue;
-		}
-		if (!discriminatorDeclarations.has(baseDecl.baseName)) {
+	for (const [variantKey, baseDecl] of baseDeclarations) {
+		const variantMapping = modelMappings.get(variantKey);
+		const variantName = variantMapping?.model.name;
+		const baseName = baseDecl.base.model.name;
+		if (!discriminatorDeclarations.has(baseDecl.base.key)) {
 			diagnostics.push({
 				code: "PSL_ORPHANED_BASE",
-				message: `Model "${variantName}" declares @@base(${baseDecl.baseName}, ...) but "${baseDecl.baseName}" has no @@discriminator`,
+				message: `Model "${variantName}" declares @@base(${baseName}, ...) but "${baseName}" has no @@discriminator`,
 				...baseDecl.source.at(baseDecl.span)
 			});
 			continue;
 		}
-		if (discriminatorDeclarations.has(variantName)) continue;
-		const variantModel = patched[coordinateFor(variantName)];
+		if (discriminatorDeclarations.has(variantKey)) continue;
+		const variantModel = patched[variantKey];
 		if (!variantModel) continue;
-		const baseMapping = modelMappings.get(baseDecl.baseName);
-		const variantMapping = modelMappings.get(variantName);
+		const baseMapping = modelMappings.get(baseDecl.base.key);
 		const resolvedTable = variantMapping?.model.attributes.some((attr) => attr.name === "map") ?? false ? variantMapping?.tableName : baseMapping?.tableName;
 		const patchedVariant = {
 			...variantModel,
-			base: crossRef(baseDecl.baseName, modelNamespaceIds.get(baseDecl.baseName) ?? defaultNamespaceId),
+			base: crossRef(baseName, baseDecl.base.namespaceId),
 			...resolvedTable ? { storage: {
 				...variantModel.storage,
 				table: resolvedTable
@@ -3348,7 +3366,7 @@ function resolvePolymorphism(models, discriminatorDeclarations, baseDeclarations
 		};
 		patched = {
 			...patched,
-			[coordinateFor(variantName)]: stripStorageOnlyDomainFields(patchedVariant, syntheticPkFieldsByVariant.get(variantName) ?? [])
+			[variantKey]: stripStorageOnlyDomainFields(patchedVariant, syntheticPkFieldsByVariant.get(variantKey) ?? [])
 		};
 	}
 	return patched;
@@ -3367,16 +3385,18 @@ function resolvePolymorphism(models, discriminatorDeclarations, baseDeclarations
 * storage table stays joinable. Single-table-inheritance variants (no own
 * table) are left untouched.
 */
-function materializeMtiVariantStorageLinks(modelNodes, baseDeclarations, stiVariantNames) {
-	const nodeByModel = new Map(modelNodes.map((node) => [node.modelName, node]));
+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 baseDecl = baseDeclarations.get(node.modelName);
+			const variantKey = keyOf(node);
+			const baseDecl = baseDeclarations.get(variantKey);
 			if (!baseDecl) return node;
-			const baseNode = nodeByModel.get(baseDecl.baseName);
+			const baseNode = nodeByModel.get(baseDecl.base.key);
 			if (!baseNode) return node;
-			if (stiVariantNames.has(node.modelName)) 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));
@@ -3393,7 +3413,7 @@ function materializeMtiVariantStorageLinks(modelNodes, baseDeclarations, stiVari
 				});
 			}
 			if (linkFields.length === 0) return node;
-			syntheticPkFieldsByVariant.set(node.modelName, linkFields.map((field) => field.fieldName));
+			syntheticPkFieldsByVariant.set(variantKey, linkFields.map((field) => field.fieldName));
 			const foreignKey = {
 				columns: basePrimaryKey.columns,
 				references: {
@@ -3435,21 +3455,22 @@ function materializeMtiVariantStorageLinks(modelNodes, baseDeclarations, stiVari
 * MTI link guard; surfacing them as diagnostics is tracked separately
 * (TML-2827).
 */
-function materializeStiVariantStorageColumns(modelNodes, baseDeclarations, stiVariantNames) {
-	if (stiVariantNames.size === 0) return {
+function materializeStiVariantStorageColumns(modelNodes, baseDeclarations, stiVariantKeys, defaultNamespaceId) {
+	if (stiVariantKeys.size === 0) return {
 		modelNodes: [...modelNodes],
 		stiBaseFieldsByBase: /* @__PURE__ */ new Map()
 	};
-	const nodeByModel = new Map(modelNodes.map((node) => [node.modelName, node]));
+	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 variantName of stiVariantNames) {
-		const variantNode = nodeByModel.get(variantName);
-		const baseDecl = baseDeclarations.get(variantName);
+	for (const variantKey of stiVariantKeys) {
+		const variantNode = nodeByModel.get(variantKey);
+		const baseDecl = baseDeclarations.get(variantKey);
 		if (!variantNode || !baseDecl) continue;
-		const baseNode = nodeByModel.get(baseDecl.baseName);
+		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.baseName) ?? [];
+		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;
@@ -3459,17 +3480,17 @@ function materializeStiVariantStorageColumns(modelNodes, baseDeclarations, stiVa
 				nullable: true
 			});
 		}
-		stiColumnsByBase.set(baseDecl.baseName, claimed);
+		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 (stiVariantNames.has(node.modelName)) return {
+			if (stiVariantKeys.has(keyOf(node))) return {
 				...node,
 				sharesBaseTable: true
 			};
-			const stiColumns = stiColumnsByBase.get(node.modelName);
+			const stiColumns = stiColumnsByBase.get(keyOf(node));
 			if (!stiColumns || stiColumns.length === 0) return node;
 			return {
 				...node,
@@ -3637,7 +3658,7 @@ function interpretPslDocumentToSqlContract(input) {
 		} },
 		warnings: authoringWarnings
 	};
-	const earlyModelMappingsByCoordinate = buildModelMappings(modelEntries, defaultNamespaceId, createPslDiagnosticCollector(input.sources), input.sources);
+	const earlyModelMappingsByCoordinate = buildModelMappings(input.symbolTable, modelEntries, defaultNamespaceId, createPslDiagnosticCollector(input.sources), input.sources);
 	const composedPslBlockDescriptors = input.authoringContributions?.pslBlockDescriptors ?? {};
 	const namespaceExtensionEntities = /* @__PURE__ */ new Map();
 	const mergeNamespaceExtensionEntities = (nsId, entities, blocks) => {
@@ -3710,7 +3731,7 @@ function interpretPslDocumentToSqlContract(input) {
 		diagnostics
 	});
 	const storageTypes = { ...namedTypeResult.storageTypes };
-	const modelMappingsByCoordinate = buildModelMappings(modelEntries, defaultNamespaceId, diagnostics, input.sources);
+	const modelMappingsByCoordinate = buildModelMappings(input.symbolTable, modelEntries, defaultNamespaceId, diagnostics, input.sources);
 	const modelMappings = /* @__PURE__ */ new Map();
 	for (const mapping of modelMappingsByCoordinate.values()) modelMappings.set(mapping.model.name, mapping);
 	const modelNodes = [];
@@ -3801,25 +3822,33 @@ function interpretPslDocumentToSqlContract(input) {
 		if (existing) existing.push(...relations);
 		else modelRelations.set(modelName, [...relations]);
 	}
-	const { discriminatorDeclarations, baseDeclarations } = collectPolymorphismDeclarations(models, input.sources, diagnostics);
-	const stiVariantNames = /* @__PURE__ */ new Set();
-	for (const variantName of baseDeclarations.keys()) if (!(modelMappings.get(variantName)?.model.attributes.some((attr) => attr.name === "map") ?? false)) stiVariantNames.add(variantName);
-	for (const variantName of stiVariantNames) {
-		const variantMapping = modelMappings.get(variantName);
+	const { discriminatorDeclarations, baseDeclarations } = collectPolymorphismDeclarations(new Map(modelEntries.map(({ model, namespaceId }) => {
+		const resolvedNamespaceId = namespaceId ?? defaultNamespaceId;
+		return [model, {
+			model,
+			namespaceId: resolvedNamespaceId,
+			key: modelCoordinateKey(resolvedNamespaceId, model.name)
+		}];
+	})), input.symbolTable, input.sources, 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 of stiVariantKeys) {
+		const variantMapping = modelMappingsByCoordinate.get(variantKey);
 		if (variantMapping === void 0) continue;
-		const baseDecl = baseDeclarations.get(variantName);
-		invariant(baseDecl !== void 0, `stiVariantNames is derived from baseDeclarations.keys(), so "${variantName}" must have a base declaration`);
+		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()) {
 			if (attribute.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.baseName}"'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.baseName}" instead.`,
+				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.syntax).at(nodePslSpan(attribute.syntax, input.sources))
 			});
 		}
 	}
-	const { modelNodes: mtiLinkedModelNodes, syntheticPkFieldsByVariant } = materializeMtiVariantStorageLinks(modelNodes, baseDeclarations, stiVariantNames);
-	const { modelNodes: stiColumnModelNodes, stiBaseFieldsByBase } = materializeStiVariantStorageColumns(mtiLinkedModelNodes, baseDeclarations, stiVariantNames);
+	const { modelNodes: mtiLinkedModelNodes, syntheticPkFieldsByVariant } = materializeMtiVariantStorageLinks(modelNodes, baseDeclarations, stiVariantKeys, defaultNamespaceId);
+	const { modelNodes: stiColumnModelNodes, stiBaseFieldsByBase } = materializeStiVariantStorageColumns(mtiLinkedModelNodes, baseDeclarations, stiVariantKeys, defaultNamespaceId);
 	const valueObjects = buildValueObjects({
 		compositeTypes,
 		enumTypeDescriptors: allEnumTypeDescriptors,
@@ -3883,13 +3912,12 @@ function interpretPslDocumentToSqlContract(input) {
 	}
 	let patchedModels = patchModelDomainFields(modelsForPatch, modelResolvedFields);
 	const polyDiagnostics = createPslDiagnosticCollector(input.sources);
-	patchedModels = resolvePolymorphism(patchedModels, discriminatorDeclarations, baseDeclarations, modelNames, modelMappings, modelNamespaceIds, input.target.defaultNamespaceId, syntheticPkFieldsByVariant, stiBaseFieldsByBase, polyDiagnostics);
+	patchedModels = resolvePolymorphism(patchedModels, discriminatorDeclarations, baseDeclarations, modelMappingsByCoordinate, syntheticPkFieldsByVariant, stiBaseFieldsByBase, polyDiagnostics);
 	if (polyDiagnostics.length > 0) return notOk({
 		summary: "PSL to SQL contract interpretation failed",
 		diagnostics: polyDiagnostics.toExternal()
 	});
-	const variantModelNames = new Set(baseDeclarations.keys());
-	const filteredRoots = Object.fromEntries(Object.entries(contract.roots).filter(([, crossReference]) => !variantModelNames.has(crossReference.model)));
+	const filteredRoots = Object.fromEntries(Object.entries(contract.roots).filter(([, crossReference]) => !baseDeclarations.has(modelCoordinateKey(crossReference.namespace, crossReference.model))));
 	return ok({
 		...contract,
 		roots: filteredRoots,
@@ -3904,4 +3932,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-DvKii7Bl-D8Ipte3f.mjs.map
+//# sourceMappingURL=interpreter-BIBwrA2w-DAiNN30m.mjs.map