@prisma/orm-framework 8.0.0-rc.11-dev.33 → 8.0.0-rc.11-dev.35

package/dist/psl-parser.mjs

@@ -3,7 +3,8 @@ import { t as InternalError } from "./internal-error-ChGYPVpq-DhUD05u0.mjs";
 import { n as ok, t as notOk } from "./result-C0NUq1Ok.mjs";
 import { h as isAuthoringPslBlockDescriptor, m as isAuthoringModelAttributeDescriptor } from "./framework-authoring-BvxZnsPY-DlD1nwU5.mjs";
 import { a as makePslNamespace, c as validateExtensionBlock, i as flatPslModels, n as UNSPECIFIED_PSL_NAMESPACE_ID, o as makePslNamespaceEntries, s as namespacePslExtensionBlocks } from "./psl-ast-DUCvVXbB.mjs";
-import { D as TypesBlockAst, P as printSyntax, _ as NumberLiteralExprAst, a as CompositeTypeDeclarationAst, d as IdentifierAst, g as NamespaceDeclarationAst, i as BooleanLiteralExprAst, l as FunctionCallAst, m as ModelDeclarationAst, t as ArrayLiteralAst, u as GenericBlockDeclarationAst, w as TaggedLiteralExprAst, x as StringLiteralExprAst, y as ObjectLiteralExprAst } from "./declarations-DU8tJk4J-BAfPaIOL.mjs";
+import { D as TypesBlockAst, P as printSyntax, _ as NumberLiteralExprAst, a as CompositeTypeDeclarationAst, d as IdentifierAst, g as NamespaceDeclarationAst, i as BooleanLiteralExprAst, l as FunctionCallAst, m as ModelDeclarationAst, t as ArrayLiteralAst, u as GenericBlockDeclarationAst, w as TaggedLiteralExprAst, x as StringLiteralExprAst, y as ObjectLiteralExprAst } from "./declarations-SwNXosDu-D39d5EQ-.mjs";
+import { i as mapPslDiagnostics, n as diagnosticFromSpan, r as diagnosticSource, t as createPslDiagnosticCollector } from "./diagnostic-Esyl8Qw1-Cd6SnWPN.mjs";
 //#region ../../../1-framework/2-authoring/psl-parser/dist/index.mjs
 function getPositionalArgument(attribute, index = 0) {
 	return attribute.args.filter((arg) => arg.kind === "positional")[index]?.value;
@@ -45,26 +46,26 @@ function blockAttribute(name, config) {
 		...config.refine !== void 0 ? { refine: config.refine } : {}
 	};
 }
-function readResolvedAttribute(attribute, sourceFile) {
+function readResolvedAttribute(attribute, sources) {
 	return {
 		name: attributeName(attribute.name()),
-		args: readResolvedArgList(attribute.argList(), sourceFile),
-		span: nodePslSpan(attribute.syntax, sourceFile)
+		args: readResolvedArgList(attribute.argList(), sources),
+		span: nodePslSpan(attribute.syntax, sources)
 	};
 }
-function readResolvedAttributes(attributes, sourceFile) {
-	return Array.from(attributes, (attribute) => readResolvedAttribute(attribute, sourceFile));
+function readResolvedAttributes(attributes, sources) {
+	return Array.from(attributes, (attribute) => readResolvedAttribute(attribute, sources));
 }
-function readResolvedConstructorCall(annotation, sourceFile) {
+function readResolvedConstructorCall(annotation, sources) {
 	const argList = annotation?.argList();
 	if (annotation === void 0 || argList === void 0) return void 0;
 	return {
 		path: annotation.name()?.path() ?? [],
-		args: readResolvedArgList(argList, sourceFile),
-		span: nodePslSpan(annotation.syntax, sourceFile)
+		args: readResolvedArgList(argList, sources),
+		span: nodePslSpan(annotation.syntax, sources)
 	};
 }
-function readResolvedArgList(argList, sourceFile) {
+function readResolvedArgList(argList, sources) {
 	if (argList === void 0) return [];
 	const args = [];
 	for (const arg of argList.args()) {
@@ -75,7 +76,7 @@ function readResolvedArgList(argList, sourceFile) {
 			...name !== void 0 ? { name } : {},
 			value: renderExpression(expression),
 			...expression !== void 0 ? { expression } : {},
-			span: nodePslSpan(arg.syntax, sourceFile)
+			span: nodePslSpan(arg.syntax, sources)
 		});
 	}
 	return args;
@@ -87,35 +88,23 @@ function renderExpression(expression) {
 	if (expression === void 0) return "";
 	return printSyntax(expression.syntax).trim();
 }
-function nodePslSpan(node, sourceFile) {
+function nodePslSpan(node, sources) {
+	const sourceFile = sources.sourceFileFor(node);
 	const start = node.offset;
 	const end = start + node.green.textLength;
 	return {
-		start: offsetToPslPosition(start, sourceFile),
-		end: offsetToPslPosition(end, sourceFile)
+		start: sourceFile.offsetToPslPosition(start),
+		end: sourceFile.offsetToPslPosition(end)
 	};
 }
 /** Unsupported-top-level-block diagnostics are anchored to the keyword token. */
-function keywordPslSpan(node, keyword, sourceFile) {
+function keywordPslSpan(node, keyword, sources) {
+	const sourceFile = sources.sourceFileFor(node);
 	const start = node.offset;
 	const end = start + keyword.length;
 	return {
-		start: offsetToPslPosition(start, sourceFile),
-		end: offsetToPslPosition(end, sourceFile)
-	};
-}
-function rangeToPslSpan(range, sourceFile) {
-	return {
-		start: offsetToPslPosition(sourceFile.offsetAt(range.start), sourceFile),
-		end: offsetToPslPosition(sourceFile.offsetAt(range.end), sourceFile)
-	};
-}
-function offsetToPslPosition(offset, sourceFile) {
-	const position = sourceFile.positionAt(offset);
-	return {
-		offset,
-		line: position.line + 1,
-		column: position.character + 1
+		start: sourceFile.offsetToPslPosition(start),
+		end: sourceFile.offsetToPslPosition(end)
 	};
 }
 const ATTRIBUTE_DIAGNOSTIC_CODE = "PSL_INVALID_ATTRIBUTE_SYNTAX";
@@ -123,8 +112,7 @@ function leafDiagnostic(ctx, node, message, code = ATTRIBUTE_DIAGNOSTIC_CODE) {
 	return {
 		code,
 		message,
-		sourceId: ctx.sourceId,
-		span: nodePslSpan(node.syntax, ctx.sourceFile)
+		...diagnosticSource(ctx.sources, node.syntax).at(nodePslSpan(node.syntax, ctx.sources))
 	};
 }
 function bool() {
@@ -176,7 +164,7 @@ function referencedFieldRef() {
 		parse: (arg, ctx) => parseFieldName(arg, ctx, ctx.resolveReferencedModel())
 	};
 }
-function interpretArgs(args, spec, ctx, span) {
+function interpretArgs(args, spec, ctx, span, sourceNode) {
 	const diagnostics = [];
 	const output = {};
 	const seen = /* @__PURE__ */ new Set();
@@ -190,7 +178,7 @@ function interpretArgs(args, spec, ctx, span) {
 			const posParam = spec.positional[positionalSlot];
 			if (posParam === void 0) {
 				if (!reportedExcess) {
-					diagnostics.push(diagnostic(`Attribute "${spec.name}" received too many positional arguments`, ctx, span));
+					diagnostics.push(diagnostic(`Attribute "${spec.name}" received too many positional arguments`, ctx, span, sourceNode));
 					reportedExcess = true;
 				}
 				continue;
@@ -201,14 +189,14 @@ function interpretArgs(args, spec, ctx, span) {
 		} else {
 			const namedParam = Object.hasOwn(spec.named, name) ? spec.named[name] : void 0;
 			if (namedParam === void 0) {
-				diagnostics.push(diagnostic(`Attribute "${spec.name}" received unknown argument "${name}"`, ctx, nodePslSpan(arg.syntax, ctx.sourceFile)));
+				diagnostics.push(diagnostic(`Attribute "${spec.name}" received unknown argument "${name}"`, ctx, nodePslSpan(arg.syntax, ctx.sources), arg.syntax));
 				continue;
 			}
 			key = name;
 			param = namedParam.type;
 		}
 		if (seen.has(key)) {
-			diagnostics.push(diagnostic(`Attribute "${spec.name}" received duplicate argument "${key}"`, ctx, nodePslSpan(arg.syntax, ctx.sourceFile)));
+			diagnostics.push(diagnostic(`Attribute "${spec.name}" received duplicate argument "${key}"`, ctx, nodePslSpan(arg.syntax, ctx.sources), arg.syntax));
 			continue;
 		}
 		seen.add(key);
@@ -225,7 +213,7 @@ function interpretArgs(args, spec, ctx, span) {
 			if (effective.hasDefault) output[key] = effective.defaultValue;
 			return;
 		}
-		diagnostics.push(diagnostic(`Attribute "${spec.name}" is missing required argument "${key}"`, ctx, span));
+		diagnostics.push(diagnostic(`Attribute "${spec.name}" is missing required argument "${key}"`, ctx, span, sourceNode));
 	};
 	for (const param of spec.positional) {
 		const namedParam = Object.hasOwn(spec.named, param.key) ? spec.named[param.key] : void 0;
@@ -236,8 +224,8 @@ function interpretArgs(args, spec, ctx, span) {
 	return ok(output);
 }
 function interpretAttribute(attrNode, spec, ctx) {
-	const attributeSpan = nodePslSpan(attrNode.syntax, ctx.sourceFile);
-	const bound = interpretArgs(attrNode.argList()?.args() ?? [], spec, ctx, attributeSpan);
+	const attributeSpan = nodePslSpan(attrNode.syntax, ctx.sources);
+	const bound = interpretArgs(attrNode.argList()?.args() ?? [], spec, ctx, attributeSpan, attrNode.syntax);
 	if (!bound.ok) return notOk(bound.failure);
 	const value = blindCast(bound.value);
 	if (spec.refine !== void 0) {
@@ -249,7 +237,7 @@ function interpretAttribute(attrNode, spec, ctx) {
 function parseArgValue(arg, argType, ctx, diagnostics) {
 	const value = arg.value();
 	if (value === void 0) {
-		const missing = diagnostic("Attribute argument is missing a value", ctx, nodePslSpan(arg.syntax, ctx.sourceFile));
+		const missing = diagnostic("Attribute argument is missing a value", ctx, nodePslSpan(arg.syntax, ctx.sources), arg.syntax);
 		diagnostics.push(missing);
 		return notOk([missing]);
 	}
@@ -260,12 +248,11 @@ function parseArgValue(arg, argType, ctx, diagnostics) {
 function isOptionalArgType(param) {
 	return "optional" in param && param.optional === true;
 }
-function diagnostic(message, ctx, span) {
+function diagnostic(message, ctx, span, sourceNode) {
 	return {
 		code: ATTRIBUTE_DIAGNOSTIC_CODE,
 		message,
-		sourceId: ctx.sourceId,
-		span
+		...diagnosticSource(ctx.sources, sourceNode).at(span)
 	};
 }
 function funcCall(name, sig) {
@@ -277,12 +264,12 @@ function funcCall(name, sig) {
 		parse: (arg, ctx) => {
 			const guard = matchCallee(arg, name, ctx);
 			if (!guard.ok) return guard;
-			const span = nodePslSpan(guard.value.syntax, ctx.sourceFile);
+			const span = nodePslSpan(guard.value.syntax, ctx.sources);
 			const bound = interpretArgs(guard.value.args(), {
 				name,
 				positional: sig.positional ?? [],
 				named: sig.named ?? {}
-			}, ctx, span);
+			}, ctx, span, guard.value.syntax);
 			if (!bound.ok) return notOk(bound.failure);
 			return ok({
 				fn: name,
@@ -534,7 +521,7 @@ function taggedLiteral(tags, options) {
 			return ok({
 				tag: literal.tagName(),
 				canonicalization: literal.canonicalization(),
-				span: nodePslSpan(literal.syntax, ctx.sourceFile)
+				span: nodePslSpan(literal.syntax, ctx.sources)
 			});
 		}
 	};
@@ -586,7 +573,7 @@ function findBlockDescriptor(descriptors, keyword) {
 }
 function validateExtensionBlockFromSymbol(input) {
 	const refCtx = buildRefResolutionContext(input.symbolTable, input.block);
-	return validateExtensionBlock(input.block.block, input.descriptor, input.sourceId, input.codecLookup, refCtx);
+	return validateExtensionBlock(input.block.block, input.descriptor, input.sources.sourceFileFor(input.block.node.syntax).filename, input.codecLookup, refCtx).map((diagnostic) => diagnosticFromSpan(diagnostic, diagnosticSource(input.sources, input.block.node.syntax)));
 }
 const ZERO_SPAN = {
 	start: {
@@ -627,12 +614,12 @@ function findOwnerNamespaceName(symbolTable, block) {
 	for (const namespace of Object.values(symbolTable.topLevel.namespaces)) if (Object.values(namespace.blocks).some((candidate) => candidate === block)) return namespace.name;
 	return UNSPECIFIED_PSL_NAMESPACE_ID;
 }
-const BLOCK_ATTRIBUTE_SOURCE_ID = "unknown";
 /**
 * Descriptor-free and unknown parameters become `value` stubs so validation can
 * report them via key-set comparison. Duplicate member names are first-wins.
 */
-function reconstructExtensionBlock(node, descriptor, sourceFile, diagnostics) {
+function reconstructExtensionBlock(node, descriptor, sources, diagnostics) {
+	const sourceFile = sources.sourceFileFor(node.syntax);
 	const keyword = node.keyword()?.text ?? "";
 	const blockName = node.name()?.name() ?? "";
 	const blockAttributes = [];
@@ -645,17 +632,17 @@ function reconstructExtensionBlock(node, descriptor, sourceFile, diagnostics) {
 			return {
 				kind: "positional",
 				value: value === void 0 ? "" : printSyntax(value.syntax).trim(),
-				span: nodePslSpan(arg.syntax, sourceFile)
+				span: nodePslSpan(arg.syntax, sources)
 			};
 		});
-		const span = nodePslSpan(attribute.syntax, sourceFile);
+		const span = nodePslSpan(attribute.syntax, sources);
 		blockAttributes.push({
 			name,
 			args,
 			span
 		});
 		if (descriptor === void 0) continue;
-		const parsed = parseBlockAttribute(attribute, name, span, descriptor, seenAttributeNames, keyword, blockName, sourceFile);
+		const parsed = parseBlockAttribute(attribute, name, span, descriptor, seenAttributeNames, keyword, blockName, sources);
 		if (parsed.ok) attributes[name] = parsed.value;
 		else diagnostics.push(...parsed.diagnostics);
 	}
@@ -663,9 +650,10 @@ function reconstructExtensionBlock(node, descriptor, sourceFile, diagnostics) {
 	for (const entry of node.entries()) {
 		const key = entry.key()?.name();
 		if (key === void 0) continue;
-		const span = nodePslSpan(entry.syntax, sourceFile);
+		const span = nodePslSpan(entry.syntax, sources);
 		if (Object.hasOwn(parameters, key)) {
 			diagnostics.push({
+				filename: sourceFile.filename,
 				code: "PSL_EXTENSION_DUPLICATE_PARAMETER",
 				message: `Duplicate parameter "${key}" in "${keyword}" block "${blockName}"; first occurrence wins`,
 				range: {
@@ -675,7 +663,7 @@ function reconstructExtensionBlock(node, descriptor, sourceFile, diagnostics) {
 			});
 			continue;
 		}
-		parameters[key] = reconstructParamValue(entry, descriptor?.parameters[key], span, sourceFile, diagnostics);
+		parameters[key] = reconstructParamValue(entry, descriptor?.parameters[key], span, sources, diagnostics);
 	}
 	return {
 		kind: descriptor?.discriminator ?? keyword,
@@ -684,15 +672,17 @@ function reconstructExtensionBlock(node, descriptor, sourceFile, diagnostics) {
 		parameters,
 		blockAttributes,
 		attributes,
-		span: nodePslSpan(node.syntax, sourceFile)
+		span: nodePslSpan(node.syntax, sources)
 	};
 }
-function parseBlockAttribute(attribute, name, span, descriptor, seenNames, keyword, blockName, sourceFile) {
-	const range = pslSpanToRange(span, sourceFile);
+function parseBlockAttribute(attribute, name, span, descriptor, seenNames, keyword, blockName, sources) {
+	const sourceFile = sources.sourceFileFor(attribute.syntax);
+	const range = sourceFile.pslSpanToRange(span);
 	const declared = descriptor.attributes ?? {};
 	if (!Object.hasOwn(declared, name)) return {
 		ok: false,
 		diagnostics: [{
+			filename: sourceFile.filename,
 			code: "PSL_EXTENSION_UNKNOWN_BLOCK_ATTRIBUTE",
 			message: `Unknown attribute "@@${name}" in "${keyword}" block "${blockName}"`,
 			range
@@ -701,19 +691,17 @@ function parseBlockAttribute(attribute, name, span, descriptor, seenNames, keywo
 	if (seenNames.has(name)) return {
 		ok: false,
 		diagnostics: [{
+			filename: sourceFile.filename,
 			code: "PSL_INVALID_EXTENSION_BLOCK_ATTRIBUTE",
 			message: `Duplicate attribute "@@${name}" in "${keyword}" block "${blockName}"; first occurrence wins`,
 			range
 		}]
 	};
 	seenNames.add(name);
-	const result = interpretAttribute(attribute, blindCast(declared[name])(), {
-		sourceId: BLOCK_ATTRIBUTE_SOURCE_ID,
-		sourceFile
-	});
+	const result = interpretAttribute(attribute, blindCast(declared[name])(), { sources });
 	if (!result.ok) return {
 		ok: false,
-		diagnostics: result.failure.map((diagnostic) => toParseDiagnostic(diagnostic, sourceFile))
+		diagnostics: result.failure
 	};
 	return {
 		ok: true,
@@ -723,33 +711,22 @@ function parseBlockAttribute(attribute, name, span, descriptor, seenNames, keywo
 		}
 	};
 }
-function toParseDiagnostic(diagnostic, sourceFile) {
-	return {
-		code: diagnostic.code,
-		message: diagnostic.message,
-		range: pslSpanToRange(diagnostic.span, sourceFile)
-	};
-}
-function pslSpanToRange(span, sourceFile) {
-	return {
-		start: sourceFile.positionAt(span.start.offset),
-		end: sourceFile.positionAt(span.end.offset)
-	};
-}
-function reconstructParamValue(entry, param, span, sourceFile, diagnostics) {
+function reconstructParamValue(entry, param, span, sources, diagnostics) {
 	const value = entry.value();
 	if (value === void 0) return {
 		kind: "bare",
 		span
 	};
-	return reconstructFromExpression(value, param, span, sourceFile, diagnostics);
+	return reconstructFromExpression(value, param, span, sources, diagnostics);
 }
-function reconstructFromExpression(value, param, span, sourceFile, diagnostics) {
+function reconstructFromExpression(value, param, span, sources, diagnostics) {
 	const raw = printSyntax(value.syntax).trim();
 	if (param?.kind === "list") {
+		const sourceFile = sources.sourceFileFor(value.syntax);
 		const array = ArrayLiteralAst.cast(value.syntax);
 		if (!array) {
 			diagnostics?.push({
+				filename: sourceFile.filename,
 				code: "PSL_EXTENSION_INVALID_VALUE",
 				message: `List parameter expects an array literal, got ${raw}`,
 				range: {
@@ -764,7 +741,7 @@ function reconstructFromExpression(value, param, span, sourceFile, diagnostics)
 			};
 		}
 		const items = [];
-		for (const element of array.elements()) items.push(reconstructFromExpression(element, param.of, nodePslSpan(element.syntax, sourceFile), sourceFile, diagnostics));
+		for (const element of array.elements()) items.push(reconstructFromExpression(element, param.of, nodePslSpan(element.syntax, sources), sources, diagnostics));
 		return {
 			kind: "list",
 			items,
@@ -794,7 +771,7 @@ function reconstructFromExpression(value, param, span, sourceFile, diagnostics)
 * should consume first-wins symbols rather than re-emitting duplicate diagnostics.
 */
 function buildSymbolTable(options) {
-	const { document, sourceFile, pslBlockDescriptors } = options;
+	const { documents, sources, pslBlockDescriptors } = options;
 	const diagnostics = [];
 	const namespaces = Object.create(null);
 	const namedTypes = {};
@@ -802,62 +779,66 @@ function buildSymbolTable(options) {
 	const models = {};
 	const compositeTypes = {};
 	const topLevelNames = /* @__PURE__ */ new Set();
-	const claim = (taken, name) => {
-		const text = name?.name();
-		if (text === void 0) return void 0;
-		if (taken.has(text)) {
-			const range = nameRange(name, sourceFile);
-			if (range) diagnostics.push({
-				code: "PSL_DUPLICATE_DECLARATION",
-				message: `Duplicate declaration of "${text}"`,
-				range
-			});
-			return;
-		}
-		taken.add(text);
-		return text;
-	};
-	for (const declaration of document.declarations()) if (declaration instanceof ModelDeclarationAst) {
-		const name = claim(topLevelNames, declaration.name());
-		if (name !== void 0) models[name] = buildModel(name, declaration, sourceFile, diagnostics);
-	} else if (declaration instanceof CompositeTypeDeclarationAst) {
-		const name = claim(topLevelNames, declaration.name());
-		if (name !== void 0) compositeTypes[name] = buildCompositeType(name, declaration, sourceFile, diagnostics);
-	} else if (declaration instanceof GenericBlockDeclarationAst) {
-		const name = claim(topLevelNames, declaration.name());
-		if (name !== void 0) blocks[name] = buildBlock(name, declaration, sourceFile, pslBlockDescriptors, diagnostics);
-	} else if (declaration instanceof NamespaceDeclarationAst) {
-		const declaredName = declaration.name()?.name();
-		if (declaredName === void 0) continue;
-		let namespace = namespaces[declaredName];
-		if (namespace === void 0) {
+	for (const document of documents) {
+		const sourceFile = sources.sourceFileFor(document.syntax);
+		const claim = (taken, name) => {
+			const text = name?.name();
+			if (text === void 0) return void 0;
+			if (taken.has(text)) {
+				const range = nameRange(name, sources);
+				if (range) diagnostics.push({
+					code: "PSL_DUPLICATE_DECLARATION",
+					message: `Duplicate declaration of "${text}"`,
+					filename: sourceFile.filename,
+					range
+				});
+				return;
+			}
+			taken.add(text);
+			return text;
+		};
+		for (const declaration of document.declarations()) if (declaration instanceof ModelDeclarationAst) {
+			const name = claim(topLevelNames, declaration.name());
+			if (name !== void 0) models[name] = buildModel(name, declaration, sources, diagnostics);
+		} else if (declaration instanceof CompositeTypeDeclarationAst) {
 			const name = claim(topLevelNames, declaration.name());
+			if (name !== void 0) compositeTypes[name] = buildCompositeType(name, declaration, sources, diagnostics);
+		} else if (declaration instanceof GenericBlockDeclarationAst) {
+			const name = claim(topLevelNames, declaration.name());
+			if (name !== void 0) blocks[name] = buildBlock(name, declaration, sources, pslBlockDescriptors, diagnostics);
+		} else if (declaration instanceof NamespaceDeclarationAst) {
+			const declaredName = declaration.name()?.name();
+			if (declaredName === void 0) continue;
+			let namespace = namespaces[declaredName];
+			if (namespace === void 0) {
+				const name = claim(topLevelNames, declaration.name());
+				if (name === void 0) continue;
+				namespace = {
+					kind: "namespace",
+					name,
+					declarations: [],
+					models: Object.create(null),
+					compositeTypes: Object.create(null),
+					blocks: Object.create(null)
+				};
+				namespaces[name] = namespace;
+			}
+			extendNamespace(namespace, declaration, diagnostics, sources, pslBlockDescriptors);
+		} else if (declaration instanceof TypesBlockAst) for (const binding of declaration.declarations()) {
+			const name = claim(topLevelNames, binding.name());
 			if (name === void 0) continue;
-			namespace = {
-				kind: "namespace",
+			const resolved = resolveNamedTypeBinding(binding, sources);
+			namedTypes[name] = {
+				kind: "namedType",
 				name,
-				declarations: [],
-				models: Object.create(null),
-				compositeTypes: Object.create(null),
-				blocks: Object.create(null)
+				node: binding,
+				span: nodePslSpan(binding.syntax, sources),
+				...resolved
 			};
-			namespaces[name] = namespace;
 		}
-		extendNamespace(namespace, declaration, diagnostics, sourceFile, pslBlockDescriptors);
-	} else if (declaration instanceof TypesBlockAst) for (const binding of declaration.declarations()) {
-		const name = claim(topLevelNames, binding.name());
-		if (name === void 0) continue;
-		const resolved = resolveNamedTypeBinding(binding, sourceFile);
-		namedTypes[name] = {
-			kind: "namedType",
-			name,
-			node: binding,
-			span: nodePslSpan(binding.syntax, sourceFile),
-			...resolved
-		};
 	}
 	return {
-		table: { topLevel: {
+		symbolTable: { topLevel: {
 			namespaces,
 			namedTypes,
 			blocks,
@@ -867,27 +848,27 @@ function buildSymbolTable(options) {
 		diagnostics
 	};
 }
-function buildModel(name, node, sourceFile, diagnostics) {
+function buildModel(name, node, sources, diagnostics) {
 	return {
 		kind: "model",
 		name,
 		node,
-		span: nodePslSpan(node.syntax, sourceFile),
-		fields: buildFields(name, node.fields(), sourceFile, diagnostics),
-		attributes: readResolvedAttributes(node.attributes(), sourceFile)
+		span: nodePslSpan(node.syntax, sources),
+		fields: buildFields(name, node.fields(), sources, diagnostics),
+		attributes: readResolvedAttributes(node.attributes(), sources)
 	};
 }
-function buildCompositeType(name, node, sourceFile, diagnostics) {
+function buildCompositeType(name, node, sources, diagnostics) {
 	return {
 		kind: "compositeType",
 		name,
 		node,
-		span: nodePslSpan(node.syntax, sourceFile),
-		fields: buildFields(name, node.fields(), sourceFile, diagnostics),
-		attributes: readResolvedAttributes(node.attributes(), sourceFile)
+		span: nodePslSpan(node.syntax, sources),
+		fields: buildFields(name, node.fields(), sources, diagnostics),
+		attributes: readResolvedAttributes(node.attributes(), sources)
 	};
 }
-function buildBlock(name, node, sourceFile, pslBlockDescriptors, diagnostics) {
+function buildBlock(name, node, sources, pslBlockDescriptors, diagnostics) {
 	const keyword = node.keyword()?.text ?? "";
 	const descriptor = findBlockDescriptor(pslBlockDescriptors, keyword);
 	return {
@@ -895,55 +876,57 @@ function buildBlock(name, node, sourceFile, pslBlockDescriptors, diagnostics) {
 		name,
 		keyword,
 		node,
-		span: nodePslSpan(node.syntax, sourceFile),
-		block: reconstructExtensionBlock(node, descriptor, sourceFile, diagnostics)
+		span: nodePslSpan(node.syntax, sources),
+		block: reconstructExtensionBlock(node, descriptor, sources, diagnostics)
 	};
 }
-function extendNamespace(namespace, node, diagnostics, sourceFile, pslBlockDescriptors) {
+function extendNamespace(namespace, node, diagnostics, sources, pslBlockDescriptors) {
 	const { models, compositeTypes, blocks } = namespace;
 	namespace.declarations.push({
 		node,
-		span: nodePslSpan(node.syntax, sourceFile)
+		span: nodePslSpan(node.syntax, sources)
 	});
 	for (const member of node.declarations()) {
 		const memberName = member.name()?.name();
 		if (memberName === void 0) continue;
 		if (Object.hasOwn(models, memberName) || Object.hasOwn(compositeTypes, memberName) || Object.hasOwn(blocks, memberName)) {
-			const range = nameRange(member.name(), sourceFile);
+			const range = nameRange(member.name(), sources);
 			if (range) diagnostics.push({
 				code: "PSL_DUPLICATE_DECLARATION",
 				message: `Duplicate declaration of "${memberName}"`,
+				filename: sources.sourceFileFor(member.syntax).filename,
 				range
 			});
 			continue;
 		}
-		if (member instanceof ModelDeclarationAst) models[memberName] = buildModel(memberName, member, sourceFile, diagnostics);
-		else if (member instanceof CompositeTypeDeclarationAst) compositeTypes[memberName] = buildCompositeType(memberName, member, sourceFile, diagnostics);
-		else if (member instanceof GenericBlockDeclarationAst) blocks[memberName] = buildBlock(memberName, member, sourceFile, pslBlockDescriptors, diagnostics);
+		if (member instanceof ModelDeclarationAst) models[memberName] = buildModel(memberName, member, sources, diagnostics);
+		else if (member instanceof CompositeTypeDeclarationAst) compositeTypes[memberName] = buildCompositeType(memberName, member, sources, diagnostics);
+		else if (member instanceof GenericBlockDeclarationAst) blocks[memberName] = buildBlock(memberName, member, sources, pslBlockDescriptors, diagnostics);
 	}
 }
-function buildFields(ownerName, fields, sourceFile, diagnostics) {
+function buildFields(ownerName, fields, sources, diagnostics) {
 	const result = {};
 	for (const field of fields) {
 		const nameNode = field.name();
 		const name = nameNode?.name();
 		if (name === void 0) continue;
 		if (Object.hasOwn(result, name)) {
-			const range = nameRange(nameNode, sourceFile);
+			const range = nameRange(nameNode, sources);
 			if (range) diagnostics.push({
 				code: "PSL_DUPLICATE_DECLARATION",
 				message: `Duplicate declaration of "${name}"`,
+				filename: sources.sourceFileFor(field.syntax).filename,
 				range
 			});
 			continue;
 		}
-		result[name] = buildField(ownerName, name, field, sourceFile, diagnostics);
+		result[name] = buildField(ownerName, name, field, sources, diagnostics);
 	}
 	return result;
 }
-function buildField(ownerName, name, node, sourceFile, diagnostics) {
-	const attributes = readResolvedAttributes(node.attributes(), sourceFile);
-	const span = nodePslSpan(node.syntax, sourceFile);
+function buildField(ownerName, name, node, sources, diagnostics) {
+	const attributes = readResolvedAttributes(node.attributes(), sources);
+	const span = nodePslSpan(node.syntax, sources);
 	const annotation = node.typeAnnotation();
 	const typeName = annotation?.name();
 	if (typeName?.isOverQualified()) {
@@ -951,7 +934,8 @@ function buildField(ownerName, name, node, sourceFile, diagnostics) {
 		diagnostics.push({
 			code: "PSL_INVALID_QUALIFIED_TYPE",
 			message: `Field "${ownerName}.${name}" has an invalid qualified type "${path.join(".")}"; use at most one namespace qualifier (e.g. "ns.TypeName")`,
-			range: nodeRange(typeName.syntax, sourceFile)
+			filename: sources.sourceFileFor(typeName.syntax).filename,
+			range: nodeRange(typeName.syntax, sources)
 		});
 		return {
 			kind: "field",
@@ -965,7 +949,7 @@ function buildField(ownerName, name, node, sourceFile, diagnostics) {
 			attributes
 		};
 	}
-	const typeConstructor = annotation?.isConstructor() ? readResolvedConstructorCall(annotation, sourceFile) : void 0;
+	const typeConstructor = annotation?.isConstructor() ? readResolvedConstructorCall(annotation, sources) : void 0;
 	const typeNamespaceId = typeName?.namespace()?.name();
 	const typeContractSpaceId = typeName?.space()?.name();
 	return {
@@ -982,26 +966,28 @@ function buildField(ownerName, name, node, sourceFile, diagnostics) {
 		attributes
 	};
 }
-function resolveNamedTypeBinding(node, sourceFile) {
+function resolveNamedTypeBinding(node, sources) {
 	const annotation = node.typeAnnotation();
 	const isConstructor = annotation?.isConstructor() ?? false;
 	const baseType = annotation?.name()?.identifier()?.name();
-	const typeConstructor = readResolvedConstructorCall(annotation, sourceFile);
+	const typeConstructor = readResolvedConstructorCall(annotation, sources);
 	return {
 		isConstructor,
 		...!isConstructor && baseType !== void 0 ? { baseType } : {},
 		...typeConstructor !== void 0 ? { typeConstructor } : {},
-		attributes: readResolvedAttributes(node.attributes(), sourceFile)
+		attributes: readResolvedAttributes(node.attributes(), sources)
 	};
 }
-function nameRange(name, sourceFile) {
+function nameRange(name, sources) {
 	if (name === void 0) return void 0;
+	const sourceFile = sources.sourceFileFor(name.syntax);
 	for (const token of name.syntax.tokens()) if (token.kind === "Ident") return {
 		start: sourceFile.positionAt(token.offset),
 		end: sourceFile.positionAt(token.offset + token.text.length)
 	};
 }
-function nodeRange(node, sourceFile) {
+function nodeRange(node, sources) {
+	const sourceFile = sources.sourceFileFor(node);
 	const start = node.offset;
 	const end = start + node.green.textLength;
 	return {
@@ -1010,6 +996,6 @@ function nodeRange(node, sourceFile) {
 	};
 }
 //#endregion
-export { assembleAttributeSpecs, blockAttribute, bool, buildSymbolTable, entityRef, fieldAttribute, fieldRef, findBlockDescriptor, flatPslModels, funcCall, getPositionalArgument, identifier, int, interpretArgs, interpretAttribute, json, keywordPslSpan, leafDiagnostic, list, modelAttribute, namespacePslExtensionBlocks, nodePslSpan, num, numLiteral, oneOf, optional, parseQuotedStringLiteral, rangeToPslSpan, readResolvedAttribute, readResolvedAttributes, readResolvedConstructorCall, record, referencedFieldRef, str, taggedLiteral, validateExtensionBlockFromSymbol };
+export { assembleAttributeSpecs, blockAttribute, bool, buildSymbolTable, createPslDiagnosticCollector, diagnosticFromSpan, diagnosticSource, entityRef, fieldAttribute, fieldRef, findBlockDescriptor, flatPslModels, funcCall, getPositionalArgument, identifier, int, interpretArgs, interpretAttribute, json, keywordPslSpan, leafDiagnostic, list, mapPslDiagnostics, modelAttribute, namespacePslExtensionBlocks, nodePslSpan, num, numLiteral, oneOf, optional, parseQuotedStringLiteral, readResolvedAttribute, readResolvedAttributes, readResolvedConstructorCall, record, referencedFieldRef, str, taggedLiteral, validateExtensionBlockFromSymbol };
 
 //# sourceMappingURL=psl-parser.mjs.map