@prisma/orm-framework 8.0.0-rc.14-dev.16 → 8.0.0-rc.14-dev.17

package/dist/psl-parser.mjs

@@ -1,20 +1,12 @@
 import { t as blindCast } from "./casts-DpaahrlC-Bd5n2coI.mjs";
 import { t as InternalError } from "./internal-error-ChGYPVpq-DhUD05u0.mjs";
 import { a as or, i as okVoid, n as notOk, r as ok, t as and } from "./result-8OXF26MN.mjs";
-import { C as isAuthoringTypeConstructorDescriptor, S as isAuthoringPslBlockDescriptor, x as isAuthoringModelAttributeDescriptor } from "./temporal-presets-DsGuaFyT-DWzKyja_.mjs";
+import { b as isAuthoringModelAttributeDescriptor, x as isAuthoringPslBlockDescriptor } from "./temporal-presets-DzBBD4St-BaL1QaZ7.mjs";
 import { a as flatPslModels, c as namespacePslExtensionBlocks } from "./psl-ast-CyvE6CR-.mjs";
 import { n as isPslIdentifier } from "./tokenizer-BMz7z2KR-J0yZ4im3.mjs";
-import { C as TaggedLiteralExprAst, S as StringLiteralExprAst, T as TypesBlockAst, _ 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, y as ObjectLiteralExprAst } from "./declarations-C0VwsVFX-24_6w6Lb.mjs";
+import { C as TaggedLiteralExprAst, S as StringLiteralExprAst, T as TypesBlockAst, _ 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, y as ObjectLiteralExprAst } from "./declarations-C0VwsVFX-BcP1Nyv4.mjs";
 import { a as mapPslDiagnostics, c as readResolvedAttributes, i as keywordPslSpan, l as readResolvedConstructorCall, n as diagnosticFromSpan, o as nodePslSpan, r as diagnosticSource, s as readResolvedAttribute, t as createPslDiagnosticCollector } from "./resolve-GE34dgM6-D33m6YEw.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;
-}
-function parseQuotedStringLiteral(value) {
-	const match = value.trim().match(/^(['"])(.*)\1$/);
-	if (!match) return void 0;
-	return match[2] ?? "";
-}
+//#region ../../../1-framework/2-authoring/psl-parser/dist/symbol-table-0DYRY2eQ.mjs
 function* modelAttributeDescriptors(namespace) {
 	for (const value of Object.values(namespace)) {
 		if (isAuthoringModelAttributeDescriptor(value)) {
@@ -37,1216 +29,1514 @@ function assembleAttributeSpecs(contributions) {
 		field: Object.freeze({ ...contributions.attributeSpecs.field })
 	}));
 }
-function blockAttribute(name, config) {
-	return {
-		level: "block",
-		name,
-		documentation: config.documentation,
-		positional: config.positional ?? [],
-		named: config.named ?? {},
-		...config.refine !== void 0 ? { refine: config.refine } : {}
-	};
+function resolveDescribeUnsupportedAttribute(pslDiagnostics) {
+	if (pslDiagnostics?.describeUnsupportedAttribute === void 0) return;
+	return blindCast(pslDiagnostics.describeUnsupportedAttribute);
 }
-const ATTRIBUTE_DIAGNOSTIC_CODE = "PSL_INVALID_ATTRIBUTE_SYNTAX";
-function leafDiagnostic(ctx, node, message, code = ATTRIBUTE_DIAGNOSTIC_CODE) {
-	return {
-		code,
-		message,
-		...diagnosticSource(ctx.sources, node.syntax).at(nodePslSpan(node.syntax, ctx.sources))
-	};
+function resolveDescribeUnresolvedType(pslDiagnostics) {
+	if (pslDiagnostics?.describeUnresolvedType === void 0) return;
+	return blindCast(pslDiagnostics.describeUnresolvedType);
 }
-function bool() {
+function blockSpecFactoryOf(descriptor) {
+	return blindCast(descriptor.spec);
+}
+function isContributedTypeDescriptor(value) {
+	return "kind" in value && (value.kind === "typeConstructor" || value.kind === "fieldPreset");
+}
+function mergeContributedTypes(...namespaces) {
+	const merged = {};
+	for (const namespace of namespaces) for (const [name, value] of Object.entries(namespace)) {
+		const existing = Object.hasOwn(merged, name) ? merged[name] : void 0;
+		merged[name] = existing !== void 0 && !isContributedTypeDescriptor(existing) && !isContributedTypeDescriptor(value) ? mergeContributedTypes(existing, value) : value;
+	}
+	return merged;
+}
+function contributedTypeScope(contributedTypes) {
+	const members = collect(contributedTypes, []);
 	return {
-		kind: "bool",
-		label: "boolean",
-		parse: (arg, ctx) => {
-			const literal = BooleanLiteralExprAst.cast(arg.syntax);
-			if (literal !== void 0) {
-				const value = literal.value();
-				if (value !== void 0) return ok(value);
-			}
-			return notOk([leafDiagnostic(ctx, arg, "Expected a boolean literal")]);
+		lookup(name) {
+			return members.get(name);
+		},
+		entries() {
+			return members.entries();
 		}
 	};
 }
-const references = /* @__PURE__ */ new WeakMap();
-function entityReference(resolution) {
-	switch (resolution.kind) {
-		case "model":
-		case "compositeType":
-		case "namedType":
-		case "block": return interned(resolution.symbol, resolution.namespace);
-		default: return;
+function collect(namespace, prefix) {
+	const members = /* @__PURE__ */ new Map();
+	for (const [name, value] of Object.entries(namespace)) {
+		const path = [...prefix, name];
+		members.set(name, isContributedTypeDescriptor(value) ? {
+			kind: "contributedType",
+			name,
+			path,
+			descriptor: value
+		} : {
+			kind: "contributedNamespace",
+			name,
+			path,
+			members: collect(value, path)
+		});
 	}
+	return members;
 }
-function interned(declaration, namespace) {
-	const existing = references.get(declaration);
-	if (existing !== void 0) return existing;
-	const reference = {
-		declaration,
-		namespace
-	};
-	references.set(declaration, reference);
-	return reference;
+function findBlockDescriptor(descriptors, keyword) {
+	if (descriptors === void 0) return void 0;
+	for (const value of Object.values(descriptors)) {
+		if (value === void 0) continue;
+		if (isAuthoringPslBlockDescriptor(value)) {
+			if (value.keyword === keyword) return value;
+			continue;
+		}
+		const nested = findBlockDescriptor(value, keyword);
+		if (nested !== void 0) return nested;
+	}
 }
-function matchesSelector(reference, expected) {
-	const declaration = reference.declaration;
-	if (declaration.kind !== expected.kind) return false;
-	return expected.kind !== "block" || declaration.kind === "block" && declaration.keyword === expected.keyword;
+function* recordNames(...records) {
+	for (const record of records) yield* Object.keys(record);
 }
-function describeResolution(resolution) {
-	switch (resolution.kind) {
-		case "block": return resolution.symbol.keyword;
-		case "contributedType": return "scalar type";
-		case "crossSpace": return "cross-space reference";
-		case "unresolved": return "unresolved name";
-		default: return resolution.kind;
+var Scope = class {
+	parent;
+	constructor(parent) {
+		this.parent = parent;
 	}
-}
-function entityRef(expected) {
-	const label = `${expected.kind === "block" ? expected.keyword : expected.kind} reference`;
-	return {
-		kind: "entityRef",
-		label,
-		expected,
-		parse: (arg, ctx) => {
-			const name = IdentifierAst.cast(arg.syntax)?.name();
-			if (name === void 0) return notOk([leafDiagnostic(ctx, arg, `Expected ${label}`)]);
-			const resolution = ctx.binder.symbolForNode(arg.syntax);
-			if (resolution === void 0 || resolution.kind === "unresolved") return notOk([]);
-			const reference = entityReference(resolution);
-			if (reference === void 0 || !matchesSelector(reference, expected)) return notOk([leafDiagnostic(ctx, arg, `Expected ${label} "${name}", found ${describeResolution(resolution)}`)]);
-			return ok(reference);
+	*entries() {
+		const seen = /* @__PURE__ */ new Set();
+		for (const name of this.ownNames()) {
+			if (seen.has(name)) continue;
+			seen.add(name);
+			const resolution = this.lookup(name);
+			if (resolution !== void 0) yield [name, resolution];
 		}
+		for (const entry of this.parent?.entries() ?? []) if (!seen.has(entry[0])) yield entry;
+	}
+};
+function contributedResolution(member) {
+	return member.kind === "contributedType" ? {
+		kind: "contributedType",
+		symbol: member
+	} : {
+		kind: "contributedNamespace",
+		symbol: member
 	};
 }
-function parseFieldName(arg, ctx) {
-	const identifier = IdentifierAst.cast(arg.syntax);
-	if (identifier === void 0) return notOk([leafDiagnostic(ctx, arg, "Expected a field name")]);
-	const name = identifier.name();
-	if (name === void 0) return notOk([leafDiagnostic(ctx, arg, "Expected a field name")]);
-	const resolution = ctx.binder.symbolForNode(arg.syntax);
-	if (resolution === void 0) return notOk([]);
-	if (resolution.kind === "field") return ok(resolution.symbol.name);
-	if (resolution.kind === "crossSpace") return ok(name);
-	return notOk([]);
-}
-function fieldRef() {
-	return {
-		kind: "fieldRef",
-		label: "field name",
-		parse: parseFieldName
+function namespaceMember(namespace, name) {
+	const model = namespace.models[name];
+	if (model !== void 0) return {
+		kind: "model",
+		symbol: model,
+		namespace
 	};
-}
-function referencedFieldRef() {
-	return {
-		kind: "referencedFieldRef",
-		label: "field name",
-		parse: parseFieldName
+	const compositeType = namespace.compositeTypes[name];
+	if (compositeType !== void 0) return {
+		kind: "compositeType",
+		symbol: compositeType,
+		namespace
+	};
+	const block = namespace.blocks[name];
+	if (block !== void 0) return {
+		kind: "block",
+		symbol: block,
+		namespace
 	};
 }
-function interpretArgs(args, spec, ctx, span, sourceNode) {
-	let outcome = okVoid();
-	const output = {};
-	const seen = /* @__PURE__ */ new Set();
-	let positionalSlot = 0;
-	let reportedExcess = false;
-	for (const arg of args) {
-		const name = arg.name()?.name();
-		let key;
-		let param;
-		if (name === void 0) {
-			const posParam = spec.positional[positionalSlot];
-			if (posParam === void 0) {
-				if (!reportedExcess) {
-					outcome = and(outcome, notOk([diagnostic(`Attribute "${spec.name}" received too many positional arguments`, ctx, span, sourceNode)]));
-					reportedExcess = true;
-				}
-				continue;
-			}
-			positionalSlot += 1;
-			key = posParam.key;
-			param = posParam.type;
-		} else {
-			const namedParam = Object.hasOwn(spec.named, name) ? spec.named[name] : void 0;
-			if (namedParam === void 0) {
-				outcome = and(outcome, notOk([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)) {
-			outcome = and(outcome, notOk([diagnostic(`Attribute "${spec.name}" received duplicate argument "${key}"`, ctx, nodePslSpan(arg.syntax, ctx.sources), arg.syntax)]));
-			continue;
-		}
-		seen.add(key);
-		const result = parseArgValue(arg, param, ctx);
-		if (result.ok) output[key] = result.value;
-		outcome = and(outcome, result);
+var ContributedScope = class extends Scope {
+	#registry;
+	constructor(registry) {
+		super(void 0);
+		this.#registry = registry;
 	}
-	const finalized = /* @__PURE__ */ new Set();
-	const finalizeAbsentKey = (key, positionalParam, namedParam) => {
-		if (finalized.has(key) || seen.has(key)) return;
-		finalized.add(key);
-		const effective = namedParam ?? positionalParam;
-		if (effective === void 0) return;
-		if (isOptionalArgType(effective)) {
-			if (effective.hasDefault) output[key] = effective.defaultValue;
-			return;
-		}
-		outcome = and(outcome, notOk([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;
-		finalizeAbsentKey(param.key, param.type, namedParam?.type);
+	lookup(name) {
+		const member = this.#registry.lookup(name);
+		return member === void 0 ? void 0 : contributedResolution(member);
 	}
-	for (const key of Object.keys(spec.named)) finalizeAbsentKey(key, void 0, spec.named[key]?.type);
-	if (!outcome.ok) return notOk(outcome.failure);
-	return ok(output);
-}
-function interpretAttribute(attrNode, spec, ctx) {
-	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) {
-		const refineDiagnostics = spec.refine(value, ctx, attrNode);
-		if (refineDiagnostics.length > 0) return notOk(refineDiagnostics);
+	*ownNames() {
+		for (const [name] of this.#registry.entries()) yield name;
+	}
+};
+var DocumentScope = class extends Scope {
+	#records;
+	constructor(records, parent) {
+		super(parent);
+		this.#records = records;
+	}
+	lookup(name) {
+		const records = this.#records;
+		const model = records.models[name];
+		if (model !== void 0) return {
+			kind: "model",
+			symbol: model
+		};
+		const compositeType = records.compositeTypes[name];
+		if (compositeType !== void 0) return {
+			kind: "compositeType",
+			symbol: compositeType
+		};
+		const namedType = records.namedTypes[name];
+		if (namedType !== void 0) return {
+			kind: "namedType",
+			symbol: namedType
+		};
+		const block = records.blocks[name];
+		if (block !== void 0) return {
+			kind: "block",
+			symbol: block
+		};
+		const namespace = records.namespaces[name];
+		if (namespace !== void 0) return {
+			kind: "namespace",
+			symbol: namespace
+		};
+		return this.parent?.lookup(name);
+	}
+	ownNames() {
+		const records = this.#records;
+		return recordNames(records.models, records.compositeTypes, records.namedTypes, records.blocks, records.namespaces);
+	}
+};
+var NamespaceScope = class extends Scope {
+	#namespace;
+	constructor(namespace, parent) {
+		super(parent);
+		this.#namespace = namespace;
+	}
+	lookup(name) {
+		return namespaceMember(this.#namespace, name) ?? this.parent?.lookup(name);
+	}
+	ownNames() {
+		const namespace = this.#namespace;
+		return recordNames(namespace.models, namespace.compositeTypes, namespace.blocks);
+	}
+};
+function contributedScope(registry) {
+	return new ContributedScope(registry);
+}
+function documentScope(records, parent) {
+	return new DocumentScope(records, parent);
+}
+function namedTypeBaseScope(records, parent) {
+	return new DocumentScope({
+		...records,
+		namedTypes: {}
+	}, parent);
+}
+function namespaceScope(namespace, parent) {
+	return new NamespaceScope(namespace, parent);
+}
+function isNamespaceLike(resolution) {
+	return resolution.kind === "namespace" || resolution.kind === "contributedNamespace";
+}
+function* memberEntries(qualifier) {
+	if (qualifier.kind === "contributedNamespace") {
+		for (const [name, member] of qualifier.symbol.members) yield [name, contributedResolution(member)];
+		return;
+	}
+	yield* new NamespaceScope(qualifier.symbol, void 0).entries();
+}
+function lookupMember(qualifier, name) {
+	if (qualifier.kind === "contributedNamespace") {
+		const member = qualifier.symbol.members.get(name);
+		return member === void 0 ? void 0 : contributedResolution(member);
+	}
+	return namespaceMember(qualifier.symbol, name);
+}
+const PSL_UNRESOLVED_REFERENCE = "PSL_UNRESOLVED_REFERENCE";
+function typeReferenceNode(symbol) {
+	return symbol.node.typeAnnotation()?.name()?.syntax;
+}
+function contributedTypeOf(resolution, binder) {
+	const base = resolution?.kind === "namedType" ? typeReferenceNode(resolution.symbol) : void 0;
+	const target = base === void 0 ? resolution : binder.symbolForNode(base);
+	return target?.kind === "contributedType" ? target.symbol : void 0;
+}
+var PslBinder = class {
+	#declarations;
+	#references;
+	#documentScope;
+	#scopes;
+	constructor(declarations, references, documentScope, scopes) {
+		this.#declarations = declarations;
+		this.#references = references;
+		this.#documentScope = documentScope;
+		this.#scopes = scopes;
+	}
+	declaredSymbol(node) {
+		return this.#declarations.get(node);
+	}
+	symbolForNode(node) {
+		return this.#references.get(node);
+	}
+	scopeAt(node) {
+		return node.findAncestor((ancestor) => this.#scopes.get(ancestor)) ?? this.#documentScope;
+	}
+};
+var ScopeStack = class {
+	#base;
+	#scopes;
+	constructor(base) {
+		this.#base = base;
+		this.#scopes = [base];
+	}
+	current() {
+		return this.#scopes[this.#scopes.length - 1] ?? this.#base;
+	}
+	push(scope) {
+		this.#scopes.push(scope);
+	}
+	pop() {
+		this.#scopes.pop();
+	}
+};
+function walkEntities(symbolTable, stack, binder, visit) {
+	const { topLevel } = symbolTable;
+	for (const entity of Object.values(topLevel.models)) visit(entity);
+	for (const entity of Object.values(topLevel.compositeTypes)) visit(entity);
+	for (const namespace of Object.values(topLevel.namespaces)) {
+		stack.push(binder.scopeAt(namespace.declarations[0].node.syntax));
+		for (const entity of Object.values(namespace.models)) visit(entity);
+		for (const entity of Object.values(namespace.compositeTypes)) visit(entity);
+		stack.pop();
+	}
+}
+function createBinder(input) {
+	const { symbolTable, sources, context } = input;
+	const contributions = context.authoringContributions;
+	const describeUnsupportedAttributeFactory = resolveDescribeUnsupportedAttribute(context.pslDiagnostics);
+	const describeUnresolvedTypeFactory = resolveDescribeUnresolvedType(context.pslDiagnostics);
+	return bind({
+		sources,
+		symbolTable,
+		contributedTypes: mergeContributedTypes(contributions.field, contributions.type),
+		attributeSpecs: assembleAttributeSpecs(contributions),
+		pslBlockDescriptors: contributions.pslBlockDescriptors,
+		controlMutationDefaults: {
+			defaultFunctionRegistry: context.controlMutationDefaults.defaultFunctionRegistry,
+			dataTypeEntries: contributions.dataTypes
+		},
+		...describeUnsupportedAttributeFactory !== void 0 ? { describeUnsupportedAttribute: describeUnsupportedAttributeFactory(sources) } : {},
+		...describeUnresolvedTypeFactory !== void 0 ? { describeUnresolvedType: describeUnresolvedTypeFactory(contributions) } : {}
+	});
+}
+function bind(options) {
+	const { sources, symbolTable, contributedTypes, attributeSpecs, controlMutationDefaults, describeUnsupportedAttribute, describeUnresolvedType } = options;
+	const pslBlockDescriptors = options.pslBlockDescriptors ?? {};
+	const contributed = contributedScope(contributedTypeScope(contributedTypes));
+	const document = documentScope(symbolTable.topLevel, contributed);
+	const stack = new ScopeStack(document);
+	const scopes = /* @__PURE__ */ new WeakMap();
+	const declarations = /* @__PURE__ */ new WeakMap();
+	const references = /* @__PURE__ */ new WeakMap();
+	const diagnostics = [];
+	const binder = new PslBinder(declarations, references, document, scopes);
+	const baseScope = namedTypeBaseScope(symbolTable.topLevel, contributed);
+	for (const symbol of Object.values(symbolTable.topLevel.namedTypes)) {
+		declarations.set(symbol.node.syntax, symbol);
+		const name = symbol.node.typeAnnotation()?.name();
+		const outcome = resolveTypeReference(name, baseScope);
+		if (name === void 0 || outcome === void 0) continue;
+		references.set(name.syntax, outcome.resolution);
+	}
+	for (const symbol of Object.values(symbolTable.topLevel.blocks)) declarations.set(symbol.node.syntax, symbol);
+	for (const namespace of Object.values(symbolTable.topLevel.namespaces)) {
+		const scope = namespaceScope(namespace, document);
+		for (const declaration of namespace.declarations) {
+			declarations.set(declaration.node.syntax, namespace);
+			scopes.set(declaration.node.syntax, scope);
+		}
+		for (const symbol of Object.values(namespace.blocks)) declarations.set(symbol.node.syntax, symbol);
+	}
+	walkEntities(symbolTable, stack, binder, (entity) => {
+		declarations.set(entity.node.syntax, entity);
+		for (const field of Object.values(entity.fields)) {
+			declarations.set(field.node.syntax, field);
+			const node = typeReferenceNode(field);
+			if (node === void 0) continue;
+			const outcome = resolveTypeReference(field.node.typeAnnotation()?.name(), stack.current(), (written) => describeUnresolvedType?.({
+				field,
+				owner: entity,
+				written
+			}));
+			if (outcome === void 0) continue;
+			references.set(node, outcome.resolution);
+			if (outcome.message !== void 0) diagnostics.push({
+				code: PSL_UNRESOLVED_REFERENCE,
+				message: outcome.message,
+				data: {
+					reference: "type",
+					name: outcome.name,
+					constructorCall: field.typeConstructor !== void 0
+				},
+				...diagnosticSource(sources, node).at()
+			});
+		}
+	});
+	walkEntities(symbolTable, stack, binder, (entity) => {
+		const context = {
+			owner: entity,
+			scope: stack.current(),
+			references,
+			diagnostics,
+			symbolTable,
+			sources,
+			describeUnsupportedAttribute
+		};
+		const specContext = entity.kind === "model" ? {
+			symbols: symbolTable,
+			model: entity,
+			controlMutationDefaults
+		} : void 0;
+		bindAttributes(entity, entity.attributes, attributeSpecs.model, (factory) => specContext === void 0 ? void 0 : factory(specContext), {
+			...context,
+			field: void 0
+		});
+		for (const field of Object.values(entity.fields)) bindAttributes(field, field.attributes, attributeSpecs.field, (factory) => {
+			if (specContext === void 0) return void 0;
+			const node = typeReferenceNode(field);
+			const typeResolution = node === void 0 ? void 0 : references.get(node);
+			return factory({
+				...specContext,
+				field,
+				typeResolution
+			});
+		}, {
+			...context,
+			field
+		});
+	});
+	const blockContext = {
+		pslBlockDescriptors,
+		symbolTable,
+		sources,
+		references,
+		diagnostics
+	};
+	const bindBlocks = (blocks) => {
+		const context = {
+			...blockContext,
+			scope: stack.current()
+		};
+		for (const block of Object.values(blocks)) bindBlock(block, context);
+	};
+	bindBlocks(symbolTable.topLevel.blocks);
+	for (const namespace of Object.values(symbolTable.topLevel.namespaces)) {
+		stack.push(binder.scopeAt(namespace.declarations[0].node.syntax));
+		bindBlocks(namespace.blocks);
+		stack.pop();
+	}
+	return {
+		binder,
+		diagnostics
+	};
+}
+function bindBlock(block, ctx) {
+	const descriptor = findBlockDescriptor(ctx.pslBlockDescriptors, block.keyword);
+	if (descriptor === void 0) return;
+	const spec = blockSpecFactoryOf(descriptor)({
+		symbols: ctx.symbolTable,
+		block
+	});
+	for (const entry of block.node.entries()) {
+		const key = entry.key()?.name();
+		if (key === void 0) continue;
+		const rule = spec.mode === "struct" ? Object.hasOwn(spec.parameters, key) ? spec.parameters[key]?.type : void 0 : spec.value.type;
+		const value = entry.value();
+		if (rule === void 0 || value === void 0) continue;
+		bindExpression(rule, value, ctx);
+	}
+	const attributeSpecs = descriptor.attributes ?? {};
+	if (Object.keys(attributeSpecs).length === 0) return;
+	for (const attribute of readResolvedAttributes(block.node.attributes(), ctx.sources)) {
+		const factory = attributeSpecs[attribute.name];
+		if (factory === void 0) continue;
+		bindArguments(attribute, blindCast(factory)({
+			symbols: ctx.symbolTable,
+			block
+		}), ctx);
+	}
+}
+function bindExpression(rule, expression, ctx, modelContext) {
+	const trial = tryBindExpression(rule, expression, ctx, modelContext);
+	for (const [node, resolution] of trial.references) ctx.references.set(node, resolution);
+	ctx.diagnostics.push(...trial.diagnostics.values());
+}
+function tryBindExpression(rule, expression, ctx, modelContext) {
+	const references = /* @__PURE__ */ new Map();
+	const diagnostics = /* @__PURE__ */ new Map();
+	switch (rule.kind) {
+		case "oneOf":
+			for (const alternative of rule.alternatives) {
+				const trial = tryBindExpression(alternative, expression, ctx, modelContext);
+				if (trial.matched) return trial;
+				for (const [node, diagnostic] of trial.diagnostics) diagnostics.set(node, diagnostic);
+				for (const [node, resolution] of trial.references) if (resolution.kind === "unresolved") references.set(node, resolution);
+			}
+			return {
+				matched: false,
+				references,
+				diagnostics
+			};
+		case "list":
+		case "record": {
+			const children = rule.kind === "list" ? ArrayLiteralAst.cast(expression.syntax)?.elements() : recordValues(expression);
+			if (children === void 0) return {
+				matched: false,
+				references,
+				diagnostics
+			};
+			let matched = true;
+			for (const child of children) {
+				const trial = tryBindExpression(rule.of, child, ctx, modelContext);
+				matched = trial.matched && matched;
+				for (const [node, resolution] of trial.references) references.set(node, resolution);
+				for (const [node, diagnostic] of trial.diagnostics) diagnostics.set(node, diagnostic);
+			}
+			return {
+				matched,
+				references,
+				diagnostics
+			};
+		}
+		case "funcCall": {
+			const call = FunctionCallAst.cast(expression.syntax);
+			const name = call?.name();
+			if (call === void 0 || name === void 0 || name.dot() !== void 0 || name.colon() !== void 0 || name.identifier()?.name() !== rule.name) return {
+				matched: false,
+				references,
+				diagnostics
+			};
+			let matched = true;
+			let positional = 0;
+			for (const arg of call.args()) {
+				const key = arg.name()?.name();
+				const parameter = argumentParameter(rule.signature, key, key === void 0 ? positional++ : positional);
+				const value = arg.value();
+				if (parameter === void 0 || value === void 0) {
+					matched = false;
+					continue;
+				}
+				const trial = tryBindExpression(parameter.type, value, ctx, modelContext);
+				matched = trial.matched && matched;
+				for (const [node, resolution] of trial.references) references.set(node, resolution);
+				for (const [node, diagnostic] of trial.diagnostics) diagnostics.set(node, diagnostic);
+			}
+			return {
+				matched,
+				references,
+				diagnostics
+			};
+		}
+		case "entityRef": {
+			const node = expression.syntax;
+			const name = IdentifierAst.cast(node)?.name();
+			if (name === void 0) return {
+				matched: false,
+				references,
+				diagnostics
+			};
+			const failures = [];
+			const resolution = resolveEntity(name, node, {
+				...ctx,
+				diagnostics: failures
+			});
+			references.set(node, resolution);
+			for (const diagnostic of failures) diagnostics.set(node, diagnostic);
+			return {
+				matched: resolution.kind !== "unresolved",
+				references,
+				diagnostics
+			};
+		}
+		case "fieldRef": {
+			const node = expression.syntax;
+			const name = IdentifierAst.cast(node)?.name();
+			if (name === void 0 || modelContext === void 0) return {
+				matched: false,
+				references,
+				diagnostics
+			};
+			const failures = [];
+			const resolution = resolveOwnerField(name, node, {
+				...modelContext,
+				diagnostics: failures
+			});
+			references.set(node, resolution);
+			for (const diagnostic of failures) diagnostics.set(node, diagnostic);
+			return {
+				matched: resolution.kind !== "unresolved",
+				references,
+				diagnostics
+			};
+		}
+		case "referencedFieldRef": {
+			const node = expression.syntax;
+			const name = IdentifierAst.cast(node)?.name();
+			if (name === void 0 || modelContext === void 0) return {
+				matched: false,
+				references,
+				diagnostics
+			};
+			const failures = [];
+			const resolution = resolveReferencedField(name, node, {
+				...modelContext,
+				diagnostics: failures
+			});
+			references.set(node, resolution);
+			for (const diagnostic of failures) diagnostics.set(node, diagnostic);
+			return {
+				matched: resolution.kind !== "unresolved",
+				references,
+				diagnostics
+			};
+		}
+		default: return {
+			matched: true,
+			references,
+			diagnostics
+		};
 	}
-	return ok(value);
-}
-function parseArgValue(arg, argType, ctx) {
-	const value = arg.value();
-	if (value === void 0) return notOk([diagnostic("Attribute argument is missing a value", ctx, nodePslSpan(arg.syntax, ctx.sources), arg.syntax)]);
-	return argType.parse(value, ctx);
 }
-function isOptionalArgType(param) {
-	return "optional" in param && param.optional === true;
+function recordValues(expression) {
+	const record = ObjectLiteralExprAst.cast(expression.syntax);
+	if (record === void 0) return void 0;
+	return (function* () {
+		for (const field of record.fields()) {
+			const value = field.value();
+			if (value !== void 0) yield value;
+		}
+	})();
 }
-function diagnostic(message, ctx, span, sourceNode) {
+function bindAttributes(holder, attributes, specs, instantiate, ctx) {
+	const declared = holder.node.attributes();
+	const nodes = Array.from(declared);
+	const level = holder.kind === "field" ? "field" : "model";
+	attributes.forEach((attribute, index) => {
+		const factory = own(specs, attribute.name);
+		if (factory === void 0) {
+			const diagnostic = ctx.describeUnsupportedAttribute?.({
+				attribute,
+				level,
+				owner: ctx.owner,
+				field: level === "field" ? ctx.field : void 0
+			});
+			if (diagnostic !== void 0) ctx.diagnostics.push(diagnostic);
+			return;
+		}
+		const spec = instantiate(factory);
+		if (spec === void 0) return;
+		const nameNode = nodes[index]?.name()?.syntax;
+		if (nameNode !== void 0) ctx.references.set(nameNode, {
+			kind: "attribute",
+			symbol: {
+				kind: "attribute",
+				name: attribute.name,
+				level,
+				spec
+			}
+		});
+		bindArguments(attribute, spec, ctx, ctx);
+	});
+}
+function bindArguments(attribute, spec, ctx, modelContext) {
+	let positional = 0;
+	for (const arg of attribute.args) {
+		const parameter = argumentParameter(spec, arg.name, arg.name === void 0 ? positional++ : positional);
+		if (parameter === void 0 || arg.expression === void 0) continue;
+		bindExpression(parameter.type, arg.expression, ctx, modelContext);
+	}
+}
+function argumentParameter(spec, name, position) {
+	if (name === void 0) return spec.positional?.[position];
+	return spec.named === void 0 ? void 0 : own(spec.named, name);
+}
+function resolveOwnerField(name, node, ctx) {
+	const field = ctx.owner.fields[name];
+	if (field !== void 0) return {
+		kind: "field",
+		symbol: field
+	};
+	report(`Cannot find field "${name}" on "${ctx.owner.name}"`, node, ctx, "field");
+	return {
+		kind: "unresolved",
+		name
+	};
+}
+function resolveReferencedField(name, node, ctx) {
+	const declaring = ctx.field;
+	if (declaring === void 0) return {
+		kind: "unresolved",
+		name
+	};
+	if (declaring.typeContractSpaceId !== void 0) return { kind: "crossSpace" };
+	const typeNode = typeReferenceNode(declaring);
+	const field = targetFields(typeNode === void 0 ? void 0 : ctx.references.get(typeNode))?.[name];
+	if (field !== void 0) return {
+		kind: "field",
+		symbol: field
+	};
+	report(`Cannot find field "${name}" on the type of "${ctx.owner.name}.${declaring.name}"`, node, ctx, "field");
+	return {
+		kind: "unresolved",
+		name
+	};
+}
+function targetFields(target) {
+	if (target === void 0) return void 0;
+	if (target.kind === "model" || target.kind === "compositeType") return target.symbol.fields;
+}
+function resolveEntity(name, node, ctx) {
+	const found = ctx.scope.lookup(name);
+	if (found === void 0) {
+		report(`Cannot find entity "${name}"`, node, ctx, "entity");
+		return {
+			kind: "unresolved",
+			name
+		};
+	}
+	return found;
+}
+function report(message, node, ctx, reference) {
+	ctx.diagnostics.push({
+		code: PSL_UNRESOLVED_REFERENCE,
+		message,
+		data: { reference },
+		...diagnosticSource(ctx.sources, node).at()
+	});
+}
+function resolveTypeReference(reference, scope, describeUnresolved) {
+	if (reference === void 0 || reference.isOverQualified()) return void 0;
+	if (reference.space() !== void 0) return { resolution: { kind: "crossSpace" } };
+	const name = reference.identifier()?.name();
+	if (name === void 0 || name === "") return void 0;
+	const namespaceId = reference.namespace()?.name();
+	const found = namespaceId === void 0 ? scope.lookup(name) : qualifiedMember(namespaceId, name, scope);
+	if (found === void 0) {
+		const written = namespaceId === void 0 ? name : `${namespaceId}.${name}`;
+		const message = describeUnresolved?.(written) ?? `Cannot find type "${written}"`;
+		return {
+			resolution: {
+				kind: "unresolved",
+				name: written
+			},
+			message,
+			name: written
+		};
+	}
+	if ("badQualifier" in found) return {
+		resolution: {
+			kind: "unresolved",
+			name: found.qualifier
+		},
+		message: found.badQualifier,
+		name: found.qualifier
+	};
+	if (found.kind === "namespace" || found.kind === "contributedNamespace") {
+		const written = namespaceId === void 0 ? name : `${namespaceId}.${name}`;
+		return {
+			resolution: found,
+			message: `"${written}" is a namespace; a type reference must name a model, composite type, enum, or named type`,
+			name: written
+		};
+	}
+	return { resolution: found };
+}
+function qualifiedMember(namespaceId, name, scope) {
+	const qualifier = scope.lookup(namespaceId);
+	if (qualifier === void 0) return void 0;
+	if (!isNamespaceLike(qualifier)) return {
+		badQualifier: `"${namespaceId}" is ${describeQualifier(qualifier)}, not a namespace`,
+		qualifier: namespaceId
+	};
+	return lookupMember(qualifier, name);
+}
+function describeQualifier(resolution) {
+	switch (resolution.kind) {
+		case "model": return "a model";
+		case "compositeType": return "a composite type";
+		case "namedType": return "a named type";
+		case "block": return `${resolution.symbol.keyword === "enum" ? "an" : "a"} ${resolution.symbol.keyword}`;
+		default: return "a scalar type";
+	}
+}
+function own(record, name) {
+	return Object.hasOwn(record, name) ? record[name] : void 0;
+}
+/**
+* Owns duplicate-declaration detection for all PSL scopes; downstream consumers
+* should consume first-wins symbols rather than re-emitting duplicate diagnostics.
+*/
+function buildSymbolTable(options) {
+	const { documents, sources } = options;
+	const diagnostics = [];
+	const namespaces = Object.create(null);
+	const namedTypes = Object.create(null);
+	const blocks = Object.create(null);
+	const models = Object.create(null);
+	const compositeTypes = Object.create(null);
+	const topLevelNames = /* @__PURE__ */ new Set();
+	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);
+		} 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: [{
+						node: declaration,
+						span: nodePslSpan(declaration.syntax, sources)
+					}],
+					models: Object.create(null),
+					compositeTypes: Object.create(null),
+					blocks: Object.create(null)
+				};
+				namespaces[name] = namespace;
+			} else namespace.declarations.push({
+				node: declaration,
+				span: nodePslSpan(declaration.syntax, sources)
+			});
+			extendNamespace(namespace, declaration, diagnostics, sources);
+		} 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, sources);
+			namedTypes[name] = {
+				kind: "namedType",
+				name,
+				node: binding,
+				span: nodePslSpan(binding.syntax, sources),
+				...resolved
+			};
+		}
+	}
 	return {
-		code: ATTRIBUTE_DIAGNOSTIC_CODE,
-		message,
-		...diagnosticSource(ctx.sources, sourceNode).at(span)
+		symbolTable: { topLevel: {
+			namespaces,
+			namedTypes,
+			blocks,
+			models,
+			compositeTypes
+		} },
+		diagnostics
 	};
 }
-function funcCall(name, sig) {
+function buildModel(name, node, sources, diagnostics) {
 	return {
-		kind: "funcCall",
-		label: `${name}()`,
+		kind: "model",
 		name,
-		signature: sig,
-		parse: (arg, ctx) => {
-			const guard = matchCallee(arg, name, ctx);
-			if (!guard.ok) return guard;
-			const span = nodePslSpan(guard.value.syntax, ctx.sources);
-			const bound = interpretArgs(guard.value.args(), {
-				name,
-				positional: sig.positional ?? [],
-				named: sig.named ?? {}
-			}, ctx, span, guard.value.syntax);
-			if (!bound.ok) return notOk(bound.failure);
-			return ok({
-				fn: name,
-				span,
-				args: bound.value
-			});
-		}
+		node,
+		span: nodePslSpan(node.syntax, sources),
+		fields: buildFields(name, node.fields(), sources, diagnostics),
+		attributes: readResolvedAttributes(node.attributes(), sources)
 	};
 }
-function matchCallee(arg, name, ctx) {
-	const call = FunctionCallAst.cast(arg.syntax);
-	if (call === void 0) return notOk([leafDiagnostic(ctx, arg, "Expected a function call")]);
-	const qname = call.name();
-	if (qname === void 0 || qname.dot() !== void 0 || qname.colon() !== void 0) return notOk([leafDiagnostic(ctx, arg, "Expected a function call")]);
-	const calleeName = qname.identifier()?.token()?.text;
-	if (calleeName === void 0) return notOk([leafDiagnostic(ctx, arg, "Expected a function call")]);
-	if (calleeName !== name) return notOk([leafDiagnostic(ctx, arg, `Expected ${name}()`)]);
-	return ok(call);
-}
-function identifier(name, options) {
-	const label = name ?? "identifier";
+function buildCompositeType(name, node, sources, diagnostics) {
 	return {
-		kind: "identifier",
-		label,
+		kind: "compositeType",
 		name,
-		documentation: options?.documentation ?? "",
-		parse: (arg, ctx) => {
-			const value = IdentifierAst.cast(arg.syntax)?.name();
-			if (value !== void 0 && (name === void 0 || value === name)) return ok(value);
-			return notOk([leafDiagnostic(ctx, arg, `Expected ${label}`)]);
-		}
+		node,
+		span: nodePslSpan(node.syntax, sources),
+		fields: buildFields(name, node.fields(), sources, diagnostics),
+		attributes: readResolvedAttributes(node.attributes(), sources)
 	};
 }
-function int(opts) {
-	const min = opts?.min;
-	const max = opts?.max;
+function buildBlock(name, node, sources) {
 	return {
-		kind: "int",
-		label: "integer",
-		...min === void 0 ? {} : { min },
-		...max === void 0 ? {} : { max },
-		parse: (arg, ctx) => {
-			const literal = NumberLiteralExprAst.cast(arg.syntax);
-			if (literal !== void 0) {
-				const value = literal.value();
-				if (value !== void 0 && Number.isInteger(value)) {
-					if ((min === void 0 || value >= min) && (max === void 0 || value <= max)) return ok(value);
-					return notOk([leafDiagnostic(ctx, arg, rangeMessage(min, max))]);
-				}
-			}
-			return notOk([leafDiagnostic(ctx, arg, "Expected an integer literal")]);
-		}
+		kind: "block",
+		name,
+		keyword: node.keyword()?.text ?? "",
+		node,
+		span: nodePslSpan(node.syntax, sources)
 	};
 }
-function rangeMessage(min, max) {
-	if (min !== void 0 && max !== void 0) return `Expected an integer between ${min} and ${max}`;
-	if (min !== void 0) return `Expected an integer greater than or equal to ${min}`;
-	return `Expected an integer less than or equal to ${max}`;
-}
-/**
-* Reads an opaque JSON object from a quoted JSON string — the ADR's one text-encoded surface
-* exception (e.g. an index `filter` / `weights` argument). The string is decoded by the parser,
-* then JSON-parsed; a non-object (array/scalar) or invalid JSON is a diagnostic.
-*/
-function json() {
-	return {
-		kind: "json",
-		label: "JSON object",
-		parse: (arg, ctx) => {
-			const literal = StringLiteralExprAst.cast(arg.syntax);
-			if (literal === void 0) return notOk([leafDiagnostic(ctx, arg, "Expected a JSON object string")]);
-			const raw = literal.value();
-			if (raw !== void 0) try {
-				const parsed = JSON.parse(raw);
-				if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) return ok(blindCast(parsed));
-			} catch {}
-			return notOk([leafDiagnostic(ctx, arg, "Expected a valid JSON object")]);
+function extendNamespace(namespace, node, diagnostics, sources) {
+	const { models, compositeTypes, blocks } = namespace;
+	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(), 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, 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);
+	}
 }
-function list(of, opts) {
-	const allowEmpty = opts?.allowEmpty ?? true;
-	const unique = opts?.unique ?? false;
-	return {
-		kind: "list",
-		label: opts?.label ?? (of.label.includes(" | ") ? `(${of.label})[]` : `${of.label}[]`),
-		of,
-		allowEmpty,
-		unique,
-		parse: (arg, ctx) => {
-			const literal = ArrayLiteralAst.cast(arg.syntax);
-			if (literal === void 0) return notOk([leafDiagnostic(ctx, arg, `Expected a list of ${of.label}`)]);
-			const parsed = [];
-			let outcome = okVoid();
-			let count = 0;
-			for (const element of literal.elements()) {
-				count += 1;
-				const result = of.parse(element, ctx);
-				if (result.ok) parsed.push({
-					node: element,
-					value: result.value
-				});
-				outcome = and(outcome, result);
-			}
-			if (!allowEmpty && count === 0) outcome = and(outcome, notOk([leafDiagnostic(ctx, arg, "Expected a non-empty list")]));
-			if (unique) {
-				const seen = /* @__PURE__ */ new Set();
-				for (const { node, value } of parsed) if (seen.has(value)) outcome = and(outcome, notOk([leafDiagnostic(ctx, node, "Duplicate list entry")]));
-				else seen.add(value);
-			}
-			if (!outcome.ok) return notOk(outcome.failure);
-			return ok(parsed.map((entry) => entry.value));
+function buildFields(ownerName, fields, sources, diagnostics) {
+	const result = Object.create(null);
+	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, 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, sources, diagnostics);
+	}
+	return result;
 }
-function oneOf(...alts) {
-	const label = alts.map((alt) => alt.label).join(" | ");
+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()) {
+		const path = typeName.path();
+		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")`,
+			filename: sources.sourceFileFor(typeName.syntax).filename,
+			range: nodeRange(typeName.syntax, sources)
+		});
+		return {
+			kind: "field",
+			name,
+			node,
+			span,
+			typeName: path[path.length - 1] ?? "",
+			optional: false,
+			list: false,
+			elementOptional: false,
+			malformedType: true,
+			attributes
+		};
+	}
+	const typeConstructor = annotation?.isConstructor() ? readResolvedConstructorCall(annotation, sources) : void 0;
+	const typeNamespaceId = typeName?.namespace()?.name();
+	const typeContractSpaceId = typeName?.space()?.name();
 	return {
-		kind: "oneOf",
-		label,
-		alternatives: alts,
-		parse: (arg, ctx) => {
-			const [head, ...tail] = blindCast(alts);
-			let rejection = head.parse(arg, ctx);
-			if (rejection.ok) return rejection;
-			for (const alt of tail) {
-				const result = alt.parse(arg, ctx);
-				if (result.ok) return result;
-				rejection = or(rejection, result);
-			}
-			if (!rejection.ok && rejection.failure.length === 0) return notOk([]);
-			return notOk([leafDiagnostic(ctx, arg, `Expected one of: ${label}`)]);
-		}
+		kind: "field",
+		name,
+		node,
+		span,
+		typeName: typeName?.identifier()?.name() ?? "",
+		...typeNamespaceId !== void 0 ? { typeNamespaceId } : {},
+		...typeContractSpaceId !== void 0 ? { typeContractSpaceId } : {},
+		optional: annotation?.isOptional() ?? false,
+		list: annotation?.isList() ?? false,
+		elementOptional: annotation?.isElementOptional() ?? false,
+		...typeConstructor !== void 0 ? { typeConstructor } : {},
+		attributes
 	};
 }
-function record(of) {
+function resolveNamedTypeBinding(node, sources) {
+	const annotation = node.typeAnnotation();
+	const isConstructor = annotation?.isConstructor() ?? false;
+	const baseType = annotation?.name()?.identifier()?.name();
+	const typeConstructor = readResolvedConstructorCall(annotation, sources);
 	return {
-		kind: "record",
-		label: `{ [key]: ${of.label} }`,
-		of,
-		parse: (arg, ctx) => {
-			const literal = ObjectLiteralExprAst.cast(arg.syntax);
-			if (literal === void 0) return notOk([leafDiagnostic(ctx, arg, "Expected an object literal")]);
-			const entries = [];
-			const keys = /* @__PURE__ */ new Set();
-			let outcome = okVoid();
-			for (const field of Array.from(literal.fields())) {
-				const key = field.keyName();
-				if (key === void 0) {
-					outcome = and(outcome, notOk([leafDiagnostic(ctx, field, "Expected a key")]));
-					continue;
-				}
-				const value = field.value();
-				if (value === void 0) {
-					outcome = and(outcome, notOk([leafDiagnostic(ctx, field, `Expected a value for key "${key}"`)]));
-					continue;
-				}
-				const parsed = of.parse(value, ctx);
-				if (!parsed.ok) {
-					outcome = and(outcome, parsed);
-					continue;
-				}
-				if (keys.has(key)) {
-					outcome = and(outcome, notOk([leafDiagnostic(ctx, field, `Duplicate key "${key}"`)]));
-					continue;
-				}
-				keys.add(key);
-				entries.push([key, parsed.value]);
-			}
-			if (!outcome.ok) return notOk(outcome.failure);
-			return ok(Object.fromEntries(entries));
-		}
+		isConstructor,
+		...!isConstructor && baseType !== void 0 ? { baseType } : {},
+		...typeConstructor !== void 0 ? { typeConstructor } : {},
+		attributes: readResolvedAttributes(node.attributes(), sources)
 	};
 }
-function str(value) {
-	if (value === void 0) return {
-		kind: "str",
-		label: "string",
-		value: void 0,
-		parse: (arg, ctx) => {
-			const literal = StringLiteralExprAst.cast(arg.syntax);
-			if (literal !== void 0) {
-				const parsed = literal.value();
-				if (parsed !== void 0) return ok(parsed);
-			}
-			return notOk([leafDiagnostic(ctx, arg, "Expected a string literal")]);
-		}
+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, sources) {
+	const sourceFile = sources.sourceFileFor(node);
+	const start = node.offset;
+	const end = start + node.green.textLength;
 	return {
-		kind: "str",
-		label: JSON.stringify(value),
-		value,
-		parse: (arg, ctx) => {
-			const literal = StringLiteralExprAst.cast(arg.syntax);
-			if (literal !== void 0) {
-				if (literal.value() === value) return ok(value);
-			}
-			return notOk([leafDiagnostic(ctx, arg, `Expected ${JSON.stringify(value)}`)]);
-		}
+		start: sourceFile.positionAt(start),
+		end: sourceFile.positionAt(end)
 	};
 }
-function jsonValue() {
-	const self = {
-		kind: "oneOf",
-		label: "JSON value",
-		get alternatives() {
-			return composed.alternatives;
-		},
-		parse: (arg, ctx) => composed.parse(arg, ctx)
-	};
-	const composed = oneOf(str(), finiteNumber(), bool(), jsonNull(), list(self), record(self));
-	return self;
+//#endregion
+//#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;
 }
-function finiteNumber() {
+function parseQuotedStringLiteral(value) {
+	const match = value.trim().match(/^(['"])(.*)\1$/);
+	if (!match) return void 0;
+	return match[2] ?? "";
+}
+function blockAttribute(name, config) {
 	return {
-		kind: "num",
-		value: void 0,
-		label: "number",
-		parse: (arg, ctx) => {
-			const value = NumberLiteralExprAst.cast(arg.syntax)?.value();
-			if (value === void 0 || Number.isNaN(value) || !Number.isFinite(value)) return notOk([leafDiagnostic(ctx, arg, "Expected a finite number literal")]);
-			return ok(value);
-		}
+		level: "block",
+		name,
+		documentation: config.documentation,
+		positional: config.positional ?? [],
+		named: config.named ?? {},
+		...config.refine !== void 0 ? { refine: config.refine } : {}
 	};
 }
-function jsonNull() {
+const ATTRIBUTE_DIAGNOSTIC_CODE = "PSL_INVALID_ATTRIBUTE_SYNTAX";
+function leafDiagnostic(ctx, node, message, code = ATTRIBUTE_DIAGNOSTIC_CODE) {
 	return {
-		kind: "null",
-		label: "null",
-		parse: (arg, ctx) => {
-			if (IdentifierAst.cast(arg.syntax)?.name() === "null") return ok(null);
-			return notOk([leafDiagnostic(ctx, arg, "Expected null")]);
-		}
+		code,
+		message,
+		...diagnosticSource(ctx.sources, node.syntax).at(nodePslSpan(node.syntax, ctx.sources))
 	};
 }
-function num(value) {
-	if (value === void 0) return {
-		kind: "num",
-		label: "number",
-		value: void 0,
-		parse: (arg, ctx) => {
-			const literal = NumberLiteralExprAst.cast(arg.syntax);
-			if (literal !== void 0) {
-				const parsed = literal.value();
-				if (parsed !== void 0) return ok(parsed);
-			}
-			return notOk([leafDiagnostic(ctx, arg, "Expected a number literal")]);
-		}
-	};
+function bool() {
 	return {
-		kind: "num",
-		label: String(value),
-		value,
+		kind: "bool",
+		label: "boolean",
 		parse: (arg, ctx) => {
-			const literal = NumberLiteralExprAst.cast(arg.syntax);
+			const literal = BooleanLiteralExprAst.cast(arg.syntax);
 			if (literal !== void 0) {
-				if (literal.value() === value) return ok(value);
+				const value = literal.value();
+				if (value !== void 0) return ok(value);
 			}
-			return notOk([leafDiagnostic(ctx, arg, `Expected ${value}`)]);
+			return notOk([leafDiagnostic(ctx, arg, "Expected a boolean literal")]);
 		}
 	};
 }
-/** A number literal kept as its source text, for consumers that must not round it through a JS number. */
-function numLiteral() {
-	return {
-		kind: "num",
-		label: "number",
-		value: void 0,
-		parse: (arg, ctx) => {
-			const text = NumberLiteralExprAst.cast(arg.syntax)?.token()?.text;
-			if (text !== void 0) return ok({ text });
-			return notOk([leafDiagnostic(ctx, arg, "Expected a number literal")]);
-		}
+const references = /* @__PURE__ */ new WeakMap();
+function entityReference(resolution) {
+	switch (resolution.kind) {
+		case "model":
+		case "compositeType":
+		case "namedType":
+		case "block": return interned(resolution.symbol, resolution.namespace);
+		default: return;
+	}
+}
+function interned(declaration, namespace) {
+	const existing = references.get(declaration);
+	if (existing !== void 0) return existing;
+	const reference = {
+		declaration,
+		namespace
 	};
+	references.set(declaration, reference);
+	return reference;
 }
-/**
-* A `` tag`...` ``, `tag"..."`, or `tag'...'` argument. `tags` and `documentation` describe the
-* registered tags for tooling; parsing accepts any tag.
-*/
-function taggedLiteral(tags, options) {
+function matchesSelector(reference, expected) {
+	const declaration = reference.declaration;
+	if (declaration.kind !== expected.kind) return false;
+	return expected.kind !== "block" || declaration.kind === "block" && declaration.keyword === expected.keyword;
+}
+function describeResolution(resolution) {
+	switch (resolution.kind) {
+		case "block": return resolution.symbol.keyword;
+		case "contributedType": return "scalar type";
+		case "crossSpace": return "cross-space reference";
+		case "unresolved": return "unresolved name";
+		default: return resolution.kind;
+	}
+}
+function entityRef(expected) {
+	const label = `${expected.kind === "block" ? expected.keyword : expected.kind} reference`;
 	return {
-		kind: "taggedLiteral",
-		label: `${tags[0] ?? "tag"}\`...\``,
-		tags,
-		documentation: options.documentation,
+		kind: "entityRef",
+		label,
+		expected,
 		parse: (arg, ctx) => {
-			const literal = TaggedLiteralExprAst.cast(arg.syntax);
-			if (literal === void 0) return notOk([leafDiagnostic(ctx, arg, "Expected a tagged literal")]);
-			return ok({
-				tag: literal.tagName(),
-				canonicalization: literal.canonicalization(),
-				span: nodePslSpan(literal.syntax, ctx.sources)
-			});
+			const name = IdentifierAst.cast(arg.syntax)?.name();
+			if (name === void 0) return notOk([leafDiagnostic(ctx, arg, `Expected ${label}`)]);
+			const resolution = ctx.binder.symbolForNode(arg.syntax);
+			if (resolution === void 0 || resolution.kind === "unresolved") return notOk([]);
+			const reference = entityReference(resolution);
+			if (reference === void 0 || !matchesSelector(reference, expected)) return notOk([leafDiagnostic(ctx, arg, `Expected ${label} "${name}", found ${describeResolution(resolution)}`)]);
+			return ok(reference);
 		}
 	};
 }
-function fieldAttribute(name, config) {
-	return {
-		level: "field",
-		name,
-		documentation: config.documentation,
-		positional: config.positional ?? [],
-		named: Object.assign(Object.create(null), config.named),
-		...config.refine !== void 0 ? { refine: config.refine } : {}
-	};
+function parseFieldName(arg, ctx) {
+	const identifier = IdentifierAst.cast(arg.syntax);
+	if (identifier === void 0) return notOk([leafDiagnostic(ctx, arg, "Expected a field name")]);
+	const name = identifier.name();
+	if (name === void 0) return notOk([leafDiagnostic(ctx, arg, "Expected a field name")]);
+	const resolution = ctx.binder.symbolForNode(arg.syntax);
+	if (resolution === void 0) return notOk([]);
+	if (resolution.kind === "field") return ok(resolution.symbol.name);
+	if (resolution.kind === "crossSpace") return ok(name);
+	return notOk([]);
 }
-function modelAttribute(name, config) {
+function fieldRef() {
 	return {
-		level: "model",
-		name,
-		documentation: config.documentation,
-		positional: config.positional ?? [],
-		named: Object.assign(Object.create(null), config.named),
-		...config.refine !== void 0 ? { refine: config.refine } : {}
+		kind: "fieldRef",
+		label: "field name",
+		parse: parseFieldName
 	};
 }
-function optional(type, ...rest) {
-	if (rest.length === 0) return {
-		...type,
-		optional: true,
-		hasDefault: false
-	};
+function referencedFieldRef() {
 	return {
-		...type,
-		optional: true,
-		hasDefault: true,
-		defaultValue: rest[0]
+		kind: "referencedFieldRef",
+		label: "field name",
+		parse: parseFieldName
 	};
 }
-function blockSpecFactoryOf(descriptor) {
-	return blindCast(descriptor.spec);
-}
-const scopes = /* @__PURE__ */ new WeakMap();
-function contributedTypeScope(typeConstructors) {
-	const existing = scopes.get(typeConstructors);
-	if (existing !== void 0) return existing;
-	const members = collect(typeConstructors, []);
-	const created = {
-		lookup(name) {
-			return members.get(name);
-		},
-		entries() {
-			return members.entries();
+function interpretArgs(args, spec, ctx, span, sourceNode) {
+	let outcome = okVoid();
+	const output = {};
+	const seen = /* @__PURE__ */ new Set();
+	let positionalSlot = 0;
+	let reportedExcess = false;
+	for (const arg of args) {
+		const name = arg.name()?.name();
+		let key;
+		let param;
+		if (name === void 0) {
+			const posParam = spec.positional[positionalSlot];
+			if (posParam === void 0) {
+				if (!reportedExcess) {
+					outcome = and(outcome, notOk([diagnostic(`Attribute "${spec.name}" received too many positional arguments`, ctx, span, sourceNode)]));
+					reportedExcess = true;
+				}
+				continue;
+			}
+			positionalSlot += 1;
+			key = posParam.key;
+			param = posParam.type;
+		} else {
+			const namedParam = Object.hasOwn(spec.named, name) ? spec.named[name] : void 0;
+			if (namedParam === void 0) {
+				outcome = and(outcome, notOk([diagnostic(`Attribute "${spec.name}" received unknown argument "${name}"`, ctx, nodePslSpan(arg.syntax, ctx.sources), arg.syntax)]));
+				continue;
+			}
+			key = name;
+			param = namedParam.type;
 		}
-	};
-	scopes.set(typeConstructors, created);
-	return created;
-}
-function collect(namespace, prefix) {
-	const members = /* @__PURE__ */ new Map();
-	for (const [name, value] of Object.entries(namespace)) {
-		const path = [...prefix, name];
-		members.set(name, isAuthoringTypeConstructorDescriptor(value) ? {
-			kind: "contributedType",
-			name,
-			path,
-			descriptor: value
-		} : {
-			kind: "contributedNamespace",
-			name,
-			path,
-			members: collect(value, path)
-		});
-	}
-	return members;
-}
-function findBlockDescriptor(descriptors, keyword) {
-	if (descriptors === void 0) return void 0;
-	for (const value of Object.values(descriptors)) {
-		if (value === void 0) continue;
-		if (isAuthoringPslBlockDescriptor(value)) {
-			if (value.keyword === keyword) return value;
+		if (seen.has(key)) {
+			outcome = and(outcome, notOk([diagnostic(`Attribute "${spec.name}" received duplicate argument "${key}"`, ctx, nodePslSpan(arg.syntax, ctx.sources), arg.syntax)]));
 			continue;
 		}
-		const nested = findBlockDescriptor(value, keyword);
-		if (nested !== void 0) return nested;
-	}
-}
-function* recordNames(...records) {
-	for (const record of records) yield* Object.keys(record);
-}
-var Scope = class {
-	parent;
-	constructor(parent) {
-		this.parent = parent;
+		seen.add(key);
+		const result = parseArgValue(arg, param, ctx);
+		if (result.ok) output[key] = result.value;
+		outcome = and(outcome, result);
 	}
-	*entries() {
-		const seen = /* @__PURE__ */ new Set();
-		for (const name of this.ownNames()) {
-			if (seen.has(name)) continue;
-			seen.add(name);
-			const resolution = this.lookup(name);
-			if (resolution !== void 0) yield [name, resolution];
+	const finalized = /* @__PURE__ */ new Set();
+	const finalizeAbsentKey = (key, positionalParam, namedParam) => {
+		if (finalized.has(key) || seen.has(key)) return;
+		finalized.add(key);
+		const effective = namedParam ?? positionalParam;
+		if (effective === void 0) return;
+		if (isOptionalArgType(effective)) {
+			if (effective.hasDefault) output[key] = effective.defaultValue;
+			return;
 		}
-		for (const entry of this.parent?.entries() ?? []) if (!seen.has(entry[0])) yield entry;
-	}
-};
-function contributedResolution(member) {
-	return member.kind === "contributedType" ? {
-		kind: "contributedType",
-		symbol: member
-	} : {
-		kind: "contributedNamespace",
-		symbol: member
-	};
-}
-function namespaceMember(namespace, name) {
-	const model = namespace.models[name];
-	if (model !== void 0) return {
-		kind: "model",
-		symbol: model,
-		namespace
-	};
-	const compositeType = namespace.compositeTypes[name];
-	if (compositeType !== void 0) return {
-		kind: "compositeType",
-		symbol: compositeType,
-		namespace
-	};
-	const block = namespace.blocks[name];
-	if (block !== void 0) return {
-		kind: "block",
-		symbol: block,
-		namespace
+		outcome = and(outcome, notOk([diagnostic(`Attribute "${spec.name}" is missing required argument "${key}"`, ctx, span, sourceNode)]));
 	};
-}
-var ContributedScope = class extends Scope {
-	#registry;
-	constructor(registry) {
-		super(void 0);
-		this.#registry = registry;
-	}
-	lookup(name) {
-		const member = this.#registry.lookup(name);
-		return member === void 0 ? void 0 : contributedResolution(member);
-	}
-	*ownNames() {
-		for (const [name] of this.#registry.entries()) yield name;
-	}
-};
-var DocumentScope = class extends Scope {
-	#records;
-	constructor(records, parent) {
-		super(parent);
-		this.#records = records;
-	}
-	lookup(name) {
-		const records = this.#records;
-		const model = records.models[name];
-		if (model !== void 0) return {
-			kind: "model",
-			symbol: model
-		};
-		const compositeType = records.compositeTypes[name];
-		if (compositeType !== void 0) return {
-			kind: "compositeType",
-			symbol: compositeType
-		};
-		const namedType = records.namedTypes[name];
-		if (namedType !== void 0) return {
-			kind: "namedType",
-			symbol: namedType
-		};
-		const block = records.blocks[name];
-		if (block !== void 0) return {
-			kind: "block",
-			symbol: block
-		};
-		const namespace = records.namespaces[name];
-		if (namespace !== void 0) return {
-			kind: "namespace",
-			symbol: namespace
-		};
-		return this.parent?.lookup(name);
-	}
-	ownNames() {
-		const records = this.#records;
-		return recordNames(records.models, records.compositeTypes, records.namedTypes, records.blocks, records.namespaces);
-	}
-};
-var NamespaceScope = class extends Scope {
-	#namespace;
-	constructor(namespace, parent) {
-		super(parent);
-		this.#namespace = namespace;
-	}
-	lookup(name) {
-		return namespaceMember(this.#namespace, name) ?? this.parent?.lookup(name);
-	}
-	ownNames() {
-		const namespace = this.#namespace;
-		return recordNames(namespace.models, namespace.compositeTypes, namespace.blocks);
+	for (const param of spec.positional) {
+		const namedParam = Object.hasOwn(spec.named, param.key) ? spec.named[param.key] : void 0;
+		finalizeAbsentKey(param.key, param.type, namedParam?.type);
 	}
-};
-function contributedScope(registry) {
-	return new ContributedScope(registry);
-}
-function documentScope(records, parent) {
-	return new DocumentScope(records, parent);
-}
-function namespaceScope(namespace, parent) {
-	return new NamespaceScope(namespace, parent);
-}
-function isNamespaceLike(resolution) {
-	return resolution.kind === "namespace" || resolution.kind === "contributedNamespace";
+	for (const key of Object.keys(spec.named)) finalizeAbsentKey(key, void 0, spec.named[key]?.type);
+	if (!outcome.ok) return notOk(outcome.failure);
+	return ok(output);
 }
-function* memberEntries(qualifier) {
-	if (qualifier.kind === "contributedNamespace") {
-		for (const [name, member] of qualifier.symbol.members) yield [name, contributedResolution(member)];
-		return;
+function interpretAttribute(attrNode, spec, ctx) {
+	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) {
+		const refineDiagnostics = spec.refine(value, ctx, attrNode);
+		if (refineDiagnostics.length > 0) return notOk(refineDiagnostics);
 	}
-	yield* new NamespaceScope(qualifier.symbol, void 0).entries();
+	return ok(value);
 }
-function lookupMember(qualifier, name) {
-	if (qualifier.kind === "contributedNamespace") {
-		const member = qualifier.symbol.members.get(name);
-		return member === void 0 ? void 0 : contributedResolution(member);
-	}
-	return namespaceMember(qualifier.symbol, name);
+function parseArgValue(arg, argType, ctx) {
+	const value = arg.value();
+	if (value === void 0) return notOk([diagnostic("Attribute argument is missing a value", ctx, nodePslSpan(arg.syntax, ctx.sources), arg.syntax)]);
+	return argType.parse(value, ctx);
 }
-const PSL_UNRESOLVED_REFERENCE = "PSL_UNRESOLVED_REFERENCE";
-function typeReferenceNode(symbol) {
-	return symbol.node.typeAnnotation()?.name()?.syntax;
+function isOptionalArgType(param) {
+	return "optional" in param && param.optional === true;
 }
-var PslBinder = class {
-	#declarations;
-	#references;
-	#documentScope;
-	#scopes;
-	constructor(declarations, references, documentScope, scopes) {
-		this.#declarations = declarations;
-		this.#references = references;
-		this.#documentScope = documentScope;
-		this.#scopes = scopes;
-	}
-	declaredSymbol(node) {
-		return this.#declarations.get(node);
-	}
-	symbolForNode(node) {
-		return this.#references.get(node);
-	}
-	scopeAt(node) {
-		return node.findAncestor((ancestor) => this.#scopes.get(ancestor)) ?? this.#documentScope;
-	}
-};
-var ScopeStack = class {
-	#base;
-	#scopes;
-	constructor(base) {
-		this.#base = base;
-		this.#scopes = [base];
-	}
-	current() {
-		return this.#scopes[this.#scopes.length - 1] ?? this.#base;
-	}
-	push(scope) {
-		this.#scopes.push(scope);
-	}
-	pop() {
-		this.#scopes.pop();
-	}
-};
-function walkEntities(symbolTable, stack, binder, visit) {
-	const { topLevel } = symbolTable;
-	for (const entity of Object.values(topLevel.models)) visit(entity);
-	for (const entity of Object.values(topLevel.compositeTypes)) visit(entity);
-	for (const namespace of Object.values(topLevel.namespaces)) {
-		stack.push(binder.scopeAt(namespace.declarations[0].node.syntax));
-		for (const entity of Object.values(namespace.models)) visit(entity);
-		for (const entity of Object.values(namespace.compositeTypes)) visit(entity);
-		stack.pop();
-	}
+function diagnostic(message, ctx, span, sourceNode) {
+	return {
+		code: ATTRIBUTE_DIAGNOSTIC_CODE,
+		message,
+		...diagnosticSource(ctx.sources, sourceNode).at(span)
+	};
 }
-function createBinder(options) {
-	const { sources, symbolTable, typeConstructors, attributeSpecs, controlMutationDefaults, describeUnsupportedAttribute } = options;
-	const pslBlockDescriptors = options.pslBlockDescriptors ?? {};
-	const document = documentScope(symbolTable.topLevel, contributedScope(contributedTypeScope(typeConstructors)));
-	const stack = new ScopeStack(document);
-	const scopes = /* @__PURE__ */ new WeakMap();
-	const declarations = /* @__PURE__ */ new WeakMap();
-	const references = /* @__PURE__ */ new WeakMap();
-	const diagnostics = [];
-	const binder = new PslBinder(declarations, references, document, scopes);
-	for (const symbol of Object.values(symbolTable.topLevel.namedTypes)) {
-		declarations.set(symbol.node.syntax, symbol);
-		const name = symbol.node.typeAnnotation()?.name();
-		const outcome = resolveTypeReference(name, document);
-		if (name !== void 0 && outcome !== void 0) references.set(name.syntax, outcome.resolution);
-	}
-	for (const symbol of Object.values(symbolTable.topLevel.blocks)) declarations.set(symbol.node.syntax, symbol);
-	for (const namespace of Object.values(symbolTable.topLevel.namespaces)) {
-		const scope = namespaceScope(namespace, document);
-		for (const declaration of namespace.declarations) {
-			declarations.set(declaration.node.syntax, namespace);
-			scopes.set(declaration.node.syntax, scope);
-		}
-		for (const symbol of Object.values(namespace.blocks)) declarations.set(symbol.node.syntax, symbol);
-	}
-	walkEntities(symbolTable, stack, binder, (entity) => {
-		declarations.set(entity.node.syntax, entity);
-		for (const field of Object.values(entity.fields)) {
-			declarations.set(field.node.syntax, field);
-			const node = typeReferenceNode(field);
-			if (node === void 0) continue;
-			const outcome = resolveTypeReference(field.node.typeAnnotation()?.name(), stack.current());
-			if (outcome === void 0) continue;
-			references.set(node, outcome.resolution);
-			if (outcome.message !== void 0) diagnostics.push({
-				code: PSL_UNRESOLVED_REFERENCE,
-				message: outcome.message,
-				data: {
-					reference: "type",
-					name: outcome.name,
-					constructorCall: field.typeConstructor !== void 0
-				},
-				...diagnosticSource(sources, node).at()
+function funcCall(name, sig) {
+	return {
+		kind: "funcCall",
+		label: `${name}()`,
+		name,
+		signature: sig,
+		parse: (arg, ctx) => {
+			const guard = matchCallee(arg, name, ctx);
+			if (!guard.ok) return guard;
+			const span = nodePslSpan(guard.value.syntax, ctx.sources);
+			const bound = interpretArgs(guard.value.args(), {
+				name,
+				positional: sig.positional ?? [],
+				named: sig.named ?? {}
+			}, ctx, span, guard.value.syntax);
+			if (!bound.ok) return notOk(bound.failure);
+			return ok({
+				fn: name,
+				span,
+				args: bound.value
 			});
 		}
-	});
-	walkEntities(symbolTable, stack, binder, (entity) => {
-		const context = {
-			owner: entity,
-			scope: stack.current(),
-			references,
-			diagnostics,
-			symbolTable,
-			sources,
-			describeUnsupportedAttribute
-		};
-		const specContext = entity.kind === "model" ? {
-			symbols: symbolTable,
-			model: entity,
-			controlMutationDefaults
-		} : void 0;
-		bindAttributes(entity, entity.attributes, attributeSpecs.model, (factory) => specContext === void 0 ? void 0 : factory(specContext), {
-			...context,
-			field: void 0
-		});
-		for (const field of Object.values(entity.fields)) bindAttributes(field, field.attributes, attributeSpecs.field, (factory) => specContext === void 0 ? void 0 : factory({
-			...specContext,
-			field
-		}), {
-			...context,
-			field
-		});
-	});
-	const blockContext = {
-		pslBlockDescriptors,
-		symbolTable,
-		sources,
-		references,
-		diagnostics
 	};
-	const bindBlocks = (blocks) => {
-		const context = {
-			...blockContext,
-			scope: stack.current()
-		};
-		for (const block of Object.values(blocks)) bindBlock(block, context);
+}
+function matchCallee(arg, name, ctx) {
+	const call = FunctionCallAst.cast(arg.syntax);
+	if (call === void 0) return notOk([leafDiagnostic(ctx, arg, "Expected a function call")]);
+	const qname = call.name();
+	if (qname === void 0 || qname.dot() !== void 0 || qname.colon() !== void 0) return notOk([leafDiagnostic(ctx, arg, "Expected a function call")]);
+	const calleeName = qname.identifier()?.token()?.text;
+	if (calleeName === void 0) return notOk([leafDiagnostic(ctx, arg, "Expected a function call")]);
+	if (calleeName !== name) return notOk([leafDiagnostic(ctx, arg, `Expected ${name}()`)]);
+	return ok(call);
+}
+function identifier(name, options) {
+	const label = name ?? "identifier";
+	return {
+		kind: "identifier",
+		label,
+		name,
+		documentation: options?.documentation ?? "",
+		parse: (arg, ctx) => {
+			const value = IdentifierAst.cast(arg.syntax)?.name();
+			if (value !== void 0 && (name === void 0 || value === name)) return ok(value);
+			return notOk([leafDiagnostic(ctx, arg, `Expected ${label}`)]);
+		}
 	};
-	bindBlocks(symbolTable.topLevel.blocks);
-	for (const namespace of Object.values(symbolTable.topLevel.namespaces)) {
-		stack.push(binder.scopeAt(namespace.declarations[0].node.syntax));
-		bindBlocks(namespace.blocks);
-		stack.pop();
-	}
+}
+function int(opts) {
+	const min = opts?.min;
+	const max = opts?.max;
+	return {
+		kind: "int",
+		label: "integer",
+		...min === void 0 ? {} : { min },
+		...max === void 0 ? {} : { max },
+		parse: (arg, ctx) => {
+			const literal = NumberLiteralExprAst.cast(arg.syntax);
+			if (literal !== void 0) {
+				const value = literal.value();
+				if (value !== void 0 && Number.isInteger(value)) {
+					if ((min === void 0 || value >= min) && (max === void 0 || value <= max)) return ok(value);
+					return notOk([leafDiagnostic(ctx, arg, rangeMessage(min, max))]);
+				}
+			}
+			return notOk([leafDiagnostic(ctx, arg, "Expected an integer literal")]);
+		}
+	};
+}
+function rangeMessage(min, max) {
+	if (min !== void 0 && max !== void 0) return `Expected an integer between ${min} and ${max}`;
+	if (min !== void 0) return `Expected an integer greater than or equal to ${min}`;
+	return `Expected an integer less than or equal to ${max}`;
+}
+/**
+* Reads an opaque JSON object from a quoted JSON string — the ADR's one text-encoded surface
+* exception (e.g. an index `filter` / `weights` argument). The string is decoded by the parser,
+* then JSON-parsed; a non-object (array/scalar) or invalid JSON is a diagnostic.
+*/
+function json() {
 	return {
-		binder,
-		diagnostics
+		kind: "json",
+		label: "JSON object",
+		parse: (arg, ctx) => {
+			const literal = StringLiteralExprAst.cast(arg.syntax);
+			if (literal === void 0) return notOk([leafDiagnostic(ctx, arg, "Expected a JSON object string")]);
+			const raw = literal.value();
+			if (raw !== void 0) try {
+				const parsed = JSON.parse(raw);
+				if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) return ok(blindCast(parsed));
+			} catch {}
+			return notOk([leafDiagnostic(ctx, arg, "Expected a valid JSON object")]);
+		}
 	};
 }
-function bindBlock(block, ctx) {
-	const descriptor = findBlockDescriptor(ctx.pslBlockDescriptors, block.keyword);
-	if (descriptor === void 0) return;
-	const spec = blockSpecFactoryOf(descriptor)({
-		symbols: ctx.symbolTable,
-		block
-	});
-	for (const entry of block.node.entries()) {
-		const key = entry.key()?.name();
-		if (key === void 0) continue;
-		const rule = spec.mode === "struct" ? Object.hasOwn(spec.parameters, key) ? spec.parameters[key]?.type : void 0 : spec.value.type;
-		const value = entry.value();
-		if (rule === void 0 || value === void 0) continue;
-		bindExpression(rule, value, ctx);
-	}
-	const attributeSpecs = descriptor.attributes ?? {};
-	if (Object.keys(attributeSpecs).length === 0) return;
-	for (const attribute of readResolvedAttributes(block.node.attributes(), ctx.sources)) {
-		const factory = attributeSpecs[attribute.name];
-		if (factory === void 0) continue;
-		bindArguments(attribute, blindCast(factory)({
-			symbols: ctx.symbolTable,
-			block
-		}), ctx);
-	}
-}
-function bindExpression(rule, expression, ctx, modelContext) {
-	const trial = tryBindExpression(rule, expression, ctx, modelContext);
-	for (const [node, resolution] of trial.references) ctx.references.set(node, resolution);
-	ctx.diagnostics.push(...trial.diagnostics.values());
-}
-function tryBindExpression(rule, expression, ctx, modelContext) {
-	const references = /* @__PURE__ */ new Map();
-	const diagnostics = /* @__PURE__ */ new Map();
-	switch (rule.kind) {
-		case "oneOf":
-			for (const alternative of rule.alternatives) {
-				const trial = tryBindExpression(alternative, expression, ctx, modelContext);
-				if (trial.matched) return trial;
-				for (const [node, diagnostic] of trial.diagnostics) diagnostics.set(node, diagnostic);
-				for (const [node, resolution] of trial.references) if (resolution.kind === "unresolved") references.set(node, resolution);
+function list(of, opts) {
+	const allowEmpty = opts?.allowEmpty ?? true;
+	const unique = opts?.unique ?? false;
+	return {
+		kind: "list",
+		label: opts?.label ?? (of.label.includes(" | ") ? `(${of.label})[]` : `${of.label}[]`),
+		of,
+		allowEmpty,
+		unique,
+		parse: (arg, ctx) => {
+			const literal = ArrayLiteralAst.cast(arg.syntax);
+			if (literal === void 0) return notOk([leafDiagnostic(ctx, arg, `Expected a list of ${of.label}`)]);
+			const parsed = [];
+			let outcome = okVoid();
+			let count = 0;
+			for (const element of literal.elements()) {
+				count += 1;
+				const result = of.parse(element, ctx);
+				if (result.ok) parsed.push({
+					node: element,
+					value: result.value
+				});
+				outcome = and(outcome, result);
 			}
-			return {
-				matched: false,
-				references,
-				diagnostics
-			};
-		case "list":
-		case "record": {
-			const children = rule.kind === "list" ? ArrayLiteralAst.cast(expression.syntax)?.elements() : recordValues(expression);
-			if (children === void 0) return {
-				matched: false,
-				references,
-				diagnostics
-			};
-			let matched = true;
-			for (const child of children) {
-				const trial = tryBindExpression(rule.of, child, ctx, modelContext);
-				matched = trial.matched && matched;
-				for (const [node, resolution] of trial.references) references.set(node, resolution);
-				for (const [node, diagnostic] of trial.diagnostics) diagnostics.set(node, diagnostic);
+			if (!allowEmpty && count === 0) outcome = and(outcome, notOk([leafDiagnostic(ctx, arg, "Expected a non-empty list")]));
+			if (unique) {
+				const seen = /* @__PURE__ */ new Set();
+				for (const { node, value } of parsed) if (seen.has(value)) outcome = and(outcome, notOk([leafDiagnostic(ctx, node, "Duplicate list entry")]));
+				else seen.add(value);
 			}
-			return {
-				matched,
-				references,
-				diagnostics
-			};
+			if (!outcome.ok) return notOk(outcome.failure);
+			return ok(parsed.map((entry) => entry.value));
 		}
-		case "funcCall": {
-			const call = FunctionCallAst.cast(expression.syntax);
-			const name = call?.name();
-			if (call === void 0 || name === void 0 || name.dot() !== void 0 || name.colon() !== void 0 || name.identifier()?.name() !== rule.name) return {
-				matched: false,
-				references,
-				diagnostics
-			};
-			let matched = true;
-			let positional = 0;
-			for (const arg of call.args()) {
-				const key = arg.name()?.name();
-				const parameter = argumentParameter(rule.signature, key, key === void 0 ? positional++ : positional);
-				const value = arg.value();
-				if (parameter === void 0 || value === void 0) {
-					matched = false;
-					continue;
-				}
-				const trial = tryBindExpression(parameter.type, value, ctx, modelContext);
-				matched = trial.matched && matched;
-				for (const [node, resolution] of trial.references) references.set(node, resolution);
-				for (const [node, diagnostic] of trial.diagnostics) diagnostics.set(node, diagnostic);
+	};
+}
+function oneOf(...alts) {
+	const label = alts.map((alt) => alt.label).join(" | ");
+	return {
+		kind: "oneOf",
+		label,
+		alternatives: alts,
+		parse: (arg, ctx) => {
+			const [head, ...tail] = blindCast(alts);
+			let rejection = head.parse(arg, ctx);
+			if (rejection.ok) return rejection;
+			for (const alt of tail) {
+				const result = alt.parse(arg, ctx);
+				if (result.ok) return result;
+				rejection = or(rejection, result);
 			}
-			return {
-				matched,
-				references,
-				diagnostics
-			};
-		}
-		case "entityRef": {
-			const node = expression.syntax;
-			const name = IdentifierAst.cast(node)?.name();
-			if (name === void 0) return {
-				matched: false,
-				references,
-				diagnostics
-			};
-			const failures = [];
-			const resolution = resolveEntity(name, node, {
-				...ctx,
-				diagnostics: failures
-			});
-			references.set(node, resolution);
-			for (const diagnostic of failures) diagnostics.set(node, diagnostic);
-			return {
-				matched: resolution.kind !== "unresolved",
-				references,
-				diagnostics
-			};
-		}
-		case "fieldRef": {
-			const node = expression.syntax;
-			const name = IdentifierAst.cast(node)?.name();
-			if (name === void 0 || modelContext === void 0) return {
-				matched: false,
-				references,
-				diagnostics
-			};
-			const failures = [];
-			const resolution = resolveOwnerField(name, node, {
-				...modelContext,
-				diagnostics: failures
-			});
-			references.set(node, resolution);
-			for (const diagnostic of failures) diagnostics.set(node, diagnostic);
-			return {
-				matched: resolution.kind !== "unresolved",
-				references,
-				diagnostics
-			};
-		}
-		case "referencedFieldRef": {
-			const node = expression.syntax;
-			const name = IdentifierAst.cast(node)?.name();
-			if (name === void 0 || modelContext === void 0) return {
-				matched: false,
-				references,
-				diagnostics
-			};
-			const failures = [];
-			const resolution = resolveReferencedField(name, node, {
-				...modelContext,
-				diagnostics: failures
-			});
-			references.set(node, resolution);
-			for (const diagnostic of failures) diagnostics.set(node, diagnostic);
-			return {
-				matched: resolution.kind !== "unresolved",
-				references,
-				diagnostics
-			};
+			if (!rejection.ok && rejection.failure.length === 0) return notOk([]);
+			return notOk([leafDiagnostic(ctx, arg, `Expected one of: ${label}`)]);
 		}
-		default: return {
-			matched: true,
-			references,
-			diagnostics
-		};
-	}
+	};
 }
-function recordValues(expression) {
-	const record = ObjectLiteralExprAst.cast(expression.syntax);
-	if (record === void 0) return void 0;
-	return (function* () {
-		for (const field of record.fields()) {
-			const value = field.value();
-			if (value !== void 0) yield value;
+function record(of) {
+	return {
+		kind: "record",
+		label: `{ [key]: ${of.label} }`,
+		of,
+		parse: (arg, ctx) => {
+			const literal = ObjectLiteralExprAst.cast(arg.syntax);
+			if (literal === void 0) return notOk([leafDiagnostic(ctx, arg, "Expected an object literal")]);
+			const entries = [];
+			const keys = /* @__PURE__ */ new Set();
+			let outcome = okVoid();
+			for (const field of Array.from(literal.fields())) {
+				const key = field.keyName();
+				if (key === void 0) {
+					outcome = and(outcome, notOk([leafDiagnostic(ctx, field, "Expected a key")]));
+					continue;
+				}
+				const value = field.value();
+				if (value === void 0) {
+					outcome = and(outcome, notOk([leafDiagnostic(ctx, field, `Expected a value for key "${key}"`)]));
+					continue;
+				}
+				const parsed = of.parse(value, ctx);
+				if (!parsed.ok) {
+					outcome = and(outcome, parsed);
+					continue;
+				}
+				if (keys.has(key)) {
+					outcome = and(outcome, notOk([leafDiagnostic(ctx, field, `Duplicate key "${key}"`)]));
+					continue;
+				}
+				keys.add(key);
+				entries.push([key, parsed.value]);
+			}
+			if (!outcome.ok) return notOk(outcome.failure);
+			return ok(Object.fromEntries(entries));
 		}
-	})();
+	};
 }
-function bindAttributes(holder, attributes, specs, instantiate, ctx) {
-	const declared = holder.node.attributes();
-	const nodes = Array.from(declared);
-	const level = holder.kind === "field" ? "field" : "model";
-	attributes.forEach((attribute, index) => {
-		const factory = own(specs, attribute.name);
-		if (factory === void 0) {
-			const diagnostic = ctx.describeUnsupportedAttribute?.({
-				attribute,
-				level,
-				owner: ctx.owner,
-				field: level === "field" ? ctx.field : void 0
-			});
-			if (diagnostic !== void 0) ctx.diagnostics.push(diagnostic);
-			return;
+function str(value) {
+	if (value === void 0) return {
+		kind: "str",
+		label: "string",
+		value: void 0,
+		parse: (arg, ctx) => {
+			const literal = StringLiteralExprAst.cast(arg.syntax);
+			if (literal !== void 0) {
+				const parsed = literal.value();
+				if (parsed !== void 0) return ok(parsed);
+			}
+			return notOk([leafDiagnostic(ctx, arg, "Expected a string literal")]);
 		}
-		const spec = instantiate(factory);
-		if (spec === void 0) return;
-		const nameNode = nodes[index]?.name()?.syntax;
-		if (nameNode !== void 0) ctx.references.set(nameNode, {
-			kind: "attribute",
-			symbol: {
-				kind: "attribute",
-				name: attribute.name,
-				level,
-				spec
+	};
+	return {
+		kind: "str",
+		label: JSON.stringify(value),
+		value,
+		parse: (arg, ctx) => {
+			const literal = StringLiteralExprAst.cast(arg.syntax);
+			if (literal !== void 0) {
+				if (literal.value() === value) return ok(value);
 			}
-		});
-		bindArguments(attribute, spec, ctx, ctx);
-	});
-}
-function bindArguments(attribute, spec, ctx, modelContext) {
-	let positional = 0;
-	for (const arg of attribute.args) {
-		const parameter = argumentParameter(spec, arg.name, arg.name === void 0 ? positional++ : positional);
-		if (parameter === void 0 || arg.expression === void 0) continue;
-		bindExpression(parameter.type, arg.expression, ctx, modelContext);
-	}
-}
-function argumentParameter(spec, name, position) {
-	if (name === void 0) return spec.positional?.[position];
-	return spec.named === void 0 ? void 0 : own(spec.named, name);
+			return notOk([leafDiagnostic(ctx, arg, `Expected ${JSON.stringify(value)}`)]);
+		}
+	};
 }
-function resolveOwnerField(name, node, ctx) {
-	const field = ctx.owner.fields[name];
-	if (field !== void 0) return {
-		kind: "field",
-		symbol: field
+function jsonValue() {
+	const self = {
+		kind: "oneOf",
+		label: "JSON value",
+		get alternatives() {
+			return composed.alternatives;
+		},
+		parse: (arg, ctx) => composed.parse(arg, ctx)
 	};
-	report(`Cannot find field "${name}" on "${ctx.owner.name}"`, node, ctx, "field");
+	const composed = oneOf(str(), finiteNumber(), bool(), jsonNull(), list(self), record(self));
+	return self;
+}
+function finiteNumber() {
 	return {
-		kind: "unresolved",
-		name
+		kind: "num",
+		value: void 0,
+		label: "number",
+		parse: (arg, ctx) => {
+			const value = NumberLiteralExprAst.cast(arg.syntax)?.value();
+			if (value === void 0 || Number.isNaN(value) || !Number.isFinite(value)) return notOk([leafDiagnostic(ctx, arg, "Expected a finite number literal")]);
+			return ok(value);
+		}
 	};
 }
-function resolveReferencedField(name, node, ctx) {
-	const declaring = ctx.field;
-	if (declaring === void 0) return {
-		kind: "unresolved",
-		name
+function jsonNull() {
+	return {
+		kind: "null",
+		label: "null",
+		parse: (arg, ctx) => {
+			if (IdentifierAst.cast(arg.syntax)?.name() === "null") return ok(null);
+			return notOk([leafDiagnostic(ctx, arg, "Expected null")]);
+		}
 	};
-	if (declaring.typeContractSpaceId !== void 0) return { kind: "crossSpace" };
-	const typeNode = typeReferenceNode(declaring);
-	const field = targetFields(typeNode === void 0 ? void 0 : ctx.references.get(typeNode))?.[name];
-	if (field !== void 0) return {
-		kind: "field",
-		symbol: field
+}
+function num(value) {
+	if (value === void 0) return {
+		kind: "num",
+		label: "number",
+		value: void 0,
+		parse: (arg, ctx) => {
+			const literal = NumberLiteralExprAst.cast(arg.syntax);
+			if (literal !== void 0) {
+				const parsed = literal.value();
+				if (parsed !== void 0) return ok(parsed);
+			}
+			return notOk([leafDiagnostic(ctx, arg, "Expected a number literal")]);
+		}
 	};
-	report(`Cannot find field "${name}" on the type of "${ctx.owner.name}.${declaring.name}"`, node, ctx, "field");
 	return {
-		kind: "unresolved",
-		name
+		kind: "num",
+		label: String(value),
+		value,
+		parse: (arg, ctx) => {
+			const literal = NumberLiteralExprAst.cast(arg.syntax);
+			if (literal !== void 0) {
+				if (literal.value() === value) return ok(value);
+			}
+			return notOk([leafDiagnostic(ctx, arg, `Expected ${value}`)]);
+		}
 	};
 }
-function targetFields(target) {
-	if (target === void 0) return void 0;
-	if (target.kind === "model" || target.kind === "compositeType") return target.symbol.fields;
-}
-function resolveEntity(name, node, ctx) {
-	const found = ctx.scope.lookup(name);
-	if (found === void 0) {
-		report(`Cannot find entity "${name}"`, node, ctx, "entity");
-		return {
-			kind: "unresolved",
-			name
-		};
-	}
-	return found;
+/** A number literal kept as its source text, for consumers that must not round it through a JS number. */
+function numLiteral() {
+	return {
+		kind: "num",
+		label: "number",
+		value: void 0,
+		parse: (arg, ctx) => {
+			const text = NumberLiteralExprAst.cast(arg.syntax)?.token()?.text;
+			if (text !== void 0) return ok({ text });
+			return notOk([leafDiagnostic(ctx, arg, "Expected a number literal")]);
+		}
+	};
 }
-function report(message, node, ctx, reference) {
-	ctx.diagnostics.push({
-		code: PSL_UNRESOLVED_REFERENCE,
-		message,
-		data: { reference },
-		...diagnosticSource(ctx.sources, node).at()
-	});
+/**
+* A `` tag`...` ``, `tag"..."`, or `tag'...'` argument. `tags` and `documentation` describe the
+* registered tags for tooling; parsing accepts any tag.
+*/
+function taggedLiteral(tags, options) {
+	return {
+		kind: "taggedLiteral",
+		label: `${tags[0] ?? "tag"}\`...\``,
+		tags,
+		documentation: options.documentation,
+		parse: (arg, ctx) => {
+			const literal = TaggedLiteralExprAst.cast(arg.syntax);
+			if (literal === void 0) return notOk([leafDiagnostic(ctx, arg, "Expected a tagged literal")]);
+			return ok({
+				tag: literal.tagName(),
+				canonicalization: literal.canonicalization(),
+				span: nodePslSpan(literal.syntax, ctx.sources)
+			});
+		}
+	};
 }
-function resolveTypeReference(reference, scope) {
-	if (reference === void 0 || reference.isOverQualified()) return void 0;
-	if (reference.space() !== void 0) return { resolution: { kind: "crossSpace" } };
-	const name = reference.identifier()?.name();
-	if (name === void 0 || name === "") return void 0;
-	const namespaceId = reference.namespace()?.name();
-	const found = namespaceId === void 0 ? scope.lookup(name) : qualifiedMember(namespaceId, name, scope);
-	if (found === void 0) {
-		const written = namespaceId === void 0 ? name : `${namespaceId}.${name}`;
-		return {
-			resolution: {
-				kind: "unresolved",
-				name: written
-			},
-			message: `Cannot find type "${written}"`,
-			name: written
-		};
-	}
-	if ("badQualifier" in found) return {
-		resolution: {
-			kind: "unresolved",
-			name: found.qualifier
-		},
-		message: found.badQualifier,
-		name: found.qualifier
+function fieldAttribute(name, config) {
+	return {
+		level: "field",
+		name,
+		documentation: config.documentation,
+		positional: config.positional ?? [],
+		named: Object.assign(Object.create(null), config.named),
+		...config.refine !== void 0 ? { refine: config.refine } : {}
 	};
-	if (found.kind === "namespace" || found.kind === "contributedNamespace") {
-		const written = namespaceId === void 0 ? name : `${namespaceId}.${name}`;
-		return {
-			resolution: found,
-			message: `"${written}" is a namespace; a type reference must name a model, composite type, enum, or named type`,
-			name: written
-		};
-	}
-	return { resolution: found };
 }
-function qualifiedMember(namespaceId, name, scope) {
-	const qualifier = scope.lookup(namespaceId);
-	if (qualifier === void 0) return void 0;
-	if (!isNamespaceLike(qualifier)) return {
-		badQualifier: `"${namespaceId}" is ${describeQualifier(qualifier)}, not a namespace`,
-		qualifier: namespaceId
+function modelAttribute(name, config) {
+	return {
+		level: "model",
+		name,
+		documentation: config.documentation,
+		positional: config.positional ?? [],
+		named: Object.assign(Object.create(null), config.named),
+		...config.refine !== void 0 ? { refine: config.refine } : {}
 	};
-	return lookupMember(qualifier, name);
-}
-function describeQualifier(resolution) {
-	switch (resolution.kind) {
-		case "model": return "a model";
-		case "compositeType": return "a composite type";
-		case "namedType": return "a named type";
-		case "block": return `${resolution.symbol.keyword === "enum" ? "an" : "a"} ${resolution.symbol.keyword}`;
-		default: return "a scalar type";
-	}
 }
-function own(record, name) {
-	return Object.hasOwn(record, name) ? record[name] : void 0;
+function optional(type, ...rest) {
+	if (rest.length === 0) return {
+		...type,
+		optional: true,
+		hasDefault: false
+	};
+	return {
+		...type,
+		optional: true,
+		hasDefault: true,
+		defaultValue: rest[0]
+	};
 }
 function structBlock(config) {
 	return {
@@ -1483,237 +1773,7 @@ function isPrismaNextSchema(text) {
 function renameLegacyDirective(text) {
 	return text.replace(DIRECTIVE, (whole, lead, name, trail) => name === LEGACY_NAME ? `${lead}prisma-8${trail}` : whole);
 }
-/**
-* Owns duplicate-declaration detection for all PSL scopes; downstream consumers
-* should consume first-wins symbols rather than re-emitting duplicate diagnostics.
-*/
-function buildSymbolTable(options) {
-	const { documents, sources } = options;
-	const diagnostics = [];
-	const namespaces = Object.create(null);
-	const namedTypes = Object.create(null);
-	const blocks = Object.create(null);
-	const models = Object.create(null);
-	const compositeTypes = Object.create(null);
-	const topLevelNames = /* @__PURE__ */ new Set();
-	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);
-		} 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: [{
-						node: declaration,
-						span: nodePslSpan(declaration.syntax, sources)
-					}],
-					models: Object.create(null),
-					compositeTypes: Object.create(null),
-					blocks: Object.create(null)
-				};
-				namespaces[name] = namespace;
-			} else namespace.declarations.push({
-				node: declaration,
-				span: nodePslSpan(declaration.syntax, sources)
-			});
-			extendNamespace(namespace, declaration, diagnostics, sources);
-		} 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, sources);
-			namedTypes[name] = {
-				kind: "namedType",
-				name,
-				node: binding,
-				span: nodePslSpan(binding.syntax, sources),
-				...resolved
-			};
-		}
-	}
-	return {
-		symbolTable: { topLevel: {
-			namespaces,
-			namedTypes,
-			blocks,
-			models,
-			compositeTypes
-		} },
-		diagnostics
-	};
-}
-function buildModel(name, node, sources, diagnostics) {
-	return {
-		kind: "model",
-		name,
-		node,
-		span: nodePslSpan(node.syntax, sources),
-		fields: buildFields(name, node.fields(), sources, diagnostics),
-		attributes: readResolvedAttributes(node.attributes(), sources)
-	};
-}
-function buildCompositeType(name, node, sources, diagnostics) {
-	return {
-		kind: "compositeType",
-		name,
-		node,
-		span: nodePslSpan(node.syntax, sources),
-		fields: buildFields(name, node.fields(), sources, diagnostics),
-		attributes: readResolvedAttributes(node.attributes(), sources)
-	};
-}
-function buildBlock(name, node, sources) {
-	return {
-		kind: "block",
-		name,
-		keyword: node.keyword()?.text ?? "",
-		node,
-		span: nodePslSpan(node.syntax, sources)
-	};
-}
-function extendNamespace(namespace, node, diagnostics, sources) {
-	const { models, compositeTypes, blocks } = namespace;
-	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(), 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, 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);
-	}
-}
-function buildFields(ownerName, fields, sources, diagnostics) {
-	const result = Object.create(null);
-	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, 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, sources, diagnostics);
-	}
-	return result;
-}
-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()) {
-		const path = typeName.path();
-		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")`,
-			filename: sources.sourceFileFor(typeName.syntax).filename,
-			range: nodeRange(typeName.syntax, sources)
-		});
-		return {
-			kind: "field",
-			name,
-			node,
-			span,
-			typeName: path[path.length - 1] ?? "",
-			optional: false,
-			list: false,
-			elementOptional: false,
-			malformedType: true,
-			attributes
-		};
-	}
-	const typeConstructor = annotation?.isConstructor() ? readResolvedConstructorCall(annotation, sources) : void 0;
-	const typeNamespaceId = typeName?.namespace()?.name();
-	const typeContractSpaceId = typeName?.space()?.name();
-	return {
-		kind: "field",
-		name,
-		node,
-		span,
-		typeName: typeName?.identifier()?.name() ?? "",
-		...typeNamespaceId !== void 0 ? { typeNamespaceId } : {},
-		...typeContractSpaceId !== void 0 ? { typeContractSpaceId } : {},
-		optional: annotation?.isOptional() ?? false,
-		list: annotation?.isList() ?? false,
-		elementOptional: annotation?.isElementOptional() ?? false,
-		...typeConstructor !== void 0 ? { typeConstructor } : {},
-		attributes
-	};
-}
-function resolveNamedTypeBinding(node, sources) {
-	const annotation = node.typeAnnotation();
-	const isConstructor = annotation?.isConstructor() ?? false;
-	const baseType = annotation?.name()?.identifier()?.name();
-	const typeConstructor = readResolvedConstructorCall(annotation, sources);
-	return {
-		isConstructor,
-		...!isConstructor && baseType !== void 0 ? { baseType } : {},
-		...typeConstructor !== void 0 ? { typeConstructor } : {},
-		attributes: readResolvedAttributes(node.attributes(), sources)
-	};
-}
-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, sources) {
-	const sourceFile = sources.sourceFileFor(node);
-	const start = node.offset;
-	const end = start + node.green.textLength;
-	return {
-		start: sourceFile.positionAt(start),
-		end: sourceFile.positionAt(end)
-	};
-}
 //#endregion
-export { NAME_THE_PSL_SOURCE_LOSES, PSL_UNRESOLVED_REFERENCE, assembleAttributeSpecs, blockAttribute, blockSpecFactoryOf, bool, buildSymbolTable, createBinder, createPslDiagnosticCollector, diagnosticFromSpan, diagnosticSource, entityRef, entityReference, fieldAttribute, fieldRef, findBlockDescriptor, flatPslModels, funcCall, getPositionalArgument, identifier, int, interpretArgs, interpretAttribute, interpretExtensionBlock, interpretExtensionBlockAttributes, interpretExtensionBlocks, isNamespaceLike, isPrismaNextSchema, isPslIdentifier, json, jsonValue, keywordPslSpan, leafDiagnostic, list, mapBlock, mapPslDiagnostics, matchesSelector, memberEntries, modelAttribute, namespacePslExtensionBlocks, nodePslSpan, num, numLiteral, oneOf, optional, parseQuotedStringLiteral, readResolvedAttribute, readResolvedAttributes, readResolvedConstructorCall, record, referencedFieldRef, renameLegacyDirective, str, structBlock, taggedLiteral, typeReferenceNode };
+export { NAME_THE_PSL_SOURCE_LOSES, PSL_UNRESOLVED_REFERENCE, assembleAttributeSpecs, blockAttribute, blockSpecFactoryOf, bool, buildSymbolTable, contributedTypeOf, createBinder, createPslDiagnosticCollector, diagnosticFromSpan, diagnosticSource, entityRef, entityReference, fieldAttribute, fieldRef, findBlockDescriptor, flatPslModels, funcCall, getPositionalArgument, identifier, int, interpretArgs, interpretAttribute, interpretExtensionBlock, interpretExtensionBlockAttributes, interpretExtensionBlocks, isNamespaceLike, isPrismaNextSchema, isPslIdentifier, json, jsonValue, keywordPslSpan, leafDiagnostic, list, mapBlock, mapPslDiagnostics, matchesSelector, memberEntries, modelAttribute, namespacePslExtensionBlocks, nodePslSpan, num, numLiteral, oneOf, optional, parseQuotedStringLiteral, readResolvedAttribute, readResolvedAttributes, readResolvedConstructorCall, record, referencedFieldRef, renameLegacyDirective, str, structBlock, taggedLiteral, typeReferenceNode };
 
 //# sourceMappingURL=psl-parser.mjs.map