@prisma/orm-toolchain 8.0.0-rc.11-dev.19 → 8.0.0-rc.11-dev.21

package/dist/{exports-DGC_nDQ0.mjs → exports-HR2MWHrQ.mjs}

@@ -7,9 +7,9 @@ import { join } from "pathe";
 import { normalize as normalize$1 } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { format } from "@prisma/orm-framework/psl-parser/format";
-import { CompletionItemKind, ConnectionError, ConnectionErrors, DiagnosticSeverity, DidChangeWatchedFilesNotification, DocumentDiagnosticReportKind, FoldingRangeKind, InsertTextFormat, LSPErrorCodes, ProposedFeatures, RegistrationRequest, ResponseError, SemanticTokenModifiers, SemanticTokenTypes, TextDocumentSyncKind, TextDocuments, createConnection } from "vscode-languageserver";
+import { CompletionItemKind, ConnectionError, ConnectionErrors, DiagnosticSeverity, DidChangeWatchedFilesNotification, DocumentDiagnosticReportKind, FoldingRangeKind, InsertTextFormat, LSPErrorCodes, MarkupKind, ProposedFeatures, RegistrationRequest, ResponseError, SemanticTokenModifiers, SemanticTokenTypes, TextDocumentSyncKind, TextDocuments, createConnection } from "vscode-languageserver";
 import { TextDocument } from "vscode-languageserver-textdocument";
-import { ArrayLiteralAst, AttributeArgListAst, BooleanLiteralExprAst, CompositeTypeDeclarationAst, FieldAttributeAst, FieldDeclarationAst, FunctionCallAst, GenericBlockDeclarationAst, IdentifierAst, KeyValuePairAst, ModelAttributeAst, ModelDeclarationAst, NamespaceDeclarationAst, NumberLiteralExprAst, ObjectLiteralExprAst, StringLiteralExprAst, TypesBlockAst, any, filterChildren, findChildToken, isTrivia, parse, skipTriviaToken } from "@prisma/orm-framework/psl-parser/syntax";
+import { ArrayLiteralAst, AttributeArgAst, AttributeArgListAst, BooleanLiteralExprAst, CompositeTypeDeclarationAst, FieldAttributeAst, FieldDeclarationAst, FunctionCallAst, GenericBlockDeclarationAst, IdentifierAst, KeyValuePairAst, ModelAttributeAst, ModelDeclarationAst, NamespaceDeclarationAst, NumberLiteralExprAst, ObjectLiteralExprAst, StringLiteralExprAst, SyntaxNode, TypesBlockAst, any, filterChildren, findChildToken, isTrivia, nonTriviaSibling, parse, skipTriviaToken } from "@prisma/orm-framework/psl-parser/syntax";
 import { isAuthoringPslBlockDescriptor } from "@prisma/orm-framework/components/authoring";
 import { assembleAttributeSpecs, buildSymbolTable, findBlockDescriptor } from "@prisma/orm-framework/psl-parser";
 import { hasPslInterpreter } from "@prisma/orm-framework/psl-parser/interpret";
@@ -56,6 +56,77 @@ function pslSpanToRange(span, sourceFile) {
 		end: sourceFile.positionAt(span.end.offset)
 	};
 }
+function locateAttributeSyntax(input) {
+	const offset = input.sourceFile.offsetAt(input.position);
+	const at = input.document.syntax.tokenAtOffset(offset);
+	if (at.leftBiased()?.kind === "Comment") return void 0;
+	const token = at.leftBiased() ?? at.rightBiased();
+	const attribute = token === void 0 ? void 0 : skipTriviaToken(token, "prev")?.parent.findAncestor(any(FieldAttributeAst.cast, ModelAttributeAst.cast));
+	if (attribute === void 0 || !isWithinAttributeOrOpenArguments(attribute, offset)) return void 0;
+	return {
+		attribute,
+		...attributeCursor(attribute, offset)
+	};
+}
+function isWithinAttributeOrOpenArguments(attribute, offset) {
+	if (attribute.syntax.isInside(offset)) return true;
+	const args = attribute.argList();
+	return args !== void 0 && args.rparen() === void 0 && offset >= args.syntax.endOffset;
+}
+function attributeCursor(attribute, offset) {
+	const anchor = attribute.syntax.tokenAtOffset(offset).leftBiased() ?? attribute.syntax.lastToken;
+	return {
+		offset,
+		preceding: anchor === void 0 ? void 0 : skipTriviaToken(anchor, "prev")
+	};
+}
+function argumentSiblings(node, selected, offset) {
+	let precedingPositionalCount = 0;
+	const otherNamedKeys = [];
+	let beforeSelected = true;
+	for (const arg of node.args()) {
+		if (arg.syntax.offset === selected?.syntax.offset) {
+			beforeSelected = false;
+			continue;
+		}
+		const name = arg.name()?.name();
+		if (name !== void 0) otherNamedKeys.push(name);
+		else if (beforeSelected && arg.syntax.offset <= offset) precedingPositionalCount += 1;
+	}
+	return {
+		precedingPositionalCount,
+		otherNamedKeys
+	};
+}
+function argumentAtCursor(cursor, node) {
+	for (const arg of node.args()) if (arg.syntax.offset <= cursor.offset && (containsCursor(arg.syntax, cursor) || recoveredContainerContainsCursor(arg.value(), cursor.offset))) return arg;
+}
+function listElementAtCursor(cursor, node) {
+	for (const element of node.elements()) if (containsCursor(element.syntax, cursor) || recoveredContainerContainsCursor(element, cursor.offset)) return element;
+}
+function recordFieldAtCursor(cursor, node) {
+	for (const field of node.fields()) {
+		const colon = field.colon();
+		if (colon !== void 0 && cursor.offset > colon.offset && (containsCursor(field.syntax, cursor) || recoveredContainerContainsCursor(field.value(), cursor.offset))) return field;
+	}
+}
+function betweenDelimiters(offset, opening, closing) {
+	return opening !== void 0 && offset > opening.offset && (closing === void 0 || offset < closing.endOffset);
+}
+function recoveredContainerContainsCursor(expression, offset) {
+	if (expression === void 0 || expression.syntax.endOffset > offset) return false;
+	if (!(expression instanceof ArrayLiteralAst ? expression.rbracket() === void 0 : expression instanceof ObjectLiteralExprAst ? expression.rbrace() === void 0 : expression instanceof FunctionCallAst && expression.rparen() === void 0)) return false;
+	for (let token = expression.syntax.lastToken?.nextToken; token !== void 0; token = token.nextToken) {
+		if (token.offset >= offset) return true;
+		if (!isTrivia(token) && token.kind !== "Comma") return false;
+	}
+	return true;
+}
+function containsCursor(node, cursor) {
+	if (node.isInside(cursor.offset)) return true;
+	const preceding = cursor.preceding;
+	return preceding !== void 0 && preceding.endOffset <= cursor.offset && preceding.offset >= node.offset && preceding.offset < node.endOffset;
+}
 const UNSUPPORTED = { kind: "unsupported" };
 function classifyPslCompletionContext(input) {
 	const root = input.document.syntax;
@@ -205,34 +276,35 @@ function blockBodyContainsOffset(block, offset) {
 }
 function classifyFieldAttribute(input) {
 	const attribute = input.node?.findAncestor(FieldAttributeAst.cast);
-	if (attribute === void 0 || !attributeContainsOffset(attribute, input.offset)) return;
+	if (attribute === void 0 || !isWithinAttributeOrOpenArguments(attribute, input.offset)) return;
 	const field = attribute.syntax.findAncestor(FieldDeclarationAst.cast);
 	const model = attribute.syntax.findAncestor(ModelDeclarationAst.cast);
 	if (field === void 0 || model === void 0) return UNSUPPORTED;
+	const owner = {
+		ownerKind: "field",
+		field,
+		model
+	};
 	return classifyAttributePosition(attribute, input, {
 		name: (position) => ({
 			kind: "fieldAttributeName",
 			...position,
-			field,
-			model
+			...owner
 		}),
 		namedKey: (position) => ({
 			kind: "fieldAttributeNamedKey",
 			...position,
-			field,
-			model
+			...owner
 		}),
 		argumentSlot: (position) => ({
 			kind: "fieldAttributeArgumentSlot",
 			...position,
-			field,
-			model
+			...owner
 		}),
 		value: (position) => ({
 			kind: "fieldAttributeValue",
 			...position,
-			field,
-			model
+			...owner
 		})
 	});
 }
@@ -242,30 +314,31 @@ function classifyGenericBlockAttribute(input) {
 	if (attribute === void 0 || block === void 0) return;
 	const blockKeyword = block.keyword()?.text;
 	if (blockKeyword === void 0 || blockKeyword.length === 0) return UNSUPPORTED;
+	const owner = {
+		ownerKind: "block",
+		block,
+		blockKeyword
+	};
 	return classifyAttributePosition(attribute, input, {
 		name: (position) => ({
 			kind: "blockAttributeName",
 			...position,
-			block,
-			blockKeyword
+			...owner
 		}),
 		namedKey: (position) => ({
 			kind: "blockAttributeNamedKey",
 			...position,
-			block,
-			blockKeyword
+			...owner
 		}),
 		argumentSlot: (position) => ({
 			kind: "blockAttributeArgumentSlot",
 			...position,
-			block,
-			blockKeyword
+			...owner
 		}),
 		value: (position) => ({
 			kind: "blockAttributeValue",
 			...position,
-			block,
-			blockKeyword
+			...owner
 		})
 	});
 }
@@ -274,75 +347,62 @@ function classifyModelAttribute(input) {
 	if (attribute === void 0) return;
 	const model = attribute.syntax.findAncestor(ModelDeclarationAst.cast);
 	if (model === void 0) return;
+	const owner = {
+		ownerKind: "model",
+		model
+	};
 	return classifyAttributePosition(attribute, input, {
 		name: (position) => ({
 			kind: "modelAttributeName",
 			...position,
-			model
+			...owner
 		}),
 		namedKey: (position) => ({
 			kind: "modelAttributeNamedKey",
 			...position,
-			model
+			...owner
 		}),
 		argumentSlot: (position) => ({
 			kind: "modelAttributeArgumentSlot",
 			...position,
-			model
+			...owner
 		}),
 		value: (position) => ({
 			kind: "modelAttributeValue",
 			...position,
-			model
+			...owner
 		})
 	});
 }
 function activeModelAttribute(input) {
 	const attribute = input.node?.findAncestor(ModelAttributeAst.cast);
-	if (attribute === void 0 || !attributeContainsOffset(attribute, input.offset)) return;
+	if (attribute === void 0 || !isWithinAttributeOrOpenArguments(attribute, input.offset)) return;
 	return attribute;
 }
 function attributeAnchor(at) {
 	const token = at.leftBiased() ?? at.rightBiased();
 	return token === void 0 ? void 0 : skipTriviaToken(token, "prev")?.parent;
 }
-function attributeContainsOffset(attribute, offset) {
-	if (attribute.syntax.isInside(offset)) return true;
-	const args = attribute.argList();
-	return args !== void 0 && args.rparen() === void 0 && offset >= args.syntax.endOffset;
-}
-function isAttributeNamePosition(attribute, offset) {
-	const argList = attribute.argList();
-	return argList === void 0 || offset < argList.syntax.offset;
-}
-function attributeArgumentName(attribute, offset) {
-	const args = attribute.argList();
-	if (args === void 0 || offset < args.syntax.offset) return void 0;
-	const closing = args.rparen();
-	if (closing !== void 0 && offset >= closing.endOffset) return void 0;
-	return attribute.name()?.identifier()?.name();
-}
 function classifyAttributePosition(attribute, input, factory) {
 	const args = attribute.argList();
-	if (isAttributeNamePosition(attribute, input.offset)) return factory.name({
+	if (args === void 0 || input.offset < args.syntax.offset) return factory.name({
 		offset: input.offset,
 		replacementStartOffset: input.replacementStartOffset,
 		replacementEndOffset: attribute.name()?.syntax.endOffset ?? input.offset,
 		hasArgumentList: args !== void 0
 	});
-	const attributeName = attributeArgumentName(attribute, input.offset);
-	if (attributeName === void 0 || args === void 0) return UNSUPPORTED;
+	const attributeName = attribute.name()?.identifier()?.name();
+	if (attributeName === void 0) return UNSUPPORTED;
 	const at = attribute.syntax.tokenAtOffset(input.offset);
 	const right = at.rightBiased();
 	const token = isValueToken(right) ? right : at.leftBiased();
 	const replaceToken = isValueToken(token);
-	const anchor = at.leftBiased() ?? attribute.syntax.lastToken;
-	return classifyArguments({
+	return classifyAttributeArguments({
 		offset: input.offset,
 		replacementStartOffset: replaceToken ? token.offset : input.offset,
 		replacementEndOffset: replaceToken ? token.endOffset : input.offset,
 		attributeName,
-		preceding: anchor === void 0 ? void 0 : skipTriviaToken(anchor, "prev"),
+		preceding: attributeCursor(attribute, input.offset).preceding,
 		factory
 	}, args, []);
 }
@@ -355,22 +415,10 @@ function argumentPosition(cursor, path) {
 		path
 	};
 }
-function classifyArguments(cursor, container, path) {
-	const opening = container.lparen();
-	const closing = container.rparen();
-	if (opening === void 0 || cursor.offset <= opening.offset || closing !== void 0 && cursor.offset >= closing.endOffset) return UNSUPPORTED;
-	let positionalIndex = 0;
-	let active;
-	const existingNamedKeys = [];
-	for (const arg of container.args()) {
-		const name = arg.name()?.name();
-		const selected = arg.syntax.offset <= cursor.offset && (containsCursor(arg.syntax, cursor) || recoveredContainerContainsCursor(arg.value(), cursor.offset));
-		if (active === void 0 && selected) active = arg;
-		else {
-			if (name !== void 0) existingNamedKeys.push(name);
-			if (active === void 0 && arg.syntax.offset <= cursor.offset && name === void 0) positionalIndex += 1;
-		}
-	}
+function classifyAttributeArguments(cursor, args, path) {
+	if (!betweenDelimiters(cursor.offset, args.lparen(), args.rparen())) return UNSUPPORTED;
+	const active = argumentAtCursor(cursor, args);
+	const { precedingPositionalCount: positionalIndex, otherNamedKeys: existingNamedKeys } = argumentSiblings(args, active, cursor.offset);
 	const position = argumentPosition(cursor, path);
 	if (active === void 0) return followsSeparator(cursor, ["LParen", "Comma"]) ? cursor.factory.argumentSlot({
 		...position,
@@ -386,7 +434,7 @@ function classifyArguments(cursor, container, path) {
 			hasColon: true
 		});
 		const name = active.name()?.name();
-		return name === void 0 ? UNSUPPORTED : classifyExpression(cursor, active.value(), [...path, {
+		return name === void 0 ? UNSUPPORTED : classifyAttributeExpression(cursor, active.value(), [...path, {
 			kind: "namedArgument",
 			name
 		}]);
@@ -398,20 +446,33 @@ function classifyArguments(cursor, container, path) {
 		existingNamedKeys,
 		hasColon: false
 	});
-	return classifyExpression(cursor, value, [...path, {
+	return classifyAttributeExpression(cursor, value, [...path, {
 		kind: "positionalArgument",
 		index: positionalIndex
 	}]);
 }
-function classifyExpression(cursor, expression, path) {
-	if (expression instanceof ArrayLiteralAst) return classifyList(cursor, expression, path);
-	if (expression instanceof ObjectLiteralExprAst) return classifyRecord(cursor, expression, path);
+function classifyAttributeExpression(cursor, expression, path) {
+	if (expression === void 0) return cursor.factory.value({
+		...argumentPosition(cursor, path),
+		syntax: "scalar"
+	});
+	if (expression instanceof ArrayLiteralAst) {
+		if (!betweenDelimiters(cursor.offset, expression.lbracket(), expression.rbracket())) return UNSUPPORTED;
+		const element = listElementAtCursor(cursor, expression);
+		return element !== void 0 || followsSeparator(cursor, ["LBracket", "Comma"]) ? classifyAttributeExpression(cursor, element, [...path, { kind: "listElement" }]) : UNSUPPORTED;
+	}
+	if (expression instanceof ObjectLiteralExprAst) {
+		const closing = expression.rbrace();
+		if (closing !== void 0 && cursor.offset >= closing.endOffset) return UNSUPPORTED;
+		const field = recordFieldAtCursor(cursor, expression);
+		return field !== void 0 ? classifyAttributeExpression(cursor, field.value(), [...path, { kind: "recordValue" }]) : UNSUPPORTED;
+	}
 	if (expression instanceof FunctionCallAst) {
 		const opening = expression.lparen();
 		if (opening !== void 0 && cursor.offset > opening.offset) {
 			const name = expression.name();
 			const identifier = name?.identifier()?.name();
-			return identifier !== void 0 && name?.isSimpleName(identifier) === true ? classifyArguments(cursor, expression, [...path, {
+			return identifier !== void 0 && name?.isSimpleName(identifier) === true ? classifyAttributeArguments(cursor, expression, [...path, {
 				kind: "functionCall",
 				name: identifier
 			}]) : UNSUPPORTED;
@@ -421,45 +482,14 @@ function classifyExpression(cursor, expression, path) {
 			syntax: "functionName"
 		}) : UNSUPPORTED;
 	}
-	return expression?.syntax.isOutside(cursor.offset) === true ? UNSUPPORTED : cursor.factory.value({
+	return expression.syntax.isOutside(cursor.offset) ? UNSUPPORTED : cursor.factory.value({
 		...argumentPosition(cursor, path),
 		syntax: "scalar"
 	});
 }
-function classifyList(cursor, expression, path) {
-	const opening = expression.lbracket();
-	const closing = expression.rbracket();
-	if (opening === void 0 || cursor.offset <= opening.offset || closing !== void 0 && cursor.offset >= closing.endOffset) return UNSUPPORTED;
-	const elementPath = [...path, { kind: "listElement" }];
-	for (const element of expression.elements()) if (containsCursor(element.syntax, cursor) || recoveredContainerContainsCursor(element, cursor.offset)) return classifyExpression(cursor, element, elementPath);
-	return followsSeparator(cursor, ["LBracket", "Comma"]) ? classifyExpression(cursor, void 0, elementPath) : UNSUPPORTED;
-}
-function classifyRecord(cursor, expression, path) {
-	const closing = expression.rbrace();
-	if (closing !== void 0 && cursor.offset >= closing.endOffset) return UNSUPPORTED;
-	for (const field of expression.fields()) {
-		const colon = field.colon();
-		if (colon !== void 0 && cursor.offset > colon.offset && (containsCursor(field.syntax, cursor) || recoveredContainerContainsCursor(field.value(), cursor.offset))) return classifyExpression(cursor, field.value(), [...path, { kind: "recordValue" }]);
-	}
-	return UNSUPPORTED;
-}
 function isValueToken(token) {
 	return token !== void 0 && (token.kind === "Ident" || token.kind === "StringLiteral" || token.kind === "NumberLiteral");
 }
-function recoveredContainerContainsCursor(expression, offset) {
-	if (expression === void 0 || expression.syntax.endOffset > offset) return false;
-	if (!(expression instanceof ArrayLiteralAst ? expression.rbracket() === void 0 : expression instanceof ObjectLiteralExprAst ? expression.rbrace() === void 0 : expression instanceof FunctionCallAst && expression.rparen() === void 0)) return false;
-	for (let token = expression.syntax.lastToken?.nextToken; token !== void 0; token = token.nextToken) {
-		if (token.offset >= offset) return true;
-		if (!isTrivia(token) && token.kind !== "Comma") return false;
-	}
-	return true;
-}
-function containsCursor(node, cursor) {
-	if (node.isInside(cursor.offset)) return true;
-	const preceding = cursor.preceding;
-	return preceding !== void 0 && preceding.endOffset <= cursor.offset && preceding.offset >= node.offset && preceding.offset < node.endOffset;
-}
 function followsSeparator(cursor, kinds) {
 	return kinds.includes(cursor.preceding?.kind ?? "");
 }
@@ -513,35 +543,6 @@ function cursorIdentifier(at, offset) {
 	const left = at.leftBiased();
 	if (left?.kind === "Ident" && left.endOffset === offset) return left;
 }
-function requiredArgumentsSnippet(signature) {
-	return requiredArguments(signature).map((argument, index) => requiredArgumentSnippet(argument, index + 1)).join(", ");
-}
-function requiredArguments(signature) {
-	const positional = signature.positional ?? [];
-	const positionalKeys = new Set(positional.map((argument) => argument.key));
-	return [...positional.flatMap((argument) => isOptionalParam(argument.type) ? [] : [{
-		kind: "positional",
-		argument
-	}]), ...Object.entries(signature.named ?? {}).flatMap(([key, type]) => positionalKeys.has(key) || isOptionalParam(type) ? [] : [{
-		kind: "named",
-		key,
-		type
-	}])];
-}
-function requiredArgumentSnippet(argument, tabStop) {
-	if (argument.kind === "positional") return argSnippetPlaceholder(argument.argument.type, tabStop);
-	return `${argument.key}: ${argSnippetPlaceholder(argument.type, tabStop)}`;
-}
-function argSnippetPlaceholder(param, tabStop) {
-	const placeholder = `\${${tabStop.toString()}:}`;
-	if (param.kind === "str") return `"${placeholder}"`;
-	if (param.kind === "list") return `[${placeholder}]`;
-	if (param.kind === "record") return `{ ${placeholder} }`;
-	return placeholder;
-}
-function isOptionalParam(param) {
-	return "optional" in param && param.optional === true;
-}
 function modelSymbolForNode(symbolTable, node) {
 	const topLevelMatch = Object.values(symbolTable.topLevel.models).find((model) => sameSyntax(model.node.syntax, node.syntax));
 	if (topLevelMatch !== void 0) return topLevelMatch;
@@ -594,18 +595,75 @@ function referencedModel(symbols, model, field) {
 function sameSyntax(left, right) {
 	return left.offset === right.offset && left.endOffset === right.endOffset;
 }
-function provideAttributeNamedKeyCompletionItems(input, spec) {
-	return orderedItems(resolveGrammar(spec, input.context.path).flatMap((grammar) => "kind" in grammar ? [] : namedKeyItems(input, grammar)));
+function attributeSpecResolver(context, source) {
+	switch (context.ownerKind) {
+		case "block": {
+			const descriptor = findBlockDescriptor(source.pslBlockDescriptors, context.blockKeyword);
+			return (name) => {
+				const factory = descriptor?.attributes?.[name];
+				if (factory === void 0) return void 0;
+				return blindCast(factory)();
+			};
+		}
+		case "model": {
+			if (source.authoringContributions === void 0) return () => void 0;
+			const model = modelSymbolForNode(source.symbolTable, context.model);
+			if (model === void 0 || source.controlMutationDefaults === void 0) return () => void 0;
+			const specs = assembleAttributeSpecs(source.authoringContributions);
+			const specContext = {
+				symbols: source.symbolTable,
+				model,
+				controlMutationDefaults: source.controlMutationDefaults.defaultFunctionRegistry
+			};
+			return (name) => specs.model[name]?.(specContext);
+		}
+		case "field": {
+			if (source.authoringContributions === void 0) return () => void 0;
+			const model = modelSymbolForNode(source.symbolTable, context.model);
+			if (model === void 0 || source.controlMutationDefaults === void 0) return () => void 0;
+			const field = fieldSymbolForNode(model, context.field);
+			if (field === void 0) return () => void 0;
+			const specs = assembleAttributeSpecs(source.authoringContributions);
+			const specContext = {
+				symbols: source.symbolTable,
+				model,
+				controlMutationDefaults: source.controlMutationDefaults.defaultFunctionRegistry
+			};
+			return (name) => specs.field[name]?.({
+				...specContext,
+				field
+			});
+		}
+	}
 }
-function provideAttributeArgumentSlotCompletionItems(input, spec) {
-	return orderedItems(resolveGrammar(spec, input.context.path).flatMap((grammar) => {
-		if ("kind" in grammar) return [];
-		const param = grammar.positional?.[input.context.positionalIndex]?.type;
-		return [...valueItems(input, param, "scalar"), ...namedKeyItems(input, grammar)];
-	}));
+function requiredArgumentsSnippet(signature) {
+	return requiredArguments(signature).map((argument, index) => requiredArgumentSnippet(argument, index + 1)).join(", ");
 }
-function provideAttributeValueCompletionItems(input, spec) {
-	return orderedItems(resolveGrammar(spec, input.context.path).flatMap((grammar) => "kind" in grammar ? valueItems(input, grammar, input.context.syntax) : []));
+function requiredArguments(signature) {
+	const positional = signature.positional ?? [];
+	const positionalKeys = new Set(positional.map((argument) => argument.key));
+	return [...positional.flatMap((argument) => isOptionalParam(argument.type) ? [] : [{
+		kind: "positional",
+		argument
+	}]), ...Object.entries(signature.named ?? {}).flatMap(([key, { type }]) => positionalKeys.has(key) || isOptionalParam(type) ? [] : [{
+		kind: "named",
+		key,
+		type
+	}])];
+}
+function requiredArgumentSnippet(argument, tabStop) {
+	if (argument.kind === "positional") return argSnippetPlaceholder(argument.argument.type, tabStop);
+	return `${argument.key}: ${argSnippetPlaceholder(argument.type, tabStop)}`;
+}
+function argSnippetPlaceholder(param, tabStop) {
+	const placeholder = `\${${tabStop.toString()}:}`;
+	if (param.kind === "str") return `"${placeholder}"`;
+	if (param.kind === "list") return `[${placeholder}]`;
+	if (param.kind === "record") return `{ ${placeholder} }`;
+	return placeholder;
+}
+function isOptionalParam(param) {
+	return "optional" in param && param.optional === true;
 }
 function directArgType(param) {
 	return blindCast(param);
@@ -626,7 +684,7 @@ function advanceGrammar(grammar, step) {
 		}
 		case "namedArgument": {
 			if ("kind" in grammar) return [];
-			const param = grammar.named?.[step.name];
+			const param = grammar.named?.[step.name]?.type;
 			return param === void 0 ? [] : [param];
 		}
 		case "listElement": return type?.kind === "list" ? [type.of] : [];
@@ -634,6 +692,19 @@ function advanceGrammar(grammar, step) {
 		case "functionCall": return type?.kind === "funcCall" && type.name === step.name ? [type.signature] : [];
 	}
 }
+function provideAttributeNamedKeyCompletionItems(input, spec) {
+	return orderedItems(resolveGrammar(spec, input.context.path).flatMap((grammar) => "kind" in grammar ? [] : namedKeyItems(input, grammar)));
+}
+function provideAttributeArgumentSlotCompletionItems(input, spec) {
+	return orderedItems(resolveGrammar(spec, input.context.path).flatMap((grammar) => {
+		if ("kind" in grammar) return [];
+		const param = grammar.positional?.[input.context.positionalIndex]?.type;
+		return [...valueItems(input, param, "scalar"), ...namedKeyItems(input, grammar)];
+	}));
+}
+function provideAttributeValueCompletionItems(input, spec) {
+	return orderedItems(resolveGrammar(spec, input.context.path).flatMap((grammar) => "kind" in grammar ? valueItems(input, grammar, input.context.syntax) : []));
+}
 function namedKeyItems(input, signature) {
 	return Object.keys(signature.named ?? {}).filter((name) => !input.context.existingNamedKeys.includes(name)).map((name) => {
 		const snippet = input.clientSupportsSnippets && !input.context.hasColon;
@@ -653,8 +724,16 @@ function valueItems(input, param, syntax) {
 	if (type.kind === "oneOf") return type.alternatives.flatMap((alternative) => valueItems(input, alternative, syntax));
 	if (type.kind === "funcCall") {
 		const snippet = input.clientSupportsSnippets && syntax !== "functionName";
-		const text = snippet ? `${type.name}(${requiredArgumentsSnippet(type.signature)})` : type.name;
-		return [completionItem(input, type.name, text, CompletionItemKind.Function, snippet)];
+		const hasParameters = (type.signature.positional?.length ?? 0) > 0 || Object.keys(type.signature.named ?? {}).length > 0;
+		const args = requiredArgumentsSnippet(type.signature) || (hasParameters ? "${1:}" : "");
+		const text = snippet ? `${type.name}(${args})` : type.name;
+		return [{
+			...completionItem(input, type.name, text, CompletionItemKind.Function, snippet),
+			...snippet && input.clientSupportsTriggerParameterHintsCommand === true && hasParameters ? { command: {
+				title: "Show argument hints",
+				command: "editor.action.triggerParameterHints"
+			} } : {}
+		}];
 	}
 	if (syntax === "functionName") return [];
 	switch (type.kind) {
@@ -747,7 +826,7 @@ function providePslCompletionItems(input) {
 		case "genericBlockValue": return [];
 		case "fieldAttributeName":
 		case "modelAttributeName":
-		case "blockAttributeName": return provideAttributeNameCompletionItems(context, input.sourceFile, input.candidates, input.clientSupportsSnippets);
+		case "blockAttributeName": return provideAttributeNameCompletionItems(context, input.sourceFile, input.candidates, input.clientSupportsSnippets, input.clientSupportsTriggerParameterHintsCommand === true);
 		case "fieldAttributeNamedKey":
 		case "modelAttributeNamedKey":
 		case "blockAttributeNamedKey": {
@@ -768,6 +847,7 @@ function providePslCompletionItems(input) {
 				sourceFile: input.sourceFile,
 				clientSupportsSnippets: input.clientSupportsSnippets,
 				clientSupportsTriggerSuggestCommand: input.clientSupportsTriggerSuggestCommand === true,
+				clientSupportsTriggerParameterHintsCommand: input.clientSupportsTriggerParameterHintsCommand === true,
 				fieldNames: (kind) => kind === "fieldRef" ? localFieldNames(context, input.candidates.symbolTable) : referencedFieldNames(context, input.candidates.symbolTable)
 			}, spec);
 		}
@@ -779,6 +859,7 @@ function providePslCompletionItems(input) {
 				context,
 				sourceFile: input.sourceFile,
 				clientSupportsSnippets: input.clientSupportsSnippets,
+				clientSupportsTriggerParameterHintsCommand: input.clientSupportsTriggerParameterHintsCommand === true,
 				fieldNames: (kind) => kind === "fieldRef" ? localFieldNames(context, input.candidates.symbolTable) : referencedFieldNames(context, input.candidates.symbolTable)
 			}, spec);
 		}
@@ -788,7 +869,7 @@ function providePslCompletionItems(input) {
 		case "namespaceMember": return provideNamespaceMemberCompletionItems(context, input.sourceFile, input.candidates);
 	}
 }
-function provideAttributeNameCompletionItems(context, sourceFile, source, clientSupportsSnippets) {
+function provideAttributeNameCompletionItems(context, sourceFile, source, clientSupportsSnippets, clientSupportsTriggerParameterHintsCommand) {
 	const names = attributeNames(context, source);
 	const replacementRange = {
 		start: sourceFile.positionAt(context.replacementStartOffset),
@@ -812,7 +893,11 @@ function provideAttributeNameCompletionItems(context, sourceFile, source, client
 				range: replacementRange,
 				newText
 			},
-			...newText !== name ? { insertTextFormat: InsertTextFormat.Snippet } : {}
+			...newText !== name ? { insertTextFormat: InsertTextFormat.Snippet } : {},
+			...newText !== name && clientSupportsTriggerParameterHintsCommand ? { command: {
+				title: "Show argument hints",
+				command: "editor.action.triggerParameterHints"
+			} } : {}
 		};
 	});
 }
@@ -835,56 +920,6 @@ function attributeNameEditText(input) {
 	const required = requiredArgumentsSnippet(input.spec);
 	return required.length === 0 ? input.name : `${input.name}(${required})`;
 }
-function attributeSpecResolver(context, source) {
-	switch (context.kind) {
-		case "blockAttributeName":
-		case "blockAttributeNamedKey":
-		case "blockAttributeArgumentSlot":
-		case "blockAttributeValue": {
-			const descriptor = findBlockDescriptor(source.pslBlockDescriptors, context.blockKeyword);
-			return (name) => {
-				const factory = descriptor?.attributes?.[name];
-				if (factory === void 0) return;
-				return blindCast(factory)();
-			};
-		}
-		case "modelAttributeName":
-		case "modelAttributeNamedKey":
-		case "modelAttributeArgumentSlot":
-		case "modelAttributeValue": {
-			if (source.authoringContributions === void 0) return () => void 0;
-			const model = modelSymbolForNode(source.symbolTable, context.model);
-			if (model === void 0 || source.controlMutationDefaults === void 0) return () => void 0;
-			const specs = assembleAttributeSpecs(source.authoringContributions);
-			const specContext = {
-				symbols: source.symbolTable,
-				model,
-				controlMutationDefaults: source.controlMutationDefaults.defaultFunctionRegistry
-			};
-			return (name) => specs.model[name]?.(specContext);
-		}
-		case "fieldAttributeName":
-		case "fieldAttributeNamedKey":
-		case "fieldAttributeArgumentSlot":
-		case "fieldAttributeValue": {
-			if (source.authoringContributions === void 0) return () => void 0;
-			const model = modelSymbolForNode(source.symbolTable, context.model);
-			if (model === void 0 || source.controlMutationDefaults === void 0) return () => void 0;
-			const field = fieldSymbolForNode(model, context.field);
-			if (field === void 0) return () => void 0;
-			const specs = assembleAttributeSpecs(source.authoringContributions);
-			const specContext = {
-				symbols: source.symbolTable,
-				model,
-				controlMutationDefaults: source.controlMutationDefaults.defaultFunctionRegistry
-			};
-			return (name) => specs.field[name]?.({
-				...specContext,
-				field
-			});
-		}
-	}
-}
 function provideDeclarationKeywordCompletionItems(context, sourceFile, source, clientSupportsSnippets) {
 	const replacementRange = {
 		start: sourceFile.positionAt(context.replacementStartOffset),
@@ -1728,6 +1763,193 @@ function createPendingSemanticToken(startOffset, endOffset, tokenType, modifierB
 function tokenTypeIndex(tokenType) {
 	return semanticTokenTypes.indexOf(tokenType);
 }
+function classifyPslSignatureContext(input) {
+	const syntax = locateAttributeSyntax(input);
+	if (syntax === void 0) return void 0;
+	const attributeName = syntax.attribute.name()?.identifier()?.name();
+	const args = syntax.attribute.argList();
+	const position = args === void 0 ? void 0 : signatureArguments(syntax, args, []);
+	const owner = signatureOwner(syntax.attribute);
+	return attributeName === void 0 || position === void 0 || owner === void 0 ? void 0 : {
+		...owner,
+		...position,
+		attributeName
+	};
+}
+function signatureOwner(attribute) {
+	if (attribute instanceof FieldAttributeAst) {
+		const field = attribute.syntax.findAncestor(FieldDeclarationAst.cast);
+		const model = attribute.syntax.findAncestor(ModelDeclarationAst.cast);
+		return field === void 0 || model === void 0 ? void 0 : {
+			ownerKind: "field",
+			field,
+			model
+		};
+	}
+	const block = attribute.syntax.findAncestor(GenericBlockDeclarationAst.cast);
+	if (block !== void 0) {
+		const blockKeyword = block.keyword()?.text;
+		return blockKeyword === void 0 || blockKeyword.length === 0 ? void 0 : {
+			ownerKind: "block",
+			block,
+			blockKeyword
+		};
+	}
+	const model = attribute.syntax.findAncestor(ModelDeclarationAst.cast);
+	return model === void 0 ? void 0 : {
+		ownerKind: "model",
+		model
+	};
+}
+function signatureArguments(context, args, path) {
+	if (!betweenDelimiters(context.offset, args.lparen(), args.rparen())) return void 0;
+	const containing = argumentAtCursor(context, args);
+	const next = context.preceding?.kind === "Comma" ? nonTriviaSibling(context.preceding, "next") : void 0;
+	const following = next instanceof SyntaxNode && next.parent?.offset === args.syntax.offset ? AttributeArgAst.cast(next) : void 0;
+	const active = containing ?? following;
+	const { precedingPositionalCount: positionalIndex, otherNamedKeys: existingNamedKeys } = argumentSiblings(args, active, context.offset);
+	if (active === void 0) return ["LParen", "Comma"].includes(context.preceding?.kind ?? "") ? {
+		path,
+		argumentSlot: {
+			positionalIndex,
+			existingNamedKeys
+		}
+	} : void 0;
+	if (active.colon() !== void 0) {
+		const name = active.name()?.name();
+		if (name === void 0) return void 0;
+		const valuePath = [...path, {
+			kind: "namedArgument",
+			name
+		}];
+		return active === containing ? signatureExpression(context, active.value(), valuePath) : {
+			path: valuePath,
+			argumentSlot: void 0
+		};
+	}
+	const value = active.value();
+	if (value === void 0 || value instanceof IdentifierAst && value.syntax.isInside(context.offset)) return {
+		path,
+		argumentSlot: {
+			positionalIndex,
+			existingNamedKeys
+		}
+	};
+	const valuePath = [...path, {
+		kind: "positionalArgument",
+		index: positionalIndex
+	}];
+	return active === containing ? signatureExpression(context, value, valuePath) : {
+		path: valuePath,
+		argumentSlot: void 0
+	};
+}
+function signatureExpression(context, expression, path) {
+	const position = {
+		path,
+		argumentSlot: void 0
+	};
+	if (expression === void 0 || context.offset <= expression.syntax.offset || context.offset >= expression.syntax.endOffset && !recoveredContainerContainsCursor(expression, context.offset)) return position;
+	if (expression instanceof ArrayLiteralAst) return betweenDelimiters(context.offset, expression.lbracket(), expression.rbracket()) ? signatureExpression(context, listElementAtCursor(context, expression), [...path, { kind: "listElement" }]) : void 0;
+	if (expression instanceof ObjectLiteralExprAst) {
+		const closing = expression.rbrace();
+		if (closing !== void 0 && context.offset >= closing.endOffset) return void 0;
+		const field = recordFieldAtCursor(context, expression);
+		return field !== void 0 ? signatureExpression(context, field.value(), [...path, { kind: "recordValue" }]) : position;
+	}
+	if (expression instanceof FunctionCallAst) {
+		const opening = expression.lparen();
+		if (opening !== void 0 && context.offset > opening.offset) {
+			const name = expression.name();
+			const identifier = name?.identifier()?.name();
+			return identifier !== void 0 && name?.isSimpleName(identifier) === true ? signatureArguments(context, expression, [...path, {
+				kind: "functionCall",
+				name: identifier
+			}]) : void 0;
+		}
+		return expression.name()?.syntax.isInside(context.offset) === true ? position : void 0;
+	}
+	return position;
+}
+function providePslSignatureHelp(input) {
+	const context = classifyPslSignatureContext(input);
+	if (context === void 0) return null;
+	const spec = attributeSpecResolver(context, input.candidates)(context.attributeName);
+	if (spec === void 0) return null;
+	return signatureHelp(context, spec, input.clientSupportsLabelOffsets === true);
+}
+function signatureHelp(context, spec, labelOffsets) {
+	const callIndex = context.path.reduce((last, step, index) => step.kind === "functionCall" ? index : last, -1);
+	const call = context.path[callIndex];
+	const signaturePath = context.path.slice(0, callIndex + 1);
+	const name = call?.kind === "functionCall" ? call.name : `${spec.level === "field" ? "@" : "@@"}${spec.name}`;
+	const signatures = resolveGrammar(spec, signaturePath).flatMap((grammar) => {
+		if ("kind" in grammar) return [];
+		const active = context.path[callIndex + 1];
+		const params = parameters(grammar, active?.kind === "namedArgument" ? active.name : void 0);
+		const index = parameterIndex(context, active, params);
+		return [{
+			signature: renderSignature(name, grammar, params, labelOffsets),
+			index
+		}];
+	});
+	if (signatures.length === 0) return null;
+	const matched = signatures.findIndex(({ signature, index }) => index >= 0 && index < (signature.parameters?.length ?? 0));
+	const activeSignature = matched < 0 ? 0 : matched;
+	const activeParameter = signatures[activeSignature]?.index;
+	return {
+		signatures: signatures.map(({ signature }) => signature),
+		activeSignature,
+		...matched >= 0 && activeParameter !== void 0 ? { activeParameter } : {}
+	};
+}
+function parameterIndex(context, active, params) {
+	if (active?.kind === "namedArgument") return params.findIndex((param) => param.key === active.name);
+	if (active?.kind === "positionalArgument") return active.index;
+	const slot = context.argumentSlot;
+	if (slot !== void 0) return params.findIndex((param, index) => index >= slot.positionalIndex && !slot.existingNamedKeys.includes(param.key));
+	return -1;
+}
+function parameters(signature, activeName) {
+	const positional = signature.positional ?? [];
+	const keys = new Set(positional.map((param) => param.key));
+	const namedAlias = activeName === void 0 ? void 0 : signature.named?.[activeName];
+	return [...positional.map((param) => param.key === activeName && namedAlias !== void 0 ? {
+		key: param.key,
+		...namedAlias
+	} : param), ...Object.entries(signature.named ?? {}).flatMap(([key, param]) => keys.has(key) ? [] : [{
+		key,
+		...param
+	}])];
+}
+function renderSignature(name, signature, params, labelOffsets) {
+	let label = `${name}(`;
+	const rendered = params.map((param, index) => {
+		if (index > 0) label += ", ";
+		const positional = index < (signature.positional?.length ?? 0);
+		const optional = "optional" in param.type && param.type.optional === true;
+		const typeLabel = optional && param.type.label.includes(" | ") ? `(${param.type.label})` : param.type.label;
+		const text = positional ? `${typeLabel}${optional ? "?" : ""}` : `${param.key}${optional ? "?" : ""}: ${param.type.label}`;
+		const start = label.length;
+		label += text;
+		const documentation = positional ? `**${param.key}**\n\n${param.documentation}${signature.named?.[param.key] === void 0 ? "" : `\n\nAccepted positionally or by \`${param.key}:\`.`}` : param.documentation;
+		return {
+			label: positional && labelOffsets ? [start, label.length] : text,
+			documentation: {
+				kind: MarkupKind.Markdown,
+				value: documentation
+			}
+		};
+	});
+	return {
+		label: `${label})`,
+		documentation: {
+			kind: MarkupKind.Markdown,
+			value: signature.documentation
+		},
+		parameters: rendered
+	};
+}
 /** The project a new load of this config could fall back to. */
 function lastGoodProject(entry) {
 	if (entry === void 0 || entry.status === "failed") return;
@@ -2007,12 +2229,36 @@ function createServerOn(connection) {
 					...project.controlStack.controlMutationDefaults === void 0 ? {} : { controlMutationDefaults: project.controlStack.controlMutationDefaults }
 				},
 				clientSupportsSnippets: clientCapabilities.completionSnippets,
-				clientSupportsTriggerSuggestCommand: clientCapabilities.completionTriggerSuggestCommand
+				clientSupportsTriggerSuggestCommand: clientCapabilities.completionTriggerSuggestCommand,
+				clientSupportsTriggerParameterHintsCommand: clientCapabilities.completionTriggerParameterHintsCommand
 			})];
 		} catch {
 			return [];
 		}
 	}
+	async function signatureHelpForDocument(uri, position) {
+		if (documents.get(uri) === void 0) return null;
+		const project = await resolveProjectForDocument(uri);
+		if (project === void 0) return null;
+		const artifacts = project.artifacts.document(uri);
+		if (artifacts === void 0) return null;
+		try {
+			return providePslSignatureHelp({
+				clientSupportsLabelOffsets: clientCapabilities.signatureLabelOffsets,
+				document: artifacts.document,
+				sourceFile: artifacts.sourceFile,
+				position,
+				candidates: {
+					pslBlockDescriptors: project.controlStack.pslBlockDescriptors,
+					symbolTable: project.artifacts.symbolTable(),
+					...project.controlStack.authoringContributions === void 0 ? {} : { authoringContributions: project.controlStack.authoringContributions },
+					...project.controlStack.controlMutationDefaults === void 0 ? {} : { controlMutationDefaults: project.controlStack.controlMutationDefaults }
+				}
+			});
+		} catch {
+			return null;
+		}
+	}
 	connection.onInitialize(async (params) => {
 		rootPath = resolveRootPath(params);
 		watchedConfigGlob = join(rootPath, "**", CONFIG_FILENAME);
@@ -2035,6 +2281,7 @@ function createServerOn(connection) {
 				":",
 				","
 			] },
+			signatureHelpProvider: { triggerCharacters: ["(", ","] },
 			...clientCapabilities.pullDiagnostics ? { diagnosticProvider: {
 				interFileDependencies: false,
 				workspaceDiagnostics: false
@@ -2063,6 +2310,7 @@ function createServerOn(connection) {
 	});
 	connection.onDocumentFormatting((params) => formatDocument(params.textDocument.uri));
 	connection.onCompletion((params) => completeDocument(params.textDocument.uri, params.position));
+	connection.onSignatureHelp((params) => signatureHelpForDocument(params.textDocument.uri, params.position));
 	connection.languages.semanticTokens.on((params) => semanticTokensForDocument(params.textDocument.uri));
 	connection.languages.semanticTokens.onRange((params) => semanticTokensForDocument(params.textDocument.uri, params.range));
 	connection.languages.diagnostics.on(async (params) => {
@@ -2153,7 +2401,9 @@ function toLspSeverity(severity) {
 const noClientCapabilities = {
 	watchedFilesRegistration: false,
 	completionSnippets: false,
+	signatureLabelOffsets: false,
 	completionTriggerSuggestCommand: false,
+	completionTriggerParameterHintsCommand: false,
 	pullDiagnostics: false,
 	diagnosticsRefresh: false
 };
@@ -2161,15 +2411,17 @@ function resolveClientCapabilities(params) {
 	return {
 		watchedFilesRegistration: params.capabilities.workspace?.didChangeWatchedFiles?.dynamicRegistration === true,
 		completionSnippets: params.capabilities.textDocument?.completion?.completionItem?.snippetSupport === true,
-		completionTriggerSuggestCommand: supportsCompletionTriggerSuggest(params.initializationOptions),
+		signatureLabelOffsets: params.capabilities.textDocument?.signatureHelp?.signatureInformation?.parameterInformation?.labelOffsetSupport === true,
+		completionTriggerSuggestCommand: supportsCompletionCommand(params.initializationOptions, "supportsTriggerSuggestCommand"),
+		completionTriggerParameterHintsCommand: supportsCompletionCommand(params.initializationOptions, "supportsTriggerParameterHintsCommand"),
 		pullDiagnostics: params.capabilities.textDocument?.diagnostic !== void 0,
 		diagnosticsRefresh: params.capabilities.workspace?.diagnostics?.refreshSupport === true
 	};
 }
-function supportsCompletionTriggerSuggest(options) {
+function supportsCompletionCommand(options, capability) {
 	if (typeof options !== "object" || options === null || !("completion" in options)) return false;
 	const completion = options.completion;
-	return typeof completion === "object" && completion !== null && "supportsTriggerSuggestCommand" in completion && completion.supportsTriggerSuggestCommand === true;
+	return typeof completion === "object" && completion !== null && capability in completion && Reflect.get(completion, capability) === true;
 }
 function resolveRootPath(params) {
 	const workspaceFolder = params.workspaceFolders?.[0];
@@ -2434,4 +2686,4 @@ function startServer(streams) {
 //#endregion
 export { startServer };
 
-//# sourceMappingURL=exports-DGC_nDQ0.mjs.map
+//# sourceMappingURL=exports-HR2MWHrQ.mjs.map