@prisma/orm-framework 8.0.0-rc.12-dev.6 → 8.0.0-rc.12-dev.7

package/dist/psl-parser.mjs

@@ -1,9 +1,9 @@
 import { t as blindCast } from "./casts-DpaahrlC-Bd5n2coI.mjs";
 import { t as InternalError } from "./internal-error-ChGYPVpq-DhUD05u0.mjs";
-import { n as ok, t as notOk } from "./result-C0NUq1Ok.mjs";
-import { h as isAuthoringPslBlockDescriptor, m as isAuthoringModelAttributeDescriptor } from "./framework-authoring-bUu_R58O-Cr-Mz1dC.mjs";
+import { a as or, i as okVoid, n as notOk, r as ok, t as and } from "./result-8OXF26MN.mjs";
+import { g as isAuthoringTypeConstructorDescriptor, h as isAuthoringPslBlockDescriptor, m as isAuthoringModelAttributeDescriptor } from "./framework-authoring-bUu_R58O-Cr-Mz1dC.mjs";
 import { a as makePslNamespace, c as validateExtensionBlock, i as flatPslModels, n as UNSPECIFIED_PSL_NAMESPACE_ID, o as makePslNamespaceEntries, s as namespacePslExtensionBlocks } from "./psl-ast-DUCvVXbB.mjs";
-import { D as TypesBlockAst, P as printSyntax, _ as NumberLiteralExprAst, a as CompositeTypeDeclarationAst, d as IdentifierAst, g as NamespaceDeclarationAst, i as BooleanLiteralExprAst, l as FunctionCallAst, m as ModelDeclarationAst, t as ArrayLiteralAst, u as GenericBlockDeclarationAst, w as TaggedLiteralExprAst, x as StringLiteralExprAst, y as ObjectLiteralExprAst } from "./declarations-SwNXosDu-D2vp62Qo.mjs";
+import { D as TypesBlockAst, P as printSyntax, _ as NumberLiteralExprAst, a as CompositeTypeDeclarationAst, d as IdentifierAst, g as NamespaceDeclarationAst, i as BooleanLiteralExprAst, l as FunctionCallAst, m as ModelDeclarationAst, t as ArrayLiteralAst, u as GenericBlockDeclarationAst, w as TaggedLiteralExprAst, x as StringLiteralExprAst, y as ObjectLiteralExprAst } from "./declarations-D79GooqC-BhBEz1Kc.mjs";
 import { i as mapPslDiagnostics, n as diagnosticFromSpan, r as diagnosticSource, t as createPslDiagnosticCollector } from "./diagnostic-Esyl8Qw1-Cd6SnWPN.mjs";
 //#region ../../../1-framework/2-authoring/psl-parser/dist/index.mjs
 function getPositionalArgument(attribute, index = 0) {
@@ -130,37 +130,41 @@ function bool() {
 	};
 }
 const references = /* @__PURE__ */ new WeakMap();
-function resolveEntityReference(expression, name, symbols) {
-	const namespaceName = expression.syntax.findAncestor(NamespaceDeclarationAst.cast)?.name()?.name();
-	const namespace = namespaceName === void 0 ? void 0 : ownValue(symbols.topLevel.namespaces, namespaceName);
-	if (namespace !== void 0) {
-		const declaration = declarationIn(namespace, name);
-		if (declaration !== void 0) return referenceFor(namespace, declaration, namespace);
+function entityReference(resolution) {
+	switch (resolution.kind) {
+		case "model":
+		case "compositeType":
+		case "namedType":
+		case "block": return interned(resolution.symbol, resolution.namespace);
+		default: return;
 	}
-	const declaration = declarationIn(symbols.topLevel, name);
-	return declaration === void 0 ? void 0 : referenceFor(symbols.topLevel, declaration, void 0);
 }
-function ownValue(values, name) {
-	return Object.hasOwn(values, name) ? values[name] : void 0;
-}
-function declarationIn(scope, name) {
-	return ownValue(scope.models, name) ?? ownValue(scope.compositeTypes, name) ?? ownValue(scope.blocks, name) ?? ("namedTypes" in scope ? ownValue(scope.namedTypes, name) : void 0);
+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 referenceFor(scope, declaration, namespace) {
-	let byDeclaration = references.get(scope);
-	if (byDeclaration === void 0) {
-		byDeclaration = /* @__PURE__ */ new WeakMap();
-		references.set(scope, byDeclaration);
-	}
-	let reference = byDeclaration.get(declaration);
-	if (reference === void 0) {
-		reference = {
-			declaration,
-			namespace
-		};
-		byDeclaration.set(declaration, reference);
+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;
 	}
-	return reference;
+}
+function unbound(name) {
+	throw new InternalError(`The binder on this attribute context bound nothing for "${name}". A reference argument is always examined, so the binder must be built over the same snapshot - the same symbol table and sources - as the interpretation consuming it.`);
 }
 function entityRef(expected) {
 	const label = `${expected.kind === "block" ? expected.keyword : expected.kind} reference`;
@@ -171,45 +175,41 @@ function entityRef(expected) {
 		parse: (arg, ctx) => {
 			const name = IdentifierAst.cast(arg.syntax)?.name();
 			if (name === void 0) return notOk([leafDiagnostic(ctx, arg, `Expected ${label}`)]);
-			const reference = resolveEntityReference(arg, name, ctx.symbols);
-			if (reference === void 0) return notOk([leafDiagnostic(ctx, arg, `Unknown ${label} "${name}"`)]);
-			if (!matchesSelector(reference, expected)) {
-				const actual = reference.declaration;
-				const kind = actual.kind === "block" ? actual.keyword : actual.kind;
-				return notOk([leafDiagnostic(ctx, arg, `Expected ${label} "${name}", found ${kind}`)]);
-			}
+			const resolution = ctx.binder.symbolForNode(arg.syntax) ?? unbound(name);
+			if (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 matchesSelector(reference, expected) {
-	const declaration = reference.declaration;
-	return declaration.kind === expected.kind && (expected.kind !== "block" || declaration.kind === "block" && declaration.keyword === expected.keyword);
-}
-function parseFieldName(arg, ctx, model) {
+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")]);
-	if (model !== void 0 && !Object.hasOwn(model.fields, name)) return notOk([leafDiagnostic(ctx, arg, `Field "${name}" does not exist on model "${model.name}"`)]);
-	return ok(name);
+	const resolution = ctx.binder.symbolForNode(arg.syntax);
+	if (resolution === void 0) throw new InternalError(`The binder on this attribute context bound nothing for "${name}". A reference argument is always examined, so the binder must be built over the same snapshot - the same symbol table and sources - as the interpretation consuming it.`);
+	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: (arg, ctx) => parseFieldName(arg, ctx, ctx.selfModel)
+		parse: (arg, ctx) => parseFieldName(arg, ctx)
 	};
 }
 function referencedFieldRef() {
 	return {
 		kind: "referencedFieldRef",
 		label: "field name",
-		parse: (arg, ctx) => parseFieldName(arg, ctx, ctx.resolveReferencedModel())
+		parse: (arg, ctx) => parseFieldName(arg, ctx)
 	};
 }
 function interpretArgs(args, spec, ctx, span, sourceNode) {
-	const diagnostics = [];
+	let outcome = okVoid();
 	const output = {};
 	const seen = /* @__PURE__ */ new Set();
 	let positionalSlot = 0;
@@ -222,7 +222,7 @@ function interpretArgs(args, spec, ctx, span, sourceNode) {
 			const posParam = spec.positional[positionalSlot];
 			if (posParam === void 0) {
 				if (!reportedExcess) {
-					diagnostics.push(diagnostic(`Attribute "${spec.name}" received too many positional arguments`, ctx, span, sourceNode));
+					outcome = and(outcome, notOk([diagnostic(`Attribute "${spec.name}" received too many positional arguments`, ctx, span, sourceNode)]));
 					reportedExcess = true;
 				}
 				continue;
@@ -233,19 +233,20 @@ function interpretArgs(args, spec, ctx, span, sourceNode) {
 		} else {
 			const namedParam = Object.hasOwn(spec.named, name) ? spec.named[name] : void 0;
 			if (namedParam === void 0) {
-				diagnostics.push(diagnostic(`Attribute "${spec.name}" received unknown argument "${name}"`, ctx, nodePslSpan(arg.syntax, ctx.sources), arg.syntax));
+				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)) {
-			diagnostics.push(diagnostic(`Attribute "${spec.name}" received duplicate argument "${key}"`, ctx, nodePslSpan(arg.syntax, ctx.sources), arg.syntax));
+			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, diagnostics);
+		const result = parseArgValue(arg, param, ctx);
 		if (result.ok) output[key] = result.value;
+		outcome = and(outcome, result);
 	}
 	const finalized = /* @__PURE__ */ new Set();
 	const finalizeAbsentKey = (key, positionalParam, namedParam) => {
@@ -257,14 +258,14 @@ function interpretArgs(args, spec, ctx, span, sourceNode) {
 			if (effective.hasDefault) output[key] = effective.defaultValue;
 			return;
 		}
-		diagnostics.push(diagnostic(`Attribute "${spec.name}" is missing required argument "${key}"`, ctx, span, sourceNode));
+		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);
 	}
 	for (const key of Object.keys(spec.named)) finalizeAbsentKey(key, void 0, spec.named[key]?.type);
-	if (diagnostics.length > 0) return notOk(diagnostics);
+	if (!outcome.ok) return notOk(outcome.failure);
 	return ok(output);
 }
 function interpretAttribute(attrNode, spec, ctx) {
@@ -278,16 +279,10 @@ function interpretAttribute(attrNode, spec, ctx) {
 	}
 	return ok(value);
 }
-function parseArgValue(arg, argType, ctx, diagnostics) {
+function parseArgValue(arg, argType, ctx) {
 	const value = arg.value();
-	if (value === void 0) {
-		const missing = diagnostic("Attribute argument is missing a value", ctx, nodePslSpan(arg.syntax, ctx.sources), arg.syntax);
-		diagnostics.push(missing);
-		return notOk([missing]);
-	}
-	const result = argType.parse(value, ctx);
-	if (!result.ok) for (const failure of result.failure) diagnostics.push(failure);
-	return result;
+	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;
@@ -406,8 +401,8 @@ function list(of, opts) {
 		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 diagnostics = [];
 			const parsed = [];
+			let outcome = okVoid();
 			let count = 0;
 			for (const element of literal.elements()) {
 				count += 1;
@@ -416,15 +411,15 @@ function list(of, opts) {
 					node: element,
 					value: result.value
 				});
-				else diagnostics.push(...result.failure);
+				outcome = and(outcome, result);
 			}
-			if (!allowEmpty && count === 0) diagnostics.push(leafDiagnostic(ctx, arg, "Expected a non-empty list"));
+			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)) diagnostics.push(leafDiagnostic(ctx, node, "Duplicate list entry"));
+				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 (diagnostics.length > 0) return notOk(diagnostics);
+			if (!outcome.ok) return notOk(outcome.failure);
 			return ok(parsed.map((entry) => entry.value));
 		}
 	};
@@ -476,10 +471,15 @@ function oneOf(...alts) {
 		label,
 		alternatives: alts,
 		parse: (arg, ctx) => {
-			for (const alt of alts) {
-				const result = blindCast(alt.parse)(arg, ctx);
-				if (result.ok) return ok(blindCast(result.value));
+			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}`)]);
 		}
 	};
@@ -492,33 +492,33 @@ function record(of) {
 		parse: (arg, ctx) => {
 			const literal = ObjectLiteralExprAst.cast(arg.syntax);
 			if (literal === void 0) return notOk([leafDiagnostic(ctx, arg, "Expected an object literal")]);
-			const diagnostics = [];
 			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) {
-					diagnostics.push(leafDiagnostic(ctx, field, "Expected a key"));
+					outcome = and(outcome, notOk([leafDiagnostic(ctx, field, "Expected a key")]));
 					continue;
 				}
 				const value = field.value();
 				if (value === void 0) {
-					diagnostics.push(leafDiagnostic(ctx, field, `Expected a value for key "${key}"`));
+					outcome = and(outcome, notOk([leafDiagnostic(ctx, field, `Expected a value for key "${key}"`)]));
 					continue;
 				}
 				const parsed = of.parse(value, ctx);
 				if (!parsed.ok) {
-					diagnostics.push(...parsed.failure);
+					outcome = and(outcome, parsed);
 					continue;
 				}
 				if (keys.has(key)) {
-					diagnostics.push(leafDiagnostic(ctx, field, `Duplicate key "${key}"`));
+					outcome = and(outcome, notOk([leafDiagnostic(ctx, field, `Duplicate key "${key}"`)]));
 					continue;
 				}
 				keys.add(key);
 				entries.push([key, parsed.value]);
 			}
-			if (diagnostics.length > 0) return notOk(diagnostics);
+			if (!outcome.ok) return notOk(outcome.failure);
 			return ok(Object.fromEntries(entries));
 		}
 	};
@@ -577,7 +577,7 @@ function fieldAttribute(name, config) {
 		name,
 		documentation: config.documentation,
 		positional: config.positional ?? [],
-		named: config.named ?? {},
+		named: Object.assign(Object.create(null), config.named),
 		...config.refine !== void 0 ? { refine: config.refine } : {}
 	};
 }
@@ -587,7 +587,7 @@ function modelAttribute(name, config) {
 		name,
 		documentation: config.documentation,
 		positional: config.positional ?? [],
-		named: config.named ?? {},
+		named: Object.assign(Object.create(null), config.named),
 		...config.refine !== void 0 ? { refine: config.refine } : {}
 	};
 }
@@ -604,6 +604,432 @@ function optional(type, ...rest) {
 		defaultValue: rest[0]
 	};
 }
+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);
+	} };
+	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 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
+	};
+}
+var ContributedScope = class {
+	#registry;
+	constructor(registry) {
+		this.#registry = registry;
+	}
+	lookup(name) {
+		const member = this.#registry.lookup(name);
+		return member === void 0 ? void 0 : contributedResolution(member);
+	}
+};
+var DocumentScope = class {
+	#records;
+	#parent;
+	constructor(records, parent) {
+		this.#records = records;
+		this.#parent = parent;
+	}
+	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);
+	}
+};
+var NamespaceScope = class {
+	#namespace;
+	#parent;
+	constructor(namespace, parent) {
+		this.#namespace = namespace;
+		this.#parent = parent;
+	}
+	lookup(name) {
+		return namespaceMember(this.#namespace, name) ?? this.#parent.lookup(name);
+	}
+};
+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";
+}
+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(field) {
+	return field.node.typeAnnotation()?.name()?.syntax;
+}
+var PslBinder = class {
+	#declarations;
+	#references;
+	constructor(declarations, references) {
+		this.#declarations = declarations;
+		this.#references = references;
+	}
+	declaredSymbol(node) {
+		return this.#declarations.get(node);
+	}
+	symbolForNode(node) {
+		return this.#references.get(node);
+	}
+};
+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, 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(namespaceScope(namespace, stack.current()));
+		for (const entity of Object.values(namespace.models)) visit(entity);
+		for (const entity of Object.values(namespace.compositeTypes)) visit(entity);
+		stack.pop();
+	}
+}
+function createBinder(options) {
+	const { sources, symbolTable, typeConstructors, attributeSpecs, controlMutationDefaults, describeUnsupportedAttribute } = options;
+	const stack = new ScopeStack(documentScope(symbolTable.topLevel, contributedScope(contributedTypeScope(typeConstructors))));
+	const declarations = /* @__PURE__ */ new WeakMap();
+	const references = /* @__PURE__ */ new WeakMap();
+	const diagnostics = [];
+	for (const symbol of Object.values(symbolTable.topLevel.namedTypes)) declarations.set(symbol.node.syntax, symbol);
+	for (const symbol of Object.values(symbolTable.topLevel.blocks)) declarations.set(symbol.node.syntax, symbol);
+	for (const namespace of Object.values(symbolTable.topLevel.namespaces)) {
+		for (const declaration of namespace.declarations) declarations.set(declaration.node.syntax, namespace);
+		for (const symbol of Object.values(namespace.blocks)) declarations.set(symbol.node.syntax, symbol);
+	}
+	walkEntities(symbolTable, stack, (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, 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
+				},
+				...diagnosticSource(sources, node).at()
+			});
+		}
+	});
+	walkEntities(symbolTable, stack, (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
+		});
+	});
+	return {
+		binder: new PslBinder(declarations, references),
+		diagnostics
+	};
+}
+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);
+	});
+}
+function bindArguments(attribute, spec, ctx) {
+	let positional = 0;
+	for (const arg of attribute.args) {
+		const param = arg.name === void 0 ? spec.positional[positional++] : spec.named[arg.name];
+		if (param === void 0 || arg.expression === void 0) continue;
+		const kind = referenceKind(param.type);
+		if (kind === void 0) continue;
+		for (const node of referenceNodes(arg.expression)) {
+			const resolution = resolveArgument(kind, node, ctx);
+			if (resolution !== void 0) ctx.references.set(node, resolution);
+		}
+	}
+}
+function resolveArgument(kind, node, ctx) {
+	const name = IdentifierAst.cast(node)?.name();
+	if (name === void 0) return void 0;
+	switch (kind) {
+		case "fieldRef": return resolveOwnerField(name, node, ctx);
+		case "referencedFieldRef": return resolveReferencedField(name, node, ctx);
+		case "entityRef": return resolveEntity(name, node, ctx);
+	}
+}
+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 referenceKind(type) {
+	if (typeof type !== "object" || type === null) return void 0;
+	if ("kind" in type) {
+		const kind = type.kind;
+		if (kind === "fieldRef" || kind === "referencedFieldRef" || kind === "entityRef") return kind;
+	}
+	if ("of" in type) return referenceKind(type.of);
+	if ("alternatives" in type && Array.isArray(type.alternatives)) for (const alternative of type.alternatives) {
+		const kind = referenceKind(alternative);
+		if (kind !== void 0) return kind;
+	}
+}
+function referenceNodes(expression) {
+	const array = ArrayLiteralAst.cast(expression.syntax);
+	if (array === void 0) return [expression.syntax];
+	return Array.from(array.elements(), (element) => element.syntax);
+}
+function resolveTypeReference(field, scope) {
+	if (field.malformedType === true) return void 0;
+	if (field.typeContractSpaceId !== void 0) return { resolution: { kind: "crossSpace" } };
+	const name = field.typeName;
+	if (name === "") return void 0;
+	const namespaceId = field.typeNamespaceId;
+	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
+	};
+	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;
+}
 function findBlockDescriptor(descriptors, keyword) {
 	if (descriptors === void 0) return void 0;
 	for (const value of Object.values(descriptors)) {
@@ -1064,6 +1490,6 @@ function nodeRange(node, sources) {
 	};
 }
 //#endregion
-export { assembleAttributeSpecs, blockAttribute, bool, buildSymbolTable, createPslDiagnosticCollector, diagnosticFromSpan, diagnosticSource, entityRef, fieldAttribute, fieldRef, findBlockDescriptor, flatPslModels, funcCall, getPositionalArgument, identifier, int, interpretArgs, interpretAttribute, isPrismaNextSchema, json, keywordPslSpan, leafDiagnostic, list, mapPslDiagnostics, modelAttribute, namespacePslExtensionBlocks, nodePslSpan, num, numLiteral, oneOf, optional, parseQuotedStringLiteral, readResolvedAttribute, readResolvedAttributes, readResolvedConstructorCall, record, referencedFieldRef, renameLegacyDirective, str, taggedLiteral, validateExtensionBlockFromSymbol };
+export { PSL_UNRESOLVED_REFERENCE, assembleAttributeSpecs, blockAttribute, bool, buildSymbolTable, createBinder, createPslDiagnosticCollector, diagnosticFromSpan, diagnosticSource, entityRef, fieldAttribute, fieldRef, findBlockDescriptor, flatPslModels, funcCall, getPositionalArgument, identifier, int, interpretArgs, interpretAttribute, isPrismaNextSchema, json, keywordPslSpan, leafDiagnostic, list, mapPslDiagnostics, modelAttribute, namespacePslExtensionBlocks, nodePslSpan, num, numLiteral, oneOf, optional, parseQuotedStringLiteral, readResolvedAttribute, readResolvedAttributes, readResolvedConstructorCall, record, referencedFieldRef, renameLegacyDirective, str, taggedLiteral, validateExtensionBlockFromSymbol };
 
 //# sourceMappingURL=psl-parser.mjs.map