@nudojs/lsp 0.4.0 → 0.4.1

package/dist/server.js

@@ -73,7 +73,7 @@ var require_ms = __commonJS({
       options = options || {};
       var type = typeof val;
       if (type === "string" && val.length > 0) {
-        return parse3(val);
+        return parse4(val);
       } else if (type === "number" && isFinite(val)) {
         return options.long ? fmtLong(val) : fmtShort(val);
       }
@@ -81,7 +81,7 @@ var require_ms = __commonJS({
         "val is not a non-empty string or a valid number. val=" + JSON.stringify(val)
       );
     };
-    function parse3(str) {
+    function parse4(str) {
       str = String(str);
       if (str.length > 100) {
         return;
@@ -17328,7 +17328,7 @@ var require_resolve_uri_umd = __commonJS({
         }
         url.path = path;
       }
-      function resolve2(input, base) {
+      function resolve3(input, base) {
         if (!input && !base)
           return "";
         const url = parseUrl(input);
@@ -17381,7 +17381,7 @@ var require_resolve_uri_umd = __commonJS({
             return url.scheme + "//" + url.user + url.host + url.port + url.path + queryHash;
         }
       }
-      return resolve2;
+      return resolve3;
     }));
   }
 });
@@ -17600,11 +17600,11 @@ var require_trace_mapping_umd = __commonJS({
         state.lastNeedle = needle;
         return state.lastIndex = binarySearch(haystack, needle, low, high);
       }
-      function parse3(map) {
+      function parse4(map) {
         return typeof map === "string" ? JSON.parse(map) : map;
       }
       var FlattenMap = function(map, mapUrl) {
-        const parsed = parse3(map);
+        const parsed = parse4(map);
         if (!("sections" in parsed)) {
           return new TraceMap(parsed, mapUrl);
         }
@@ -17668,7 +17668,7 @@ var require_trace_mapping_umd = __commonJS({
         }
       }
       function addSection(input, mapUrl, mappings, sources, sourcesContent, names, ignoreList, lineOffset, columnOffset, stopLine, stopColumn) {
-        const parsed = parse3(input);
+        const parsed = parse4(input);
         if ("sections" in parsed) return recurse(...arguments);
         const map = new TraceMap(parsed, mapUrl);
         const sourcesOffset = sources.length;
@@ -17718,7 +17718,7 @@ var require_trace_mapping_umd = __commonJS({
         constructor(map, mapUrl) {
           const isString = typeof map === "string";
           if (!isString && map._decodedMemo) return map;
-          const parsed = parse3(map);
+          const parsed = parse4(map);
           const { version, file, names, sourceRoot, sources, sourcesContent } = parsed;
           this.version = version;
           this.file = file;
@@ -17727,8 +17727,8 @@ var require_trace_mapping_umd = __commonJS({
           this.sources = sources;
           this.sourcesContent = sourcesContent;
           this.ignoreList = parsed.ignoreList || parsed.x_google_ignoreList || void 0;
-          const resolve2 = resolver(mapUrl, sourceRoot);
-          this.resolvedSources = sources.map(resolve2);
+          const resolve3 = resolver(mapUrl, sourceRoot);
+          this.resolvedSources = sources.map(resolve3);
           const { mappings } = parsed;
           if (typeof mappings === "string") {
             this._encoded = mappings;
@@ -28350,14 +28350,14 @@ var require_lib6 = __commonJS({
         super.checkParams(node, false, true);
         this.scope.exit();
       }
-      forwardNoArrowParamsConversionAt(node, parse4) {
+      forwardNoArrowParamsConversionAt(node, parse5) {
         let result;
         if (this.state.noArrowParamsConversionAt.includes(this.offsetToSourcePos(node.start))) {
           this.state.noArrowParamsConversionAt.push(this.state.start);
-          result = parse4();
+          result = parse5();
           this.state.noArrowParamsConversionAt.pop();
         } else {
-          result = parse4();
+          result = parse5();
         }
         return result;
       }
@@ -39752,7 +39752,7 @@ var require_lib6 = __commonJS({
         return result;
       }
     };
-    function parse3(input, options) {
+    function parse4(input, options) {
       var _options;
       if (((_options = options) == null ? void 0 : _options.sourceType) === "unambiguous") {
         options = Object.assign({}, options);
@@ -39839,7 +39839,7 @@ var require_lib6 = __commonJS({
       }
       return cls;
     }
-    exports.parse = parse3;
+    exports.parse = parse4;
     exports.parseExpression = parseExpression;
     exports.tokTypes = tokTypes;
   }
@@ -41773,7 +41773,7 @@ var require_introspection = __commonJS({
     exports.isStatic = isStatic;
     exports.matchesPattern = matchesPattern;
     exports.referencesImport = referencesImport;
-    exports.resolve = resolve2;
+    exports.resolve = resolve3;
     exports.willIMaybeExecuteBefore = willIMaybeExecuteBefore;
     var _t = require_lib3();
     var {
@@ -42031,7 +42031,7 @@ var require_introspection = __commonJS({
       nodeMap.set(target.node, result);
       return result;
     }
-    function resolve2(dangerous, resolved) {
+    function resolve3(dangerous, resolved) {
       return _resolve.call(this, dangerous, resolved) || this;
     }
     function _resolve(dangerous, resolved) {
@@ -43396,6 +43396,7 @@ import {
   InlayHintKind
 } from "vscode-languageserver/node";
 import { TextDocument } from "vscode-languageserver-textdocument";
+import { readFileSync as readFileSync3 } from "fs";
 import {
   getTypeAtPosition,
   getHoverAtPosition as getHoverAtPosition2,
@@ -43405,23 +43406,27 @@ import {
   isNudoTargetPath,
   collectAbsInlays as collectAbsInlays2
 } from "@nudojs/service";
-import { parse as parse2 } from "@nudojs/parser";
+import { parse as parse3 } from "@nudojs/parser";
 
 // src/symbols.ts
 var import_traverse = __toESM(require_lib8(), 1);
+import { parse } from "@nudojs/parser";
+import { existsSync, readFileSync, readdirSync, statSync } from "fs";
+import { dirname, join, resolve } from "path";
 function locFromNode(node) {
   return {
     start: { line: node.loc?.start.line ?? 1, column: node.loc?.start.column ?? 0 },
     end: { line: node.loc?.end.line ?? 1, column: node.loc?.end.column ?? 0 }
   };
 }
+function traverseFn() {
+  return typeof import_traverse.default === "function" ? import_traverse.default : import_traverse.default.default;
+}
 function buildSymbolTable(ast, uri) {
   const definitions = /* @__PURE__ */ new Map();
   const references = [];
-  const traverseFn = typeof import_traverse.default === "function" ? import_traverse.default : import_traverse.default.default;
   try {
-    traverseFn(ast, {
-      // Collect definitions
+    traverseFn()(ast, {
       FunctionDeclaration(path) {
         if (path.node.id) {
           definitions.set(path.node.id.name, {
@@ -43452,7 +43457,6 @@ function buildSymbolTable(ast, uri) {
           });
         }
       },
-      // Collect references
       Identifier(path) {
         if (path.parentPath?.node.type === "FunctionDeclaration" && path.parentPath.node.id === path.node) return;
         if (path.parentPath?.node.type === "VariableDeclarator" && path.parentPath.node.id === path.node) return;
@@ -43476,9 +43480,8 @@ function findReferences(symbolTable, name) {
 }
 function findIdentifierAtPosition(ast, line, column) {
   let found = null;
-  const traverseFn = typeof import_traverse.default === "function" ? import_traverse.default : import_traverse.default.default;
   try {
-    traverseFn(ast, {
+    traverseFn()(ast, {
       Identifier(path) {
         const loc = path.node.loc;
         if (!loc) return;
@@ -43492,6 +43495,349 @@ function findIdentifierAtPosition(ast, line, column) {
   }
   return found;
 }
+var SymbolKind = {
+  Function: 12,
+  Variable: 13,
+  Class: 5,
+  Method: 6,
+  Property: 7,
+  Constant: 14
+};
+function rangeOfLoc(loc) {
+  return {
+    start: { line: loc.start.line - 1, character: loc.start.column },
+    end: { line: loc.end.line - 1, character: loc.end.column }
+  };
+}
+function rangeOfNode(node) {
+  return rangeOfLoc(locFromNode(node));
+}
+function documentSymbols(ast) {
+  const out = [];
+  const program = ast.program ?? ast;
+  const body = program.body ?? [];
+  const pushFn = (fnNode, idNode, exported) => {
+    if (!idNode?.name) return;
+    const range = rangeOfNode(fnNode);
+    const selection = rangeOfNode(idNode);
+    const children = [];
+    const params = (fnNode.params ?? []).map((p) => p?.name ?? (p?.type === "RestElement" ? `...${p.argument?.name}` : "_")).filter(Boolean);
+    out.push({
+      name: idNode.name,
+      detail: `(${params.join(", ")})${exported ? " export" : ""}`,
+      kind: SymbolKind.Function,
+      range,
+      selectionRange: selection,
+      children: children.length ? children : void 0
+    });
+  };
+  for (const stmt of body) {
+    let decl = stmt;
+    let exported = false;
+    if (stmt.type === "ExportNamedDeclaration" && stmt.declaration) {
+      decl = stmt.declaration;
+      exported = true;
+    } else if (stmt.type === "ExportDefaultDeclaration") {
+      decl = stmt.declaration;
+      exported = true;
+    }
+    if (decl?.type === "FunctionDeclaration") {
+      pushFn(decl, decl.id, exported);
+      continue;
+    }
+    if (decl?.type === "ClassDeclaration" && decl.id) {
+      out.push({
+        name: decl.id.name,
+        detail: exported ? "export class" : "class",
+        kind: SymbolKind.Class,
+        range: rangeOfNode(decl),
+        selectionRange: rangeOfNode(decl.id),
+        children: (decl.body?.body ?? []).flatMap((m) => {
+          const key = m.key?.name ?? m.key?.value;
+          if (!key || m.type !== "ClassMethod" && m.type !== "ClassProperty") return [];
+          return [{
+            name: String(key),
+            kind: m.type === "ClassMethod" ? SymbolKind.Method : SymbolKind.Property,
+            range: rangeOfNode(m),
+            selectionRange: rangeOfNode(m.key)
+          }];
+        })
+      });
+      continue;
+    }
+    if (decl?.type === "VariableDeclaration") {
+      for (const d of decl.declarations ?? []) {
+        if (d.id?.type !== "Identifier") continue;
+        const init = d.init;
+        const isFn = init && (init.type === "ArrowFunctionExpression" || init.type === "FunctionExpression");
+        out.push({
+          name: d.id.name,
+          detail: exported ? "export const" : "const",
+          kind: isFn ? SymbolKind.Function : SymbolKind.Variable,
+          range: rangeOfNode(d),
+          selectionRange: rangeOfNode(d.id)
+        });
+      }
+    }
+  }
+  return out;
+}
+function collectImportBindings(ast, fromFile) {
+  const map = /* @__PURE__ */ new Map();
+  const program = ast.program ?? ast;
+  for (const stmt of program.body ?? []) {
+    if (stmt.type !== "ImportDeclaration") continue;
+    const spec = stmt.source.value;
+    const resolvedPath = resolveRelativeModule(spec, fromFile);
+    for (const specNode of stmt.specifiers ?? []) {
+      if (specNode.type === "ImportSpecifier") {
+        const imported = specNode.imported.type === "Identifier" ? specNode.imported.name : String(specNode.imported.value);
+        map.set(specNode.local.name, { spec, importedName: imported, resolvedPath });
+      } else if (specNode.type === "ImportDefaultSpecifier") {
+        map.set(specNode.local.name, { spec, importedName: "default", resolvedPath });
+      } else if (specNode.type === "ImportNamespaceSpecifier") {
+        map.set(specNode.local.name, { spec, importedName: "*", resolvedPath });
+      }
+    }
+  }
+  return map;
+}
+function resolveRelativeModule(spec, fromFile) {
+  if (!spec.startsWith(".") && !spec.startsWith("/")) return void 0;
+  const base = resolve(dirname(fromFile), spec);
+  for (const cand of [
+    base,
+    `${base}.js`,
+    `${base}.cjs`,
+    `${base}.mjs`,
+    `${base}.ts`,
+    `${base}.mts`,
+    `${base}.cts`,
+    join(base, "index.js"),
+    join(base, "index.mjs"),
+    join(base, "index.ts")
+  ]) {
+    try {
+      if (existsSync(cand) && statSync(cand).isFile()) return cand;
+    } catch {
+    }
+  }
+  return void 0;
+}
+function readSourceIfExists(filePath) {
+  try {
+    return readFileSync(filePath, "utf-8");
+  } catch {
+    return void 0;
+  }
+}
+function findExportDefinition(targetSource, exportName) {
+  let ast;
+  try {
+    ast = parse(targetSource);
+  } catch {
+    return null;
+  }
+  const program = ast.program ?? ast;
+  for (const stmt of program.body ?? []) {
+    let decl = stmt;
+    if (stmt.type === "ExportNamedDeclaration" && stmt.declaration) {
+      decl = stmt.declaration;
+    } else if (stmt.type === "ExportDefaultDeclaration") {
+      decl = stmt.declaration;
+      if (exportName === "default") {
+        if (decl?.type === "FunctionDeclaration" && decl.id) {
+          return { name: decl.id.name, kind: "function", loc: locFromNode(decl.id) };
+        }
+        if (decl?.type === "ClassDeclaration" && decl.id) {
+          return { name: decl.id.name, kind: "class", loc: locFromNode(decl.id) };
+        }
+        if (decl?.type === "Identifier") {
+          return { name: decl.name, kind: "variable", loc: locFromNode(decl) };
+        }
+        return null;
+      }
+      continue;
+    }
+    if (decl?.type === "FunctionDeclaration" && decl.id?.name === exportName) {
+      return { name: decl.id.name, kind: "function", loc: locFromNode(decl.id) };
+    }
+    if (decl?.type === "ClassDeclaration" && decl.id?.name === exportName) {
+      return { name: decl.id.name, kind: "class", loc: locFromNode(decl.id) };
+    }
+    if (decl?.type === "VariableDeclaration") {
+      for (const d of decl.declarations ?? []) {
+        if (d.id?.type === "Identifier" && d.id.name === exportName) {
+          return { name: d.id.name, kind: "variable", loc: locFromNode(d.id) };
+        }
+      }
+    }
+    if (stmt.type === "ExportNamedDeclaration" && !stmt.declaration && stmt.specifiers) {
+      for (const s of stmt.specifiers) {
+        if (s.type !== "ExportSpecifier") continue;
+        const exported = s.exported.type === "Identifier" ? s.exported.name : String(s.exported.value);
+        if (exported !== exportName) continue;
+        const local = s.local.type === "Identifier" ? s.local.name : String(s.local.value);
+        const table = buildSymbolTable(ast, "");
+        const def = table.definitions.get(local);
+        if (def) return { name: local, kind: def.kind, loc: def.loc };
+      }
+    }
+  }
+  return null;
+}
+function findCrossFileDefinition(fromFile, source, ident) {
+  let ast;
+  try {
+    ast = parse(source);
+  } catch {
+    return null;
+  }
+  const bindings = collectImportBindings(ast, fromFile);
+  const binding = bindings.get(ident);
+  if (!binding?.resolvedPath) return null;
+  if (binding.importedName === "*") return null;
+  const targetSource = readSourceIfExists(binding.resolvedPath);
+  if (targetSource === void 0) return null;
+  const def = findExportDefinition(targetSource, binding.importedName);
+  if (!def) return null;
+  return { filePath: binding.resolvedPath, loc: def.loc, name: def.name };
+}
+function findCrossFileReferences(definingFile, exportName, options = {}) {
+  const out = [];
+  const root = options.rootDir ?? dirname(definingFile);
+  const maxFiles = options.maxFiles ?? 200;
+  const candidates = new Set(options.extraFiles ?? []);
+  try {
+    collectJsFiles(root, candidates, maxFiles, 0);
+  } catch {
+  }
+  const definingNorm = resolve(definingFile);
+  for (const cand of candidates) {
+    if (resolve(cand) === definingNorm) continue;
+    const src = readSourceIfExists(cand);
+    if (src === void 0) continue;
+    let ast;
+    try {
+      ast = parse(src);
+    } catch {
+      continue;
+    }
+    const bindings = collectImportBindings(ast, cand);
+    for (const [local, b] of bindings) {
+      if (!b.resolvedPath || resolve(b.resolvedPath) !== definingNorm) continue;
+      if (b.importedName !== exportName && b.importedName !== "*") continue;
+      const table = buildSymbolTable(ast, cand);
+      for (const ref of table.references) {
+        if (ref.name !== local) continue;
+        out.push({ name: local, loc: ref.loc, uri: cand });
+      }
+    }
+  }
+  return out;
+}
+function collectJsFiles(dir, out, max, depth) {
+  if (out.size >= max || depth > 6) return;
+  let entries;
+  try {
+    entries = readdirSync(dir);
+  } catch {
+    return;
+  }
+  for (const name of entries) {
+    if (name === "node_modules" || name === ".git" || name === "dist") continue;
+    const full = join(dir, name);
+    try {
+      const st = statSync(full);
+      if (st.isDirectory()) {
+        collectJsFiles(full, out, max, depth + 1);
+      } else if (/\.(js|mjs|cjs|ts|mts)$/.test(name) && !/\.d\.ts$/.test(name)) {
+        out.add(full);
+      }
+    } catch {
+    }
+  }
+}
+function resolveDefinition(fromFile, source, ident) {
+  const ast = parse(source);
+  const table = buildSymbolTable(ast, fromFile);
+  const local = findDefinition(table, ident);
+  if (local) return { filePath: fromFile, loc: local.loc, name: local.name };
+  return findCrossFileDefinition(fromFile, source, ident);
+}
+function resolveReferences(fromFile, source, ident, options = {}) {
+  const includeDecl = options.includeDeclaration !== false;
+  const ast = parse(source);
+  const table = buildSymbolTable(ast, fromFile);
+  const localRefs = findReferences(table, ident);
+  const localDef = findDefinition(table, ident);
+  if (localDef) {
+    const exportName = localDef.name;
+    const isExported = isExportedName(ast, exportName);
+    const cross2 = isExported ? findCrossFileReferences(fromFile, exportName, { extraFiles: options.extraFiles }) : [];
+    const decl = includeDecl ? [{ name: localDef.name, loc: localDef.loc, uri: fromFile }] : [];
+    return [...decl, ...localRefs, ...cross2];
+  }
+  const crossDef = findCrossFileDefinition(fromFile, source, ident);
+  if (!crossDef) return localRefs;
+  const defSource = readSourceIfExists(crossDef.filePath) ?? "";
+  let defAst = null;
+  try {
+    defAst = parse(defSource);
+  } catch {
+    defAst = null;
+  }
+  const defLocalRefs = [];
+  let defDecl = [];
+  if (defAst) {
+    const defTable = buildSymbolTable(defAst, crossDef.filePath);
+    defLocalRefs.push(...findReferences(defTable, crossDef.name));
+    const d = findDefinition(defTable, crossDef.name);
+    if (d && includeDecl) {
+      defDecl = [{ name: d.name, loc: d.loc, uri: crossDef.filePath }];
+    }
+  }
+  const cross = findCrossFileReferences(crossDef.filePath, crossDef.name, {
+    extraFiles: [...options.extraFiles ?? [], fromFile]
+  });
+  const seen = /* @__PURE__ */ new Set();
+  const all = [];
+  for (const r of [...defDecl, ...defLocalRefs, ...localRefs, ...cross]) {
+    const key = `${r.uri ?? ""}:${r.loc.start.line}:${r.loc.start.column}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    all.push(r);
+  }
+  return all;
+}
+function isExportedName(ast, name) {
+  const program = ast.program ?? ast;
+  for (const stmt of program.body ?? []) {
+    if (stmt.type === "ExportNamedDeclaration") {
+      if (stmt.declaration) {
+        const d = stmt.declaration;
+        if (d.type === "FunctionDeclaration" && d.id?.name === name) return true;
+        if (d.type === "ClassDeclaration" && d.id?.name === name) return true;
+        if (d.type === "VariableDeclaration") {
+          for (const dec of d.declarations ?? []) {
+            if (dec.id?.type === "Identifier" && dec.id.name === name) return true;
+          }
+        }
+      }
+      for (const s of stmt.specifiers ?? []) {
+        if (s.type !== "ExportSpecifier") continue;
+        const exported = s.exported.type === "Identifier" ? s.exported.name : String(s.exported.value);
+        if (exported === name) return true;
+      }
+    }
+    if (stmt.type === "ExportDefaultDeclaration") {
+      const d = stmt.declaration;
+      if (d?.id?.name === name) return true;
+      if (d?.type === "Identifier" && d.name === name) return true;
+    }
+  }
+  return false;
+}
 
 // src/semantic-tokens.ts
 import {
@@ -43501,7 +43847,7 @@ import {
 } from "@nudojs/service";
 
 // src/validation.ts
-import { dirname, resolve as resolvePath } from "path";
+import { dirname as dirname2, resolve as resolvePath } from "path";
 import {
   analyzeFile,
   analyzeFileAsync,
@@ -43540,7 +43886,7 @@ function registerNudoImportDeps(filePath, source) {
   const imports = extractNudoImports(source);
   for (const imp of imports) {
     if (!imp.spec.startsWith(".") && !imp.spec.startsWith("/")) continue;
-    const dep = normPath(resolvePath(dirname(filePath), imp.spec));
+    const dep = normPath(resolvePath(dirname2(filePath), imp.spec));
     let set = nudoDepParents.get(dep);
     if (!set) {
       set = /* @__PURE__ */ new Set();
@@ -43714,8 +44060,8 @@ async function validateText(filePath, uri, text, version, deps, propagate = fals
 }
 
 // src/agent-tools.ts
-import { readFileSync } from "fs";
-import { resolve } from "path";
+import { readFileSync as readFileSync2 } from "fs";
+import { resolve as resolve2 } from "path";
 import {
   analyzeFile as analyzeFile2,
   buildCaseDirective,
@@ -43723,14 +44069,14 @@ import {
   collectAbsInlays,
   serializeInferJson
 } from "@nudojs/service";
-import { parse } from "@nudojs/parser";
+import { parse as parse2 } from "@nudojs/parser";
 import { T, typeValueToString, checkSource as checkSource2, serializeCheckJson, pTrue as pTrue2 } from "@nudojs/core";
 function textResult(text) {
   return { content: [{ type: "text", text }] };
 }
 function normalizeFilePath(file) {
   const path = file.startsWith("file://") ? decodeURIComponent(file.slice(7)) : file;
-  return resolve(path);
+  return resolve2(path);
 }
 var BARE_PRIMITIVES = /* @__PURE__ */ new Set(["number", "string", "boolean", "bigint", "symbol"]);
 function splitTopLevelUnion(expr) {
@@ -43795,7 +44141,7 @@ function injectBindings(source, bindings) {
   const applied = [];
   const unapplied = [];
   if (bindings.length === 0) return { source, applied, unapplied };
-  const ast = parse(source);
+  const ast = parse2(source);
   const declLines = /* @__PURE__ */ new Map();
   for (const stmt of ast.program.body) {
     const names = /* @__PURE__ */ new Set();
@@ -43834,7 +44180,7 @@ function injectBindings(source, bindings) {
 function readSource(filePath, deps = {}) {
   const open = deps.getOpenText?.(filePath);
   if (open) return open.text;
-  return (deps.readFile ?? ((p) => readFileSync(p, "utf-8")))(filePath);
+  return (deps.readFile ?? ((p) => readFileSync2(p, "utf-8")))(filePath);
 }
 function analysisError(err) {
   return textResult(`Error: ${err.message}`);
@@ -44054,6 +44400,8 @@ connection.onInitialize((_params) => ({
     definitionProvider: true,
     referencesProvider: true,
     renameProvider: true,
+    documentSymbolProvider: true,
+    workspaceSymbolProvider: true,
     codeActionProvider: {
       codeActionKinds: ["quickfix"]
     },
@@ -44306,84 +44654,174 @@ connection.languages.inlayHint.on((params) => {
     return [];
   }
 });
+function filePathToUri(filePath) {
+  if (filePath.startsWith("file://")) return filePath;
+  const normalized = filePath.replace(/\\/g, "/");
+  return normalized.startsWith("/") ? `file://${normalized}` : `file:///${normalized}`;
+}
+function navigationExtraFiles(currentPath) {
+  const open = documents.all().map((d) => uriToFilePath(d.uri));
+  const all = /* @__PURE__ */ new Set([...open, ...knownFiles, currentPath]);
+  return [...all];
+}
+connection.onDocumentSymbol((params) => {
+  const document2 = documents.get(params.textDocument.uri);
+  if (!document2) return [];
+  if (!isNudoFile(params.textDocument.uri)) return [];
+  try {
+    const ast = parse3(document2.getText());
+    const toLsp = (s) => ({
+      name: s.name,
+      detail: s.detail,
+      kind: s.kind,
+      range: s.range,
+      selectionRange: s.selectionRange,
+      children: s.children?.map(toLsp)
+    });
+    return documentSymbols(ast).map(toLsp);
+  } catch {
+    return [];
+  }
+});
+connection.onWorkspaceSymbol((params) => {
+  const query = params.query.toLowerCase();
+  const out = [];
+  const files = /* @__PURE__ */ new Set([...knownFiles]);
+  for (const d of documents.all()) files.add(uriToFilePath(d.uri));
+  for (const filePath of files) {
+    const doc = documents.all().find((d) => uriToFilePath(d.uri) === filePath);
+    let source;
+    if (doc) {
+      source = doc.getText();
+    } else {
+      try {
+        source = readFileSync3(filePath, "utf-8");
+      } catch {
+        source = void 0;
+      }
+    }
+    if (source === void 0) continue;
+    try {
+      const ast = parse3(source);
+      const uri = doc?.uri ?? filePathToUri(filePath);
+      for (const sym of documentSymbols(ast)) {
+        if (query && !sym.name.toLowerCase().includes(query)) continue;
+        out.push({
+          name: sym.name,
+          kind: sym.kind,
+          location: {
+            uri,
+            range: {
+              start: { line: sym.selectionRange.start.line, character: sym.selectionRange.start.character },
+              end: { line: sym.selectionRange.end.line, character: sym.selectionRange.end.character }
+            }
+          }
+        });
+      }
+    } catch {
+    }
+  }
+  return out;
+});
 connection.onDefinition((params) => {
   const document2 = documents.get(params.textDocument.uri);
   if (!document2) return null;
   if (!isNudoFile(params.textDocument.uri)) return null;
   const source = document2.getText();
-  const ast = parse2(source);
-  const table = buildSymbolTable(ast, params.textDocument.uri);
+  const filePath = uriToFilePath(params.textDocument.uri);
   const line = params.position.line + 1;
   const column = params.position.character;
-  const identAtPos = findIdentifierAtPosition(ast, line, column);
-  if (!identAtPos) return null;
-  const def = findDefinition(table, identAtPos);
-  if (!def) return null;
-  return {
-    uri: params.textDocument.uri,
-    range: {
-      start: { line: def.loc.start.line - 1, character: def.loc.start.column },
-      end: { line: def.loc.end.line - 1, character: def.loc.end.column }
-    }
-  };
+  try {
+    const ast = parse3(source);
+    const identAtPos = findIdentifierAtPosition(ast, line, column);
+    if (!identAtPos) return null;
+    const def = resolveDefinition(filePath, source, identAtPos);
+    if (!def) return null;
+    return {
+      uri: filePathToUri(def.filePath),
+      range: {
+        start: { line: def.loc.start.line - 1, character: def.loc.start.column },
+        end: { line: def.loc.end.line - 1, character: def.loc.end.column }
+      }
+    };
+  } catch {
+    return null;
+  }
 });
 connection.onReferences((params) => {
   const document2 = documents.get(params.textDocument.uri);
   if (!document2) return [];
   if (!isNudoFile(params.textDocument.uri)) return [];
   const source = document2.getText();
-  const ast = parse2(source);
-  const table = buildSymbolTable(ast, params.textDocument.uri);
+  const filePath = uriToFilePath(params.textDocument.uri);
   const line = params.position.line + 1;
   const column = params.position.character;
-  const identAtPos = findIdentifierAtPosition(ast, line, column);
-  if (!identAtPos) return [];
-  const refs = findReferences(table, identAtPos);
-  return refs.map((ref) => ({
-    uri: params.textDocument.uri,
-    range: {
-      start: { line: ref.loc.start.line - 1, character: ref.loc.start.column },
-      end: { line: ref.loc.end.line - 1, character: ref.loc.end.column }
-    }
-  }));
+  try {
+    const ast = parse3(source);
+    const identAtPos = findIdentifierAtPosition(ast, line, column);
+    if (!identAtPos) return [];
+    const refs = resolveReferences(filePath, source, identAtPos, {
+      extraFiles: navigationExtraFiles(filePath),
+      includeDeclaration: params.context?.includeDeclaration !== false
+    });
+    return refs.map((ref) => ({
+      uri: ref.uri ? filePathToUri(ref.uri) : params.textDocument.uri,
+      range: {
+        start: { line: ref.loc.start.line - 1, character: ref.loc.start.column },
+        end: { line: ref.loc.end.line - 1, character: ref.loc.end.column }
+      }
+    }));
+  } catch {
+    return [];
+  }
 });
 connection.onRenameRequest((params) => {
   const document2 = documents.get(params.textDocument.uri);
   if (!document2) return null;
   if (!isNudoFile(params.textDocument.uri)) return null;
   const source = document2.getText();
-  const ast = parse2(source);
-  const table = buildSymbolTable(ast, params.textDocument.uri);
+  const filePath = uriToFilePath(params.textDocument.uri);
   const line = params.position.line + 1;
   const column = params.position.character;
-  const identAtPos = findIdentifierAtPosition(ast, line, column);
-  if (!identAtPos) return null;
-  const def = findDefinition(table, identAtPos);
-  const refs = findReferences(table, identAtPos);
-  const edits = [];
-  if (def) {
-    edits.push({
-      range: {
-        start: { line: def.loc.start.line - 1, character: def.loc.start.column },
-        end: { line: def.loc.end.line - 1, character: def.loc.end.column }
-      },
-      newText: params.newName
-    });
-  }
-  for (const ref of refs) {
-    edits.push({
-      range: {
-        start: { line: ref.loc.start.line - 1, character: ref.loc.start.column },
-        end: { line: ref.loc.end.line - 1, character: ref.loc.end.column }
-      },
-      newText: params.newName
-    });
-  }
-  return {
-    changes: {
-      [params.textDocument.uri]: edits
+  try {
+    const ast = parse3(source);
+    const identAtPos = findIdentifierAtPosition(ast, line, column);
+    if (!identAtPos) return null;
+    const def = resolveDefinition(filePath, source, identAtPos);
+    const refs = resolveReferences(filePath, source, identAtPos, {
+      extraFiles: navigationExtraFiles(filePath)
+    });
+    const changes = {};
+    const push = (uri, loc) => {
+      const list = changes[uri] ??= [];
+      list.push({
+        range: {
+          start: { line: loc.start.line - 1, character: loc.start.column },
+          end: { line: loc.end.line - 1, character: loc.end.column }
+        },
+        newText: params.newName
+      });
+    };
+    if (def) {
+      push(filePathToUri(def.filePath), def.loc);
+    }
+    for (const ref of refs) {
+      push(ref.uri ? filePathToUri(ref.uri) : params.textDocument.uri, ref.loc);
+    }
+    for (const uri of Object.keys(changes)) {
+      const seen = /* @__PURE__ */ new Set();
+      changes[uri] = changes[uri].filter((e) => {
+        const key = `${e.range.start.line}:${e.range.start.character}:${e.range.end.line}:${e.range.end.character}`;
+        if (seen.has(key)) return false;
+        seen.add(key);
+        return true;
+      });
     }
-  };
+    if (Object.keys(changes).length === 0) return null;
+    return { changes };
+  } catch {
+    return null;
+  }
 });
 connection.onCodeAction((params) => {
   const document2 = documents.get(params.textDocument.uri);
@@ -44419,7 +44857,7 @@ connection.onSignatureHelp((params) => {
   const column = params.position.character;
   const cases = getActiveCasesForUri(params.textDocument.uri);
   try {
-    const ast = parse2(source);
+    const ast = parse3(source);
     const callInfo = findEnclosingCall(ast, line, column);
     if (!callInfo) return null;
     const fnType = getTypeAtPosition(filePath, source, callInfo.calleeLine, callInfo.calleeCol, cases);