@prisma-next/language-server 0.14.0-dev.46 → 0.14.0-dev.48

package/dist/exports/index.mjs

@@ -1,8 +1,8 @@
-import { join } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { findNearestConfigPathForFile, loadConfig } from "@prisma-next/config-loader";
 import { format } from "@prisma-next/psl-parser/format";
-import { CompletionItemKind, DiagnosticSeverity, DidChangeWatchedFilesNotification, FoldingRangeKind, InsertTextFormat, RegistrationRequest, SemanticTokenModifiers, SemanticTokenTypes, TextDocumentSyncKind, TextDocuments } from "vscode-languageserver";
+import { join } from "pathe";
+import { CompletionItemKind, DiagnosticSeverity, DidChangeWatchedFilesNotification, DocumentDiagnosticReportKind, FoldingRangeKind, InsertTextFormat, RegistrationRequest, SemanticTokenModifiers, SemanticTokenTypes, TextDocumentSyncKind, TextDocuments } 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-next/psl-parser/syntax";
 import { isAuthoringPslBlockDescriptor } from "@prisma-next/framework-components/authoring";
@@ -348,7 +348,7 @@ function provideModelTypeCompletionItems(context, sourceFile, source) {
 }
 function provideNamespaceMemberCompletionItems(context, sourceFile, source) {
 	if (context.space !== void 0) return [];
-	return modelTypeCompletionItems(context, sourceFile, namespaceCandidates(source.symbolTable?.topLevel.namespaces[context.namespace]));
+	return modelTypeCompletionItems(context, sourceFile, namespaceCandidates(source.symbolTable.topLevel.namespaces[context.namespace]));
 }
 function modelTypeCompletionItems(context, sourceFile, candidates) {
 	const replacementRange = {
@@ -378,7 +378,6 @@ function configuredScalarCandidates(scalarTypes) {
 	}));
 }
 function topLevelSymbolCandidates(symbolTable) {
-	if (symbolTable === void 0) return [];
 	const { topLevel } = symbolTable;
 	return [
 		...symbolCandidates(recordNames(topLevel.models), "topLevelModel", "Model", CompletionItemKind.Class),
@@ -388,7 +387,6 @@ function topLevelSymbolCandidates(symbolTable) {
 	];
 }
 function allNamespaceCandidates(symbolTable) {
-	if (symbolTable === void 0) return [];
 	return Object.values(symbolTable.topLevel.namespaces).sort((left, right) => compareNames(left.name, right.name)).map(namespaceQualifierCandidate);
 }
 function namespaceCandidates(namespace) {
@@ -441,7 +439,10 @@ function hasPslInputs(config) {
 function resolveSchemaInputs(config) {
 	const inputs = hasPslInputs(config) ? config.contract?.source.inputs : void 0;
 	const uris = new Set(inputs?.map((input) => pathToFileURL(input).toString()));
-	return { includes: (uri) => uris.has(uri) };
+	return {
+		includes: (uri) => uris.has(uri),
+		uris: () => uris
+	};
 }
 //#endregion
 //#region src/config-resolution.ts
@@ -552,29 +553,48 @@ function computeDocumentDiagnostics(uri, text, inputs, controlStack) {
 }
 //#endregion
 //#region src/project-artifacts.ts
-function createProjectArtifacts() {
+function createProjectArtifacts(options) {
+	const { inputs, controlStack, getText } = options;
 	const documents = /* @__PURE__ */ new Map();
 	let symbolTable;
+	function drop(uri) {
+		if (documents.delete(uri)) symbolTable = void 0;
+	}
+	function readDocument(uri) {
+		const existing = documents.get(uri);
+		if (existing !== void 0) return existing;
+		const text = getText(uri);
+		if (text === void 0) return;
+		const computed = computeDocumentDiagnostics(uri, text, inputs, controlStack);
+		if (computed === null) return;
+		const artifacts = {
+			document: computed.document,
+			sourceFile: computed.sourceFile,
+			diagnostics: computed.diagnostics
+		};
+		documents.set(uri, artifacts);
+		symbolTable = computed.symbolTable;
+		return artifacts;
+	}
 	return {
-		getDocument: (uri) => documents.get(uri),
-		getSymbolTable: () => symbolTable,
-		update: (uri, text, inputs, controlStack) => {
-			const computed = computeDocumentDiagnostics(uri, text, inputs, controlStack);
-			if (computed === null) {
-				if (documents.delete(uri)) symbolTable = void 0;
-				return null;
+		document: readDocument,
+		symbolTable: () => {
+			if (symbolTable !== void 0) return symbolTable;
+			for (const uri of inputs.uris()) {
+				const artifacts = readDocument(uri);
+				if (artifacts === void 0) continue;
+				symbolTable ??= buildSymbolTable({
+					document: artifacts.document,
+					sourceFile: artifacts.sourceFile,
+					scalarTypes: controlStack.scalarTypes,
+					pslBlockDescriptors: controlStack.pslBlockDescriptors
+				}).table;
+				return symbolTable;
 			}
-			documents.set(uri, {
-				document: computed.document,
-				sourceFile: computed.sourceFile,
-				text
-			});
-			symbolTable = computed.symbolTable;
-			return computed.diagnostics;
+			throw new Error("invariant violated: project has no open configured input — the server must drop such projects");
 		},
-		remove: (uri) => {
-			if (documents.delete(uri)) symbolTable = void 0;
-		}
+		documentChanged: drop,
+		documentClosed: drop
 	};
 }
 //#endregion
@@ -827,21 +847,19 @@ function classifyTypeReference(path, source, namespace) {
 	if (name === void 0) return { tokenType: "type" };
 	const table = source.symbolTable;
 	const namespaceName = path.length > 1 ? path[path.length - 2] : namespace;
-	const namespaceScope = namespaceName !== void 0 ? table?.topLevel.namespaces[namespaceName] : void 0;
+	const namespaceScope = namespaceName !== void 0 ? table.topLevel.namespaces[namespaceName] : void 0;
 	if (namespaceScope !== void 0) {
 		if (Object.hasOwn(namespaceScope.models, name)) return { tokenType: "class" };
 		if (Object.hasOwn(namespaceScope.compositeTypes, name)) return { tokenType: "struct" };
 		if (Object.hasOwn(namespaceScope.blocks, name)) return { tokenType: "type" };
 	}
-	if (table !== void 0) {
-		if (Object.hasOwn(table.topLevel.models, name)) return { tokenType: "class" };
-		if (Object.hasOwn(table.topLevel.compositeTypes, name)) return { tokenType: "struct" };
-		if (Object.hasOwn(table.topLevel.scalars, name)) return {
-			tokenType: "type",
-			modifierBitset: semanticTokenModifierBits.defaultLibrary
-		};
-		if (Object.hasOwn(table.topLevel.typeAliases, name) || Object.hasOwn(table.topLevel.blocks, name)) return { tokenType: "type" };
-	}
+	if (Object.hasOwn(table.topLevel.models, name)) return { tokenType: "class" };
+	if (Object.hasOwn(table.topLevel.compositeTypes, name)) return { tokenType: "struct" };
+	if (Object.hasOwn(table.topLevel.scalars, name)) return {
+		tokenType: "type",
+		modifierBitset: semanticTokenModifierBits.defaultLibrary
+	};
+	if (Object.hasOwn(table.topLevel.typeAliases, name) || Object.hasOwn(table.topLevel.blocks, name)) return { tokenType: "type" };
 	if (source.scalarTypes.includes(name)) return {
 		tokenType: "type",
 		modifierBitset: semanticTokenModifierBits.defaultLibrary
@@ -849,7 +867,7 @@ function classifyTypeReference(path, source, namespace) {
 	return { tokenType: "type" };
 }
 function isKnownNamespace(name, table) {
-	return table !== void 0 && Object.hasOwn(table.topLevel.namespaces, name);
+	return Object.hasOwn(table.topLevel.namespaces, name);
 }
 function identifierSegments(name) {
 	const segments = [];
@@ -917,13 +935,11 @@ function tokenTypeIndex(tokenType) {
 const semanticTokenSourceLimit = 1e5;
 function createServer(connection) {
 	const documents = new TextDocuments(TextDocument);
-	const projects = /* @__PURE__ */ new Map();
-	const projectLoads = /* @__PURE__ */ new Map();
+	const managedProjects = /* @__PURE__ */ new Map();
 	const documentConfigPaths = /* @__PURE__ */ new Map();
 	let rootPath = process.cwd();
 	let watchedConfigGlob = join(rootPath, "**", CONFIG_FILENAME);
-	let supportsWatchedFilesRegistration = false;
-	let clientSupportsSnippets = false;
+	let clientCapabilities = noClientCapabilities;
 	let disposed = false;
 	function sendDiagnostics(params) {
 		if (disposed) return;
@@ -936,13 +952,12 @@ function createServer(connection) {
 	async function publish(uri) {
 		const project = await resolveProjectForDocument(uri);
 		if (project === void 0) return;
-		const document = documents.get(uri);
-		if (document === void 0) {
+		if (documents.get(uri) === void 0) {
 			documentConfigPaths.delete(uri);
 			return;
 		}
-		const computed = project.artifacts.update(uri, document.getText(), project.inputs, project.controlStack);
-		if (computed === null) {
+		const artifacts = project.artifacts.document(uri);
+		if (artifacts === void 0) {
 			sendDiagnostics({
 				uri,
 				diagnostics: []
@@ -951,16 +966,27 @@ function createServer(connection) {
 		}
 		sendDiagnostics({
 			uri,
-			diagnostics: computed.map((diagnostic) => ({
-				range: diagnostic.range,
-				message: diagnostic.message,
-				code: diagnostic.code,
-				severity: toLspSeverity(diagnostic.severity),
-				source: "prisma-next"
-			}))
+			diagnostics: toDiagnostics(artifacts.diagnostics)
 		});
 	}
+	/**
+	* Project-scoped so a future multi-input symbol table can attach
+	* `relatedDocuments` for cross-file effects.
+	*/
+	function buildDocumentDiagnosticReport(project, uri) {
+		const artifacts = project.artifacts.document(uri);
+		return {
+			kind: DocumentDiagnosticReportKind.Full,
+			items: artifacts === void 0 ? [] : toDiagnostics(artifacts.diagnostics)
+		};
+	}
 	async function resolveProjectForDocument(uri) {
+		const project = await projectForNearestConfig(uri);
+		if (project === void 0 || project.inputs.includes(uri)) return project;
+		documentConfigPaths.delete(uri);
+		dropProjectWithoutManagedDocuments(project.configPath);
+	}
+	async function projectForNearestConfig(uri) {
 		const knownConfigPath = documentConfigPaths.get(uri);
 		if (knownConfigPath !== void 0) {
 			const project = await resolveProjectIfLoadable(knownConfigPath);
@@ -969,7 +995,12 @@ function createServer(connection) {
 		}
 		const filePath = filePathFromUri(uri);
 		if (filePath === void 0) return;
-		const configPath = await findNearestConfigPathForFile(filePath);
+		let configPath;
+		try {
+			configPath = await findNearestConfigPathForFile(filePath);
+		} catch {
+			return;
+		}
 		if (configPath === void 0) return;
 		documentConfigPaths.set(uri, configPath);
 		const project = await resolveProjectIfLoadable(configPath);
@@ -985,26 +1016,44 @@ function createServer(connection) {
 		}
 	}
 	async function resolveProject(configPath) {
-		const existing = projects.get(configPath);
-		if (existing !== void 0) return existing;
-		const existingLoad = projectLoads.get(configPath);
-		if (existingLoad !== void 0) return existingLoad;
-		return queueProjectLoad(configPath);
+		const entry = managedProjects.get(configPath);
+		if (entry === void 0) return startProjectLoad(configPath);
+		return entry.status === "loaded" ? entry.project : entry.load;
 	}
 	function refreshProject(configPath) {
-		return queueProjectLoad(configPath);
+		return startProjectLoad(configPath);
 	}
-	function queueProjectLoad(configPath) {
-		const load = (projectLoads.get(configPath) ?? Promise.resolve()).catch(() => void 0).then(() => loadProject(configPath)).finally(() => {
-			if (projectLoads.get(configPath) === load) projectLoads.delete(configPath);
+	function startProjectLoad(configPath) {
+		const existing = managedProjects.get(configPath);
+		const previousLoad = existing?.status === "loading" ? existing.load : void 0;
+		const hadLoadedProject = existing?.status === "loaded" || existing?.status === "loading" && existing.hadLoadedProject;
+		const load = (previousLoad ?? Promise.resolve(void 0)).catch(() => void 0).then(() => loadProject(configPath)).then((project) => {
+			if (isCurrentLoad(configPath, load)) if (hasManagedDocuments(configPath)) managedProjects.set(configPath, {
+				status: "loaded",
+				project
+			});
+			else managedProjects.delete(configPath);
+			return project;
+		});
+		managedProjects.set(configPath, {
+			status: "loading",
+			load,
+			hadLoadedProject
 		});
-		projectLoads.set(configPath, load);
 		return load;
 	}
+	function isCurrentLoad(configPath, load) {
+		const entry = managedProjects.get(configPath);
+		return entry?.status === "loading" && entry.load === load;
+	}
 	async function loadProject(configPath) {
 		const resolution = await resolveConfigInputs(configPath);
-		const artifacts = projects.get(configPath)?.artifacts ?? createProjectArtifacts();
-		const project = resolution.formatter === void 0 ? {
+		const artifacts = createProjectArtifacts({
+			inputs: resolution.inputs,
+			controlStack: resolution.controlStack,
+			getText: (uri) => documents.get(uri)?.getText()
+		});
+		return resolution.formatter === void 0 ? {
 			configPath,
 			inputs: resolution.inputs,
 			controlStack: resolution.controlStack,
@@ -1016,14 +1065,14 @@ function createServer(connection) {
 			controlStack: resolution.controlStack,
 			artifacts
 		};
-		projects.set(configPath, project);
-		return project;
 	}
 	function stopManagingProject(configPath) {
-		const hadProject = projects.delete(configPath);
+		const entry = managedProjects.get(configPath);
+		const hadProject = entry?.status === "loaded" || entry?.status === "loading" && entry.hadLoadedProject;
+		managedProjects.delete(configPath);
 		for (const document of documents.all()) if (documentConfigPaths.get(document.uri) === configPath) {
 			documentConfigPaths.delete(document.uri);
-			if (hadProject) sendDiagnostics({
+			if (hadProject && !clientCapabilities.pullDiagnostics) sendDiagnostics({
 				uri: document.uri,
 				diagnostics: []
 			});
@@ -1032,6 +1081,13 @@ function createServer(connection) {
 	async function republishOpenDocumentsForConfig(configPath) {
 		for (const document of documents.all()) {
 			if (documentConfigPaths.get(document.uri) === configPath) {
+				if (await resolveProjectForDocument(document.uri) === void 0) {
+					sendDiagnostics({
+						uri: document.uri,
+						diagnostics: []
+					});
+					continue;
+				}
 				await publish(document.uri);
 				continue;
 			}
@@ -1052,13 +1108,8 @@ function createServer(connection) {
 	async function formatDocument(uri) {
 		const document = documents.get(uri);
 		if (document === void 0) return [];
-		let project;
-		try {
-			project = await resolveProjectForDocument(uri);
-		} catch {
-			return [];
-		}
-		if (project === void 0 || !project.inputs.includes(uri)) return [];
+		const project = await resolveProjectForDocument(uri);
+		if (project === void 0) return [];
 		const source = document.getText();
 		let formatted;
 		try {
@@ -1081,62 +1132,47 @@ function createServer(connection) {
 	async function semanticTokensForDocument(uri, range) {
 		const document = documents.get(uri);
 		if (document === void 0) return emptySemanticTokens();
-		const text = document.getText();
-		if (text.length > semanticTokenSourceLimit) return emptySemanticTokens();
+		if (document.getText().length > semanticTokenSourceLimit) return emptySemanticTokens();
 		const project = await resolveProjectForDocument(uri);
 		if (project === void 0) return emptySemanticTokens();
-		const cached = project.artifacts.getDocument(uri);
-		if (cached === void 0 || cached.text !== text) return emptySemanticTokens();
+		const artifacts = project.artifacts.document(uri);
+		if (artifacts === void 0) return emptySemanticTokens();
 		return buildSemanticTokens({
-			document: cached.document,
-			sourceFile: cached.sourceFile,
-			symbolTable: project.artifacts.getSymbolTable(),
+			document: artifacts.document,
+			sourceFile: artifacts.sourceFile,
+			symbolTable: project.artifacts.symbolTable(),
 			scalarTypes: project.controlStack.scalarTypes
 		}, range);
 	}
 	async function completeDocument(uri, position) {
-		const document = documents.get(uri);
-		if (document === void 0) return [];
-		let project;
-		try {
-			project = await resolveProjectForDocument(uri);
-		} catch {
-			return [];
-		}
-		if (project === void 0 || !project.inputs.includes(uri)) return [];
-		const cached = currentDocumentArtifact(project, uri, document.getText());
-		const symbolTable = project.artifacts.getSymbolTable();
-		if (cached === void 0 || symbolTable === void 0) return [];
+		if (documents.get(uri) === void 0) return [];
+		const project = await resolveProjectForDocument(uri);
+		if (project === void 0) return [];
+		const artifacts = project.artifacts.document(uri);
+		if (artifacts === void 0) return [];
 		try {
 			return [...providePslCompletionItems({
 				context: classifyPslCompletionContext({
-					document: cached.document,
-					sourceFile: cached.sourceFile,
+					document: artifacts.document,
+					sourceFile: artifacts.sourceFile,
 					position
 				}),
-				sourceFile: cached.sourceFile,
+				sourceFile: artifacts.sourceFile,
 				candidates: {
 					scalarTypes: project.controlStack.scalarTypes,
 					pslBlockDescriptors: project.controlStack.pslBlockDescriptors,
-					symbolTable
+					symbolTable: project.artifacts.symbolTable()
 				},
-				clientSupportsSnippets
+				clientSupportsSnippets: clientCapabilities.completionSnippets
 			})];
 		} catch {
 			return [];
 		}
 	}
-	function currentDocumentArtifact(project, uri, text) {
-		const cached = project.artifacts.getDocument(uri);
-		if (cached?.sourceFile.text === text) return cached;
-		if (project.artifacts.update(uri, text, project.inputs, project.controlStack) === null) return;
-		return project.artifacts.getDocument(uri);
-	}
 	connection.onInitialize(async (params) => {
-		rootPath = resolveRootPath(params.rootUri, params.rootPath);
+		rootPath = resolveRootPath(params);
 		watchedConfigGlob = join(rootPath, "**", CONFIG_FILENAME);
-		supportsWatchedFilesRegistration = clientSupportsWatchedFilesRegistration(params);
-		clientSupportsSnippets = clientSupportsCompletionSnippets(params);
+		clientCapabilities = resolveClientCapabilities(params);
 		return { capabilities: {
 			textDocumentSync: TextDocumentSyncKind.Incremental,
 			documentFormattingProvider: true,
@@ -1146,11 +1182,15 @@ function createServer(connection) {
 				full: true,
 				range: true
 			},
-			completionProvider: { triggerCharacters: ["."] }
+			completionProvider: { triggerCharacters: ["."] },
+			...clientCapabilities.pullDiagnostics ? { diagnosticProvider: {
+				interFileDependencies: false,
+				workspaceDiagnostics: false
+			} } : {}
 		} };
 	});
 	connection.onInitialized(() => {
-		if (supportsWatchedFilesRegistration) connection.sendRequest(RegistrationRequest.type, { registrations: [{
+		if (clientCapabilities.watchedFilesRegistration) connection.sendRequest(RegistrationRequest.type, { registrations: [{
 			id: "prisma-next-config-watcher",
 			method: DidChangeWatchedFilesNotification.type.method,
 			registerOptions: { watchers: [{ globPattern: watchedConfigGlob }] }
@@ -1160,43 +1200,52 @@ function createServer(connection) {
 	connection.onDidChangeWatchedFiles(async (params) => {
 		const changedConfigPaths = configPathsFromWatchedChanges(params.changes.map((change) => filePathFromUri(change.uri)));
 		for (const configPath of changedConfigPaths) {
-			try {
+			if (managedProjects.has(configPath)) try {
 				await refreshProject(configPath);
 			} catch {
 				stopManagingProject(configPath);
 				continue;
 			}
-			await republishOpenDocumentsForConfig(configPath);
+			if (!clientCapabilities.pullDiagnostics) await republishOpenDocumentsForConfig(configPath);
 		}
+		if (clientCapabilities.pullDiagnostics && clientCapabilities.diagnosticsRefresh && changedConfigPaths.size > 0 && !disposed) connection.languages.diagnostics.refresh().catch(() => void 0);
 	});
 	connection.onDocumentFormatting((params) => formatDocument(params.textDocument.uri));
 	connection.onCompletion((params) => completeDocument(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) => {
+		const project = await resolveProjectForDocument(params.textDocument.uri);
+		if (project === void 0) return {
+			kind: DocumentDiagnosticReportKind.Full,
+			items: []
+		};
+		return buildDocumentDiagnosticReport(project, params.textDocument.uri);
+	});
 	connection.onFoldingRanges(async (params) => {
-		let project;
-		try {
-			project = await resolveProjectForDocument(params.textDocument.uri);
-		} catch {
-			return [];
-		}
+		const project = await resolveProjectForDocument(params.textDocument.uri);
 		if (project === void 0) return [];
-		const cached = project.artifacts.getDocument(params.textDocument.uri);
-		if (cached === void 0) return [];
-		return computeFoldingRanges(cached.document, cached.sourceFile);
+		const artifacts = project.artifacts.document(params.textDocument.uri);
+		if (artifacts === void 0) return [];
+		return computeFoldingRanges(artifacts.document, artifacts.sourceFile);
 	});
 	documents.onDidOpen((event) => {
+		artifactsForDocument(event.document.uri)?.documentChanged(event.document.uri);
+		if (clientCapabilities.pullDiagnostics) return;
 		publishSafely(event.document.uri);
 	});
 	documents.onDidChangeContent((event) => {
+		artifactsForDocument(event.document.uri)?.documentChanged(event.document.uri);
+		if (clientCapabilities.pullDiagnostics) return;
 		publishSafely(event.document.uri);
 	});
 	documents.onDidClose((event) => {
 		const uri = event.document.uri;
 		const configPath = documentConfigPaths.get(uri);
-		if (configPath !== void 0) projects.get(configPath)?.artifacts.remove(uri);
+		artifactsForDocument(uri)?.documentClosed(uri);
 		documentConfigPaths.delete(uri);
-		sendDiagnostics({
+		if (configPath !== void 0) dropProjectWithoutManagedDocuments(configPath);
+		if (!clientCapabilities.pullDiagnostics) sendDiagnostics({
 			uri,
 			diagnostics: []
 		});
@@ -1205,20 +1254,39 @@ function createServer(connection) {
 	connection.listen();
 	function artifactsForDocument(uri) {
 		const configPath = documentConfigPaths.get(uri);
-		return configPath === void 0 ? void 0 : projects.get(configPath)?.artifacts;
+		if (configPath === void 0) return;
+		const entry = managedProjects.get(configPath);
+		return entry?.status === "loaded" ? entry.project.artifacts : void 0;
+	}
+	function hasManagedDocuments(configPath) {
+		for (const managedConfigPath of documentConfigPaths.values()) if (managedConfigPath === configPath) return true;
+		return false;
+	}
+	function dropProjectWithoutManagedDocuments(configPath) {
+		if (hasManagedDocuments(configPath)) return;
+		if (managedProjects.get(configPath)?.status === "loaded") managedProjects.delete(configPath);
 	}
 	return {
 		dispose: () => {
 			disposed = true;
 			connection.dispose();
 		},
-		getDocumentAst: (uri) => artifactsForDocument(uri)?.getDocument(uri),
-		getProjectSymbolTable: (uri) => artifactsForDocument(uri)?.getSymbolTable()
+		getDocumentAst: (uri) => artifactsForDocument(uri)?.document(uri),
+		getProjectSymbolTable: (uri) => artifactsForDocument(uri)?.symbolTable()
 	};
 }
 function emptySemanticTokens() {
 	return { data: [] };
 }
+function toDiagnostics(computed) {
+	return computed.map((diagnostic) => ({
+		range: diagnostic.range,
+		message: diagnostic.message,
+		code: diagnostic.code,
+		severity: toLspSeverity(diagnostic.severity),
+		source: "prisma-next"
+	}));
+}
 function toLspSeverity(severity) {
 	switch (severity) {
 		case ParseDiagnosticSeverity.Warning: return DiagnosticSeverity.Warning;
@@ -1227,15 +1295,25 @@ function toLspSeverity(severity) {
 		default: return DiagnosticSeverity.Error;
 	}
 }
-function clientSupportsWatchedFilesRegistration(params) {
-	return params.capabilities.workspace?.didChangeWatchedFiles?.dynamicRegistration === true;
-}
-function clientSupportsCompletionSnippets(params) {
-	return params.capabilities.textDocument?.completion?.completionItem?.snippetSupport === true;
+const noClientCapabilities = {
+	watchedFilesRegistration: false,
+	completionSnippets: false,
+	pullDiagnostics: false,
+	diagnosticsRefresh: false
+};
+function resolveClientCapabilities(params) {
+	return {
+		watchedFilesRegistration: params.capabilities.workspace?.didChangeWatchedFiles?.dynamicRegistration === true,
+		completionSnippets: params.capabilities.textDocument?.completion?.completionItem?.snippetSupport === true,
+		pullDiagnostics: params.capabilities.textDocument?.diagnostic !== void 0,
+		diagnosticsRefresh: params.capabilities.workspace?.diagnostics?.refreshSupport === true
+	};
 }
-function resolveRootPath(rootUri, rootPath) {
-	if (rootUri) return fileURLToPath(rootUri);
-	if (rootPath) return rootPath;
+function resolveRootPath(params) {
+	const workspaceFolder = params.workspaceFolders?.[0];
+	if (workspaceFolder !== void 0) return fileURLToPath(workspaceFolder.uri);
+	if (params.rootUri) return fileURLToPath(params.rootUri);
+	if (params.rootPath) return params.rootPath;
 	return process.cwd();
 }
 function filePathFromUri(uri) {