@prisma-next/sql-contract-psl 0.14.0-dev.1 → 0.14.0-dev.11

package/dist/{interpreter-B0BsCLKT.mjs → interpreter-CygvamTk.mjs}

@@ -1,13 +1,15 @@
 import { crossRef } from "@prisma-next/contract/types";
-import { hasRegisteredFieldNamespace, instantiateAuthoringEntityType, instantiateAuthoringFieldPreset, instantiateAuthoringTypeConstructor, isAuthoringEntityTypeDescriptor, isAuthoringFieldPresetDescriptor, isAuthoringTypeConstructorDescriptor, validateAuthoringHelperArguments } from "@prisma-next/framework-components/authoring";
-import { namespacePslExtensionBlocks } from "@prisma-next/framework-components/psl-ast";
+import { hasRegisteredFieldNamespace, instantiateAuthoringEntityType, instantiateAuthoringFieldPreset, instantiateAuthoringTypeConstructor, isAuthoringEntityTypeDescriptor, isAuthoringFieldPresetDescriptor, isAuthoringPslBlockDescriptor, isAuthoringTypeConstructorDescriptor, validateAuthoringHelperArguments } from "@prisma-next/framework-components/authoring";
+import { keywordPslSpan, nodePslSpan, parseQuotedStringLiteral } from "@prisma-next/psl-parser";
 import { buildSqlContractFromDefinition } from "@prisma-next/sql-contract-ts/contract-builder";
+import { assertDefined, invariant } from "@prisma-next/utils/assertions";
 import { blindCast } from "@prisma-next/utils/casts";
 import { ifDefined } from "@prisma-next/utils/defined";
 import { notOk, ok } from "@prisma-next/utils/result";
-import { getPositionalArgument, parseQuotedStringLiteral } from "@prisma-next/psl-parser";
-import { assertDefined, invariant } from "@prisma-next/utils/assertions";
 //#region src/psl-attribute-parsing.ts
+function getPositionalArgument(attribute, index = 0) {
+	return attribute.args.filter((arg) => arg.kind === "positional")[index]?.value;
+}
 function lowerFirst(value) {
 	if (value.length === 0) return value;
 	return value[0]?.toLowerCase() + value.slice(1);
@@ -931,7 +933,7 @@ function resolvePslTypeConstructorDescriptor(input) {
 *
 * Symmetric with `instantiatePslTypeConstructor` but richer: a field preset can contribute `default`, `executionDefaults`, `id`, `unique`, and `nullable` in addition to the storage-type triple. PSL → typed-args coercion happens here (via `mapPslHelperArgs`) so that `instantiateAuthoringFieldPreset` itself stays typed-input-only and TS keeps its zero-runtime-validation cost.
 */
-function instantiatePslFieldPreset(input) {
+function instantiateFieldPreset(input) {
 	const helperPath = input.call.path.join(".");
 	const args = mapPslHelperArgs({
 		args: input.call.args,
@@ -970,10 +972,14 @@ function instantiatePslFieldPreset(input) {
 	}
 }
 function resolveFieldTypeDescriptor(input) {
+	if (input.field.malformedType) return {
+		ok: false,
+		alreadyReported: true
+	};
 	if (input.field.typeConstructor) {
 		const presetDescriptor = getAuthoringFieldPreset(input.authoringContributions, input.field.typeConstructor.path);
 		if (presetDescriptor) {
-			const instantiated = instantiatePslFieldPreset({
+			const instantiated = instantiateFieldPreset({
 				call: input.field.typeConstructor,
 				descriptor: presetDescriptor,
 				diagnostics: input.diagnostics,
@@ -1301,7 +1307,6 @@ function lowerDefaultForField(input) {
 	return { executionDefaults: { onCreate: lowered.value.generated } };
 }
 function resolveColumnDescriptor(field, enumTypeDescriptors, namedTypeDescriptors, scalarTypeDescriptors) {
-	if (field.typeRef && namedTypeDescriptors.has(field.typeRef)) return namedTypeDescriptors.get(field.typeRef);
 	if (namedTypeDescriptors.has(field.typeName)) return namedTypeDescriptors.get(field.typeName);
 	if (enumTypeDescriptors.has(field.typeName)) return enumTypeDescriptors.get(field.typeName);
 	return scalarTypeDescriptors.get(field.typeName);
@@ -1309,8 +1314,18 @@ function resolveColumnDescriptor(field, enumTypeDescriptors, namedTypeDescriptor
 //#endregion
 //#region src/psl-field-resolution.ts
 function lowerEnumDefaultForField(input) {
-	const expressionEntry = getPositionalArgumentEntry(input.defaultAttribute);
-	if (!expressionEntry) return {};
+	const positionalEntries = input.defaultAttribute.args.filter((arg) => arg.kind === "positional");
+	const hasNamedEntries = input.defaultAttribute.args.some((arg) => arg.kind === "named");
+	const expressionEntry = positionalEntries[0];
+	if (hasNamedEntries || positionalEntries.length !== 1 || expressionEntry === void 0) {
+		input.diagnostics.push({
+			code: "PSL_INVALID_DEFAULT_FUNCTION_ARGUMENT",
+			message: `Field "${input.modelName}.${input.fieldName}" @default on an enum field expects exactly one positional enum member argument.`,
+			sourceId: input.sourceId,
+			span: input.defaultAttribute.span
+		});
+		return {};
+	}
 	const raw = expressionEntry.value.trim();
 	const isQuotedString = /^(['"]).*\1$/.test(raw);
 	const isFunctionCall = raw.includes("(") && raw.endsWith(")");
@@ -1414,7 +1429,7 @@ function extractFieldConstraintNames(input) {
 function collectResolvedFields(input) {
 	const { model, mapping, enumTypeDescriptors, namedTypeDescriptors, modelNames, compositeTypeNames, composedExtensions, authoringContributions, familyId, targetId, defaultFunctionRegistry, generatorDescriptorById, diagnostics, sourceId, scalarTypeDescriptors, enumHandles } = input;
 	const resolvedFields = [];
-	for (const field of model.fields) {
+	for (const field of Object.values(model.fields)) {
 		const isModelField = modelNames.has(field.typeName);
 		if (field.list && isModelField) continue;
 		validateFieldAttributes({
@@ -1534,7 +1549,7 @@ function collectResolvedFields(input) {
 			});
 			continue;
 		}
-		const fieldUsesNamedType = field.typeRef !== void 0 || namedTypeDescriptors.has(field.typeName);
+		const fieldUsesNamedType = namedTypeDescriptors.has(field.typeName);
 		if (loweredOnCreate && !fieldUsesNamedType) {
 			const generatedDescriptor = generatorDescriptorById.get(loweredOnCreate.id)?.resolveGeneratedColumnDescriptor?.({ generated: loweredOnCreate });
 			if (generatedDescriptor) descriptor = generatedDescriptor;
@@ -1571,6 +1586,7 @@ function collectResolvedFields(input) {
 			field,
 			columnName: mappedColumnName,
 			descriptor,
+			nullable: presetContributions?.nullable ?? field.optional,
 			...ifDefined("defaultValue", fieldDefaultValue),
 			...ifDefined("executionDefaults", fieldExecutionDefaults),
 			isId: isIdField || Boolean(presetContributions?.id),
@@ -1596,7 +1612,7 @@ function buildModelMappings(modelEntries, defaultNamespaceId, diagnostics, sourc
 			span: model.span
 		});
 		const fieldColumns = /* @__PURE__ */ new Map();
-		for (const field of model.fields) {
+		for (const field of Object.values(model.fields)) {
 			const columnName = parseMapName({
 				attribute: getAttribute(field.attributes, "map"),
 				defaultValue: field.name,
@@ -1616,6 +1632,171 @@ function buildModelMappings(modelEntries, defaultNamespaceId, diagnostics, sourc
 	return result;
 }
 //#endregion
+//#region src/psl-named-type-resolution.ts
+function validateNamedTypeAttributes(input) {
+	const [dbNativeTypeAttribute, ...extraDbNativeTypeAttributes] = input.allowDbNativeType ? input.declaration.attributes.filter((attribute) => attribute.name.startsWith("db.")) : [];
+	let hasUnsupportedNamedTypeAttribute = false;
+	for (const extra of extraDbNativeTypeAttributes) {
+		input.diagnostics.push({
+			code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
+			message: `Named type "${input.declaration.name}" can declare at most one @db.* attribute`,
+			sourceId: input.sourceId,
+			span: extra.span
+		});
+		hasUnsupportedNamedTypeAttribute = true;
+	}
+	for (const attribute of input.declaration.attributes) {
+		if (input.allowDbNativeType && attribute.name.startsWith("db.")) continue;
+		const uncomposedNamespace = checkUncomposedNamespace(attribute.name, input.composedExtensions, {
+			familyId: input.familyId,
+			targetId: input.targetId,
+			authoringContributions: input.authoringContributions
+		});
+		if (uncomposedNamespace) {
+			reportUncomposedNamespace({
+				subjectLabel: `Attribute "@${attribute.name}"`,
+				namespace: uncomposedNamespace,
+				sourceId: input.sourceId,
+				span: attribute.span,
+				diagnostics: input.diagnostics
+			});
+			hasUnsupportedNamedTypeAttribute = true;
+			continue;
+		}
+		input.diagnostics.push({
+			code: "PSL_UNSUPPORTED_NAMED_TYPE_ATTRIBUTE",
+			message: `Named type "${input.declaration.name}" uses unsupported attribute "${attribute.name}"`,
+			sourceId: input.sourceId,
+			span: attribute.span
+		});
+		hasUnsupportedNamedTypeAttribute = true;
+	}
+	return {
+		dbNativeTypeAttribute,
+		hasUnsupportedNamedTypeAttribute
+	};
+}
+function resolveNamedTypeDeclarations(input) {
+	const storageTypeEntries = [];
+	const namedTypeDescriptors = /* @__PURE__ */ new Map();
+	for (const declaration of input.declarations) {
+		if (declaration.isConstructor) {
+			const typeConstructor = declaration.typeConstructor;
+			if (typeConstructor === void 0) {
+				input.diagnostics.push({
+					code: "PSL_UNSUPPORTED_NAMED_TYPE_BASE",
+					message: `Named type "${declaration.name}" must declare a base type or constructor`,
+					sourceId: input.sourceId,
+					span: declaration.span
+				});
+				continue;
+			}
+			const { hasUnsupportedNamedTypeAttribute } = validateNamedTypeAttributes({
+				declaration,
+				sourceId: input.sourceId,
+				diagnostics: input.diagnostics,
+				composedExtensions: input.composedExtensions,
+				authoringContributions: input.authoringContributions,
+				allowDbNativeType: false,
+				familyId: input.familyId,
+				targetId: input.targetId
+			});
+			if (hasUnsupportedNamedTypeAttribute) continue;
+			const helperPath = typeConstructor.path.join(".");
+			const descriptor = resolvePslTypeConstructorDescriptor({
+				call: typeConstructor,
+				authoringContributions: input.authoringContributions,
+				composedExtensions: input.composedExtensions,
+				familyId: input.familyId,
+				targetId: input.targetId,
+				diagnostics: input.diagnostics,
+				sourceId: input.sourceId,
+				unsupportedCode: "PSL_UNSUPPORTED_NAMED_TYPE_CONSTRUCTOR",
+				unsupportedMessage: `Named type "${declaration.name}" references unsupported constructor "${helperPath}"`
+			});
+			if (!descriptor) continue;
+			const storageType = instantiatePslTypeConstructor({
+				call: typeConstructor,
+				descriptor,
+				diagnostics: input.diagnostics,
+				sourceId: input.sourceId,
+				entityLabel: `Named type "${declaration.name}"`
+			});
+			if (!storageType) continue;
+			namedTypeDescriptors.set(declaration.name, toNamedTypeFieldDescriptor(declaration.name, storageType));
+			storageTypeEntries.push([declaration.name, {
+				kind: "codec-instance",
+				codecId: storageType.codecId,
+				nativeType: storageType.nativeType,
+				typeParams: storageType.typeParams ?? {}
+			}]);
+			continue;
+		}
+		const baseType = declaration.baseType;
+		if (baseType === void 0) {
+			input.diagnostics.push({
+				code: "PSL_UNSUPPORTED_NAMED_TYPE_BASE",
+				message: `Named type "${declaration.name}" must declare a base type or constructor`,
+				sourceId: input.sourceId,
+				span: declaration.span
+			});
+			continue;
+		}
+		const baseDescriptor = input.enumTypeDescriptors.get(baseType) ?? input.scalarTypeDescriptors.get(baseType);
+		if (!baseDescriptor) {
+			input.diagnostics.push({
+				code: "PSL_UNSUPPORTED_NAMED_TYPE_BASE",
+				message: `Named type "${declaration.name}" references unsupported base type "${baseType}"`,
+				sourceId: input.sourceId,
+				span: declaration.span
+			});
+			continue;
+		}
+		const { dbNativeTypeAttribute, hasUnsupportedNamedTypeAttribute } = validateNamedTypeAttributes({
+			declaration,
+			sourceId: input.sourceId,
+			diagnostics: input.diagnostics,
+			composedExtensions: input.composedExtensions,
+			authoringContributions: input.authoringContributions,
+			allowDbNativeType: true,
+			familyId: input.familyId,
+			targetId: input.targetId
+		});
+		if (hasUnsupportedNamedTypeAttribute) continue;
+		if (dbNativeTypeAttribute) {
+			const descriptor = resolveDbNativeTypeAttribute({
+				attribute: dbNativeTypeAttribute,
+				baseType,
+				baseDescriptor,
+				diagnostics: input.diagnostics,
+				sourceId: input.sourceId,
+				entityLabel: `Named type "${declaration.name}"`
+			});
+			if (!descriptor) continue;
+			namedTypeDescriptors.set(declaration.name, toNamedTypeFieldDescriptor(declaration.name, descriptor));
+			storageTypeEntries.push([declaration.name, {
+				kind: "codec-instance",
+				codecId: descriptor.codecId,
+				nativeType: descriptor.nativeType,
+				typeParams: descriptor.typeParams ?? {}
+			}]);
+			continue;
+		}
+		const descriptor = toNamedTypeFieldDescriptor(declaration.name, baseDescriptor);
+		namedTypeDescriptors.set(declaration.name, descriptor);
+		storageTypeEntries.push([declaration.name, {
+			kind: "codec-instance",
+			codecId: baseDescriptor.codecId,
+			nativeType: baseDescriptor.nativeType,
+			typeParams: {}
+		}]);
+	}
+	return {
+		storageTypes: Object.fromEntries(storageTypeEntries),
+		namedTypeDescriptors
+	};
+}
+//#endregion
 //#region src/psl-relation-resolution.ts
 const REFERENTIAL_ACTION_MAP = {
 	NoAction: "noAction",
@@ -1753,7 +1934,11 @@ function parseRelationAttribute(input) {
 function indexFkRelations(input) {
 	const modelRelations = /* @__PURE__ */ new Map();
 	const fkRelationsByPair = /* @__PURE__ */ new Map();
+	const fkRelationsByDeclaringModel = /* @__PURE__ */ new Map();
 	for (const relation of input.fkRelationMetadata) {
+		const declaringFkRelations = fkRelationsByDeclaringModel.get(relation.declaringModelName);
+		if (declaringFkRelations) declaringFkRelations.push(relation);
+		else fkRelationsByDeclaringModel.set(relation.declaringModelName, [relation]);
 		const existing = modelRelations.get(relation.declaringModelName);
 		const current = existing ?? [];
 		if (!existing) modelRelations.set(relation.declaringModelName, current);
@@ -1780,8 +1965,146 @@ function indexFkRelations(input) {
 	}
 	return {
 		modelRelations,
-		fkRelationsByPair
+		fkRelationsByPair,
+		fkRelationsByDeclaringModel
+	};
+}
+function idColumnsAreExactlyFkPair(idColumns, parentColumns, childColumns) {
+	if (idColumns.length !== parentColumns.length + childColumns.length) return false;
+	const fkColumns = new Set([...parentColumns, ...childColumns]);
+	if (fkColumns.size !== parentColumns.length + childColumns.length) return false;
+	return idColumns.every((column) => fkColumns.has(column));
+}
+/**
+* Reorders the child FK's junction columns into the target model's id-column
+* order. Returns undefined unless the FK references exactly the target's full
+* id, because downstream consumers pair `through.childColumns` positionally
+* against the target id columns — an FK referencing anything else (a non-id
+* unique, a partial id) would produce a silently wrong join.
+*/
+function childColumnsInTargetIdOrder(childFk, targetIdColumns) {
+	if (childFk.referencedColumns.length !== targetIdColumns.length) return;
+	const localByReferenced = /* @__PURE__ */ new Map();
+	for (const [index, referencedColumn] of childFk.referencedColumns.entries()) {
+		const localColumn = childFk.localColumns[index];
+		if (localColumn === void 0) return;
+		localByReferenced.set(referencedColumn, localColumn);
+	}
+	if (localByReferenced.size !== targetIdColumns.length) return;
+	const ordered = [];
+	for (const idColumn of targetIdColumns) {
+		const localColumn = localByReferenced.get(idColumn);
+		if (localColumn === void 0) return;
+		ordered.push(localColumn);
+	}
+	return ordered;
+}
+/**
+* Finds explicit junction models that connect a bare backrelation list field
+* to its target model: a model whose composite id columns are exactly the FK
+* columns of one relation back to the candidate's model (the parent side) and
+* one relation to the candidate's target model (the child side). The child
+* FK must reference exactly the target model's id columns; its junction
+* columns are carried in target-id order on the pair. A relation name on the
+* list field pins the parent-side FK relation, which is how self-referential
+* many-to-many sides are disambiguated.
+*
+* Alongside the recognised pairs, returns junction-shaped near-misses (models
+* that link both sides but were declined) so the caller can emit a
+* junction-specific diagnostic instead of the generic orphaned-list message.
+*/
+function findJunctionFkPairs(input) {
+	const targetIdColumns = input.modelIdColumns.get(input.candidate.targetModelName);
+	if (!targetIdColumns || targetIdColumns.length === 0) return {
+		pairs: [],
+		nearMisses: []
+	};
+	const pairs = [];
+	const nearMisses = [];
+	for (const [junctionModelName, junctionFks] of input.fkRelationsByDeclaringModel) {
+		const idColumns = input.modelIdColumns.get(junctionModelName);
+		for (const parentFk of junctionFks) {
+			if (parentFk.targetModelName !== input.candidate.modelName) continue;
+			if (input.candidate.relationName !== void 0 && parentFk.relationName !== input.candidate.relationName) continue;
+			for (const childFk of junctionFks) {
+				if (childFk === parentFk || childFk.targetModelName !== input.candidate.targetModelName) continue;
+				if (!idColumns || !idColumnsAreExactlyFkPair(idColumns, parentFk.localColumns, childFk.localColumns)) {
+					nearMisses.push({
+						junctionModelName,
+						reason: "id-not-fk-covering"
+					});
+					continue;
+				}
+				const orderedChildColumns = childColumnsInTargetIdOrder(childFk, targetIdColumns);
+				if (!orderedChildColumns) {
+					nearMisses.push({
+						junctionModelName,
+						reason: "target-fk-not-id"
+					});
+					continue;
+				}
+				pairs.push({
+					parentFk,
+					childFk,
+					childColumnsInTargetIdOrder: orderedChildColumns
+				});
+			}
+		}
+	}
+	return {
+		pairs,
+		nearMisses
+	};
+}
+function junctionNearMissDiagnostic(candidate, nearMiss, sourceId) {
+	const listField = `${candidate.modelName}.${candidate.field.name}`;
+	const data = {
+		listField,
+		junctionModel: nearMiss.junctionModelName,
+		targetModel: candidate.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.`,
+		sourceId,
+		span: 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.`,
+		sourceId,
+		span: candidate.field.span,
+		data
+	};
+}
+function manyToManyRelationNode(candidate, pair) {
+	return {
+		fieldName: candidate.field.name,
+		toModel: pair.childFk.targetModelName,
+		toTable: pair.childFk.targetTableName,
+		...ifDefined("toNamespaceId", pair.childFk.targetNamespaceId),
+		cardinality: "N:M",
+		on: {
+			parentTable: candidate.tableName,
+			parentColumns: pair.parentFk.referencedColumns,
+			childTable: pair.parentFk.declaringTableName,
+			childColumns: pair.parentFk.localColumns
+		},
+		through: {
+			table: pair.parentFk.declaringTableName,
+			...ifDefined("namespaceId", pair.parentFk.declaringNamespaceId),
+			parentColumns: pair.parentFk.localColumns,
+			childColumns: pair.childColumnsInTargetIdOrder
+		}
+	};
+}
+function relationsForModel(modelRelations, modelName) {
+	const existing = modelRelations.get(modelName);
+	if (existing) return existing;
+	const created = [];
+	modelRelations.set(modelName, created);
+	return created;
 }
 function applyBackrelationCandidates(input) {
 	for (const candidate of input.backrelationCandidates) {
@@ -1789,6 +2112,30 @@ function applyBackrelationCandidates(input) {
 		const pairMatches = input.fkRelationsByPair.get(pairKey) ?? [];
 		const matches = candidate.relationName ? pairMatches.filter((relation) => relation.relationName === candidate.relationName) : [...pairMatches];
 		if (matches.length === 0) {
+			const { pairs: junctionPairs, nearMisses } = findJunctionFkPairs({
+				candidate,
+				fkRelationsByDeclaringModel: input.fkRelationsByDeclaringModel,
+				modelIdColumns: input.modelIdColumns
+			});
+			const junctionPair = junctionPairs[0];
+			if (junctionPairs.length === 1 && junctionPair) {
+				relationsForModel(input.modelRelations, candidate.modelName).push(manyToManyRelationNode(candidate, junctionPair));
+				continue;
+			}
+			if (junctionPairs.length > 1) {
+				input.diagnostics.push({
+					code: "PSL_AMBIGUOUS_BACKRELATION_LIST",
+					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.`,
+					sourceId: input.sourceId,
+					span: candidate.field.span
+				});
+				continue;
+			}
+			const nearMiss = nearMisses[0];
+			if (nearMiss) {
+				input.diagnostics.push(junctionNearMissDiagnostic(candidate, nearMiss, input.sourceId));
+				continue;
+			}
 			input.diagnostics.push({
 				code: "PSL_ORPHANED_BACKRELATION_LIST",
 				message: `Backrelation list 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 or use an explicit join model for many-to-many.`,
@@ -1809,13 +2156,11 @@ function applyBackrelationCandidates(input) {
 		invariant(matches.length === 1, "Backrelation matching requires exactly one match");
 		const matched = matches[0];
 		assertDefined(matched, "Backrelation matching requires a defined relation match");
-		const existing = input.modelRelations.get(candidate.modelName);
-		const current = existing ?? [];
-		if (!existing) input.modelRelations.set(candidate.modelName, current);
-		current.push({
+		relationsForModel(input.modelRelations, candidate.modelName).push({
 			fieldName: candidate.field.name,
 			toModel: matched.declaringModelName,
 			toTable: matched.declaringTableName,
+			...ifDefined("toNamespaceId", matched.declaringNamespaceId),
 			cardinality: "1:N",
 			on: {
 				parentTable: candidate.tableName,
@@ -1869,32 +2214,11 @@ function buildComposedExtensionPackRefs(target, extensionIds, extensionPackRefs
 		version: "0.0.1"
 	}]));
 }
-function diagnosticDedupKey(diagnostic) {
-	const span = diagnostic.span;
-	const spanKey = span ? `${span.start.offset}:${span.end.offset}:${span.start.line}:${span.end.line}` : "";
-	return `${diagnostic.code}\u0000${diagnostic.sourceId}\u0000${spanKey}\u0000${diagnostic.message}`;
-}
-function dedupeDiagnostics(diagnostics) {
-	const seen = /* @__PURE__ */ new Map();
-	for (const diagnostic of diagnostics) {
-		const key = diagnosticDedupKey(diagnostic);
-		if (!seen.has(key)) seen.set(key, diagnostic);
-	}
-	return [...seen.values()];
-}
 function compareStrings(left, right) {
 	if (left < right) return -1;
 	if (left > right) return 1;
 	return 0;
 }
-function mapParserDiagnostics(document) {
-	return document.diagnostics.map((diagnostic) => ({
-		code: diagnostic.code,
-		message: diagnostic.message,
-		sourceId: diagnostic.sourceId,
-		span: diagnostic.span
-	}));
-}
 /**
 * Name of the framework-parser synthesised bucket for top-level
 * declarations. Re-declared here so the per-target dispatch does not
@@ -1956,28 +2280,24 @@ function resolveNamespaceIdForSqlTarget(input) {
 }
 function validateNamespaceBlocksForSqlTarget(input) {
 	if (input.targetId === "sqlite") {
-		for (const namespace of input.namespaces) {
-			if (namespace.name === UNSPECIFIED_PSL_NAMESPACE_NAME) continue;
-			input.diagnostics.push({
-				code: "PSL_UNSUPPORTED_NAMESPACE_BLOCK",
-				message: `SQLite does not support \`namespace ${namespace.name} { … }\` blocks (SQLite has no schema concept; declare models at the document top level instead).`,
-				sourceId: input.sourceId,
-				span: namespace.span
-			});
-		}
+		for (const namespace of input.namespaces) input.diagnostics.push({
+			code: "PSL_UNSUPPORTED_NAMESPACE_BLOCK",
+			message: `SQLite does not support \`namespace ${namespace.name} { … }\` blocks (SQLite has no schema concept; declare models at the document top level instead).`,
+			sourceId: input.sourceId,
+			span: nodePslSpan(namespace.node.syntax, input.sourceFile)
+		});
 		return;
 	}
 	if (input.targetId === "postgres") {
-		const namedBlocks = input.namespaces.filter((ns) => ns.name !== UNSPECIFIED_PSL_NAMESPACE_NAME);
-		const hasUnbound = namedBlocks.some((ns) => ns.name === "unbound");
-		const hasSibling = namedBlocks.some((ns) => ns.name !== "unbound");
+		const hasUnbound = input.namespaces.some((ns) => ns.name === "unbound");
+		const hasSibling = input.namespaces.some((ns) => ns.name !== "unbound");
 		if (hasUnbound && hasSibling) {
-			const unboundBlock = namedBlocks.find((ns) => ns.name === "unbound");
+			const unboundBlock = input.namespaces.find((ns) => ns.name === "unbound");
 			input.diagnostics.push({
 				code: "PSL_RESERVED_NAMESPACE_NAME",
 				message: "Namespace \"unbound\" is reserved for the late-binding sentinel mapping and cannot appear alongside other named namespace blocks. Use `namespace unbound { … }` alone (no sibling named namespaces) for late-binding multi-tenant contracts.",
 				sourceId: input.sourceId,
-				...ifDefined("span", unboundBlock?.span)
+				...unboundBlock !== void 0 ? { span: nodePslSpan(unboundBlock.node.syntax, input.sourceFile) } : {}
 			});
 		}
 	}
@@ -2017,158 +2337,12 @@ function processEnumDeclarations(input) {
 		enumTypeDescriptors
 	};
 }
-function validateNamedTypeAttributes(input) {
-	const [dbNativeTypeAttribute, ...extraDbNativeTypeAttributes] = input.allowDbNativeType ? input.declaration.attributes.filter((attribute) => attribute.name.startsWith("db.")) : [];
-	let hasUnsupportedNamedTypeAttribute = false;
-	for (const extra of extraDbNativeTypeAttributes) {
-		input.diagnostics.push({
-			code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
-			message: `Named type "${input.declaration.name}" can declare at most one @db.* attribute`,
-			sourceId: input.sourceId,
-			span: extra.span
-		});
-		hasUnsupportedNamedTypeAttribute = true;
-	}
-	for (const attribute of input.declaration.attributes) {
-		if (input.allowDbNativeType && attribute.name.startsWith("db.")) continue;
-		const uncomposedNamespace = checkUncomposedNamespace(attribute.name, input.composedExtensions, {
-			familyId: input.familyId,
-			targetId: input.targetId,
-			authoringContributions: input.authoringContributions
-		});
-		if (uncomposedNamespace) {
-			reportUncomposedNamespace({
-				subjectLabel: `Attribute "@${attribute.name}"`,
-				namespace: uncomposedNamespace,
-				sourceId: input.sourceId,
-				span: attribute.span,
-				diagnostics: input.diagnostics
-			});
-			hasUnsupportedNamedTypeAttribute = true;
-			continue;
-		}
-		input.diagnostics.push({
-			code: "PSL_UNSUPPORTED_NAMED_TYPE_ATTRIBUTE",
-			message: `Named type "${input.declaration.name}" uses unsupported attribute "${attribute.name}"`,
-			sourceId: input.sourceId,
-			span: attribute.span
-		});
-		hasUnsupportedNamedTypeAttribute = true;
-	}
-	return {
-		dbNativeTypeAttribute,
-		hasUnsupportedNamedTypeAttribute
-	};
-}
-function resolveNamedTypeDeclarations(input) {
-	const storageTypes = {};
-	const namedTypeDescriptors = /* @__PURE__ */ new Map();
-	for (const declaration of input.declarations) {
-		if (declaration.typeConstructor) {
-			const { hasUnsupportedNamedTypeAttribute } = validateNamedTypeAttributes({
-				declaration,
-				sourceId: input.sourceId,
-				diagnostics: input.diagnostics,
-				composedExtensions: input.composedExtensions,
-				authoringContributions: input.authoringContributions,
-				allowDbNativeType: false,
-				familyId: input.familyId,
-				targetId: input.targetId
-			});
-			if (hasUnsupportedNamedTypeAttribute) continue;
-			const helperPath = declaration.typeConstructor.path.join(".");
-			const typeConstructor = resolvePslTypeConstructorDescriptor({
-				call: declaration.typeConstructor,
-				authoringContributions: input.authoringContributions,
-				composedExtensions: input.composedExtensions,
-				familyId: input.familyId,
-				targetId: input.targetId,
-				diagnostics: input.diagnostics,
-				sourceId: input.sourceId,
-				unsupportedCode: "PSL_UNSUPPORTED_NAMED_TYPE_CONSTRUCTOR",
-				unsupportedMessage: `Named type "${declaration.name}" references unsupported constructor "${helperPath}"`
-			});
-			if (!typeConstructor) continue;
-			const storageType = instantiatePslTypeConstructor({
-				call: declaration.typeConstructor,
-				descriptor: typeConstructor,
-				diagnostics: input.diagnostics,
-				sourceId: input.sourceId,
-				entityLabel: `Named type "${declaration.name}"`
-			});
-			if (!storageType) continue;
-			namedTypeDescriptors.set(declaration.name, toNamedTypeFieldDescriptor(declaration.name, storageType));
-			storageTypes[declaration.name] = {
-				kind: "codec-instance",
-				codecId: storageType.codecId,
-				nativeType: storageType.nativeType,
-				typeParams: storageType.typeParams ?? {}
-			};
-			continue;
-		}
-		if (declaration.baseType === void 0) {
-			input.diagnostics.push({
-				code: "PSL_UNSUPPORTED_NAMED_TYPE_BASE",
-				message: `Named type "${declaration.name}" must declare a base type or constructor`,
-				sourceId: input.sourceId,
-				span: declaration.span
-			});
-			continue;
-		}
-		const { baseType } = declaration;
-		const baseDescriptor = input.enumTypeDescriptors.get(baseType) ?? input.scalarTypeDescriptors.get(baseType);
-		if (!baseDescriptor) {
-			input.diagnostics.push({
-				code: "PSL_UNSUPPORTED_NAMED_TYPE_BASE",
-				message: `Named type "${declaration.name}" references unsupported base type "${baseType}"`,
-				sourceId: input.sourceId,
-				span: declaration.span
-			});
-			continue;
-		}
-		const { dbNativeTypeAttribute, hasUnsupportedNamedTypeAttribute } = validateNamedTypeAttributes({
-			declaration,
-			sourceId: input.sourceId,
-			diagnostics: input.diagnostics,
-			composedExtensions: input.composedExtensions,
-			authoringContributions: input.authoringContributions,
-			allowDbNativeType: true,
-			familyId: input.familyId,
-			targetId: input.targetId
-		});
-		if (hasUnsupportedNamedTypeAttribute) continue;
-		if (dbNativeTypeAttribute) {
-			const descriptor = resolveDbNativeTypeAttribute({
-				attribute: dbNativeTypeAttribute,
-				baseType,
-				baseDescriptor,
-				diagnostics: input.diagnostics,
-				sourceId: input.sourceId,
-				entityLabel: `Named type "${declaration.name}"`
-			});
-			if (!descriptor) continue;
-			namedTypeDescriptors.set(declaration.name, toNamedTypeFieldDescriptor(declaration.name, descriptor));
-			storageTypes[declaration.name] = {
-				kind: "codec-instance",
-				codecId: descriptor.codecId,
-				nativeType: descriptor.nativeType,
-				typeParams: descriptor.typeParams ?? {}
-			};
-			continue;
-		}
-		const descriptor = toNamedTypeFieldDescriptor(declaration.name, baseDescriptor);
-		namedTypeDescriptors.set(declaration.name, descriptor);
-		storageTypes[declaration.name] = {
-			kind: "codec-instance",
-			codecId: baseDescriptor.codecId,
-			nativeType: baseDescriptor.nativeType,
-			typeParams: {}
-		};
-	}
-	return {
-		storageTypes,
-		namedTypeDescriptors
-	};
+/** Generic top-level blocks are supported only when a composed descriptor claims their keyword. */
+function composedBlockKeywords(authoringContributions) {
+	const keywords = /* @__PURE__ */ new Set();
+	const descriptors = authoringContributions?.pslBlockDescriptors ?? {};
+	for (const [keyword, value] of Object.entries(descriptors)) if (isAuthoringPslBlockDescriptor(value)) keywords.add(keyword);
+	return keywords;
 }
 function buildModelNodeFromPsl(input) {
 	const { model, mapping, sourceId, diagnostics } = input;
@@ -2208,7 +2382,7 @@ function buildModelNodeFromPsl(input) {
 	let controlPolicyDeclared = false;
 	let controlPolicy;
 	const resultBackrelationCandidates = [];
-	for (const field of model.fields) {
+	for (const field of Object.values(model.fields)) {
 		if (!field.list || !input.modelNames.has(field.typeName)) continue;
 		const attributesValid = validateNavigationListFieldAttributes({
 			modelName: model.name,
@@ -2260,7 +2434,7 @@ function buildModelNodeFromPsl(input) {
 			...ifDefined("relationName", relationName)
 		});
 	}
-	const relationAttributes = model.fields.map((field) => ({
+	const relationAttributes = Object.values(model.fields).map((field) => ({
 		field,
 		relation: getAttribute(field.attributes, "relation")
 	})).filter((entry) => Boolean(entry.relation));
@@ -2331,7 +2505,7 @@ function buildModelNodeFromPsl(input) {
 				});
 				continue;
 			}
-			const nullableFieldName = fieldNames.find((name) => model.fields.find((f) => f.name === name)?.optional === true);
+			const nullableFieldName = fieldNames.find((name) => model.fields[name]?.optional === true);
 			if (nullableFieldName !== void 0) {
 				diagnostics.push({
 					code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
@@ -2718,6 +2892,7 @@ function buildModelNodeFromPsl(input) {
 			declaringModelName: model.name,
 			declaringFieldName: relationAttribute.field.name,
 			declaringTableName: tableName,
+			...ifDefined("declaringNamespaceId", input.modelNamespaceIds.get(model.name)),
 			targetModelName: targetMapping.model.name,
 			targetTableName: targetMapping.tableName,
 			...ifDefined("targetNamespaceId", targetNamespaceId),
@@ -2736,7 +2911,7 @@ function buildModelNodeFromPsl(input) {
 					fieldName: resolvedField.field.name,
 					columnName: resolvedField.columnName,
 					descriptor: resolvedField.descriptor,
-					nullable: resolvedField.field.optional,
+					nullable: resolvedField.nullable,
 					...ifDefined("default", resolvedField.defaultValue),
 					...ifDefined("executionDefaults", resolvedField.executionDefaults),
 					...ifDefined("enumTypeHandle", enumHandle)
@@ -2760,7 +2935,7 @@ function buildValueObjects(input) {
 	const compositeTypeNames = new Set(compositeTypes.map((ct) => ct.name));
 	for (const compositeType of compositeTypes) {
 		const fields = {};
-		for (const field of compositeType.fields) {
+		for (const field of Object.values(compositeType.fields)) {
 			if (compositeTypeNames.has(field.typeName)) {
 				const result = {
 					type: {
@@ -2866,7 +3041,7 @@ function collectPolymorphismDeclarations(models, sourceId, diagnostics) {
 				});
 				continue;
 			}
-			const discField = model.fields.find((f) => f.name === fieldName);
+			const discField = model.fields[fieldName];
 			if (discField && discField.typeName !== "String") {
 				diagnostics.push({
 					code: "PSL_INVALID_ATTRIBUTE_ARGUMENT",
@@ -3171,7 +3346,7 @@ function stripStorageOnlyDomainFields(model, fieldNames) {
 	};
 }
 function interpretPslDocumentToSqlContract(input) {
-	const sourceId = input.document.ast.sourceId;
+	const sourceId = input.sourceId;
 	if (!input.target) return notOk({
 		summary: "PSL to SQL contract interpretation failed",
 		diagnostics: [{
@@ -3188,22 +3363,27 @@ function interpretPslDocumentToSqlContract(input) {
 			sourceId
 		}]
 	});
-	const diagnostics = mapParserDiagnostics(input.document);
+	const { topLevel } = input.symbolTable;
+	const sourceFile = input.sourceFile;
+	const namespaceSymbols = Object.values(topLevel.namespaces);
+	const diagnostics = [...input.seedDiagnostics ?? []];
 	validateNamespaceBlocksForSqlTarget({
-		namespaces: input.document.ast.namespaces,
+		namespaces: namespaceSymbols,
 		targetId: input.target.targetId,
 		sourceId,
+		sourceFile,
 		diagnostics
 	});
 	const models = [];
 	const modelEntries = [];
 	const modelNamespaceIds = /* @__PURE__ */ new Map();
-	for (const namespace of input.document.ast.namespaces) {
+	const compositeTypes = [];
+	const collectScope = (bucketName, scopeModels, scopeCompositeTypes) => {
 		const resolvedNamespaceId = resolveNamespaceIdForSqlTarget({
-			bucketName: namespace.name,
+			bucketName,
 			targetId: input.target.targetId
 		});
-		for (const model of namespace.models) {
+		for (const model of scopeModels) {
 			models.push(model);
 			modelEntries.push({
 				model,
@@ -3211,9 +3391,11 @@ function interpretPslDocumentToSqlContract(input) {
 			});
 			if (resolvedNamespaceId !== void 0) modelNamespaceIds.set(model.name, resolvedNamespaceId);
 		}
-	}
+		for (const compositeType of scopeCompositeTypes) compositeTypes.push(compositeType);
+	};
+	collectScope(UNSPECIFIED_PSL_NAMESPACE_NAME, 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 defaultNamespaceId = input.target.defaultNamespaceId;
-	const compositeTypes = input.document.ast.namespaces.flatMap((ns) => ns.compositeTypes);
 	const modelNames = new Set(models.map((model) => model.name));
 	const compositeTypeNames = new Set(compositeTypes.map((ct) => ct.name));
 	const composedExtensions = new Set(input.composedExtensionPacks ?? []);
@@ -3222,17 +3404,34 @@ function interpretPslDocumentToSqlContract(input) {
 	const generatorDescriptors = input.controlMutationDefaults?.generatorDescriptors ?? [];
 	const generatorDescriptorById = /* @__PURE__ */ new Map();
 	for (const descriptor of generatorDescriptors) generatorDescriptorById.set(descriptor.id, descriptor);
-	const topLevelEnums = input.document.ast.namespaces.filter((ns) => ns.name === UNSPECIFIED_PSL_NAMESPACE_NAME).flatMap((ns) => namespacePslExtensionBlocks(ns).filter((b) => b.kind === "enum"));
-	for (const ns of input.document.ast.namespaces) {
-		if (ns.name === UNSPECIFIED_PSL_NAMESPACE_NAME) continue;
-		const nsEnums = namespacePslExtensionBlocks(ns).filter((b) => b.kind === "enum");
-		if (nsEnums.length === 0) continue;
-		for (const decl of nsEnums) diagnostics.push({
-			code: "PSL_ENUM_NAMESPACE_NOT_SUPPORTED",
-			message: `enum "${decl.name}" inside namespace "${ns.name}" is not supported; declare enum at the top level`,
+	const isEnumBlock = (block) => block.keyword === "enum";
+	const legitimateBlockKeywords = composedBlockKeywords(input.authoringContributions);
+	const reportUnsupportedTopLevelBlock = (block) => {
+		diagnostics.push({
+			code: "PSL_UNSUPPORTED_TOP_LEVEL_BLOCK",
+			message: `Unsupported top-level block "${block.keyword}"`,
 			sourceId,
-			span: decl.span
+			span: keywordPslSpan(block.node.syntax, block.keyword, sourceFile)
 		});
+	};
+	const topLevelEnums = Object.values(topLevel.blocks).filter((block) => {
+		if (!legitimateBlockKeywords.has(block.keyword)) {
+			reportUnsupportedTopLevelBlock(block);
+			return false;
+		}
+		return isEnumBlock(block);
+	}).map((block) => block.block);
+	for (const namespace of namespaceSymbols) for (const block of Object.values(namespace.blocks)) {
+		if (isEnumBlock(block)) {
+			diagnostics.push({
+				code: "PSL_ENUM_NAMESPACE_NOT_SUPPORTED",
+				message: `enum "${block.name}" inside namespace "${namespace.name}" is not supported; declare enum at the top level`,
+				sourceId,
+				span: nodePslSpan(block.node.syntax, sourceFile)
+			});
+			continue;
+		}
+		if (!legitimateBlockKeywords.has(block.keyword)) reportUnsupportedTopLevelBlock(block);
 	}
 	const enumResult = processEnumDeclarations({
 		enumBlocks: topLevelEnums,
@@ -3253,7 +3452,7 @@ function interpretPslDocumentToSqlContract(input) {
 	const validEnumHandles = { ...enumResult.enumHandles };
 	const enumHandlesByName = new Map(Object.entries(validEnumHandles));
 	const namedTypeResult = resolveNamedTypeDeclarations({
-		declarations: input.document.ast.types?.declarations ?? [],
+		declarations: [...Object.values(topLevel.scalars), ...Object.values(topLevel.typeAliases)],
 		sourceId,
 		enumTypeDescriptors: allEnumTypeDescriptors,
 		scalarTypeDescriptors: input.scalarTypeDescriptors,
@@ -3310,10 +3509,14 @@ function interpretPslDocumentToSqlContract(input) {
 			crossSpaceRelationsByModel.set(model.name, [...existing, ...result.crossSpaceRelations]);
 		}
 	}
-	const { modelRelations, fkRelationsByPair } = indexFkRelations({ fkRelationMetadata });
+	const { modelRelations, fkRelationsByPair, fkRelationsByDeclaringModel } = indexFkRelations({ fkRelationMetadata });
+	const modelIdColumns = /* @__PURE__ */ new Map();
+	for (const modelNode of modelNodes) if (modelNode.id) modelIdColumns.set(modelNode.modelName, modelNode.id.columns);
 	applyBackrelationCandidates({
 		backrelationCandidates,
 		fkRelationsByPair,
+		fkRelationsByDeclaringModel,
+		modelIdColumns,
 		modelRelations,
 		diagnostics,
 		sourceId
@@ -3342,7 +3545,7 @@ function interpretPslDocumentToSqlContract(input) {
 	});
 	if (diagnostics.length > 0) return notOk({
 		summary: "PSL to SQL contract interpretation failed",
-		diagnostics: dedupeDiagnostics(diagnostics)
+		diagnostics
 	});
 	const contract = buildSqlContractFromDefinition({
 		target: input.target,
@@ -3358,7 +3561,7 @@ function interpretPslDocumentToSqlContract(input) {
 	const modelsForPatch = {};
 	for (const [namespaceId, namespaceSlice] of Object.entries(contract.domain.namespaces)) for (const [modelName, model] of Object.entries(namespaceSlice.models)) {
 		const coordinate = modelCoordinateKey(namespaceId, modelName);
-		if (Object.hasOwn(modelsForPatch, coordinate)) throw new Error(`duplicate model "${namespaceId}.${modelName}" during PSL interpretation`);
+		invariant(!Object.hasOwn(modelsForPatch, coordinate), `symbol table guarantees coordinate uniqueness; duplicate model "${namespaceId}.${modelName}" reached interpretation`);
 		modelsForPatch[coordinate] = model;
 	}
 	let patchedModels = patchModelDomainFields(modelsForPatch, modelResolvedFields);
@@ -3384,4 +3587,4 @@ function interpretPslDocumentToSqlContract(input) {
 //#endregion
 export { interpretPslDocumentToSqlContract as t };
 
-//# sourceMappingURL=interpreter-B0BsCLKT.mjs.map
+//# sourceMappingURL=interpreter-CygvamTk.mjs.map