@prisma-next/sql-contract-psl 0.14.0-dev.4 → 0.14.0-dev.6

package/dist/{interpreter-B0BsCLKT.mjs → interpreter-kDkm5opL.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",
@@ -1869,32 +2050,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 +2116,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 +2173,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 +2218,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 +2270,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 +2341,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",
@@ -2736,7 +2746,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 +2770,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 +2876,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 +3181,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 +3198,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 +3226,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 +3239,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 +3287,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,
@@ -3342,7 +3376,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 +3392,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 +3418,4 @@ function interpretPslDocumentToSqlContract(input) {
 //#endregion
 export { interpretPslDocumentToSqlContract as t };
 
-//# sourceMappingURL=interpreter-B0BsCLKT.mjs.map
+//# sourceMappingURL=interpreter-kDkm5opL.mjs.map