@prisma/orm-framework 8.0.0-rc.13 → 8.0.0-rc.13-dev.3

package/dist/psl-parser.mjs

@@ -1,11 +1,10 @@
 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 { _ as isAuthoringModelAttributeDescriptor, v as isAuthoringPslBlockDescriptor, y as isAuthoringTypeConstructorDescriptor } from "./temporal-presets-DABMpaxB-DDEaCwpa.mjs";
-import { a as flatPslModels, c as namespacePslExtensionBlocks, l as validateExtensionBlock, o as makePslNamespace, r as UNSPECIFIED_PSL_NAMESPACE_ID, s as makePslNamespaceEntries } from "./psl-ast-DYtFdynZ.mjs";
+import { _ as isAuthoringModelAttributeDescriptor, v as isAuthoringPslBlockDescriptor, y as isAuthoringTypeConstructorDescriptor } from "./temporal-presets-Cqi6Fnl--DNtY0oCw.mjs";
+import { a as flatPslModels, c as namespacePslExtensionBlocks } from "./psl-ast-CyvE6CR-.mjs";
 import { n as isPslIdentifier } from "./tokenizer-BMz7z2KR-J0yZ4im3.mjs";
-import { l as printSyntax } from "./ast-helpers-2XRnkQEO-BxG5qx3Q.mjs";
-import { S as TaggedLiteralExprAst, _ 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 TypesBlockAst, x as StringLiteralExprAst, y as ObjectLiteralExprAst } from "./declarations-43E1JFHg-DGBa0YH_.mjs";
+import { S as TaggedLiteralExprAst, _ 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 TypesBlockAst, x as StringLiteralExprAst, y as ObjectLiteralExprAst } from "./declarations-BrSntcPa-Bm0uutX8.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-D_lZ54qh-DqOQkoMT.mjs";
 //#region ../../../1-framework/2-authoring/psl-parser/dist/index.mjs
 function getPositionalArgument(attribute, index = 0) {
@@ -104,9 +103,6 @@ function describeResolution(resolution) {
 		default: return resolution.kind;
 	}
 }
-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`;
 	return {
@@ -116,8 +112,8 @@ 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 resolution = ctx.binder.symbolForNode(arg.syntax) ?? unbound(name);
-			if (resolution.kind === "unresolved") return notOk([]);
+			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);
@@ -130,7 +126,7 @@ function parseFieldName(arg, ctx) {
 	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) 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 === void 0) return notOk([]);
 	if (resolution.kind === "field") return ok(resolution.symbol.name);
 	if (resolution.kind === "crossSpace") return ok(name);
 	return notOk([]);
@@ -139,14 +135,14 @@ function fieldRef() {
 	return {
 		kind: "fieldRef",
 		label: "field name",
-		parse: (arg, ctx) => parseFieldName(arg, ctx)
+		parse: parseFieldName
 	};
 }
 function referencedFieldRef() {
 	return {
 		kind: "referencedFieldRef",
 		label: "field name",
-		parse: (arg, ctx) => parseFieldName(arg, ctx)
+		parse: parseFieldName
 	};
 }
 function interpretArgs(args, spec, ctx, span, sourceNode) {
@@ -365,46 +361,6 @@ function list(of, opts) {
 		}
 	};
 }
-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")]);
-		}
-	};
-	return {
-		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}`)]);
-		}
-	};
-}
-/** 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 oneOf(...alts) {
 	const label = alts.map((alt) => alt.label).join(" | ");
 	return {
@@ -491,6 +447,80 @@ function str(value) {
 		}
 	};
 }
+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;
+}
+function finiteNumber() {
+	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);
+		}
+	};
+}
+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")]);
+		}
+	};
+}
+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")]);
+		}
+	};
+	return {
+		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}`)]);
+		}
+	};
+}
+/** 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")]);
+		}
+	};
+}
 /**
 * A `` tag`...` ``, `tag"..."`, or `tag'...'` argument. `tags` and `documentation` describe the
 * registered tags for tooling; parsing accepts any tag.
@@ -545,6 +575,9 @@ function optional(type, ...rest) {
 		defaultValue: rest[0]
 	};
 }
+function blockSpecFactoryOf(descriptor) {
+	return blindCast(descriptor.spec);
+}
 const scopes = /* @__PURE__ */ new WeakMap();
 function contributedTypeScope(typeConstructors) {
 	const existing = scopes.get(typeConstructors);
@@ -574,6 +607,18 @@ function collect(namespace, prefix) {
 	}
 	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;
+			continue;
+		}
+		const nested = findBlockDescriptor(value, keyword);
+		if (nested !== void 0) return nested;
+	}
+}
 function contributedResolution(member) {
 	return member.kind === "contributedType" ? {
 		kind: "contributedType",
@@ -728,10 +773,12 @@ function walkEntities(symbolTable, stack, visit) {
 }
 function createBinder(options) {
 	const { sources, symbolTable, typeConstructors, attributeSpecs, controlMutationDefaults, describeUnsupportedAttribute } = options;
+	const pslBlockDescriptors = options.pslBlockDescriptors ?? {};
 	const stack = new ScopeStack(documentScope(symbolTable.topLevel, contributedScope(contributedTypeScope(typeConstructors))));
 	const declarations = /* @__PURE__ */ new WeakMap();
 	const references = /* @__PURE__ */ new WeakMap();
 	const diagnostics = [];
+	const binder = new PslBinder(declarations, references);
 	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)) {
@@ -785,11 +832,208 @@ function createBinder(options) {
 			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(namespaceScope(namespace, stack.current()));
+		bindBlocks(namespace.blocks);
+		stack.pop();
+	}
 	return {
-		binder: new PslBinder(declarations, references),
+		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
+		};
+	}
+}
+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 bindAttributes(holder, attributes, specs, instantiate, ctx) {
 	const declared = holder.node.attributes();
 	const nodes = Array.from(declared);
@@ -818,30 +1062,20 @@ function bindAttributes(holder, attributes, specs, instantiate, ctx) {
 				spec
 			}
 		});
-		bindArguments(attribute, spec, ctx);
+		bindArguments(attribute, spec, ctx, ctx);
 	});
 }
-function bindArguments(attribute, spec, ctx) {
+function bindArguments(attribute, spec, ctx, modelContext) {
 	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);
-		}
+		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 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 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];
@@ -897,23 +1131,6 @@ function report(message, node, ctx, 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" } };
@@ -971,240 +1188,248 @@ function describeQualifier(resolution) {
 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)) {
-		if (value === void 0) continue;
-		if (isAuthoringPslBlockDescriptor(value)) {
-			if (value.keyword === keyword) return value;
+function structBlock(config) {
+	return {
+		mode: "struct",
+		parameters: config.parameters
+	};
+}
+function mapBlock(config) {
+	return {
+		mode: "map",
+		value: config.value,
+		allowBare: config.allowBare ?? false
+	};
+}
+function interpretExtensionBlock(input) {
+	const { block, descriptor, spec, symbols, sources, binder } = input;
+	const ctx = {
+		sources,
+		symbols,
+		binder
+	};
+	const entries = spec.mode === "struct" ? interpretStructBlock(block, spec, ctx) : interpretMapBlock(block, spec, ctx);
+	const diagnostics = [...entries.diagnostics];
+	const interpretedAttributes = interpretExtensionBlockAttributes({
+		block,
+		descriptor,
+		symbols,
+		sources,
+		binder
+	});
+	diagnostics.push(...interpretedAttributes.diagnostics);
+	if (entries.failed || diagnostics.length > 0) return notOk(diagnostics);
+	return ok({
+		kind: descriptor.discriminator,
+		keyword: block.keyword,
+		name: block.name,
+		values: blindCast(entries.values),
+		parameterSpans: entries.parameterSpans,
+		attributes: interpretedAttributes.attributes,
+		span: block.span
+	});
+}
+function interpretStructBlock(block, spec, ctx) {
+	const diagnostics = [];
+	let failed = false;
+	const values = Object.create(null);
+	const parameterSpans = Object.create(null);
+	const seen = /* @__PURE__ */ new Set();
+	for (const entry of block.node.entries()) {
+		const key = entry.key()?.name();
+		if (key === void 0) continue;
+		const span = nodePslSpan(entry.syntax, ctx.sources);
+		if (seen.has(key)) {
+			diagnostics.push(duplicateParameterDiagnostic(block, key, ctx, entry, span));
 			continue;
 		}
-		const nested = findBlockDescriptor(value, keyword);
-		if (nested !== void 0) return nested;
+		seen.add(key);
+		const rule = Object.hasOwn(spec.parameters, key) ? spec.parameters[key]?.type : void 0;
+		if (rule === void 0) {
+			diagnostics.push(entryDiagnostic("PSL_EXTENSION_UNKNOWN_PARAMETER", `Unknown parameter "${key}" in "${block.keyword}" block "${block.name}". The block does not declare this parameter.`, ctx, entry, span));
+			continue;
+		}
+		parameterSpans[key] = span;
+		const value = entry.value();
+		if (value === void 0) {
+			diagnostics.push(bareEntryDiagnostic(block, key, ctx, entry, span));
+			continue;
+		}
+		const parsed = rule.parse(value, ctx);
+		if (parsed.ok) values[key] = parsed.value;
+		else {
+			failed = true;
+			diagnostics.push(...parsed.failure);
+		}
 	}
-}
-function validateExtensionBlockFromSymbol(input) {
-	const refCtx = buildRefResolutionContext(input.symbolTable, input.block);
-	return validateExtensionBlock(input.block.block, input.descriptor, input.sources.sourceFileFor(input.block.node.syntax).filename, input.codecLookup, refCtx).map((diagnostic) => diagnosticFromSpan(diagnostic, diagnosticSource(input.sources, input.block.node.syntax)));
-}
-const ZERO_SPAN = {
-	start: {
-		offset: 0,
-		line: 1,
-		column: 1
-	},
-	end: {
-		offset: 0,
-		line: 1,
-		column: 1
+	for (const [key, param] of Object.entries(spec.parameters)) {
+		if (seen.has(key)) continue;
+		if (isOptionalArgType(param.type)) {
+			if (param.type.hasDefault) values[key] = param.type.defaultValue;
+			continue;
+		}
+		diagnostics.push(entryDiagnostic("PSL_EXTENSION_MISSING_REQUIRED_PARAMETER", `Required parameter "${key}" is missing from "${block.keyword}" block "${block.name}".`, ctx, block.node, block.span));
 	}
-};
-function buildRefResolutionContext(symbolTable, block) {
-	const unspecifiedNamespace = makeNamespace(UNSPECIFIED_PSL_NAMESPACE_ID, Object.values(symbolTable.topLevel.models));
-	const allNamespaces = [unspecifiedNamespace, ...Object.values(symbolTable.topLevel.namespaces).map((namespace) => makeNamespace(namespace.name, Object.values(namespace.models)))];
-	const ownerNamespaceName = findOwnerNamespaceName(symbolTable, block);
 	return {
-		ownerNamespace: allNamespaces.find((namespace) => namespace.name === ownerNamespaceName) ?? unspecifiedNamespace,
-		allNamespaces
+		values,
+		parameterSpans,
+		diagnostics,
+		failed
 	};
 }
-function makeNamespace(name, models) {
-	return makePslNamespace({
-		kind: "namespace",
-		name,
-		entries: makePslNamespaceEntries(models.map((model) => ({
-			kind: "model",
-			name: model.name,
-			fields: [],
-			attributes: [],
-			span: ZERO_SPAN
-		})), [], []),
-		span: ZERO_SPAN
-	});
-}
-function findOwnerNamespaceName(symbolTable, block) {
-	for (const namespace of Object.values(symbolTable.topLevel.namespaces)) if (Object.values(namespace.blocks).some((candidate) => candidate === block)) return namespace.name;
-	return UNSPECIFIED_PSL_NAMESPACE_ID;
+function interpretMapBlock(block, spec, ctx) {
+	const diagnostics = [];
+	let failed = false;
+	const values = Object.create(null);
+	const parameterSpans = Object.create(null);
+	const seen = /* @__PURE__ */ new Set();
+	for (const entry of block.node.entries()) {
+		const key = entry.key()?.name();
+		if (key === void 0) continue;
+		const span = nodePslSpan(entry.syntax, ctx.sources);
+		if (seen.has(key)) {
+			diagnostics.push(duplicateParameterDiagnostic(block, key, ctx, entry, span));
+			continue;
+		}
+		seen.add(key);
+		parameterSpans[key] = span;
+		const value = entry.value();
+		if (value === void 0) {
+			if (spec.allowBare) {
+				values[key] = void 0;
+				continue;
+			}
+			diagnostics.push(bareEntryDiagnostic(block, key, ctx, entry, span));
+			continue;
+		}
+		const parsed = spec.value.type.parse(value, ctx);
+		if (parsed.ok) values[key] = parsed.value;
+		else {
+			failed = true;
+			diagnostics.push(...parsed.failure);
+		}
+	}
+	return {
+		values,
+		parameterSpans,
+		diagnostics,
+		failed
+	};
 }
-/**
-* A name that is lost when a PSL file is read. The parser keeps block members, and the PSL contract sources keep other names, as keys of plain objects, where assigning this key sets the object's prototype instead of adding a key. Code that writes PSL must not write this name anywhere a PSL source reads a name, including inside `@map` and `@@map`.
-*/
-const NAME_THE_PSL_SOURCE_LOSES = "__proto__";
-const DIRECTIVE = /^(\s*\/\/ *use +)(prisma-8|prisma-next)( *)(?!\S)/;
-const LEGACY_NAME = "prisma-next";
-function isPrismaNextSchema(text) {
-	return DIRECTIVE.test(text);
+function duplicateParameterDiagnostic(block, key, ctx, node, span) {
+	return entryDiagnostic("PSL_EXTENSION_DUPLICATE_PARAMETER", `Duplicate parameter "${key}" in "${block.keyword}" block "${block.name}"; first occurrence wins`, ctx, node, span);
 }
-/** The document with the directive earlier releases wrote replaced by the current one. */
-function renameLegacyDirective(text) {
-	return text.replace(DIRECTIVE, (whole, lead, name, trail) => name === LEGACY_NAME ? `${lead}prisma-8${trail}` : whole);
+function bareEntryDiagnostic(block, key, ctx, node, span) {
+	return entryDiagnostic("PSL_INVALID_EXTENSION_BLOCK_MEMBER", `Parameter "${key}" in "${block.keyword}" block "${block.name}" must be written as "${key} = <value>".`, ctx, node, span);
 }
-/**
-* Descriptor-free and unknown parameters become `value` stubs so validation can
-* report them via key-set comparison. Duplicate member names are first-wins.
-*/
-function reconstructExtensionBlock(node, descriptor, sources, diagnostics) {
-	const sourceFile = sources.sourceFileFor(node.syntax);
-	const keyword = node.keyword()?.text ?? "";
-	const blockName = node.name()?.name() ?? "";
-	const blockAttributes = [];
-	for (const attribute of node.attributes()) {
+function interpretExtensionBlockAttributes(input) {
+	const { block, descriptor, symbols, sources, binder } = input;
+	const declared = descriptor.attributes ?? {};
+	const attributes = Object.create(null);
+	const diagnostics = [];
+	const seenNames = /* @__PURE__ */ new Set();
+	for (const attribute of block.node.attributes()) {
 		const name = attribute.name()?.path().join(".") ?? "";
-		const args = Array.from(attribute.argList()?.args() ?? [], (arg) => {
-			const value = arg.value();
-			return {
-				kind: "positional",
-				value: value === void 0 ? "" : printSyntax(value.syntax).trim(),
-				span: nodePslSpan(arg.syntax, sources)
-			};
-		});
 		const span = nodePslSpan(attribute.syntax, sources);
-		blockAttributes.push({
-			name,
-			args,
-			span
-		});
-	}
-	const parameters = {};
-	for (const entry of node.entries()) {
-		const key = entry.key()?.name();
-		if (key === void 0) continue;
-		const span = nodePslSpan(entry.syntax, sources);
-		if (Object.hasOwn(parameters, key)) {
+		if (!Object.hasOwn(declared, name)) {
 			diagnostics.push({
-				filename: sourceFile.filename,
-				code: "PSL_EXTENSION_DUPLICATE_PARAMETER",
-				message: `Duplicate parameter "${key}" in "${keyword}" block "${blockName}"; first occurrence wins`,
-				range: {
-					start: sourceFile.positionAt(entry.syntax.offset),
-					end: sourceFile.positionAt(entry.syntax.offset + entry.syntax.green.textLength)
-				}
+				code: "PSL_EXTENSION_UNKNOWN_BLOCK_ATTRIBUTE",
+				message: `Unknown attribute "@@${name}" in "${block.keyword}" block "${block.name}"`,
+				...diagnosticSource(sources, attribute.syntax).at(span)
+			});
+			continue;
+		}
+		if (seenNames.has(name)) {
+			diagnostics.push({
+				code: "PSL_INVALID_EXTENSION_BLOCK_ATTRIBUTE",
+				message: `Duplicate attribute "@@${name}" in "${block.keyword}" block "${block.name}"; first occurrence wins`,
+				...diagnosticSource(sources, attribute.syntax).at(span)
 			});
 			continue;
 		}
-		parameters[key] = reconstructParamValue(entry, descriptor?.parameters[key], span, sources, diagnostics);
+		seenNames.add(name);
+		const spec = blindCast(declared[name])({
+			symbols,
+			block
+		});
+		const result = interpretAttribute(attribute, spec, {
+			sources,
+			symbols,
+			binder
+		});
+		if (result.ok) {
+			const argSpans = Object.create(null);
+			let positionalSlot = 0;
+			for (const arg of readResolvedAttribute(attribute, sources).args) {
+				const key = arg.name ?? spec.positional[positionalSlot++]?.key;
+				if (key !== void 0) argSpans[key] = arg.span;
+			}
+			attributes[name] = {
+				args: result.value,
+				argSpans,
+				span
+			};
+		} else diagnostics.push(...result.failure);
 	}
 	return {
-		kind: descriptor?.discriminator ?? keyword,
-		keyword,
-		name: blockName,
-		parameters,
-		blockAttributes,
-		attributes: {},
-		span: nodePslSpan(node.syntax, sources)
+		attributes,
+		diagnostics
 	};
 }
-function interpretBlockAttributes(symbol, descriptor, sources, symbols, diagnostics) {
-	const seenNames = /* @__PURE__ */ new Set();
-	for (const attribute of symbol.node.attributes()) {
-		const name = attribute.name()?.path().join(".") ?? "";
-		const parsed = parseBlockAttribute(attribute, name, nodePslSpan(attribute.syntax, sources), descriptor, seenNames, symbol.keyword, symbol.name, sources, symbols);
-		if (parsed.ok) Object.assign(symbol.block.attributes, { [name]: parsed.value });
-		else diagnostics.push(...parsed.diagnostics);
-	}
-}
-function parseBlockAttribute(attribute, name, span, descriptor, seenNames, keyword, blockName, sources, symbols) {
-	const sourceFile = sources.sourceFileFor(attribute.syntax);
-	const range = sourceFile.pslSpanToRange(span);
-	const declared = descriptor.attributes ?? {};
-	if (!Object.hasOwn(declared, name)) return {
-		ok: false,
-		diagnostics: [{
-			filename: sourceFile.filename,
-			code: "PSL_EXTENSION_UNKNOWN_BLOCK_ATTRIBUTE",
-			message: `Unknown attribute "@@${name}" in "${keyword}" block "${blockName}"`,
-			range
-		}]
-	};
-	if (seenNames.has(name)) return {
-		ok: false,
-		diagnostics: [{
-			filename: sourceFile.filename,
-			code: "PSL_INVALID_EXTENSION_BLOCK_ATTRIBUTE",
-			message: `Duplicate attribute "@@${name}" in "${keyword}" block "${blockName}"; first occurrence wins`,
-			range
-		}]
-	};
-	seenNames.add(name);
-	const result = interpretAttribute(attribute, blindCast(declared[name])(), {
-		sources,
-		symbols
-	});
-	if (!result.ok) return {
-		ok: false,
-		diagnostics: result.failure
-	};
+function entryDiagnostic(code, message, ctx, node, span) {
 	return {
-		ok: true,
-		value: {
-			args: result.value,
-			span
-		}
+		code,
+		message,
+		...diagnosticSource(ctx.sources, node.syntax).at(span)
 	};
 }
-function reconstructParamValue(entry, param, span, sources, diagnostics) {
-	const value = entry.value();
-	if (value === void 0) return {
-		kind: "bare",
-		span
-	};
-	return reconstructFromExpression(value, param, span, sources, diagnostics);
-}
-function reconstructFromExpression(value, param, span, sources, diagnostics) {
-	const raw = printSyntax(value.syntax).trim();
-	if (param?.kind === "list") {
-		const sourceFile = sources.sourceFileFor(value.syntax);
-		const array = ArrayLiteralAst.cast(value.syntax);
-		if (!array) {
-			diagnostics?.push({
-				filename: sourceFile.filename,
-				code: "PSL_EXTENSION_INVALID_VALUE",
-				message: `List parameter expects an array literal, got ${raw}`,
-				range: {
-					start: sourceFile.positionAt(value.syntax.offset),
-					end: sourceFile.positionAt(value.syntax.offset + value.syntax.green.textLength)
-				}
-			});
-			return {
-				kind: "value",
-				raw,
-				span
-			};
-		}
-		const items = [];
-		for (const element of array.elements()) items.push(reconstructFromExpression(element, param.of, nodePslSpan(element.syntax, sources), sources, diagnostics));
-		return {
-			kind: "list",
-			items,
-			span
-		};
-	}
-	switch (param?.kind) {
-		case "ref": return {
-			kind: "ref",
-			identifier: raw,
-			span
-		};
-		case "option": return {
-			kind: "option",
-			token: raw,
-			span
-		};
-		default: return {
-			kind: "value",
-			raw,
-			span
-		};
+function interpretExtensionBlocks(input) {
+	const { symbolTable, sources, pslBlockDescriptors, binder } = input;
+	const parsedBlocks = /* @__PURE__ */ new Map();
+	const diagnostics = [];
+	const scopes = [symbolTable.topLevel, ...Object.values(symbolTable.topLevel.namespaces)];
+	for (const scope of scopes) for (const block of Object.values(scope.blocks)) {
+		const descriptor = findBlockDescriptor(pslBlockDescriptors, block.keyword);
+		if (descriptor === void 0) continue;
+		const parsed = interpretExtensionBlock({
+			block,
+			descriptor,
+			spec: blockSpecFactoryOf(descriptor)({
+				symbols: symbolTable,
+				block
+			}),
+			symbols: symbolTable,
+			sources,
+			binder
+		});
+		if (parsed.ok) parsedBlocks.set(block, parsed.value);
+		else diagnostics.push(...parsed.failure);
 	}
+	return {
+		parsedBlocks,
+		diagnostics
+	};
+}
+/**
+* A name that is lost when a PSL file is read. The parser keeps block members, and the PSL contract sources keep other names, as keys of plain objects, where assigning this key sets the object's prototype instead of adding a key. Code that writes PSL must not write this name anywhere a PSL source reads a name, including inside `@map` and `@@map`.
+*/
+const NAME_THE_PSL_SOURCE_LOSES = "__proto__";
+const DIRECTIVE = /^(\s*\/\/ *use +)(prisma-8|prisma-next)( *)(?!\S)/;
+const LEGACY_NAME = "prisma-next";
+function isPrismaNextSchema(text) {
+	return DIRECTIVE.test(text);
+}
+/** The document with the directive earlier releases wrote replaced by the current one. */
+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, pslBlockDescriptors } = options;
+	const { documents, sources } = options;
 	const diagnostics = [];
-	const collectedBlocks = [];
 	const namespaces = Object.create(null);
 	const namedTypes = Object.create(null);
 	const blocks = Object.create(null);
@@ -1237,7 +1462,7 @@ function buildSymbolTable(options) {
 			if (name !== void 0) compositeTypes[name] = buildCompositeType(name, declaration, sources, diagnostics);
 		} else if (declaration instanceof GenericBlockDeclarationAst) {
 			const name = claim(topLevelNames, declaration.name());
-			if (name !== void 0) blocks[name] = buildBlock(name, declaration, sources, pslBlockDescriptors, diagnostics, collectedBlocks);
+			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;
@@ -1255,7 +1480,7 @@ function buildSymbolTable(options) {
 				};
 				namespaces[name] = namespace;
 			}
-			extendNamespace(namespace, declaration, diagnostics, sources, pslBlockDescriptors, collectedBlocks);
+			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;
@@ -1269,19 +1494,14 @@ function buildSymbolTable(options) {
 			};
 		}
 	}
-	const symbolTable = { topLevel: {
-		namespaces,
-		namedTypes,
-		blocks,
-		models,
-		compositeTypes
-	} };
-	for (const block of collectedBlocks) {
-		const descriptor = findBlockDescriptor(pslBlockDescriptors, block.keyword);
-		if (descriptor !== void 0) interpretBlockAttributes(block, descriptor, sources, symbolTable, diagnostics);
-	}
 	return {
-		symbolTable,
+		symbolTable: { topLevel: {
+			namespaces,
+			namedTypes,
+			blocks,
+			models,
+			compositeTypes
+		} },
 		diagnostics
 	};
 }
@@ -1305,21 +1525,16 @@ function buildCompositeType(name, node, sources, diagnostics) {
 		attributes: readResolvedAttributes(node.attributes(), sources)
 	};
 }
-function buildBlock(name, node, sources, pslBlockDescriptors, diagnostics, collectedBlocks) {
-	const keyword = node.keyword()?.text ?? "";
-	const descriptor = findBlockDescriptor(pslBlockDescriptors, keyword);
-	const symbol = {
+function buildBlock(name, node, sources) {
+	return {
 		kind: "block",
 		name,
-		keyword,
+		keyword: node.keyword()?.text ?? "",
 		node,
-		span: nodePslSpan(node.syntax, sources),
-		block: reconstructExtensionBlock(node, descriptor, sources, diagnostics)
+		span: nodePslSpan(node.syntax, sources)
 	};
-	collectedBlocks.push(symbol);
-	return symbol;
 }
-function extendNamespace(namespace, node, diagnostics, sources, pslBlockDescriptors, collectedBlocks) {
+function extendNamespace(namespace, node, diagnostics, sources) {
 	const { models, compositeTypes, blocks } = namespace;
 	namespace.declarations.push({
 		node,
@@ -1340,7 +1555,7 @@ function extendNamespace(namespace, node, diagnostics, sources, pslBlockDescript
 		}
 		if (member instanceof ModelDeclarationAst) models[memberName] = buildModel(memberName, member, sources, diagnostics);
 		else if (member instanceof CompositeTypeDeclarationAst) compositeTypes[memberName] = buildCompositeType(memberName, member, sources, diagnostics);
-		else if (member instanceof GenericBlockDeclarationAst) blocks[memberName] = buildBlock(memberName, member, sources, pslBlockDescriptors, diagnostics, collectedBlocks);
+		else if (member instanceof GenericBlockDeclarationAst) blocks[memberName] = buildBlock(memberName, member, sources);
 	}
 }
 function buildFields(ownerName, fields, sources, diagnostics) {
@@ -1435,6 +1650,6 @@ function nodeRange(node, sources) {
 	};
 }
 //#endregion
-export { NAME_THE_PSL_SOURCE_LOSES, PSL_UNRESOLVED_REFERENCE, assembleAttributeSpecs, blockAttribute, bool, buildSymbolTable, createBinder, createPslDiagnosticCollector, diagnosticFromSpan, diagnosticSource, entityRef, fieldAttribute, fieldRef, findBlockDescriptor, flatPslModels, funcCall, getPositionalArgument, identifier, int, interpretArgs, interpretAttribute, isPrismaNextSchema, isPslIdentifier, json, keywordPslSpan, leafDiagnostic, list, mapPslDiagnostics, modelAttribute, namespacePslExtensionBlocks, nodePslSpan, num, numLiteral, oneOf, optional, parseQuotedStringLiteral, readResolvedAttribute, readResolvedAttributes, readResolvedConstructorCall, record, referencedFieldRef, renameLegacyDirective, str, taggedLiteral, validateExtensionBlockFromSymbol };
+export { NAME_THE_PSL_SOURCE_LOSES, PSL_UNRESOLVED_REFERENCE, assembleAttributeSpecs, blockAttribute, blockSpecFactoryOf, bool, buildSymbolTable, createBinder, createPslDiagnosticCollector, diagnosticFromSpan, diagnosticSource, entityRef, fieldAttribute, fieldRef, findBlockDescriptor, flatPslModels, funcCall, getPositionalArgument, identifier, int, interpretArgs, interpretAttribute, interpretExtensionBlock, interpretExtensionBlockAttributes, interpretExtensionBlocks, isPrismaNextSchema, isPslIdentifier, json, jsonValue, keywordPslSpan, leafDiagnostic, list, mapBlock, mapPslDiagnostics, modelAttribute, namespacePslExtensionBlocks, nodePslSpan, num, numLiteral, oneOf, optional, parseQuotedStringLiteral, readResolvedAttribute, readResolvedAttributes, readResolvedConstructorCall, record, referencedFieldRef, renameLegacyDirective, str, structBlock, taggedLiteral };
 
 //# sourceMappingURL=psl-parser.mjs.map