@prisma-next/sql-contract-psl 0.13.0 → 0.14.0-dev.10

package/dist/{interpreter-B_KtZusL.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 { isPostgresEnumStorageEntry } from "@prisma-next/sql-contract/types";
+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,
@@ -1071,7 +1077,7 @@ const NATIVE_TYPE_SPECS = {
 	"db.Uuid": {
 		args: "noArgs",
 		baseType: "String",
-		codecId: null,
+		codecId: "pg/uuid@1",
 		nativeType: "uuid"
 	},
 	"db.SmallInt": {
@@ -1301,13 +1307,53 @@ 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);
 }
 //#endregion
 //#region src/psl-field-resolution.ts
+function lowerEnumDefaultForField(input) {
+	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(")");
+	if (isQuotedString || isFunctionCall) {
+		input.diagnostics.push({
+			code: "PSL_ENUM_DEFAULT_MUST_BE_MEMBER_NAME",
+			message: `Field "${input.modelName}.${input.fieldName}" @default on an enum field must name a member (e.g. @default(Low)), not a raw value or function.`,
+			sourceId: input.sourceId,
+			span: input.defaultAttribute.span
+		});
+		return {};
+	}
+	const match = input.enumHandle.enumMembers.find((m) => m.name === raw);
+	if (!match) {
+		const validNames = input.enumHandle.enumMembers.map((m) => m.name).join(", ");
+		input.diagnostics.push({
+			code: "PSL_ENUM_UNKNOWN_DEFAULT_MEMBER",
+			message: `Field "${input.modelName}.${input.fieldName}" @default(${raw}) does not name a member of ${input.enumHandle.enumName}. Valid members: ${validNames}.`,
+			sourceId: input.sourceId,
+			span: input.defaultAttribute.span
+		});
+		return {};
+	}
+	return { defaultValue: {
+		kind: "literal",
+		value: blindCast(match.value)
+	} };
+}
 const MODEL_COORDINATE_SEPARATOR = "\0";
 function modelCoordinateKey(namespaceId, modelName) {
 	return `${namespaceId}${MODEL_COORDINATE_SEPARATOR}${modelName}`;
@@ -1381,9 +1427,9 @@ function extractFieldConstraintNames(input) {
 	};
 }
 function collectResolvedFields(input) {
-	const { model, mapping, enumTypeDescriptors, namedTypeDescriptors, modelNames, compositeTypeNames, composedExtensions, authoringContributions, familyId, targetId, defaultFunctionRegistry, generatorDescriptorById, diagnostics, sourceId, scalarTypeDescriptors } = 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({
@@ -1474,7 +1520,15 @@ function collectResolvedFields(input) {
 			});
 			continue;
 		}
-		const loweredDefault = defaultAttribute ? lowerDefaultForField({
+		const enumHandle = enumHandles?.get(field.typeName);
+		const loweredDefault = defaultAttribute ? enumHandle ? lowerEnumDefaultForField({
+			modelName: model.name,
+			fieldName: field.name,
+			defaultAttribute,
+			enumHandle,
+			sourceId,
+			diagnostics
+		}) : lowerDefaultForField({
 			modelName: model.name,
 			fieldName: field.name,
 			defaultAttribute,
@@ -1495,7 +1549,8 @@ function collectResolvedFields(input) {
 			});
 			continue;
 		}
-		if (loweredOnCreate) {
+		const fieldUsesNamedType = namedTypeDescriptors.has(field.typeName);
+		if (loweredOnCreate && !fieldUsesNamedType) {
 			const generatedDescriptor = generatorDescriptorById.get(loweredOnCreate.id)?.resolveGeneratedColumnDescriptor?.({ generated: loweredOnCreate });
 			if (generatedDescriptor) descriptor = generatedDescriptor;
 		}
@@ -1531,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),
@@ -1556,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,
@@ -1576,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",
@@ -1713,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);
@@ -1740,15 +1965,177 @@ 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) {
 		const pairKey = fkRelationPairKey(candidate.targetModelName, candidate.modelName);
 		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.`,
@@ -1769,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,
@@ -1829,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
@@ -1916,240 +2280,69 @@ 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) } : {}
 			});
 		}
 	}
 }
 function processEnumDeclarations(input) {
-	const storageTypes = {};
+	const enumHandles = {};
 	const enumTypeDescriptors = /* @__PURE__ */ new Map();
-	if (input.enums.length === 0) return {
-		storageTypes,
+	if (input.enumBlocks.length === 0) return {
+		enumHandles,
 		enumTypeDescriptors
 	};
-	if (!input.enumEntityDescriptor) {
-		for (const enumDeclaration of input.enums) input.diagnostics.push({
-			code: "PSL_UNSUPPORTED_NAMED_TYPE_BASE",
-			message: `Enum "${enumDeclaration.name}" requires the active target pack to contribute an enum entity-type helper`,
+	const enumDescriptor = getAuthoringEntity(input.authoringContributions, ["enum"]);
+	if (!enumDescriptor) {
+		for (const decl of input.enumBlocks) input.diagnostics.push({
+			code: "PSL_ENUM_MISSING_FACTORY",
+			message: `enum "${decl.name}" requires an "enum" entityType factory in the active authoring contributions`,
 			sourceId: input.sourceId,
-			span: enumDeclaration.span
+			span: decl.span
 		});
 		return {
-			storageTypes,
+			enumHandles,
 			enumTypeDescriptors
 		};
 	}
-	for (const enumDeclaration of input.enums) {
-		const nativeType = parseMapName({
-			attribute: getAttribute(enumDeclaration.attributes, "map"),
-			defaultValue: enumDeclaration.name,
-			sourceId: input.sourceId,
-			diagnostics: input.diagnostics,
-			entityLabel: `Enum "${enumDeclaration.name}"`,
-			span: enumDeclaration.span
-		});
-		const values = enumDeclaration.values.map((value) => value.name);
-		const constructed = instantiateAuthoringEntityType("enum", input.enumEntityDescriptor, [{
-			name: enumDeclaration.name,
-			nativeType,
-			values
-		}], input.entityContext);
-		if (!isPostgresEnumStorageEntry(constructed)) {
-			input.diagnostics.push({
-				code: "PSL_UNSUPPORTED_NAMED_TYPE_BASE",
-				message: `Enum "${enumDeclaration.name}": enum entity-type factory must return a PostgresEnumStorageEntry-shaped value (kind: 'postgres-enum')`,
-				sourceId: input.sourceId,
-				span: enumDeclaration.span
-			});
-			continue;
-		}
-		const descriptor = {
-			codecId: constructed.codecId,
-			nativeType: constructed.nativeType,
-			typeRef: enumDeclaration.name
-		};
-		enumTypeDescriptors.set(enumDeclaration.name, descriptor);
-		storageTypes[enumDeclaration.name] = constructed;
-	}
-	return {
-		storageTypes,
-		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
+	for (const decl of input.enumBlocks) {
+		const handle = instantiateAuthoringEntityType("enum", enumDescriptor, [decl], input.entityContext);
+		if (handle === void 0 || handle === null) continue;
+		const enumHandle = blindCast(handle);
+		enumHandles[decl.name] = enumHandle;
+		enumTypeDescriptors.set(decl.name, {
+			codecId: enumHandle.codecId,
+			nativeType: enumHandle.nativeType
 		});
-		hasUnsupportedNamedTypeAttribute = true;
 	}
 	return {
-		dbNativeTypeAttribute,
-		hasUnsupportedNamedTypeAttribute
+		enumHandles,
+		enumTypeDescriptors
 	};
 }
-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;
@@ -2169,7 +2362,8 @@ function buildModelNodeFromPsl(input) {
 		generatorDescriptorById: input.generatorDescriptorById,
 		diagnostics,
 		sourceId,
-		scalarTypeDescriptors: input.scalarTypeDescriptors
+		scalarTypeDescriptors: input.scalarTypeDescriptors,
+		...ifDefined("enumHandles", input.enumHandles)
 	});
 	const inlineIdFields = resolvedFields.filter((field) => field.isId);
 	if (inlineIdFields.length > 1) diagnostics.push({
@@ -2188,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,
@@ -2240,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));
@@ -2311,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",
@@ -2698,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),
@@ -2710,14 +2905,18 @@ function buildModelNodeFromPsl(input) {
 		modelNode: {
 			modelName: model.name,
 			tableName,
-			fields: resolvedFields.map((resolvedField) => ({
-				fieldName: resolvedField.field.name,
-				columnName: resolvedField.columnName,
-				descriptor: resolvedField.descriptor,
-				nullable: resolvedField.field.optional,
-				...ifDefined("default", resolvedField.defaultValue),
-				...ifDefined("executionDefaults", resolvedField.executionDefaults)
-			})),
+			fields: resolvedFields.map((resolvedField) => {
+				const enumHandle = input.enumHandles?.get(resolvedField.field.typeName);
+				return {
+					fieldName: resolvedField.field.name,
+					columnName: resolvedField.columnName,
+					descriptor: resolvedField.descriptor,
+					nullable: resolvedField.nullable,
+					...ifDefined("default", resolvedField.defaultValue),
+					...ifDefined("executionDefaults", resolvedField.executionDefaults),
+					...ifDefined("enumTypeHandle", enumHandle)
+				};
+			}),
 			...ifDefined("id", primaryKey),
 			...uniqueConstraints.length > 0 ? { uniques: uniqueConstraints } : {},
 			...indexNodes.length > 0 ? { indexes: indexNodes } : {},
@@ -2736,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: {
@@ -2842,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",
@@ -3147,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: [{
@@ -3164,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,
@@ -3187,21 +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 topLevelEnums = input.document.ast.namespaces.filter((ns) => ns.name === UNSPECIFIED_PSL_NAMESPACE_NAME).flatMap((ns) => ns.enums);
-	const namedNamespaceEnumsByNsId = /* @__PURE__ */ new Map();
-	for (const ns of input.document.ast.namespaces) {
-		if (ns.name === UNSPECIFIED_PSL_NAMESPACE_NAME || ns.enums.length === 0) continue;
-		const resolvedId = resolveNamespaceIdForSqlTarget({
-			bucketName: ns.name,
-			targetId: input.target.targetId
-		});
-		if (resolvedId === void 0) continue;
-		const existing = namedNamespaceEnumsByNsId.get(resolvedId) ?? [];
-		namedNamespaceEnumsByNsId.set(resolvedId, [...existing, ...ns.enums]);
-	}
-	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 ?? []);
@@ -3210,35 +3404,55 @@ function interpretPslDocumentToSqlContract(input) {
 	const generatorDescriptors = input.controlMutationDefaults?.generatorDescriptors ?? [];
 	const generatorDescriptorById = /* @__PURE__ */ new Map();
 	for (const descriptor of generatorDescriptors) generatorDescriptorById.set(descriptor.id, descriptor);
-	const enumEntityDescriptor = getAuthoringEntity(input.authoringContributions, ["enum"]);
-	const enumEntityContext = {
-		family: input.target.familyId,
-		target: input.target.targetId
+	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: 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({
-		enums: topLevelEnums,
+		enumBlocks: topLevelEnums,
 		sourceId,
-		enumEntityDescriptor,
-		entityContext: enumEntityContext,
+		authoringContributions: input.authoringContributions,
+		entityContext: {
+			family: input.target.familyId,
+			target: input.target.targetId,
+			...ifDefined("codecLookup", input.codecLookup),
+			sourceId,
+			diagnostics: { push: (d) => {
+				diagnostics.push(blindCast(d));
+			} }
+		},
 		diagnostics
 	});
 	const allEnumTypeDescriptors = new Map(enumResult.enumTypeDescriptors);
-	const namespaceEnumStorageTypes = {};
-	for (const [nsId, nsEnums] of namedNamespaceEnumsByNsId) {
-		const nsEnumResult = processEnumDeclarations({
-			enums: nsEnums,
-			sourceId,
-			enumEntityDescriptor,
-			entityContext: enumEntityContext,
-			diagnostics
-		});
-		for (const [name, descriptor] of nsEnumResult.enumTypeDescriptors) allEnumTypeDescriptors.set(name, descriptor);
-		const nsEntries = {};
-		for (const [name, entry] of Object.entries(nsEnumResult.storageTypes)) if (isPostgresEnumStorageEntry(entry)) nsEntries[name] = entry;
-		if (Object.keys(nsEntries).length > 0) namespaceEnumStorageTypes[nsId] = nsEntries;
-	}
+	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,
@@ -3248,10 +3462,7 @@ function interpretPslDocumentToSqlContract(input) {
 		authoringContributions: input.authoringContributions,
 		diagnostics
 	});
-	const storageTypes = {
-		...enumResult.storageTypes,
-		...namedTypeResult.storageTypes
-	};
+	const storageTypes = { ...namedTypeResult.storageTypes };
 	const modelMappingsByCoordinate = buildModelMappings(modelEntries, defaultNamespaceId, diagnostics, sourceId);
 	const modelMappings = /* @__PURE__ */ new Map();
 	for (const mapping of modelMappingsByCoordinate.values()) modelMappings.set(mapping.model.name, mapping);
@@ -3283,7 +3494,8 @@ function interpretPslDocumentToSqlContract(input) {
 			scalarTypeDescriptors: input.scalarTypeDescriptors,
 			sourceId,
 			diagnostics,
-			modelNamespaceIds
+			modelNamespaceIds,
+			...enumHandlesByName.size > 0 ? { enumHandles: enumHandlesByName } : {}
 		});
 		modelNodes.push(namespaceId !== void 0 ? {
 			...result.modelNode,
@@ -3297,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
@@ -3329,13 +3545,13 @@ 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,
 		...ifDefined("extensionPacks", buildComposedExtensionPackRefs(input.target, [...composedExtensions].sort(compareStrings), input.composedExtensionPackRefs)),
 		...Object.keys(storageTypes).length > 0 ? { storageTypes } : {},
-		...Object.keys(namespaceEnumStorageTypes).length > 0 ? { namespaceTypes: namespaceEnumStorageTypes } : {},
+		...Object.keys(validEnumHandles).length > 0 ? { enums: validEnumHandles } : {},
 		...ifDefined("createNamespace", input.createNamespace),
 		models: stiColumnModelNodes.map((model) => ({
 			...model,
@@ -3345,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);
@@ -3362,6 +3578,7 @@ function interpretPslDocumentToSqlContract(input) {
 		roots: filteredRoots,
 		domain: { namespaces: Object.fromEntries(Object.entries(contract.domain.namespaces).map(([namespaceId, namespaceSlice]) => [namespaceId, {
 			models: Object.fromEntries(Object.entries(namespaceSlice.models).map(([modelName, model]) => [modelName, patchedModels[modelCoordinateKey(namespaceId, modelName)] ?? model])),
+			...namespaceSlice.enum !== void 0 ? { enum: namespaceSlice.enum } : {},
 			...namespaceSlice.valueObjects !== void 0 ? { valueObjects: namespaceSlice.valueObjects } : {},
 			...namespaceId === input.target.defaultNamespaceId && Object.keys(valueObjects).length > 0 ? { valueObjects } : {}
 		}])) }
@@ -3370,4 +3587,4 @@ function interpretPslDocumentToSqlContract(input) {
 //#endregion
 export { interpretPslDocumentToSqlContract as t };
 
-//# sourceMappingURL=interpreter-B_KtZusL.mjs.map
+//# sourceMappingURL=interpreter-CygvamTk.mjs.map