@prisma/orm-family-mongo 8.0.0-rc.14-dev.12 → 8.0.0-rc.14-dev.13

package/dist/{interpreter-Da0fGDSM-DGCJEzeI.mjs → interpreter-DSD7dXPk-D37QHryH.mjs}

@@ -8,11 +8,11 @@ import { ArrayLiteralAst, FunctionCallAst, PathExprAst } from "@prisma/orm-frame
 import { notOk, ok } from "@prisma/orm-framework/utils/result";
 import { resolveToOneRelationNullable } from "@prisma/orm-framework/contract-authoring";
 import { checkUncomposedNamespace, getAuthoringFieldPreset, hasRegisteredFieldNamespace, instantiateAuthoringEntityType, isAuthoringEntityTypeDescriptor, isAuthoringTypeConstructorDescriptor } from "@prisma/orm-framework/components/authoring";
-import { bool, createBinder, createPslDiagnosticCollector, diagnosticSource, entityRef, fieldAttribute, fieldRef, funcCall, identifier, int, interpretAttribute, interpretExtensionBlocks, json, list, mapPslDiagnostics, modelAttribute, nodePslSpan, num, oneOf, optional, record, referencedFieldRef, str } from "@prisma/orm-framework/psl-parser";
+import { bool, createBinder, createPslDiagnosticCollector, diagnosticSource, entityRef, fieldAttribute, fieldRef, funcCall, identifier, int, interpretAttribute, interpretExtensionBlocks, json, list, mapPslDiagnostics, modelAttribute, nodePslSpan, num, oneOf, optional, record, referencedFieldRef, str, typeReferenceNode } from "@prisma/orm-framework/psl-parser";
 import { claimedBlockKeywords, consumeInvalidFkPairing, enumMemberAttributeDiagnostics, fkRelationPairKey, instantiatePslFieldPreset, reportUncomposedNamespace, reportUnknownFieldPreset, requiredOneToOneBackrelationDiagnostic, unsupportedBlockDiagnostic } from "@prisma/orm-framework/psl-parser/interpret";
 import { assertDefined } from "@prisma/orm-framework/utils/assertions";
 import { ifDefined } from "@prisma/orm-framework/utils/defined";
-//#region ../../../2-mongo-family/2-authoring/contract-psl/dist/interpreter-Da0fGDSM.mjs
+//#region ../../../2-mongo-family/2-authoring/contract-psl/dist/interpreter-DSD7dXPk.mjs
 /**
 * The `bsonType` keyword for a list of BSON type names: the name itself for one entry, the list for several.
 */
@@ -258,12 +258,6 @@ function resolveFieldPreset(input) {
 		...ifDefined("executionDefaults", instantiated.executionDefaults)
 	};
 }
-function findModelAttributeNode(model, name) {
-	for (const attribute of model.node.attributes()) if (attribute.name()?.isSimpleName(name) === true) return attribute;
-}
-function findFieldAttributeNode(field, name) {
-	for (const attribute of field.node.attributes()) if (attribute.name()?.isSimpleName(name) === true) return attribute;
-}
 function buildModelAttributeCtx(input) {
 	return {
 		sources: input.sources,
@@ -736,14 +730,24 @@ function relationNullabilityMismatchDiagnostic(modelName, field, sources) {
 		...source.at(field.span)
 	};
 }
-function resolveFieldMappings(input) {
-	const { model, specContext, sources, binder, diagnostics } = input;
-	const pslNameToMapped = /* @__PURE__ */ new Map();
+function resolvePhysicalNames(input) {
+	const { model, physicalNames, specContext, sources, binder, diagnostics } = input;
+	const modelMap = model.attributes.find((attr) => attr.name === "map");
+	const collectionName = modelMap ? interpretModelAttribute({
+		symbols: specContext.symbols,
+		node: modelMap.node,
+		spec: mongoAttributeSpecs.model.map(specContext),
+		model,
+		sources,
+		binder,
+		diagnostics
+	})?.name : void 0;
+	physicalNames.set(model, collectionName ?? defaultCollectionName(model.name));
 	for (const field of Object.values(model.fields)) {
-		const mapNode = findFieldAttributeNode(field, "map");
-		const mapped = (mapNode ? interpretFieldAttribute({
+		const fieldMap = field.attributes.find((attr) => attr.name === "map");
+		const mapped = fieldMap ? interpretFieldAttribute({
 			symbols: specContext.symbols,
-			node: mapNode,
+			node: fieldMap.node,
 			spec: mongoAttributeSpecs.field.map({
 				...specContext,
 				field
@@ -753,33 +757,25 @@ function resolveFieldMappings(input) {
 			sources,
 			binder,
 			diagnostics
-		})?.name : void 0) ?? field.name;
-		pslNameToMapped.set(field.name, mapped);
+		})?.name : void 0;
+		physicalNames.set(field, mapped ?? field.name);
 	}
-	return { pslNameToMapped };
 }
-function resolveCollectionName(input) {
-	const { model, specContext, sources, binder, diagnostics } = input;
-	const mapNode = findModelAttributeNode(model, "map");
-	return (mapNode ? interpretModelAttribute({
-		symbols: specContext.symbols,
-		node: mapNode,
-		spec: mongoAttributeSpecs.model.map(specContext),
-		model,
-		sources,
-		binder,
-		diagnostics
-	})?.name : void 0) ?? defaultCollectionName(model.name);
+function physicalName(physicalNames, symbol) {
+	assertDefined(symbol, "Physical names require a bound declaration");
+	const name = physicalNames.get(symbol);
+	assertDefined(name, "Physical names must be populated before lowering");
+	return name;
 }
 function mongoCrossRef(modelName) {
 	return crossRef(modelName, UNBOUND_NAMESPACE_ID);
 }
-function collectPolymorphismDeclarations(models, specContextFor, modelMetadataByName, sources, binder, diagnostics) {
+function collectPolymorphismDeclarations(models, specContextFor, physicalNames, sources, binder, diagnostics) {
 	const discriminatorDeclarations = /* @__PURE__ */ new Map();
 	const baseDeclarations = /* @__PURE__ */ new Map();
 	for (const model of models) {
 		const specContext = specContextFor(model);
-		const discNode = findModelAttributeNode(model, "discriminator");
+		const discNode = model.attributes.find((attr) => attr.name === "discriminator")?.node;
 		if (discNode) {
 			const parsed = interpretModelAttribute({
 				symbols: specContext.symbols,
@@ -805,7 +801,7 @@ function collectPolymorphismDeclarations(models, specContextFor, modelMetadataBy
 				});
 			}
 		}
-		const baseNode = findModelAttributeNode(model, "base");
+		const baseNode = model.attributes.find((attr) => attr.name === "base")?.node;
 		if (baseNode) {
 			const parsed = interpretModelAttribute({
 				symbols: specContext.symbols,
@@ -817,7 +813,7 @@ function collectPolymorphismDeclarations(models, specContextFor, modelMetadataBy
 				diagnostics
 			});
 			if (parsed) {
-				const collectionName = modelMetadataByName.get(model.name)?.collectionName ?? defaultCollectionName(model.name);
+				const collectionName = physicalName(physicalNames, model);
 				baseDeclarations.set(model, {
 					base: parsed.base.declaration,
 					value: parsed.value,
@@ -834,7 +830,7 @@ function collectPolymorphismDeclarations(models, specContextFor, modelMetadataBy
 	};
 }
 function resolvePolymorphism(input) {
-	const { discriminatorDeclarations, baseDeclarations, modelMetadataByName, indexSpans, modelIndexesByName, indexSources } = input;
+	const { discriminatorDeclarations, baseDeclarations, physicalNames, indexSpans, modelIndexesByName, indexSources } = input;
 	let patched = input.models;
 	let roots = input.roots;
 	let collections = input.collections;
@@ -851,7 +847,7 @@ function resolvePolymorphism(input) {
 		}
 		const model = patched[modelName];
 		if (!model) continue;
-		const mappedDiscriminatorField = modelMetadataByName.get(modelName)?.fieldMappings.pslNameToMapped.get(decl.fieldName) ?? decl.fieldName;
+		const mappedDiscriminatorField = physicalName(physicalNames, declaration.fields[decl.fieldName]);
 		if (!Object.hasOwn(model.fields, mappedDiscriminatorField)) {
 			diagnostics.push({
 				code: "PSL_DISCRIMINATOR_FIELD_NOT_FOUND",
@@ -913,7 +909,7 @@ function resolvePolymorphism(input) {
 				storage: { collection: baseCollection }
 			}
 		};
-		const variantCollectionName = modelMetadataByName.get(variantName)?.collectionName ?? defaultCollectionName(variantName);
+		const variantCollectionName = physicalName(physicalNames, variant);
 		if (roots[variantCollectionName]?.model === variantName) if (variantCollectionName === baseCollection && baseModel) roots = {
 			...roots,
 			[variantCollectionName]: mongoCrossRef(baseName)
@@ -1050,12 +1046,12 @@ function resolveIndexKeys(parsedFields, defaultDirection, ctx) {
 					direction: defaultDirection
 				};
 				return {
-					field: `${ctx.fieldMappings.pslNameToMapped.get(field.scope) ?? field.scope}.$**`,
+					field: `${physicalName(ctx.physicalNames, ctx.pslModel.fields[field.scope])}.$**`,
 					direction: defaultDirection
 				};
 			}
 			return {
-				field: ctx.fieldMappings.pslNameToMapped.get(field.name) ?? field.name,
+				field: physicalName(ctx.physicalNames, ctx.pslModel.fields[field.name]),
 				direction: field.direction ?? defaultDirection
 			};
 		}),
@@ -1198,20 +1194,20 @@ function nestedIndexPath(node) {
 		}
 	}
 }
-function nestedIndexPathMessage(path, pslModel, compositeTypeNames) {
+function nestedIndexPathMessage(path, pslModel, binder) {
 	const [root = ""] = path;
 	const label = `Index field "${path.join(".")}" on model "${pslModel.name}"`;
-	const rootType = Object.hasOwn(pslModel.fields, root) ? pslModel.fields[root]?.typeName : void 0;
-	return rootType !== void 0 && compositeTypeNames.has(rootType) ? `${label} is a path into a composite type; indexes on fields of a composite type are not supported yet. Index a top-level field of "${pslModel.name}" or remove the index.` : `${label} is a dotted path, but "${root}" is not a field of "${pslModel.name}" whose type is a composite type, so the path names no field. List fields of "${pslModel.name}" by name.`;
+	const rootField = Object.hasOwn(pslModel.fields, root) ? pslModel.fields[root] : void 0;
+	return rootField !== void 0 && fieldTypeResolution(rootField, binder)?.kind === "compositeType" ? `${label} is a path into a composite type; indexes on fields of a composite type are not supported yet. Index a top-level field of "${pslModel.name}" or remove the index.` : `${label} is a dotted path, but "${root}" is not a field of "${pslModel.name}" whose type is a composite type, so the path names no field. List fields of "${pslModel.name}" by name.`;
 }
-function collectIndexes(pslModel, specContext, fieldMappings, modelNames, compositeTypeNames, sources, binder, diagnostics, indexSpans, indexSources) {
+function collectIndexes(pslModel, specContext, physicalNames, sources, binder, diagnostics, indexSpans, indexSources) {
 	const indexes = [];
 	let textIndexCount = 0;
 	const indexableFieldNames = /* @__PURE__ */ new Set();
-	for (const field of Object.values(pslModel.fields)) if (!modelNames.has(field.typeName)) indexableFieldNames.add(field.name);
+	for (const field of Object.values(pslModel.fields)) if (fieldTypeResolution(field, binder)?.kind !== "model") indexableFieldNames.add(field.name);
 	for (const field of Object.values(pslModel.fields)) {
-		if (modelNames.has(field.typeName)) continue;
-		const uniqueNode = findFieldAttributeNode(field, "unique");
+		if (fieldTypeResolution(field, binder)?.kind === "model") continue;
+		const uniqueNode = field.attributes.find((attr) => attr.name === "unique")?.node;
 		if (!uniqueNode) continue;
 		if (interpretFieldAttribute({
 			symbols: specContext.symbols,
@@ -1228,7 +1224,7 @@ function collectIndexes(pslModel, specContext, fieldMappings, modelNames, compos
 		}) === void 0) continue;
 		const fieldUniqueIndex = new MongoIndex({
 			keys: [{
-				field: fieldMappings.pslNameToMapped.get(field.name) ?? field.name,
+				field: physicalName(physicalNames, field),
 				direction: 1
 			}],
 			unique: true
@@ -1237,15 +1233,13 @@ function collectIndexes(pslModel, specContext, fieldMappings, modelNames, compos
 		indexSpans.set(fieldUniqueIndex, nodePslSpan(uniqueNode.syntax, sources));
 		indexSources.set(fieldUniqueIndex, diagnosticSource(sources, uniqueNode.syntax));
 	}
-	const attributeNodes = Array.from(pslModel.node.attributes());
-	for (const [attrIndex, attr] of pslModel.attributes.entries()) {
+	for (const attr of pslModel.attributes) {
 		if (attr.name !== "index" && attr.name !== "unique" && attr.name !== "textIndex") continue;
-		const node = attributeNodes[attrIndex];
-		if (!node) continue;
+		const node = attr.node;
 		const source = diagnosticSource(sources, node.syntax);
 		const ctx = {
 			pslModel,
-			fieldMappings,
+			physicalNames,
 			indexableFieldNames,
 			source,
 			span: attr.span,
@@ -1255,7 +1249,7 @@ function collectIndexes(pslModel, specContext, fieldMappings, modelNames, compos
 		if (nested !== void 0) {
 			diagnostics.push({
 				code: "PSL_INVALID_INDEX",
-				message: nestedIndexPathMessage(nested.path, pslModel, compositeTypeNames),
+				message: nestedIndexPathMessage(nested.path, pslModel, binder),
 				...source.at(nodePslSpan(nested.syntax, sources))
 			});
 			continue;
@@ -1303,13 +1297,11 @@ function collectIndexes(pslModel, specContext, fieldMappings, modelNames, compos
 	}
 	return indexes;
 }
-function isRelationField(field, modelNames) {
-	return modelNames.has(field.typeName);
+function fieldTypeResolution(field, binder) {
+	const node = typeReferenceNode(field);
+	return node === void 0 ? void 0 : binder.symbolForNode(node);
 }
 const MONGO_OBJECT_ID_PSL_TYPE = "ObjectId";
-function resolveFieldCodecId(field, scalarTypeCodecIds) {
-	return scalarTypeCodecIds.get(field.typeName);
-}
 /**
 * Keys each preset's execution defaults by collection and stored field. Rejects presets on variant fields, since a default keyed by collection applies to every document in it, and merges identical defaults that two models declare for the same collection field.
 */
@@ -1357,14 +1349,13 @@ function resolvePresetExecutionDefaults(input) {
 	}
 	return resolved;
 }
-function resolveNonRelationField(field, owner, compositeTypeNames, scalarTypeCodecIds, codecIdByEnumName, presetContext, scalarNames) {
-	const { sources, diagnostics } = presetContext;
+function resolveNonRelationField(field, owner, resolution, codecIdByEnumName, presetContext, scalarNames, onPresetHandled, onUnresolvedType) {
 	const ownerName = owner.name;
-	if (compositeTypeNames.has(field.typeName)) {
+	if (resolution?.kind === "compositeType") {
 		const result = {
 			type: {
 				kind: "valueObject",
-				name: field.typeName
+				name: resolution.symbol.name
 			},
 			nullable: field.optional
 		};
@@ -1373,13 +1364,14 @@ function resolveNonRelationField(field, owner, compositeTypeNames, scalarTypeCod
 			many: true
 		} : result };
 	}
-	const enumCodecId = codecIdByEnumName.get(field.typeName);
-	if (enumCodecId !== void 0) {
+	if (resolution?.kind === "block" && resolution.symbol.keyword === "enum") {
+		const enumCodecId = codecIdByEnumName.get(resolution.symbol.name);
+		if (enumCodecId === void 0) return void 0;
 		const valueSet = {
 			plane: "domain",
 			entityKind: "enum",
 			namespaceId: UNBOUND_NAMESPACE_ID,
-			entityName: field.typeName
+			entityName: resolution.symbol.name
 		};
 		const result = {
 			type: {
@@ -1394,30 +1386,36 @@ function resolveNonRelationField(field, owner, compositeTypeNames, scalarTypeCod
 			many: true
 		} : result };
 	}
-	if (field.malformedType) return;
-	const preset = resolveFieldPreset({
-		field,
-		ownerName,
-		ownerKind: owner.kind,
-		context: presetContext
-	});
-	if (preset.kind === "invalid") return;
-	if (preset.kind === "preset") return {
-		field: preset.field,
-		...ifDefined("executionDefaults", preset.executionDefaults)
-	};
-	const codecId = resolveFieldCodecId(field, scalarTypeCodecIds);
-	if (!codecId && scalarNames.declaredEnums.has(field.typeName)) return;
-	if (!codecId) {
-		const typeNode = field.node.typeAnnotation()?.name()?.syntax;
-		const source = diagnosticSource(sources, field.node.syntax);
-		diagnostics.push({
+	if (resolution?.kind === "model" || resolution?.kind === "namedType" || resolution?.kind === "block" || resolution?.kind === "crossSpace") {
+		presetContext.diagnostics.push({
 			code: "PSL_UNSUPPORTED_FIELD_TYPE",
-			message: scalarNames.unknownTypeMessage(field, ownerName),
-			...typeNode === void 0 ? source.at(field.span) : diagnosticSource(sources, typeNode).at()
+			message: `Field "${ownerName}.${field.name}" type "${field.typeName}" is not supported in Mongo PSL interpreter`,
+			...diagnosticSource(presetContext.sources, field.node.syntax).at(field.span)
 		});
 		return;
 	}
+	if (resolution?.kind !== "contributedType" && resolution?.kind !== "unresolved") return;
+	if (resolution.kind === "unresolved") {
+		if (field.typeConstructor === void 0) {
+			if (resolution.name === field.typeName) onUnresolvedType(field, ownerName);
+			return;
+		}
+		if (resolution.name !== field.typeConstructor.path.join(".")) return void 0;
+		const preset = resolveFieldPreset({
+			field,
+			ownerName,
+			ownerKind: owner.kind,
+			context: presetContext
+		});
+		if (preset.kind === "none") return void 0;
+		onPresetHandled(field);
+		if (preset.kind === "invalid") return void 0;
+		return {
+			field: preset.field,
+			...ifDefined("executionDefaults", preset.executionDefaults)
+		};
+	}
+	const codecId = resolution.symbol.descriptor.output.codecId;
 	scalarNames.warnDeprecated(field);
 	const result = {
 		type: {
@@ -1492,8 +1490,7 @@ function interpretPslDocumentToMongoContract(input) {
 			types: input.authoringContributions?.type,
 			scalarTypeCodecIds,
 			formerScalarCodecIds: input.formerScalarCodecIds ?? /* @__PURE__ */ new Map()
-		}),
-		declaredEnums: new Set(Object.values(symbolTable.topLevel.blocks).filter((block) => block.keyword === "enum").map((block) => block.name))
+		})
 	};
 	const { binder, diagnostics: binderDiagnostics } = createMongoBinder({
 		symbolTable,
@@ -1502,7 +1499,20 @@ function interpretPslDocumentToMongoContract(input) {
 		controlMutationDefaults: input.controlMutationDefaults,
 		authoringContributions: input.authoringContributions
 	});
-	diagnostics.push(...binderDiagnostics.filter((diagnostic) => diagnostic.data?.["reference"] !== "type"));
+	const replacedTypeDiagnostics = /* @__PURE__ */ new Set();
+	const unresolvedTypeMessages = /* @__PURE__ */ new Map();
+	const typeDiagnosticsFor = (field) => {
+		const node = typeReferenceNode(field);
+		if (node === void 0) return [];
+		const { filename, range } = diagnosticSource(sources, node).at();
+		return binderDiagnostics.filter((diagnostic) => diagnostic.code === "PSL_UNRESOLVED_REFERENCE" && diagnostic.filename === filename && diagnostic.range.start.line === range.start.line && diagnostic.range.start.character === range.start.character && diagnostic.range.end.line === range.end.line && diagnostic.range.end.character === range.end.character);
+	};
+	const onPresetHandled = (field) => {
+		for (const diagnostic of typeDiagnosticsFor(field)) replacedTypeDiagnostics.add(diagnostic);
+	};
+	const onUnresolvedType = (field, ownerName) => {
+		for (const diagnostic of typeDiagnosticsFor(field)) unresolvedTypeMessages.set(diagnostic, scalarNames.unknownTypeMessage(field, ownerName));
+	};
 	const { parsedBlocks, diagnostics: blockDiagnostics } = interpretExtensionBlocks({
 		symbolTable,
 		sources,
@@ -1519,33 +1529,20 @@ function interpretPslDocumentToMongoContract(input) {
 	});
 	const allModels = Object.values(topLevel.models);
 	const allCompositeTypes = Object.values(topLevel.compositeTypes);
-	const modelNames = new Set(allModels.map((m) => m.name));
-	const compositeTypeNames = new Set(allCompositeTypes.map((ct) => ct.name));
 	const specContextFor = (model) => ({
 		symbols: symbolTable,
 		model,
 		controlMutationDefaults: input.controlMutationDefaults
 	});
-	const modelMetadataByName = /* @__PURE__ */ new Map();
-	for (const model of allModels) {
-		const specContext = specContextFor(model);
-		modelMetadataByName.set(model.name, {
-			collectionName: resolveCollectionName({
-				model,
-				specContext,
-				sources,
-				binder,
-				diagnostics
-			}),
-			fieldMappings: resolveFieldMappings({
-				model,
-				specContext,
-				sources,
-				binder,
-				diagnostics
-			})
-		});
-	}
+	const physicalNames = /* @__PURE__ */ new Map();
+	for (const model of allModels) resolvePhysicalNames({
+		model,
+		physicalNames,
+		specContext: specContextFor(model),
+		sources,
+		binder,
+		diagnostics
+	});
 	const blockKeywords = /* @__PURE__ */ new Set(["enum", ...claimedBlockKeywords(input.authoringContributions?.pslBlockDescriptors)]);
 	for (const block of Object.values(topLevel.blocks)) if (!blockKeywords.has(block.keyword)) diagnostics.push(unsupportedBlockDiagnostic(block, sources));
 	const builtEnums = processEnumDeclarations({
@@ -1577,15 +1574,15 @@ function interpretPslDocumentToMongoContract(input) {
 	const invalidFkPairings = [];
 	for (const pslModel of allModels) {
 		const modelSource = diagnosticSource(sources, pslModel.node.syntax);
-		const metadata = modelMetadataByName.get(pslModel.name);
-		if (!metadata) continue;
-		const { collectionName, fieldMappings } = metadata;
+		const collectionName = physicalName(physicalNames, pslModel);
 		const specContext = specContextFor(pslModel);
 		const fields = {};
 		const relations = {};
 		for (const field of Object.values(pslModel.fields)) {
-			if (isRelationField(field, modelNames)) {
-				const relationNode = findFieldAttributeNode(field, "relation");
+			const resolution = fieldTypeResolution(field, binder);
+			if (resolution?.kind === "model") {
+				const target = resolution.symbol;
+				const relationNode = field.attributes.find((attr) => attr.name === "relation")?.node;
 				const relation = relationNode ? interpretFieldAttribute({
 					symbols: specContext.symbols,
 					node: relationNode,
@@ -1602,7 +1599,7 @@ function interpretPslDocumentToMongoContract(input) {
 				if (field.list || !(relation?.fields && relation?.references)) {
 					backrelationCandidates.push({
 						modelName: pslModel.name,
-						targetModelName: field.typeName,
+						targetModelName: target.name,
 						...ifDefined("relationName", relation?.name),
 						cardinality: field.list ? "1:N" : "1:1",
 						field,
@@ -1618,16 +1615,16 @@ function interpretPslDocumentToMongoContract(input) {
 					}).contradiction !== void 0) {
 						diagnostics.push(relationNullabilityMismatchDiagnostic(pslModel.name, field, sources));
 						invalidFkPairings.push({
-							pairKey: fkRelationPairKey(pslModel.name, field.typeName),
+							pairKey: fkRelationPairKey(pslModel.name, target.name),
 							...ifDefined("relationName", relation.name)
 						});
 						continue;
 					}
-					const localMapped = relation.fields.map((f) => fieldMappings.pslNameToMapped.get(f) ?? f);
-					const targetFieldMappings = modelMetadataByName.get(field.typeName)?.fieldMappings;
-					const targetMapped = relation.references.map((f) => targetFieldMappings?.pslNameToMapped.get(f) ?? f);
+					if (!physicalNames.has(target)) continue;
+					const localMapped = relation.fields.map((name) => physicalName(physicalNames, pslModel.fields[name]));
+					const targetMapped = relation.references.map((name) => physicalName(physicalNames, target.fields[name]));
 					relations[field.name] = {
-						to: mongoCrossRef(field.typeName),
+						to: mongoCrossRef(target.name),
 						cardinality: "N:1",
 						nullable: field.optional,
 						on: {
@@ -1637,7 +1634,7 @@ function interpretPslDocumentToMongoContract(input) {
 					};
 					allFkRelations.push({
 						declaringModel: pslModel.name,
-						targetModel: field.typeName,
+						targetModel: target.name,
 						...ifDefined("relationName", relation.name),
 						localFields: localMapped,
 						targetFields: targetMapped
@@ -1648,9 +1645,9 @@ function interpretPslDocumentToMongoContract(input) {
 			const resolved = resolveNonRelationField(field, {
 				name: pslModel.name,
 				kind: "model"
-			}, compositeTypeNames, scalarTypeCodecIds, codecIdByEnumName, presetContext, scalarNames);
+			}, resolution, codecIdByEnumName, presetContext, scalarNames, onPresetHandled, onUnresolvedType);
 			if (!resolved) continue;
-			const mappedName = fieldMappings.pslNameToMapped.get(field.name) ?? field.name;
+			const mappedName = physicalName(physicalNames, field);
 			fields[mappedName] = resolved.field;
 			if (resolved.executionDefaults) presetExecutionDefaults.push({
 				modelName: pslModel.name,
@@ -1661,7 +1658,7 @@ function interpretPslDocumentToMongoContract(input) {
 		}
 		const isVariantModel = pslModel.attributes.some((attr) => attr.name === "base");
 		const hasIdField = Object.values(pslModel.fields).filter((field) => {
-			const idNode = findFieldAttributeNode(field, "id");
+			const idNode = field.attributes.find((attr) => attr.name === "id")?.node;
 			if (!idNode) return false;
 			return interpretFieldAttribute({
 				symbols: specContext.symbols,
@@ -1696,7 +1693,7 @@ function interpretPslDocumentToMongoContract(input) {
 			relations,
 			storage: { collection: collectionName }
 		};
-		const modelIndexes = collectIndexes(pslModel, specContext, fieldMappings, modelNames, compositeTypeNames, sources, binder, diagnostics, indexSpans, indexSources);
+		const modelIndexes = collectIndexes(pslModel, specContext, physicalNames, sources, binder, diagnostics, indexSpans, indexSources);
 		modelIndexesByName.set(pslModel.name, modelIndexes);
 		const existingColl = collections[collectionName];
 		if (existingColl && modelIndexes.length > 0) collections[collectionName] = { indexes: [...collectionIndexes(existingColl), ...modelIndexes] };
@@ -1710,7 +1707,7 @@ function interpretPslDocumentToMongoContract(input) {
 			const resolved = resolveNonRelationField(field, {
 				name: compositeType.name,
 				kind: "compositeType"
-			}, compositeTypeNames, scalarTypeCodecIds, codecIdByEnumName, presetContext, scalarNames);
+			}, fieldTypeResolution(field, binder), codecIdByEnumName, presetContext, scalarNames, onPresetHandled, onUnresolvedType);
 			if (!resolved) continue;
 			fields[field.name] = resolved.field;
 		}
@@ -1726,7 +1723,7 @@ function interpretPslDocumentToMongoContract(input) {
 		const modelEntry = models[modelName];
 		if (modelEntry) modelEntry.relations[fieldName] = relation;
 	}
-	const { discriminatorDeclarations, baseDeclarations } = collectPolymorphismDeclarations(allModels, specContextFor, modelMetadataByName, sources, binder, diagnostics);
+	const { discriminatorDeclarations, baseDeclarations } = collectPolymorphismDeclarations(allModels, specContextFor, physicalNames, sources, binder, diagnostics);
 	const polyResult = resolvePolymorphism({
 		sources,
 		models,
@@ -1736,7 +1733,7 @@ function interpretPslDocumentToMongoContract(input) {
 		baseDeclarations,
 		indexSpans,
 		modelIndexesByName,
-		modelMetadataByName,
+		physicalNames,
 		indexSources
 	});
 	const executionDefaults = resolvePresetExecutionDefaults({
@@ -1745,10 +1742,18 @@ function interpretPslDocumentToMongoContract(input) {
 		sources,
 		diagnostics
 	});
-	if (diagnostics.length > 0 || polyResult.diagnostics.length > 0 || (input.seedDiagnostics?.length ?? 0) > 0) return notOk({
+	const remainingBinderDiagnostics = binderDiagnostics.filter((diagnostic) => !replacedTypeDiagnostics.has(diagnostic)).map((diagnostic) => {
+		const message = unresolvedTypeMessages.get(diagnostic);
+		return message === void 0 ? diagnostic : {
+			...diagnostic,
+			message
+		};
+	});
+	if (remainingBinderDiagnostics.length > 0 || diagnostics.length > 0 || polyResult.diagnostics.length > 0 || (input.seedDiagnostics?.length ?? 0) > 0) return notOk({
 		summary: "PSL to Mongo contract interpretation failed",
 		diagnostics: [
 			...input.seedDiagnostics ?? [],
+			...mapPslDiagnostics(remainingBinderDiagnostics, sources),
 			...diagnostics.toExternal(),
 			...polyResult.diagnostics.toExternal()
 		]
@@ -1817,4 +1822,4 @@ function interpretPslDocumentToMongoContract(input) {
 //#endregion
 export { pairMongoBackRelations as a, mongoAttributeSpecs as i, derivePolymorphicJsonSchema as n, interpretPslDocumentToMongoContract as r, deriveJsonSchema as t };
 
-//# sourceMappingURL=interpreter-Da0fGDSM-DGCJEzeI.mjs.map
+//# sourceMappingURL=interpreter-DSD7dXPk-D37QHryH.mjs.map