@prisma/orm-toolchain 8.0.0-rc.1-dev.46 → 8.0.0-rc.10

package/dist/{exports-8ZUN43ve.mjs → exports-CYa2di3d.mjs}

@@ -1,15 +1,17 @@
-import { n as findNearestConfigPathForFile, o as requireConfigSections, r as loadConfig } from "./exports-BZaG8_w_.mjs";
+import { n as findNearestConfigPathForFile, o as requireConfigSections, r as loadConfig } from "./exports-BXXeNWlj.mjs";
+import { blindCast } from "@prisma/orm-framework/utils/casts";
 import { InternalError } from "@prisma/orm-framework/utils/internal-error";
 import { CliStructuredError } from "@prisma/orm-framework/errors/control";
 import { createControlStack } from "@prisma/orm-framework/components/control";
 import { join } from "pathe";
-import { format } from "@prisma/orm-framework/psl-parser/format";
+import { normalize as normalize$1 } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import { CompletionItemKind, ConnectionError, DiagnosticSeverity, DidChangeWatchedFilesNotification, DocumentDiagnosticReportKind, FoldingRangeKind, InsertTextFormat, ProposedFeatures, RegistrationRequest, SemanticTokenModifiers, SemanticTokenTypes, TextDocumentSyncKind, TextDocuments, createConnection } from "vscode-languageserver";
+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 { 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, 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, TypesBlockAst, any, filterChildren, findChildToken, parse, skipTriviaToken } from "@prisma/orm-framework/psl-parser/syntax";
 import { isAuthoringPslBlockDescriptor } from "@prisma/orm-framework/components/authoring";
-import { buildSymbolTable, findBlockDescriptor } from "@prisma/orm-framework/psl-parser";
+import { assembleAttributeSpecs, buildSymbolTable, findBlockDescriptor } from "@prisma/orm-framework/psl-parser";
 import { hasPslInterpreter } from "@prisma/orm-framework/psl-parser/interpret";
 import { ProposedFeatures as ProposedFeatures$1, StreamMessageReader, StreamMessageWriter, createConnection as createConnection$1, createProtocolConnection } from "vscode-languageserver/node";
 import { Console } from "node:console";
@@ -64,6 +66,13 @@ function classifyPslCompletionContext(input) {
 	const preceding = precedingToken(at, edit);
 	const precedingNode = preceding?.parent;
 	const replacementStartOffset = edit?.offset ?? offset;
+	const attributeClassifierInput = {
+		offset,
+		node: at.leftBiased()?.parent ?? at.rightBiased()?.parent,
+		replacementStartOffset
+	};
+	const attributeContext = classifyFieldAttribute(attributeClassifierInput) ?? classifyGenericBlockAttribute(attributeClassifierInput) ?? classifyModelAttribute(attributeClassifierInput);
+	if (attributeContext !== void 0) return attributeContext;
 	const declarationKeywordContext = classifyDeclarationKeyword({
 		node: precedingNode,
 		offset,
@@ -194,6 +203,113 @@ function blockBodyContainsOffset(block, offset) {
 	const bodyEnd = block.rbrace()?.offset ?? block.syntax.endOffset;
 	return offset >= bodyStart && offset <= bodyEnd;
 }
+function classifyFieldAttribute(input) {
+	const attribute = input.node?.findAncestor(FieldAttributeAst.cast);
+	if (attribute === void 0 || attribute.syntax.isOutside(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
+	};
+}
+function classifyGenericBlockAttribute(input) {
+	const attribute = activeModelAttribute(input);
+	const block = attribute?.syntax.findAncestor(GenericBlockDeclarationAst.cast);
+	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
+	};
+}
+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",
+		offset: input.offset,
+		replacementStartOffset: input.replacementStartOffset,
+		attribute,
+		model
+	};
+	const attributeName = attributeNamedKeyName(attribute, input.offset);
+	if (attributeName === void 0) return UNSUPPORTED;
+	return {
+		kind: "modelAttributeNamedKey",
+		offset: input.offset,
+		replacementStartOffset: input.replacementStartOffset,
+		attributeName,
+		attribute,
+		model
+	};
+}
+function activeModelAttribute(input) {
+	const attribute = input.node?.findAncestor(ModelAttributeAst.cast);
+	if (attribute === void 0 || attribute.syntax.isOutside(input.offset)) return;
+	return attribute;
+}
+function isAttributeNamePosition(attribute, offset) {
+	return !attribute.argList()?.syntax.isInside(offset);
+}
+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 classifyGenericBlockParameter(input) {
 	const node = input.at.leftBiased()?.parent;
 	const block = node?.findAncestor(GenericBlockDeclarationAst.cast);
@@ -282,12 +398,193 @@ function providePslCompletionItems(input) {
 		case "unsupported": return [];
 		case "spaceMember": return [];
 		case "genericBlockValue": return [];
+		case "fieldAttributeName":
+		case "modelAttributeName":
+		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 "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);
 		case "namespaceMember": return provideNamespaceMemberCompletionItems(context, input.sourceFile, input.candidates);
 	}
 }
+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)
+	};
+	const resolveSpec = attributeSpecResolver(context, source);
+	return names.map((name) => {
+		const newText = attributeNameEditText({
+			name,
+			spec: resolveSpec(name),
+			attribute: context.attribute,
+			clientSupportsSnippets
+		});
+		return {
+			label: name,
+			kind: CompletionItemKind.Function,
+			detail: "PSL attribute",
+			sortText: name,
+			filterText: name,
+			textEdit: {
+				range: replacementRange,
+				newText
+			},
+			...newText !== name ? { insertTextFormat: InsertTextFormat.Snippet } : {}
+		};
+	});
+}
+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": {
+			const descriptor = findBlockDescriptor(source.pslBlockDescriptors, context.blockKeyword);
+			return sortedUnique(Object.keys(descriptor?.attributes ?? {}));
+		}
+		case "fieldAttributeName":
+			if (source.authoringContributions === void 0) return [];
+			return sortedUnique(Object.keys(assembleAttributeSpecs(source.authoringContributions).field));
+		case "modelAttributeName":
+			if (source.authoringContributions === void 0) return [];
+			return sortedUnique(Object.keys(assembleAttributeSpecs(source.authoringContributions).model));
+	}
+}
+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);
+}
+function attributeSpecResolver(context, source) {
+	switch (context.kind) {
+		case "blockAttributeName":
+		case "blockAttributeNamedKey": {
+			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": {
+			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": {
+			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 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),
@@ -474,13 +771,43 @@ function hasPslInputs(config) {
 	return source?.format === "psl" && source.inputs !== void 0;
 }
 function resolveSchemaInputs(config) {
-	const inputs = hasPslInputs(config) ? config.contract?.source.inputs : void 0;
-	const uris = new Set(inputs?.map((input) => pathToFileURL(input).toString()));
+	const uris = (hasPslInputs(config) ? config.contract?.source.inputs : void 0)?.map(configuredInputUri) ?? [];
+	const identities = new Set(uris.map(canonicalFileIdentity));
 	return {
-		includes: (uri) => uris.has(uri),
+		includes: (uri) => identities.has(canonicalFileIdentity(uri)),
 		uris: () => uris
 	};
 }
+function configuredInputUri(input) {
+	if (isFileUri(input)) return input;
+	return pathToFileURL(input, { windows: isWindowsPlatform() }).toString();
+}
+function isFileUri(input) {
+	try {
+		return new URL(input).protocol === "file:";
+	} catch {
+		return false;
+	}
+}
+function canonicalFileIdentity(uri) {
+	let url;
+	try {
+		url = new URL(uri);
+	} catch {
+		return uri;
+	}
+	if (url.protocol !== "file:") return uri;
+	try {
+		const windows = isWindowsPlatform();
+		const filePath = normalize$1(fileURLToPath(url, { windows }));
+		return windows ? filePath.toLowerCase() : filePath;
+	} catch {
+		return uri;
+	}
+}
+function isWindowsPlatform() {
+	return process.platform === "win32";
+}
 const CONFIG_FILENAME = "prisma.config.ts";
 const emptyPipelineInputs = {
 	scalarTypes: [],
@@ -518,7 +845,9 @@ async function resolveConfigInputs(configPath) {
 function pipelineInputsFromStack(stack) {
 	return {
 		scalarTypes: [...stack.scalarTypes],
-		pslBlockDescriptors: stack.authoringContributions.pslBlockDescriptors
+		pslBlockDescriptors: stack.authoringContributions.pslBlockDescriptors,
+		authoringContributions: stack.authoringContributions,
+		...stack.controlMutationDefaults === void 0 ? {} : { controlMutationDefaults: stack.controlMutationDefaults }
 	};
 }
 function resolveInterpretation(config, stack, inputs) {
@@ -611,12 +940,27 @@ function guardCalls(target) {
 		return value;
 	} });
 }
+/**
+* Whether an error says the connection is gone.
+*
+* The identity check is the fast path. It misses when the error comes from a
+* second copy of `vscode-jsonrpc` in the dependency tree, whose
+* `ConnectionError` is a different class carrying the same shape, so the code
+* is what decides: `Closed`, `Disposed` and `AlreadyListening` are the whole
+* range, and no other error jsonrpc throws carries a numeric `code` in it.
+*/
+function isConnectionGone(error) {
+	if (error instanceof ConnectionError) return true;
+	if (!(error instanceof Error) || !("code" in error)) return false;
+	const { code } = error;
+	return code === ConnectionErrors.Closed || code === ConnectionErrors.Disposed || code === ConnectionErrors.AlreadyListening;
+}
 function whileConnected(send) {
 	let sent;
 	try {
 		sent = send();
 	} catch (error) {
-		if (error instanceof ConnectionError) return Promise.resolve(void 0);
+		if (isConnectionGone(error)) return Promise.resolve(void 0);
 		throw error;
 	}
 	return isThenable(sent) ? sent.then(void 0, () => void 0) : sent;
@@ -644,6 +988,15 @@ function runPipeline(text, inputs) {
 		diagnostics: mapParseDiagnostics([...parseDiagnostics, ...symbolTableDiagnostics])
 	};
 }
+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);
+}
 /**
 * `null` (not a configured input) is distinct from a `DocumentDiagnostics` whose
 * `diagnostics` are `[]` (an input that parsed clean): the caller treats both as
@@ -651,7 +1004,7 @@ function runPipeline(text, inputs) {
 * diagnosing.
 */
 function computeDocumentDiagnostics(uri, text, inputs, controlStack) {
-	if (!inputs.includes(uri)) return null;
+	if (!inputs.includes(uri) || !isPrismaNextSchema(text)) return null;
 	const { document, sourceFile, symbolTable, diagnostics } = runPipeline(text, controlStack);
 	return {
 		diagnostics,
@@ -714,7 +1067,7 @@ function createProjectArtifacts(options) {
 				}).table;
 				return symbolTable;
 			}
-			throw new InternalError("invariant violated: project has no open configured input — the server must drop such projects");
+			throw new InternalError("invariant violated: project has no readable configured input — callers must check document artifacts first");
 		},
 		documentChanged: drop,
 		documentClosed: drop
@@ -1057,7 +1410,7 @@ function lastGoodProject(entry) {
 	if (entry === void 0 || entry.status === "failed") return;
 	return entry.status === "loaded" ? entry.project : entry.lastGood;
 }
-const CONFIG_LOAD_FAILED_CODE = "PRISMA_NEXT_CONFIG_LOAD_FAILED";
+const CONFIG_LOAD_FAILED_CODE = "PRISMA_CONFIG_LOAD_FAILED";
 const semanticTokenSourceLimit = 1e5;
 function createServer(connection) {
 	return createServerOn(guardedConnection(connection));
@@ -1201,7 +1554,7 @@ function createServerOn(connection) {
 				message: configFailureMessage(error),
 				code: CONFIG_LOAD_FAILED_CODE,
 				severity: DiagnosticSeverity.Error,
-				source: "prisma-next"
+				source: "prisma"
 			}]
 		});
 	}
@@ -1268,12 +1621,13 @@ function createServerOn(connection) {
 	async function formatDocument(uri) {
 		const document = documents.get(uri);
 		if (document === void 0) return [];
+		const source = document.getText();
+		if (!isPrismaNextSchema(source)) return [];
 		const project = await resolveProjectForDocument(uri);
 		if (project === void 0) return [];
-		const source = document.getText();
 		let formatted;
 		try {
-			formatted = format(source, project.formatter);
+			formatted = renameLegacyDirective(format(source, project.formatter));
 		} catch {
 			return [];
 		}
@@ -1321,7 +1675,9 @@ function createServerOn(connection) {
 				candidates: {
 					scalarTypes: project.controlStack.scalarTypes,
 					pslBlockDescriptors: project.controlStack.pslBlockDescriptors,
-					symbolTable: project.artifacts.symbolTable()
+					symbolTable: project.artifacts.symbolTable(),
+					...project.controlStack.authoringContributions === void 0 ? {} : { authoringContributions: project.controlStack.authoringContributions },
+					...project.controlStack.controlMutationDefaults === void 0 ? {} : { controlMutationDefaults: project.controlStack.controlMutationDefaults }
 				},
 				clientSupportsSnippets: clientCapabilities.completionSnippets
 			})];
@@ -1342,7 +1698,7 @@ function createServerOn(connection) {
 				full: true,
 				range: true
 			},
-			completionProvider: { triggerCharacters: ["."] },
+			completionProvider: { triggerCharacters: [".", "@"] },
 			...clientCapabilities.pullDiagnostics ? { diagnosticProvider: {
 				interFileDependencies: false,
 				workspaceDiagnostics: false
@@ -1355,7 +1711,7 @@ function createServerOn(connection) {
 			method: DidChangeWatchedFilesNotification.type.method,
 			registerOptions: { watchers: [{ globPattern: watchedConfigGlob }] }
 		}] });
-		else logWarn("Client does not support dynamic file-watcher registration; Prisma Next config changes will not be picked up without a restart.");
+		else logWarn("Client does not support dynamic file-watcher registration; Prisma 8 config changes will not be picked up without a restart.");
 	});
 	connection.onDidChangeWatchedFiles(async (params) => {
 		const changedConfigPaths = configPathsFromWatchedChanges(params.changes.map((change) => filePathFromUri(change.uri)));
@@ -1431,7 +1787,11 @@ function createServerOn(connection) {
 	return {
 		dispose: () => connection.dispose(),
 		getDocumentAst: (uri) => artifactsForDocument(uri)?.document(uri),
-		getProjectSymbolTable: (uri) => artifactsForDocument(uri)?.symbolTable()
+		getProjectSymbolTable: (uri) => {
+			const artifacts = artifactsForDocument(uri);
+			if (artifacts?.document(uri) === void 0) return;
+			return artifacts.symbolTable();
+		}
 	};
 }
 function emptySemanticTokens() {
@@ -1443,7 +1803,7 @@ function toDiagnostics(computed) {
 		message: diagnostic.message,
 		code: diagnostic.code,
 		severity: toLspSeverity(diagnostic.severity),
-		source: "prisma-next"
+		source: "prisma"
 	}));
 }
 function toLspSeverity(severity) {
@@ -1731,4 +2091,4 @@ function startServer(streams) {
 //#endregion
 export { startServer };
 
-//# sourceMappingURL=exports-8ZUN43ve.mjs.map
+//# sourceMappingURL=exports-CYa2di3d.mjs.map