@prisma/orm-toolchain 8.0.0-rc.11-dev.6 → 8.0.0-rc.11-dev.8

package/dist/{exports-CYa2di3d.mjs → exports-B8peSdx4.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, ProposedFeatures, RegistrationRequest, SemanticTokenModifiers, SemanticTokenTypes, TextDocumentSyncKind, TextDocuments, createConnection } from "vscode-languageserver";
+import { CompletionItemKind, ConnectionError, ConnectionErrors, DiagnosticSeverity, DidChangeWatchedFilesNotification, DocumentDiagnosticReportKind, FoldingRangeKind, InsertTextFormat, LSPErrorCodes, ProposedFeatures, RegistrationRequest, ResponseError, SemanticTokenModifiers, SemanticTokenTypes, TextDocumentSyncKind, TextDocuments, createConnection } from "vscode-languageserver";
 import { TextDocument } from "vscode-languageserver-textdocument";
-import { ArrayLiteralAst, AttributeArgAst, AttributeArgListAst, BooleanLiteralExprAst, CompositeTypeDeclarationAst, FieldAttributeAst, FieldDeclarationAst, FunctionCallAst, GenericBlockDeclarationAst, IdentifierAst, KeyValuePairAst, ModelAttributeAst, ModelDeclarationAst, NamespaceDeclarationAst, NumberLiteralExprAst, ObjectLiteralExprAst, StringLiteralExprAst, TypesBlockAst, any, filterChildren, findChildToken, parse, skipTriviaToken } from "@prisma/orm-framework/psl-parser/syntax";
+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 { 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";
@@ -68,7 +68,7 @@ function classifyPslCompletionContext(input) {
 	const replacementStartOffset = edit?.offset ?? offset;
 	const attributeClassifierInput = {
 		offset,
-		node: at.leftBiased()?.parent ?? at.rightBiased()?.parent,
+		node: attributeAnchor(at),
 		replacementStartOffset
 	};
 	const attributeContext = classifyFieldAttribute(attributeClassifierInput) ?? classifyGenericBlockAttribute(attributeClassifierInput) ?? classifyModelAttribute(attributeClassifierInput);
@@ -205,29 +205,36 @@ function blockBodyContainsOffset(block, offset) {
 }
 function classifyFieldAttribute(input) {
 	const attribute = input.node?.findAncestor(FieldAttributeAst.cast);
-	if (attribute === void 0 || attribute.syntax.isOutside(input.offset)) return;
+	if (attribute === void 0 || !attributeContainsOffset(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;
-	if (isAttributeNamePosition(attribute, input.offset)) return {
-		kind: "fieldAttributeName",
-		offset: input.offset,
-		replacementStartOffset: input.replacementStartOffset,
-		attribute,
-		field,
-		model
-	};
-	const attributeName = attributeNamedKeyName(attribute, input.offset);
-	if (attributeName === void 0) return UNSUPPORTED;
-	return {
-		kind: "fieldAttributeNamedKey",
-		offset: input.offset,
-		replacementStartOffset: input.replacementStartOffset,
-		attributeName,
-		attribute,
-		field,
-		model
-	};
+	return classifyAttributePosition(attribute, input, {
+		name: (position) => ({
+			kind: "fieldAttributeName",
+			...position,
+			field,
+			model
+		}),
+		namedKey: (position) => ({
+			kind: "fieldAttributeNamedKey",
+			...position,
+			field,
+			model
+		}),
+		argumentSlot: (position) => ({
+			kind: "fieldAttributeArgumentSlot",
+			...position,
+			field,
+			model
+		}),
+		value: (position) => ({
+			kind: "fieldAttributeValue",
+			...position,
+			field,
+			model
+		})
+	});
 }
 function classifyGenericBlockAttribute(input) {
 	const attribute = activeModelAttribute(input);
@@ -235,80 +242,226 @@ 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;
-	if (isAttributeNamePosition(attribute, input.offset)) return {
-		kind: "blockAttributeName",
-		offset: input.offset,
-		replacementStartOffset: input.replacementStartOffset,
-		attribute,
-		block,
-		blockKeyword
-	};
-	const attributeName = attributeNamedKeyName(attribute, input.offset);
-	if (attributeName === void 0) return UNSUPPORTED;
-	return {
-		kind: "blockAttributeNamedKey",
-		offset: input.offset,
-		replacementStartOffset: input.replacementStartOffset,
-		attributeName,
-		attribute,
-		block,
-		blockKeyword
-	};
+	return classifyAttributePosition(attribute, input, {
+		name: (position) => ({
+			kind: "blockAttributeName",
+			...position,
+			block,
+			blockKeyword
+		}),
+		namedKey: (position) => ({
+			kind: "blockAttributeNamedKey",
+			...position,
+			block,
+			blockKeyword
+		}),
+		argumentSlot: (position) => ({
+			kind: "blockAttributeArgumentSlot",
+			...position,
+			block,
+			blockKeyword
+		}),
+		value: (position) => ({
+			kind: "blockAttributeValue",
+			...position,
+			block,
+			blockKeyword
+		})
+	});
 }
 function classifyModelAttribute(input) {
 	const attribute = activeModelAttribute(input);
 	if (attribute === void 0) return;
 	const model = attribute.syntax.findAncestor(ModelDeclarationAst.cast);
 	if (model === void 0) return;
-	if (isAttributeNamePosition(attribute, input.offset)) return {
-		kind: "modelAttributeName",
+	return classifyAttributePosition(attribute, input, {
+		name: (position) => ({
+			kind: "modelAttributeName",
+			...position,
+			model
+		}),
+		namedKey: (position) => ({
+			kind: "modelAttributeNamedKey",
+			...position,
+			model
+		}),
+		argumentSlot: (position) => ({
+			kind: "modelAttributeArgumentSlot",
+			...position,
+			model
+		}),
+		value: (position) => ({
+			kind: "modelAttributeValue",
+			...position,
+			model
+		})
+	});
+}
+function activeModelAttribute(input) {
+	const attribute = input.node?.findAncestor(ModelAttributeAst.cast);
+	if (attribute === void 0 || !attributeContainsOffset(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({
 		offset: input.offset,
 		replacementStartOffset: input.replacementStartOffset,
-		attribute,
-		model
-	};
-	const attributeName = attributeNamedKeyName(attribute, input.offset);
-	if (attributeName === void 0) return UNSUPPORTED;
-	return {
-		kind: "modelAttributeNamedKey",
+		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 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({
 		offset: input.offset,
-		replacementStartOffset: input.replacementStartOffset,
+		replacementStartOffset: replaceToken ? token.offset : input.offset,
+		replacementEndOffset: replaceToken ? token.endOffset : input.offset,
 		attributeName,
-		attribute,
-		model
+		preceding: anchor === void 0 ? void 0 : skipTriviaToken(anchor, "prev"),
+		factory
+	}, args, []);
+}
+function argumentPosition(cursor, path) {
+	return {
+		offset: cursor.offset,
+		replacementStartOffset: cursor.replacementStartOffset,
+		replacementEndOffset: cursor.replacementEndOffset,
+		attributeName: cursor.attributeName,
+		path
 	};
 }
-function activeModelAttribute(input) {
-	const attribute = input.node?.findAncestor(ModelAttributeAst.cast);
-	if (attribute === void 0 || attribute.syntax.isOutside(input.offset)) return;
-	return attribute;
+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;
+		}
+	}
+	const position = argumentPosition(cursor, path);
+	if (active === void 0) return followsSeparator(cursor, ["LParen", "Comma"]) ? cursor.factory.argumentSlot({
+		...position,
+		positionalIndex,
+		existingNamedKeys,
+		hasColon: false
+	}) : UNSUPPORTED;
+	const colon = active.colon();
+	if (colon !== void 0) {
+		if (cursor.offset <= colon.offset) return cursor.factory.namedKey({
+			...position,
+			existingNamedKeys,
+			hasColon: true
+		});
+		const name = active.name()?.name();
+		return name === void 0 ? UNSUPPORTED : classifyExpression(cursor, active.value(), [...path, {
+			kind: "namedArgument",
+			name
+		}]);
+	}
+	const value = active.value();
+	if (value === void 0 || value instanceof IdentifierAst && value.syntax.isInside(cursor.offset)) return cursor.factory.argumentSlot({
+		...position,
+		positionalIndex,
+		existingNamedKeys,
+		hasColon: false
+	});
+	return classifyExpression(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);
+	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, {
+				kind: "functionCall",
+				name: identifier
+			}]) : UNSUPPORTED;
+		}
+		return expression.name()?.syntax.isInside(cursor.offset) === true ? cursor.factory.value({
+			...argumentPosition(cursor, path),
+			syntax: "functionName"
+		}) : UNSUPPORTED;
+	}
+	return expression?.syntax.isOutside(cursor.offset) === true ? UNSUPPORTED : cursor.factory.value({
+		...argumentPosition(cursor, path),
+		syntax: "scalar"
+	});
 }
-function isAttributeNamePosition(attribute, offset) {
-	return !attribute.argList()?.syntax.isInside(offset);
+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 attributeNamedKeyName(attribute, offset) {
-	const argList = attribute.argList();
-	if (argList === void 0 || argList.syntax.isOutside(offset)) return;
-	const rparen = argList.rparen();
-	if (rparen !== void 0 && offset >= rparen.endOffset) return;
-	for (const arg of argList.args()) {
-		const colon = arg.colon();
-		if (colon !== void 0 && offset > colon.offset && offset >= arg.syntax.offset && offset <= arg.syntax.endOffset) return;
-	}
-	const token = attribute.syntax.tokenAtOffset(offset).leftBiased();
-	if (token?.kind === "Colon") return;
-	const node = token?.parent;
-	const activeArg = node?.findAncestor(AttributeArgAst.cast);
-	if (activeArg === void 0 && node?.kind !== "AttributeArgList") return;
-	if (activeArg !== void 0) {
-		const colon = activeArg.colon();
-		if (colon !== void 0 && offset > colon.offset) return;
-		const value = activeArg.value();
-		if (colon === void 0 && value !== void 0 && value.syntax.kind !== "Identifier" && value.syntax.isInside(offset)) return;
-	}
-	const attributeName = attribute.name()?.identifier()?.name();
-	if (attributeName === void 0) return;
-	return attributeName;
+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 ?? "");
 }
 function classifyGenericBlockParameter(input) {
 	const node = input.at.leftBiased()?.parent;
@@ -360,6 +513,200 @@ 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;
+	for (const namespace of Object.values(symbolTable.topLevel.namespaces)) {
+		const namespaceMatch = Object.values(namespace.models).find((model) => sameSyntax(model.node.syntax, node.syntax));
+		if (namespaceMatch !== void 0) return namespaceMatch;
+	}
+}
+function fieldSymbolForNode(model, node) {
+	return Object.values(model.fields).find((field) => sameSyntax(field.node.syntax, node.syntax));
+}
+function localFieldNames(context, symbols) {
+	switch (context.kind) {
+		case "blockAttributeNamedKey":
+		case "blockAttributeArgumentSlot":
+		case "blockAttributeValue": return [];
+		case "fieldAttributeNamedKey":
+		case "fieldAttributeArgumentSlot":
+		case "fieldAttributeValue":
+		case "modelAttributeNamedKey":
+		case "modelAttributeArgumentSlot":
+		case "modelAttributeValue": return Object.keys(modelSymbolForNode(symbols, context.model)?.fields ?? {});
+	}
+}
+function referencedFieldNames(context, symbols) {
+	switch (context.kind) {
+		case "blockAttributeNamedKey":
+		case "blockAttributeArgumentSlot":
+		case "blockAttributeValue":
+		case "modelAttributeNamedKey":
+		case "modelAttributeArgumentSlot":
+		case "modelAttributeValue": return [];
+		case "fieldAttributeNamedKey":
+		case "fieldAttributeArgumentSlot":
+		case "fieldAttributeValue": {
+			const model = modelSymbolForNode(symbols, context.model);
+			if (model === void 0) return [];
+			const field = fieldSymbolForNode(model, context.field);
+			if (field === void 0) return [];
+			return Object.keys(referencedModel(symbols, model, field)?.fields ?? {});
+		}
+	}
+}
+function referencedModel(symbols, model, field) {
+	if (field.malformedType === true || field.typeContractSpaceId !== void 0) return void 0;
+	if (field.typeNamespaceId !== void 0) return symbols.topLevel.namespaces[field.typeNamespaceId]?.models[field.typeName];
+	const namespace = model.node.syntax.findAncestor(NamespaceDeclarationAst.cast)?.name()?.name();
+	return (namespace === void 0 ? void 0 : symbols.topLevel.namespaces[namespace]?.models[field.typeName]) ?? symbols.topLevel.models[field.typeName];
+}
+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 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 directArgType(param) {
+	return blindCast(param);
+}
+function resolveGrammar(signature, path) {
+	let grammars = [signature];
+	for (const step of path) grammars = grammars.flatMap((grammar) => advanceGrammar(grammar, step));
+	return grammars;
+}
+function advanceGrammar(grammar, step) {
+	const type = "kind" in grammar ? directArgType(grammar) : void 0;
+	if (type?.kind === "oneOf") return type.alternatives.flatMap((alternative) => advanceGrammar(alternative, step));
+	switch (step.kind) {
+		case "positionalArgument": {
+			if ("kind" in grammar) return [];
+			const param = grammar.positional?.[step.index]?.type;
+			return param === void 0 ? [] : [param];
+		}
+		case "namedArgument": {
+			if ("kind" in grammar) return [];
+			const param = grammar.named?.[step.name];
+			return param === void 0 ? [] : [param];
+		}
+		case "listElement": return type?.kind === "list" ? [type.of] : [];
+		case "recordValue": return type?.kind === "record" ? [type.of] : [];
+		case "functionCall": return type?.kind === "funcCall" && type.name === step.name ? [type.signature] : [];
+	}
+}
+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;
+		const value = snippet ? "${1:}" : "";
+		return {
+			...completionItem(input, name, input.context.hasColon ? name : `${name}: ${value}`, CompletionItemKind.Property, snippet),
+			...!input.context.hasColon && input.clientSupportsTriggerSuggestCommand === true ? { command: {
+				title: "Suggest argument values",
+				command: "editor.action.triggerSuggest"
+			} } : {}
+		};
+	});
+}
+function valueItems(input, param, syntax) {
+	if (param === void 0) return [];
+	const type = directArgType(param);
+	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)];
+	}
+	if (syntax === "functionName") return [];
+	switch (type.kind) {
+		case "identifier": return scalarItems(input, [type.name]);
+		case "str": return scalarItems(input, type.value === void 0 ? [] : [JSON.stringify(type.value)]);
+		case "num": return scalarItems(input, type.value === void 0 ? [] : [String(type.value)]);
+		case "bool": return scalarItems(input, ["true", "false"]);
+		case "fieldRef":
+		case "referencedFieldRef": return scalarItems(input, input.fieldNames(type.kind));
+		case "list":
+		case "record":
+		case "entityRef":
+		case "int":
+		case "json":
+		case "rejecting": return [];
+	}
+}
+function scalarItems(input, labels) {
+	return labels.map((label) => completionItem(input, label, label, CompletionItemKind.Value));
+}
+function completionItem(input, label, newText, kind, snippet = false) {
+	return {
+		label,
+		kind,
+		detail: kind === CompletionItemKind.Property ? "Attribute argument" : "PSL argument value",
+		filterText: label,
+		textEdit: {
+			range: {
+				start: input.sourceFile.positionAt(input.context.replacementStartOffset),
+				end: input.sourceFile.positionAt(input.context.replacementEndOffset)
+			},
+			newText
+		},
+		...snippet ? { insertTextFormat: InsertTextFormat.Snippet } : {}
+	};
+}
+function orderedItems(items) {
+	const seen = /* @__PURE__ */ new Set();
+	return items.filter((item) => {
+		const key = JSON.stringify([
+			item.label,
+			item.textEdit,
+			item.insertTextFormat
+		]);
+		if (seen.has(key)) return false;
+		seen.add(key);
+		return true;
+	}).map((item, index) => ({
+		...item,
+		sortText: index.toString().padStart(4, "0")
+	}));
+}
 /**
 * Presentation-level classification of a `types {}` binding: a
 * non-constructor binding whose base is a configured scalar type refines that
@@ -403,7 +750,38 @@ function providePslCompletionItems(input) {
 		case "blockAttributeName": return provideAttributeNameCompletionItems(context, input.sourceFile, input.candidates, input.clientSupportsSnippets);
 		case "fieldAttributeNamedKey":
 		case "modelAttributeNamedKey":
-		case "blockAttributeNamedKey": return provideAttributeNamedKeyCompletionItems(context, input.sourceFile, input.candidates);
+		case "blockAttributeNamedKey": {
+			const spec = attributeSpecResolver(context, input.candidates)(context.attributeName);
+			return spec === void 0 ? [] : provideAttributeNamedKeyCompletionItems({
+				context,
+				sourceFile: input.sourceFile,
+				clientSupportsSnippets: input.clientSupportsSnippets,
+				clientSupportsTriggerSuggestCommand: input.clientSupportsTriggerSuggestCommand === true
+			}, spec);
+		}
+		case "fieldAttributeArgumentSlot":
+		case "modelAttributeArgumentSlot":
+		case "blockAttributeArgumentSlot": {
+			const spec = attributeSpecResolver(context, input.candidates)(context.attributeName);
+			return spec === void 0 ? [] : provideAttributeArgumentSlotCompletionItems({
+				context,
+				sourceFile: input.sourceFile,
+				clientSupportsSnippets: input.clientSupportsSnippets,
+				clientSupportsTriggerSuggestCommand: input.clientSupportsTriggerSuggestCommand === true,
+				fieldNames: (kind) => kind === "fieldRef" ? localFieldNames(context, input.candidates.symbolTable) : referencedFieldNames(context, input.candidates.symbolTable)
+			}, spec);
+		}
+		case "fieldAttributeValue":
+		case "modelAttributeValue":
+		case "blockAttributeValue": {
+			const spec = attributeSpecResolver(context, input.candidates)(context.attributeName);
+			return spec === void 0 ? [] : provideAttributeValueCompletionItems({
+				context,
+				sourceFile: input.sourceFile,
+				clientSupportsSnippets: input.clientSupportsSnippets,
+				fieldNames: (kind) => kind === "fieldRef" ? localFieldNames(context, input.candidates.symbolTable) : referencedFieldNames(context, input.candidates.symbolTable)
+			}, spec);
+		}
 		case "declarationKeyword": return provideDeclarationKeywordCompletionItems(context, input.sourceFile, input.candidates, input.clientSupportsSnippets);
 		case "genericBlockKey": return provideGenericBlockKeyCompletionItems(context, input.sourceFile, input.candidates);
 		case "modelType": return provideModelTypeCompletionItems(context, input.sourceFile, input.candidates);
@@ -412,17 +790,16 @@ function providePslCompletionItems(input) {
 }
 function provideAttributeNameCompletionItems(context, sourceFile, source, clientSupportsSnippets) {
 	const names = attributeNames(context, source);
-	const replacementEndOffset = attributeNameReplacementEndOffset(context);
 	const replacementRange = {
 		start: sourceFile.positionAt(context.replacementStartOffset),
-		end: sourceFile.positionAt(replacementEndOffset)
+		end: sourceFile.positionAt(context.replacementEndOffset)
 	};
 	const resolveSpec = attributeSpecResolver(context, source);
 	return names.map((name) => {
 		const newText = attributeNameEditText({
 			name,
 			spec: resolveSpec(name),
-			attribute: context.attribute,
+			hasArgumentList: context.hasArgumentList,
 			clientSupportsSnippets
 		});
 		return {
@@ -439,26 +816,6 @@ function provideAttributeNameCompletionItems(context, sourceFile, source, client
 		};
 	});
 }
-function provideAttributeNamedKeyCompletionItems(context, sourceFile, source) {
-	const spec = attributeSpec(context, source);
-	if (spec === void 0) return [];
-	const existing = existingAttributeNamedKeys(context.attribute, context.offset);
-	const replacementRange = {
-		start: sourceFile.positionAt(context.replacementStartOffset),
-		end: sourceFile.positionAt(namedKeyReplacementEndOffset(context))
-	};
-	return Object.keys(spec.named).filter((name) => !existing.has(name)).map((name) => ({
-		label: name,
-		kind: CompletionItemKind.Property,
-		detail: "Attribute argument",
-		sortText: name,
-		filterText: name,
-		textEdit: {
-			range: replacementRange,
-			newText: name
-		}
-	}));
-}
 function attributeNames(context, source) {
 	switch (context.kind) {
 		case "blockAttributeName": {
@@ -474,54 +831,16 @@ function attributeNames(context, source) {
 	}
 }
 function attributeNameEditText(input) {
-	if (!input.clientSupportsSnippets || input.spec === void 0 || input.attribute.argList() !== void 0) return input.name;
-	const required = requiredAttributeArguments(input.spec);
-	if (required.length === 0) return input.name;
-	return `${input.name}(${required.map((argument, index) => requiredAttributeArgumentSnippet(argument, index + 1)).join(", ")})`;
-}
-function requiredAttributeArguments(spec) {
-	const positionalKeys = new Set(spec.positional.map((argument) => argument.key));
-	return [...spec.positional.flatMap((argument) => isOptionalParam(argument.type) ? [] : [{
-		kind: "positional",
-		argument
-	}]), ...Object.entries(spec.named).flatMap(([key, type]) => positionalKeys.has(key) || isOptionalParam(type) ? [] : [{
-		kind: "named",
-		key,
-		type
-	}])];
-}
-function requiredAttributeArgumentSnippet(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 attributeNameReplacementEndOffset(context) {
-	return context.attribute.name()?.syntax.endOffset ?? context.offset;
-}
-function namedKeyReplacementEndOffset(context) {
-	const token = context.attribute.syntax.tokenAtOffset(context.offset).rightBiased();
-	if (token?.kind === "Ident" && token.offset <= context.offset) return token.endOffset;
-	return context.offset;
-}
-function attributeSpec(context, source) {
-	return attributeSpecForName(context, source, context.attributeName);
-}
-function attributeSpecForName(context, source, name) {
-	return attributeSpecResolver(context, source)(name);
+	if (!input.clientSupportsSnippets || input.spec === void 0 || input.hasArgumentList) return input.name;
+	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 "blockAttributeNamedKey":
+		case "blockAttributeArgumentSlot":
+		case "blockAttributeValue": {
 			const descriptor = findBlockDescriptor(source.pslBlockDescriptors, context.blockKeyword);
 			return (name) => {
 				const factory = descriptor?.attributes?.[name];
@@ -530,7 +849,9 @@ function attributeSpecResolver(context, source) {
 			};
 		}
 		case "modelAttributeName":
-		case "modelAttributeNamedKey": {
+		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;
@@ -543,7 +864,9 @@ function attributeSpecResolver(context, source) {
 			return (name) => specs.model[name]?.(specContext);
 		}
 		case "fieldAttributeName":
-		case "fieldAttributeNamedKey": {
+		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;
@@ -562,29 +885,6 @@ function attributeSpecResolver(context, source) {
 		}
 	}
 }
-function existingAttributeNamedKeys(attribute, cursorOffset) {
-	const names = /* @__PURE__ */ new Set();
-	for (const arg of attribute.argList()?.args() ?? []) {
-		if (!arg.syntax.isOutside(cursorOffset)) continue;
-		const name = arg.name()?.name();
-		if (name !== void 0) names.add(name);
-	}
-	return names;
-}
-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;
-	for (const namespace of Object.values(symbolTable.topLevel.namespaces)) {
-		const namespaceMatch = Object.values(namespace.models).find((model) => sameSyntax(model.node.syntax, node.syntax));
-		if (namespaceMatch !== void 0) return namespaceMatch;
-	}
-}
-function fieldSymbolForNode(model, node) {
-	return Object.values(model.fields).find((field) => sameSyntax(field.node.syntax, node.syntax));
-}
-function sameSyntax(left, right) {
-	return left.offset === right.offset && left.endOffset === right.endOffset;
-}
 function provideDeclarationKeywordCompletionItems(context, sourceFile, source, clientSupportsSnippets) {
 	const replacementRange = {
 		start: sourceFile.positionAt(context.replacementStartOffset),
@@ -1020,7 +1320,7 @@ function createProjectArtifacts(options) {
 	function createInterpretSlot(uri, computed) {
 		if (interpretation === void 0) return () => [];
 		let memo;
-		return () => {
+		const interpretDiagnostics = () => {
 			if (memo === void 0) {
 				const result = interpretation.source.interpret({
 					document: computed.document,
@@ -1032,6 +1332,29 @@ function createProjectArtifacts(options) {
 			}
 			return memo;
 		};
+		return () => {
+			try {
+				return interpretDiagnostics();
+			} catch (error) {
+				if (error instanceof ResponseError && (error.code === LSPErrorCodes.RequestCancelled || error.code === LSPErrorCodes.ServerCancelled || error.code === LSPErrorCodes.ContentModified)) throw error;
+				options.onInterpretationError(uri, error);
+				return [{
+					range: {
+						start: {
+							line: 0,
+							character: 0
+						},
+						end: {
+							line: 0,
+							character: 1
+						}
+					},
+					code: "PRISMA_NEXT_INTERPRETATION_FAILED",
+					message: "Semantic diagnostics are unavailable because of an internal error. A subsequent diagnostic request or edit will retry.",
+					severity: ParseDiagnosticSeverity.Error
+				}];
+			}
+		};
 	}
 	function drop(uri) {
 		if (documents.delete(uri)) symbolTable = void 0;
@@ -1578,6 +1901,10 @@ function createServerOn(connection) {
 			inputs: resolution.inputs,
 			controlStack: resolution.controlStack,
 			getText: (uri) => documents.get(uri)?.getText(),
+			onInterpretationError: (uri, error) => {
+				const detail = error instanceof Error ? error.stack ?? error.message : String(error);
+				connection.console.error(`PSL interpretation failed for ${uri}: ${detail}`);
+			},
 			...resolution.interpretation === void 0 ? {} : { interpretation: resolution.interpretation }
 		});
 		return {
@@ -1679,7 +2006,8 @@ function createServerOn(connection) {
 					...project.controlStack.authoringContributions === void 0 ? {} : { authoringContributions: project.controlStack.authoringContributions },
 					...project.controlStack.controlMutationDefaults === void 0 ? {} : { controlMutationDefaults: project.controlStack.controlMutationDefaults }
 				},
-				clientSupportsSnippets: clientCapabilities.completionSnippets
+				clientSupportsSnippets: clientCapabilities.completionSnippets,
+				clientSupportsTriggerSuggestCommand: clientCapabilities.completionTriggerSuggestCommand
 			})];
 		} catch {
 			return [];
@@ -1698,7 +2026,15 @@ function createServerOn(connection) {
 				full: true,
 				range: true
 			},
-			completionProvider: { triggerCharacters: [".", "@"] },
+			completionProvider: { triggerCharacters: [
+				".",
+				"@",
+				"[",
+				"(",
+				"{",
+				":",
+				","
+			] },
 			...clientCapabilities.pullDiagnostics ? { diagnosticProvider: {
 				interFileDependencies: false,
 				workspaceDiagnostics: false
@@ -1817,6 +2153,7 @@ function toLspSeverity(severity) {
 const noClientCapabilities = {
 	watchedFilesRegistration: false,
 	completionSnippets: false,
+	completionTriggerSuggestCommand: false,
 	pullDiagnostics: false,
 	diagnosticsRefresh: false
 };
@@ -1824,10 +2161,16 @@ function resolveClientCapabilities(params) {
 	return {
 		watchedFilesRegistration: params.capabilities.workspace?.didChangeWatchedFiles?.dynamicRegistration === true,
 		completionSnippets: params.capabilities.textDocument?.completion?.completionItem?.snippetSupport === true,
+		completionTriggerSuggestCommand: supportsCompletionTriggerSuggest(params.initializationOptions),
 		pullDiagnostics: params.capabilities.textDocument?.diagnostic !== void 0,
 		diagnosticsRefresh: params.capabilities.workspace?.diagnostics?.refreshSupport === true
 	};
 }
+function supportsCompletionTriggerSuggest(options) {
+	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;
+}
 function resolveRootPath(params) {
 	const workspaceFolder = params.workspaceFolders?.[0];
 	if (workspaceFolder !== void 0) return fileURLToPath(workspaceFolder.uri);
@@ -2091,4 +2434,4 @@ function startServer(streams) {
 //#endregion
 export { startServer };
 
-//# sourceMappingURL=exports-CYa2di3d.mjs.map
+//# sourceMappingURL=exports-B8peSdx4.mjs.map