stan-language-server 0.2.0 → 0.3.1

package/README.md

@@ -10,28 +10,80 @@ A language server for the Stan probabilistic programming language written in Typ
 - **Code formatting**: Using the official Stan compiler
 - **Include file support**: Full `#include` resolution and compilation
 
-To install dependencies:
 
-```bash
-bun install
-```
+## Editor-specific configuration
 
-To run the language server:
+### VSCode:
 
-```bash
-bun run src/server.ts
-```
+Install the [extension](https://github.com/WardBrian/vscode-stan-extension)
+from [Marketplace](https://marketplace.visualstudio.com/items?itemName=wardbrian.vscode-stan-extension)
+or [open-vsx](https://open-vsx.org/extension/wardbrian/vscode-stan-extension).
 
-Building a binary executable:
+### Neovim
 
-```bash
-bun build server.ts --compile --outfile stan-language-server
+There are many ways to install language servers in neovim. Here is one (if you have a different or better way, consider contributing it!):
+
+Download the latest language server executable from [GitHub](https://github.com/tomatitito/stan-language-server/tags) and put it somewhere in your PATH. Then in your `nvim` config folder add `lua/lsp/init.lua` with:
+```lua
+local servers = {
+    stan_ls = "lsp.stan",
+}
+
+local function setup_server(name, config_module)
+    local config = require(config_module)
+
+    vim.api.nvim_create_autocmd("FileType", {
+        pattern = config.filetypes,
+        callback = function()
+            if #vim.lsp.get_clients({ bufnr = 0, name = name }) > 0 then
+                return
+            end
+
+            local root_dir = vim.fs.root(0, config.root_markers)
+            print(string.format("Starting %s for buffer %d with root: %s", name, vim.api.nvim_get_current_buf(),
+                root_dir or "none"))
+
+            vim.lsp.start({
+                name = name,
+                cmd = config.cmd,
+                root_dir = root_dir,
+                initialization_options = config.settings or {},
+                on_exit = function(code, signal)
+                    print(string.format("%s exited with code %d, signal %d", name, code, signal))
+                end,
+            })
+        end,
+    })
+end
+
+for server_name, config_path in pairs(servers) do
+    setup_server(server_name, config_path)
+end
+```
+
+Then in `lua/lsp/stan.lua` add the following:
+```lua
+return {
+    cmd = { "stan-language-server", "--stdio" },
+    filetypes = { "stan" },
+    root_markers = { ".git" },
+    settings = {
+        maxLineLength = 78,
+        includePaths = {},
+    },
+}
 ```
 
-## Configuration
+### Zed
+
+Install the [Stan extension](https://zed.dev/extensions/stan).
 
 ### Sublime Text 4
 
+Using [LSP for Sublime Text](https://lsp.sublimetext.io/),
+[download the latest release](https://github.com/tomatitito/stan-language-server/releases)
+and add the following to the settings file:
+
 ```json
 {
   "clients": {
@@ -50,10 +102,41 @@ bun build server.ts --compile --outfile stan-language-server
 
 ### Emacs (eglot)
 
-Assuming you are using stan-ts-mode:
+Assuming you are using [stan-ts-mode](https://github.com/WardBrian/stan-ts-mode),
+[download the latest release](https://github.com/tomatitito/stan-language-server/releases)
+and add the following to your `init.el`:
 
 ```elisp
+; elgot is built in to emacs 29+, but a similar config would work for lsp-mode
 (with-eval-after-load 'eglot
     (add-to-list 'eglot-server-programs
         '(stan-ts-mode . ("/YOUR/PATH/TO/stan-language-server" "--stdio"))))
 ```
+
+
+## For developers
+
+Development uses [bun](https://bun.sh/)
+
+To install dependencies:
+
+```bash
+bun install
+```
+
+Building a binary executable:
+
+```bash
+bun build:binary
+```
+
+To run unit tests:
+```bash
+bun test
+```
+
+To run end-to-end tests:
+```bash
+pip install pytest pytest-lsp
+bun build:binary && pytest tests/
+```

package/dist/handlers/compilation/compilation.d.ts

@@ -1,6 +1,7 @@
 import type { TextDocument } from "vscode-languageserver-textdocument";
 import { type TextDocuments, type WorkspaceFolder, type RemoteConsole } from "vscode-languageserver";
-import type { FileSystemReader, StancReturn } from "../../types/common";
+import type { FileSystemReader } from "../../types/common";
+import { type StancReturn } from "stanc3";
 export interface Settings {
     maxLineLength: number;
     includePaths: string[];

package/dist/handlers/compilation/includes.d.ts

@@ -1,5 +1,5 @@
 import { TextDocuments, WorkspaceFolder, type RemoteConsole } from "vscode-languageserver";
-import type { TextDocument } from "vscode-languageserver-textdocument";
+import { TextDocument } from "vscode-languageserver-textdocument";
 import type { FileSystemReader } from "../../types";
 export type Filename = string;
 export type FileContent = string;
@@ -8,4 +8,4 @@ export type FilePathError = {
 };
 export declare function getFilenames(fileContent: string): Filename[];
 export declare function isFilePathError(value: unknown): value is FilePathError;
-export declare function handleIncludes(document: TextDocument, documentManager: TextDocuments<TextDocument>, workspaceFolders: WorkspaceFolder[], includePaths: string[], logger: RemoteConsole, reader?: FileSystemReader): Promise<Record<Filename, FileContent>>;
+export declare function handleIncludes(document: TextDocument, documentManager: TextDocuments<TextDocument>, workspaceFolders: WorkspaceFolder[], includePaths: string[], logger: RemoteConsole, reader?: FileSystemReader, alreadyIncluded?: Set<Filename>): Promise<Record<Filename, FileContent>>;

package/dist/handlers/diagnostics.d.ts

@@ -1,5 +1,5 @@
 import { Diagnostic, TextDocuments, WorkspaceFolder, type DocumentDiagnosticParams, type RemoteConsole } from "vscode-languageserver";
 import { TextDocument } from "vscode-languageserver-textdocument";
-import { type Settings } from "./compilation/compilation";
 import type { FileSystemReader } from "../types";
+import { type Settings } from "./compilation/compilation";
 export declare function handleDiagnostics(params: DocumentDiagnosticParams, documents: TextDocuments<TextDocument>, workspaceFolders: WorkspaceFolder[], settings: Settings, logger: RemoteConsole, reader?: FileSystemReader): Promise<Diagnostic[]>;

package/dist/handlers/hover.d.ts

@@ -1,8 +1,5 @@
-import type { HoverParams, Hover, MarkupContent } from "vscode-languageserver";
+import type { HoverParams, Hover } from "vscode-languageserver";
 import type { TextDocument } from "vscode-languageserver-textdocument";
 export declare const manual_functions: string[];
-type MarkupLookupMap = Map<string, MarkupContent>;
-type GetMarkupLookupMapFn = () => MarkupLookupMap;
-export declare const handleHover: (getMarkupLookupFn: GetMarkupLookupMapFn) => (document: TextDocument, params: HoverParams) => Promise<Hover | null>;
-declare const _default: (document: TextDocument, params: HoverParams) => Promise<Hover | null>;
-export default _default;
+declare function handleHover(document: TextDocument, params: HoverParams): Promise<Hover | null>;
+export default handleHover;

package/dist/language/diagnostics/provider.d.ts

@@ -1,3 +1,7 @@
-import { type StanDiagnostic } from "../../types/diagnostics";
-import type { StancReturn } from "../../types/common";
-export declare function provideDiagnostics(compilerResult: StancReturn): StanDiagnostic[];
+import type { StancReturn } from "stanc3";
+import type { Range } from "vscode-languageserver";
+export declare function provideDiagnostics(compilerResult: StancReturn): {
+    range: Range;
+    severity: string;
+    message: string;
+}[];

package/dist/server/index.js

@@ -1,9 +1,10 @@
 // src/server/index.ts
-import { TextDocument } from "vscode-languageserver-textdocument";
+import { TextDocument as TextDocument2 } from "vscode-languageserver-textdocument";
 import {
   DiagnosticRefreshRequest,
   DidChangeConfigurationNotification,
   DocumentDiagnosticRequest,
+  MessageType,
   TextDocumentSyncKind,
   TextDocuments as TextDocuments3
 } from "vscode-languageserver/node";
@@ -217,6 +218,7 @@ var setupDistributionMap = () => {
   }
   return distributionToFunctionMap;
 };
+var DISTRIBUTION_FUNCTION_MAP = setupDistributionMap();
 var tildeBefore = (text, pos) => {
   for (let i = pos - 1;i >= 0; i--) {
     const char = text[i];
@@ -233,9 +235,8 @@ var tildeBefore = (text, pos) => {
 var tryDistributionHover = (text, beginningOfWord, endOfWord) => {
   if (!tildeBefore(text, beginningOfWord))
     return null;
-  const distributionToFunctionMap = setupDistributionMap();
   const dist = text.substring(beginningOfWord, endOfWord).trim();
-  const functionName = distributionToFunctionMap.get(dist);
+  const functionName = DISTRIBUTION_FUNCTION_MAP.get(dist);
   if (!functionName)
     return null;
   return functionName;
@@ -325,6 +326,7 @@ var initializeFunctionMarkupMap = () => {
   }
   return markupLookupMap;
 };
+var FUNCTION_MARKUP_LOOKUP = initializeFunctionMarkupMap();
 function markupContentToHover(content, document, beginningOfWord, endOfWord) {
   return {
     contents: content,
@@ -334,15 +336,7 @@ function markupContentToHover(content, document, beginningOfWord, endOfWord) {
     }
   };
 }
-var handleHover = (getMarkupLookupFn) => async (document, params) => {
-  const functionMarkupLookup = getMarkupLookupFn();
-  const currentLine = document.getText({
-    start: { line: params.position.line, character: 0 },
-    end: { line: params.position.line + 1, character: 0 }
-  }).trim();
-  if (!currentLine || !currentLine.includes("(")) {
-    return null;
-  }
+async function handleHover(document, params) {
   const text = document.getText();
   const offset = document.offsetAt(params.position);
   if (!isWordChar(text[offset])) {
@@ -355,14 +349,14 @@ var handleHover = (getMarkupLookupFn) => async (document, params) => {
   const beginningOfWord = previousWordBoundary(text, offset);
   const hoverName = provideHover(text, beginningOfWord, nextParen);
   if (hoverName) {
-    const hoverContent = functionMarkupLookup.get(hoverName);
+    const hoverContent = FUNCTION_MARKUP_LOOKUP.get(hoverName);
     if (hoverContent !== undefined) {
       return markupContentToHover(hoverContent, document, beginningOfWord, nextParen);
     }
   }
   return null;
-};
-var hover_default = handleHover(initializeFunctionMarkupMap);
+}
+var hover_default = handleHover;
 
 // src/language/completion/providers/functions.ts
 var provideFunctionCompletions = (text, position, functionSignatures) => {
@@ -457,31 +451,21 @@ function constraintToCompletionItem(constraint) {
     kind: CompletionItemKind.Property
   };
 }
-function convertPosition(position) {
-  return {
-    line: position.line,
-    character: position.character
-  };
-}
-function getDistributionData() {
-  return dump_stan_math_distributions2().split(`
+var DISTRIBUTION_DATA = dump_stan_math_distributions2().split(`
 `).map((line) => line.split(":")[0]?.trim() ?? "").filter((name) => name !== "");
-}
-function getFunctionData() {
-  return dump_stan_math_signatures2().split(`
+var FUNCTION_DATA = dump_stan_math_signatures2().split(`
 `);
-}
 function handleCompletion(params, documents) {
   const document = documents.get(params.textDocument.uri);
   if (!document) {
     return [];
   }
   const text = document.getText();
-  const position = convertPosition(params.position);
+  const position = params.position;
   const keywords = provideKeywordCompletions(text, position);
-  const distributions = provideDistributionCompletions(text, position, getDistributionData());
+  const distributions = provideDistributionCompletions(text, position, DISTRIBUTION_DATA);
   const datatypes = provideDatatypeCompletions(text, position);
-  const functions = provideFunctionCompletions(text, position, getFunctionData());
+  const functions = provideFunctionCompletions(text, position, FUNCTION_DATA);
   const constraints = provideConstraintCompletions(text, position);
   const allItems = [
     ...keywords.map(keywordToCompletionItem),
@@ -494,14 +478,18 @@ function handleCompletion(params, documents) {
 }
 // src/handlers/diagnostics.ts
 import {
-  DiagnosticSeverity as DiagnosticSeverity2
+  DiagnosticSeverity
 } from "vscode-languageserver";
 
-// src/language/diagnostics/linter.ts
-function rangeFromMessage(message) {
-  if (!message)
+// src/constants/index.ts
+var SERVER_ID = "stan-language-server";
+
+// src/language/diagnostics/provider.ts
+function getRangeFromMessage(message) {
+  const msg = String(message);
+  if (!msg)
     return;
-  const start = message.matchAll(/'.*', line (\d+), column (\d+)( to)?/g);
+  const start = msg.matchAll(/'.*', line (\d+), column (\d+)( to)?/g);
   const lastMatch = Array.from(start).pop();
   if (!lastMatch || !lastMatch[1] || !lastMatch[2]) {
     return;
@@ -511,7 +499,7 @@ function rangeFromMessage(message) {
   let endLine = startLine;
   let endColumn = startColumn;
   if (lastMatch[3]) {
-    const end = message.match(/to (line (\d+), )?column (\d+)/);
+    const end = msg.match(/to (line (\d+), )?column (\d+)/);
     if (end && end[3]) {
       if (end[1] && end[2]) {
         endLine = parseInt(end[2]) - 1;
@@ -525,64 +513,60 @@ function rangeFromMessage(message) {
   };
 }
 function getWarningMessage(message) {
-  let warning = message.replace(/Warning.*column \d+: /s, "");
+  const msg = String(message);
+  let warning = msg.replace(/Warning.*column \d+: /s, "");
   warning = warning.replace(/\s+/gs, " ");
   warning = warning.trim();
-  warning = message.includes("included from") ? `Warning in included file:
+  warning = msg.includes("included from") ? `Warning in included file:
 ` + warning : warning;
   return warning;
 }
 function getErrorMessage(message) {
-  let error = message;
-  if (message.includes(`------
+  const msg = String(message);
+  let error = msg;
+  if (msg.includes(`------
 `)) {
     error = error.split(`------
 `)[2] ?? error;
   }
   error = error.trim();
-  error = message.includes("included from") ? `Error in included file:
+  error = msg.includes("included from") ? `Error in included file:
 ` + error : error;
   error = error.includes("given information about") ? error + `
 Try opening the included file and making the Stan language server aware of it.` : error;
   return error;
 }
-
-// src/constants/index.ts
-var SERVER_ID = "stan-language-server";
-
-// src/language/diagnostics/provider.ts
+function provideErrorMessageAndRange(message) {
+  return { range: getRangeFromMessage(message), message: getErrorMessage(message) };
+}
+function provideWarningMessageAndRange(message) {
+  return { range: getRangeFromMessage(message), message: getWarningMessage(message) };
+}
 function provideDiagnostics(compilerResult) {
-  const diagnostics = [];
-  if (compilerResult.errors) {
-    for (const error of compilerResult.errors) {
-      const range = rangeFromMessage(error);
-      if (range) {
-        diagnostics.push({
-          range,
-          severity: 1 /* Error */,
-          message: getErrorMessage(error),
-          source: SERVER_ID
-        });
-      }
-    }
-  }
-  if (compilerResult.warnings) {
-    for (const warning of compilerResult.warnings) {
-      const range = rangeFromMessage(warning);
-      if (range) {
-        diagnostics.push({
-          range,
-          severity: 2 /* Warning */,
-          message: getWarningMessage(warning),
-          source: SERVER_ID
-        });
-      }
-    }
-  }
-  return diagnostics;
+  const errorDiagnostics = compilerResult.errors?.map((msg) => {
+    return provideErrorMessageAndRange(msg);
+  }).filter((item) => item.range !== undefined && item.message !== undefined).map(({ range, message }) => {
+    return {
+      range,
+      severity: "error",
+      message
+    };
+  }) ?? [];
+  const warningDiagnostics = compilerResult.warnings?.map((msg) => {
+    return provideWarningMessageAndRange(msg);
+  }).filter((item) => item.range !== undefined).map(({ range, message }) => {
+    return {
+      range,
+      severity: "warning",
+      message
+    };
+  }) ?? [];
+  return [...errorDiagnostics, ...warningDiagnostics];
 }
+
 // src/handlers/compilation/includes.ts
 import { join } from "path";
+import { TextDocument } from "vscode-languageserver-textdocument";
 import { URI, Utils } from "vscode-uri";
 function getFilenames(fileContent) {
   const includePattern = /#include\s*[<"]?([^>"\s]*)[>"]?/g;
@@ -593,13 +577,16 @@ function getFilenames(fileContent) {
 function isFilePathError(value) {
   return typeof value === "object" && value !== null && "msg" in value;
 }
-async function handleIncludes(document, documentManager, workspaceFolders, includePaths, logger, reader) {
+async function handleIncludes(document, documentManager, workspaceFolders, includePaths, logger, reader, alreadyIncluded = new Set) {
   try {
     const includeFilenames = getFilenames(document.getText());
     if (includeFilenames.length === 0) {
       return {};
     }
     const allResults = await Promise.all(includeFilenames.map(async (filename) => {
+      if (alreadyIncluded.has(filename)) {
+        return [filename, { msg: `File already included: ${filename}` }];
+      }
       try {
         const content = await readIncludedFile(document, documentManager, workspaceFolders, includePaths, filename, reader);
         return [filename, content];
@@ -608,7 +595,10 @@ async function handleIncludes(document, documentManager, workspaceFolders, inclu
       }
     }));
     const validResults = allResults.filter(([_, content]) => !isFilePathError(content));
-    return Object.fromEntries(validResults);
+    const currentlyIncluded = new Set(validResults.map(([filename, _]) => filename)).union(alreadyIncluded);
+    const recursiveIncludes = await Promise.all(validResults.map(async ([_, content]) => await handleIncludes(content, documentManager, workspaceFolders, includePaths, logger, reader, currentlyIncluded)));
+    const results = validResults.map(([filename, contents]) => [filename, contents.getText()]).concat(recursiveIncludes.map(Object.entries).flat());
+    return Object.fromEntries(results);
   } catch (error) {
     logger.warn(`Resolving included files failed: ${error}`);
     return Promise.resolve({});
@@ -621,10 +611,7 @@ var readIncludedFile = async (document, documentManager, workspaceFolders, inclu
     return Promise.resolve(includedFileContent);
   }
   if (reader) {
-    includedFileContent = await readIncludedFileFromFileSystem(filename, [
-      currentDir.fsPath,
-      ...includePaths
-    ], reader);
+    includedFileContent = await readIncludedFileFromFileSystem(filename, [currentDir.fsPath, ...includePaths], reader);
   }
   if (!isFilePathError(includedFileContent)) {
     return Promise.resolve(includedFileContent);
@@ -645,13 +632,14 @@ var readIncludedFileFromWorkspace = (documentManager, workspaceFolders, filename
   if (!includedFile) {
     return Promise.resolve({ msg: `File not found: ${filename}` });
   }
-  return Promise.resolve(includedFile.getText());
+  return Promise.resolve(includedFile);
 };
 var readIncludedFileFromFileSystem = async (filename, dirs, fileSystemReader) => {
   for (const currentDir of dirs) {
     try {
       const localPath = join(currentDir, filename);
-      return await fileSystemReader(localPath);
+      const content = await fileSystemReader(localPath);
+      return TextDocument.create(URI.file(localPath).toString(), "stan", 0, content);
     } catch (error) {}
   }
   return Promise.resolve({ msg: `File not found: ${filename}` });
@@ -682,48 +670,30 @@ async function handleCompilation(document, documentManager, workspaceFolders, se
 }
 
 // src/handlers/diagnostics.ts
-function stanDiagnosticToLspDiagnostic(stanDiag) {
-  return {
-    range: domainRangeToLspRange(stanDiag.range),
-    severity: domainSeverityToLspSeverity(stanDiag.severity),
-    message: stanDiag.message,
-    source: stanDiag.source ?? SERVER_ID
-  };
-}
-function domainRangeToLspRange(domainRange) {
-  return {
-    start: {
-      line: domainRange.start.line,
-      character: domainRange.start.character
-    },
-    end: {
-      line: domainRange.end.line,
-      character: domainRange.end.character
-    }
-  };
-}
-function domainSeverityToLspSeverity(domainSeverity) {
-  switch (domainSeverity) {
-    case 1:
-      return DiagnosticSeverity2.Error;
-    case 2:
-      return DiagnosticSeverity2.Warning;
-    case 3:
-      return DiagnosticSeverity2.Information;
-    case 4:
-      return DiagnosticSeverity2.Hint;
-    default:
-      return DiagnosticSeverity2.Error;
-  }
-}
 async function handleDiagnostics(params, documents, workspaceFolders, settings, logger, reader) {
   const document = documents.get(params.textDocument.uri);
   if (!document) {
     return [];
   }
   const compilerResult = await handleCompilation(document, documents, workspaceFolders, settings, logger, reader);
-  const stanDiagnostics = provideDiagnostics(compilerResult);
-  return stanDiagnostics.map(stanDiagnosticToLspDiagnostic);
+  const diagnostics = provideDiagnostics(compilerResult).map((diagnostic) => {
+    if (diagnostic.severity === "error") {
+      return {
+        range: diagnostic.range,
+        severity: DiagnosticSeverity.Error,
+        message: diagnostic.message,
+        source: SERVER_ID
+      };
+    } else if (diagnostic.severity === "warning") {
+      return {
+        range: diagnostic.range,
+        severity: DiagnosticSeverity.Warning,
+        message: diagnostic.message,
+        source: SERVER_ID
+      };
+    }
+  }).filter((diagnostic) => diagnostic !== undefined);
+  return diagnostics;
 }
 // src/handlers/formatting.ts
 async function handleFormatting(params, documents, workspaceFolders, settings, logger, reader) {
@@ -755,11 +725,13 @@ async function handleFormatting(params, documents, workspaceFolders, settings, l
 var startLanguageServer = (connection, reader) => {
   let hasConfigurationCapability = false;
   let hasWorkspaceFolderCapability = false;
+  let hasDynamicConfigurationRequestCapability = false;
   connection.onInitialize((params) => {
     connection.console.info("Initializing Stan language server...");
     let capabilities = params.capabilities;
-    hasConfigurationCapability = !!(capabilities.workspace && !!capabilities.workspace.configuration);
-    hasWorkspaceFolderCapability = !!(capabilities.workspace && !!capabilities.workspace.workspaceFolders);
+    hasConfigurationCapability = Boolean(capabilities.workspace?.configuration);
+    hasDynamicConfigurationRequestCapability = Boolean(capabilities.workspace?.configuration && capabilities.workspace?.didChangeConfiguration?.dynamicRegistration);
+    hasWorkspaceFolderCapability = Boolean(capabilities.workspace?.workspaceFolders);
     return {
       capabilities: {
         textDocumentSync: TextDocumentSyncKind.Incremental,
@@ -768,6 +740,7 @@ var startLanguageServer = (connection, reader) => {
           resolveProvider: false
         },
         documentFormattingProvider: true,
+        documentRangeFormattingProvider: false,
         workspace: {
           workspaceFolders: {
             supported: hasWorkspaceFolderCapability
@@ -781,9 +754,10 @@ var startLanguageServer = (connection, reader) => {
       }
     };
   });
-  connection.onInitialized(() => {
-    if (hasConfigurationCapability) {
-      connection.client.register(DidChangeConfigurationNotification.type);
+  connection.onInitialized(async () => {
+    if (hasDynamicConfigurationRequestCapability) {
+      await connection.client.register(DidChangeConfigurationNotification.type);
+      connection.console.info("Registered for didChangeConfiguration");
     }
     connection.console.info("Stan language server is initialized!");
   });
@@ -793,7 +767,7 @@ var startLanguageServer = (connection, reader) => {
   let globalSettings = defaultSettings;
   let documentSettings = new Map;
   connection.onDidChangeConfiguration((change) => {
-    if (hasConfigurationCapability) {
+    if (hasDynamicConfigurationRequestCapability) {
       documentSettings.clear();
     } else {
       const incomingSettings = change.settings[SERVER_ID] || {};
@@ -817,7 +791,7 @@ var startLanguageServer = (connection, reader) => {
     documentSettings.set(resource, docSettings);
     return docSettings;
   };
-  const documents = new TextDocuments3(TextDocument);
+  const documents = new TextDocuments3(TextDocument2);
   connection.onCompletion((params) => {
     return handleCompletion(params, documents);
   });
@@ -846,6 +820,10 @@ var startLanguageServer = (connection, reader) => {
       for (const error of formattingResult.errors) {
         connection.console.error(error);
       }
+      connection.sendNotification("window/showMessage", {
+        type: MessageType.Error,
+        message: "Formatting failed due to compile errors. See diagnostics for details."
+      });
       return [];
     }
   });

package/dist/types/common.d.ts

@@ -3,17 +3,4 @@ export interface Position {
     line: number;
     character: number;
 }
-type StancSuccess = {
-    errors: undefined;
-    result: string;
-    warnings?: string[];
-};
-type StancFailure = {
-    errors: string[];
-    result: undefined;
-    warnings?: string[];
-};
-export type StancReturn = StancSuccess | StancFailure;
-export type StancFunction = (filename: string, code: string, options: string[], includes?: Record<string, string>) => StancReturn;
 export type FileSystemReader = (filename: Filename) => Promise<FileContent>;
-export {};

package/dist/types/index.d.ts

@@ -1,3 +1,2 @@
 export * from './common';
 export * from './completion';
-export * from './diagnostics';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stan-language-server",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "Language Server Protocol implementation for the Stan probabilistic programming language",
   "main": "dist/server/index.js",
   "module": "src/server/index.ts",
@@ -64,11 +64,11 @@
   },
   "devDependencies": {
     "@types/bun": "latest",
-    "@types/node": "24.5.2",
+    "@types/node": "24.8.1",
     "@typescript-eslint/eslint-plugin": "^8.0.0",
     "@typescript-eslint/parser": "^8.0.0",
     "eslint": "^9.0.0",
-    "typescript": "5.9.2"
+    "typescript": "5.9.3"
   },
   "dependencies": {
     "stanc3": "^2.37.0",

package/dist/language/diagnostics/index.d.ts

@@ -1,2 +0,0 @@
-export { provideDiagnostics } from "./provider";
-export { rangeFromMessage, getWarningMessage, getErrorMessage } from "./linter";

package/dist/language/diagnostics/linter.d.ts

@@ -1,5 +0,0 @@
-import type { Range } from "../../types/diagnostics";
-declare function rangeFromMessage(message: string): Range | undefined;
-declare function getWarningMessage(message: string): string;
-declare function getErrorMessage(message: string): string;
-export { rangeFromMessage, getWarningMessage, getErrorMessage };

package/dist/types/diagnostics.d.ts

@@ -1,18 +0,0 @@
-import type { Position } from "./common";
-export type { Position };
-export interface Range {
-    start: Position;
-    end: Position;
-}
-export declare enum DiagnosticSeverity {
-    Error = 1,
-    Warning = 2,
-    Information = 3,
-    Hint = 4
-}
-export interface StanDiagnostic {
-    range: Range;
-    severity: DiagnosticSeverity;
-    message: string;
-    source?: string;
-}