@nudojs/lsp 0.3.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,29 +43396,37 @@ import {
   InlayHintKind
 } from "vscode-languageserver/node";
 import { TextDocument } from "vscode-languageserver-textdocument";
-import { typeValueToString as typeValueToString2 } from "@nudojs/core";
+import { readFileSync as readFileSync3 } from "fs";
 import {
   getTypeAtPosition,
+  getHoverAtPosition as getHoverAtPosition2,
   getCompletionsAtPosition,
-  getCasesForFile
+  getCasesForFile,
+  buildSemanticTokens,
+  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, {
@@ -43449,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;
@@ -43473,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;
@@ -43489,34 +43495,378 @@ 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
-var TOKEN_TYPES = [
-  "function",
-  "variable",
-  "parameter",
-  "property",
-  "type",
-  "keyword",
-  "string",
-  "number",
-  "comment",
-  "decorator"
-];
-var TOKEN_MODIFIERS = [
-  "declaration",
-  "readonly",
-  "deprecated",
-  "unreachable"
-];
+import {
+  SEMANTIC_TOKEN_TYPES,
+  SEMANTIC_TOKEN_MODIFIERS,
+  encodeSemanticTokens
+} from "@nudojs/service";
 
 // src/validation.ts
+import { dirname as dirname2, resolve as resolvePath } from "path";
 import {
   analyzeFile,
   analyzeFileAsync,
   buildModuleGraph,
-  computeDirtySet
+  computeDirtySet,
+  defaultLoadModule,
+  clearAnalysisSessionCaches,
+  evictAbsModuleCacheFiles,
+  evictBPathCacheForFiles,
+  evictAnalysisFileCacheForFiles,
+  evictFnAnalysisCacheForFiles
 } from "@nudojs/service";
+import {
+  checkSource,
+  pTrue,
+  evictGeneralizeMemoForPaths,
+  evictCheckSourceMemoForPaths,
+  extractNudoImports
+} from "@nudojs/core";
 import {
   DiagnosticSeverity,
   DiagnosticTag
@@ -43524,15 +43874,65 @@ import {
 var analysisCache = /* @__PURE__ */ new Map();
 var knownFiles = /* @__PURE__ */ new Set();
 var moduleGraphCache = /* @__PURE__ */ new Map();
+var nudoDepParents = /* @__PURE__ */ new Map();
+function normPath(p) {
+  return p.replace(/\\/g, "/");
+}
+function registerNudoImportDeps(filePath, source) {
+  const parent = normPath(resolvePath(filePath));
+  for (const set of nudoDepParents.values()) {
+    set.delete(parent);
+  }
+  const imports = extractNudoImports(source);
+  for (const imp of imports) {
+    if (!imp.spec.startsWith(".") && !imp.spec.startsWith("/")) continue;
+    const dep = normPath(resolvePath(dirname2(filePath), imp.spec));
+    let set = nudoDepParents.get(dep);
+    if (!set) {
+      set = /* @__PURE__ */ new Set();
+      nudoDepParents.set(dep, set);
+    }
+    set.add(parent);
+  }
+}
+async function handleNudoDepFileChanged(nudoPath, deps) {
+  const p = normPath(resolvePath(nudoPath));
+  evictGeneralizeMemoForPaths([p]);
+  evictCheckSourceMemoForPaths([p]);
+  const parents = nudoDepParents.get(p);
+  if (!parents || parents.size === 0) return;
+  const parentList = [...parents];
+  evictBPathCacheForFiles(parentList);
+  evictAnalysisFileCacheForFiles(parentList);
+  evictFnAnalysisCacheForFiles(parentList);
+  for (const parent of parentList) {
+    const doc = deps.getOpenDocumentByPath?.(parent);
+    if (!doc) continue;
+    await validateText(
+      parent,
+      doc.uri,
+      doc.getText(),
+      doc.version,
+      deps,
+      false
+    );
+  }
+}
 function forgetValidatedFile(filePath) {
+  const parent = normPath(resolvePath(filePath));
   knownFiles.delete(filePath);
   analysisCache.delete(filePath);
+  for (const set of nudoDepParents.values()) {
+    set.delete(parent);
+  }
 }
 function evictModuleGraphCacheEntries(uris) {
-  for (const uri of uris) moduleGraphCache.delete(uriToFilePath(uri));
+  const paths = uris.map(uriToFilePath);
+  for (const p of paths) moduleGraphCache.delete(p);
+  evictAbsModuleCacheFiles(paths);
 }
 function hasNudoDirectives(source) {
-  return /@nudo:(case|mock|pure|skip|sample|returns|env|mock-module|as|replace)\b/.test(source);
+  return /@nudo:(case|mock|pure|skip|sample|refine|import|env|mock-module|as|replace)\b/.test(source);
 }
 function uriToFilePath(uri) {
   return uri.startsWith("file://") ? decodeURIComponent(uri.slice(7)) : uri;
@@ -43578,6 +43978,43 @@ function toLspDiagnostic(d, uri) {
   }
   return diag;
 }
+function lspLoadModule(spec, fromFile) {
+  return defaultLoadModule(spec, fromFile);
+}
+function checkToLspDiagnostics(filePath, source, loadModule) {
+  try {
+    const report = checkSource(filePath, source, pTrue, {
+      loadModule: loadModule ?? lspLoadModule,
+      fromFile: filePath
+    });
+    return report.issues.filter((i) => i.severity === "error" || i.severity === "warning").map((i) => {
+      const line = (i.line ?? 1) - 1;
+      const col = i.column ?? 0;
+      const parts = [i.message];
+      if (i.actual) parts.push(`actual: ${i.actual}`);
+      if (i.expected) parts.push(`expected: ${i.expected}`);
+      if (i.suggestion) parts.push(i.suggestion);
+      return {
+        severity: i.severity === "error" ? DiagnosticSeverity.Error : i.severity === "warning" ? DiagnosticSeverity.Warning : DiagnosticSeverity.Information,
+        range: {
+          start: { line, character: col },
+          end: { line, character: col + 1 }
+        },
+        message: parts.join(" \xB7 "),
+        source: "nudo-check",
+        code: i.code,
+        data: {
+          actual: i.actual,
+          expected: i.expected,
+          fn: i.fn,
+          suggestions: i.suggestion ? [i.suggestion] : []
+        }
+      };
+    });
+  } catch {
+    return [];
+  }
+}
 async function validateText(filePath, uri, text, version, deps, propagate = false) {
   if (deps.isNudoUri && !deps.isNudoUri(uri)) {
     deps.sendDiagnostics({ uri, diagnostics: [] });
@@ -43600,7 +44037,10 @@ async function validateText(filePath, uri, text, version, deps, propagate = fals
   }
   analysisCache.set(filePath, { version, result });
   knownFiles.add(filePath);
-  deps.sendDiagnostics({ uri, diagnostics: result.diagnostics.map((d) => toLspDiagnostic(d, uri)) });
+  registerNudoImportDeps(filePath, text);
+  const checkDiags = checkToLspDiagnostics(filePath, text);
+  const evalDiags = result.diagnostics.map((d) => toLspDiagnostic(d, uri));
+  deps.sendDiagnostics({ uri, diagnostics: [...checkDiags, ...evalDiags] });
   if (!propagate || !deps.getOpenDocumentByPath) return;
   let dependents;
   try {
@@ -43612,22 +44052,31 @@ async function validateText(filePath, uri, text, version, deps, propagate = fals
     if (dirtyPath === filePath) continue;
     const doc = deps.getOpenDocumentByPath(dirtyPath);
     if (!doc) continue;
+    evictBPathCacheForFiles([dirtyPath]);
+    evictAnalysisFileCacheForFiles([dirtyPath]);
+    evictFnAnalysisCacheForFiles([dirtyPath]);
     await validateText(dirtyPath, doc.uri, doc.getText(), doc.version, deps, false);
   }
 }
 
 // src/agent-tools.ts
-import { readFileSync } from "fs";
-import { resolve } from "path";
-import { analyzeFile as analyzeFile2, buildCaseDirective } from "@nudojs/service";
-import { parse } from "@nudojs/parser";
-import { T, typeValueToString } from "@nudojs/core";
+import { readFileSync as readFileSync2 } from "fs";
+import { resolve as resolve2 } from "path";
+import {
+  analyzeFile as analyzeFile2,
+  buildCaseDirective,
+  getHoverAtPosition,
+  collectAbsInlays,
+  serializeInferJson
+} from "@nudojs/service";
+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) {
@@ -43692,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();
@@ -43731,11 +44180,111 @@ 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}`);
 }
+function checkTool(params, deps = {}) {
+  try {
+    const filePath = normalizeFilePath(params.file);
+    const source = params.source ?? readSource(filePath, deps);
+    const report = checkSource2(filePath, source, pTrue2, {
+      loadModule: params.loadModule ?? lspLoadModule,
+      fromFile: filePath
+    });
+    const json = serializeCheckJson(report);
+    if (params.format === "json") {
+      return textResult(JSON.stringify(json, null, 2));
+    }
+    const lines = [
+      json.ok ? "nudo check OK" : "nudo check FAILED",
+      `${json.summary.errors} error \xB7 ${json.summary.warnings} warning \xB7 ${json.summary.functions} fn`
+    ];
+    for (const i of json.issues) {
+      if (i.severity === "info") continue;
+      const loc = i.line != null ? ` L${i.line}` : "";
+      lines.push(`[${i.severity}]${loc} ${i.message}`);
+      if (i.actual) lines.push(`  actual:   ${i.actual}`);
+      if (i.expected) lines.push(`  expected: ${i.expected}`);
+    }
+    lines.push("");
+    lines.push(JSON.stringify(json, null, 2));
+    return textResult(lines.join("\n"));
+  } catch (err) {
+    return analysisError(err);
+  }
+}
+function hoverTool(params, deps = {}) {
+  try {
+    const filePath = normalizeFilePath(params.file);
+    const source = params.source ?? readSource(filePath, deps);
+    const hover = getHoverAtPosition(filePath, source, params.line, params.column);
+    const payload = {
+      file: filePath,
+      line: params.line,
+      column: params.column,
+      abs: hover?.abs ?? null,
+      absMultiline: hover?.absMultiline ?? null,
+      intension: hover?.intension ?? null,
+      /** 有损外延，仅对照 */
+      ext: hover?.typeText ?? null
+    };
+    if (params.includeInlays) {
+      payload.inlays = collectAbsInlays(source, {
+        loadModule: params.loadModule ?? lspLoadModule,
+        fromFile: filePath
+      });
+    }
+    return textResult(JSON.stringify(payload, null, 2));
+  } catch (err) {
+    return analysisError(err);
+  }
+}
+function inferTool(params, deps = {}) {
+  try {
+    const filePath = normalizeFilePath(params.file);
+    const source = params.source ?? readSource(filePath, deps);
+    const result = analyzeFile2(filePath, source);
+    let json = serializeInferJson(result, filePath);
+    if (params.functions && params.functions.length > 0) {
+      const keep = new Set(params.functions);
+      const filtered = json.functions.filter((f) => keep.has(f.name));
+      let cases = 0;
+      for (const f of filtered) {
+        cases += f.cases?.length ?? 0;
+      }
+      const summary = {
+        ...json.summary,
+        functions: filtered.length,
+        cases
+      };
+      json = { ...json, functions: filtered, summary };
+    }
+    if (params.format === "json") {
+      return textResult(JSON.stringify(json, null, 2));
+    }
+    const lines = [
+      `nudo infer  ${json.file}`,
+      `${json.summary.functions} fn \xB7 ${json.summary.cases} case \xB7 ${json.summary.diagnostics} diag`
+    ];
+    for (const f of json.functions) {
+      lines.push("");
+      lines.push(`${f.name}${f.entryOnly ? "  [entry-only]" : ""}`);
+      for (const c of f.cases) {
+        const args = c.args.join(", ");
+        lines.push(`  ${c.name}: (${args}) => ${c.result}`);
+        if (c.intension?.abs) lines.push(`    abs: ${c.intension.abs}`);
+        else if (c.intension?.display) lines.push(`    intension: ${c.intension.display}`);
+      }
+    }
+    lines.push("");
+    lines.push(JSON.stringify(json, null, 2));
+    return textResult(lines.join("\n"));
+  } catch (err) {
+    return analysisError(err);
+  }
+}
 function whatIf(params, deps = {}) {
   try {
     const filePath = normalizeFilePath(params.file);
@@ -43820,6 +44369,9 @@ var NUDO_COMMANDS = [
   "nudo.whatIf",
   "nudo.suggestCase",
   "nudo.trace",
+  "nudo.check",
+  "nudo.hover",
+  "nudo.infer",
   "nudo.selectCase",
   "nudo.getActiveCases"
 ];
@@ -43848,6 +44400,8 @@ connection.onInitialize((_params) => ({
     definitionProvider: true,
     referencesProvider: true,
     renameProvider: true,
+    documentSymbolProvider: true,
+    workspaceSymbolProvider: true,
     codeActionProvider: {
       codeActionKinds: ["quickfix"]
     },
@@ -43857,8 +44411,8 @@ connection.onInitialize((_params) => ({
     semanticTokensProvider: {
       full: true,
       legend: {
-        tokenTypes: [...TOKEN_TYPES],
-        tokenModifiers: [...TOKEN_MODIFIERS]
+        tokenTypes: [...SEMANTIC_TOKEN_TYPES],
+        tokenModifiers: [...SEMANTIC_TOKEN_MODIFIERS]
       }
     },
     executeCommandProvider: {
@@ -43906,16 +44460,27 @@ function registerWatchedFilesListener(listener) {
     if (idx >= 0) watchedFilesListeners.splice(idx, 1);
   };
 }
+function isNudoDepPath(filePath) {
+  return /\.nudo\.(js|mjs|ts)$/.test(filePath);
+}
 function handleWatchedFilesChanges(changes, isOpen) {
   const gone = [];
+  const nudoTouched = [];
   for (const change of changes) {
-    if (change.type !== FileChangeType.Deleted) continue;
-    if (isOpen(change.uri)) continue;
-    gone.push(change.uri);
-    forgetValidatedFile(uriToFilePath(change.uri));
-    activeCases.delete(change.uri);
-    nudoFileCache.delete(change.uri);
-    connection.sendDiagnostics({ uri: change.uri, diagnostics: [] });
+    const filePath = uriToFilePath(change.uri);
+    if (change.type === FileChangeType.Deleted) {
+      if (isOpen(change.uri)) continue;
+      gone.push(change.uri);
+      forgetValidatedFile(filePath);
+      activeCases.delete(change.uri);
+      nudoFileCache.delete(change.uri);
+      connection.sendDiagnostics({ uri: change.uri, diagnostics: [] });
+      if (isNudoDepPath(filePath)) nudoTouched.push(filePath);
+      continue;
+    }
+    if (isNudoDepPath(filePath)) {
+      nudoTouched.push(filePath);
+    }
   }
   if (gone.length > 0) {
     for (const listener of [...watchedFilesListeners]) {
@@ -43925,6 +44490,13 @@ function handleWatchedFilesChanges(changes, isOpen) {
       }
     }
   }
+  if (nudoTouched.length > 0) {
+    const deps = validationDeps();
+    for (const p of nudoTouched) {
+      void handleNudoDepFileChanged(p, deps).catch(() => {
+      });
+    }
+  }
   return gone;
 }
 connection.onDidChangeWatchedFiles(
@@ -43959,14 +44531,27 @@ connection.onHover((params) => {
   const column = params.position.character;
   const cases = getActiveCasesForUri(params.textDocument.uri);
   try {
-    const tv = getTypeAtPosition(filePath, source, line, column, cases);
-    if (!tv) return null;
+    const hover = getHoverAtPosition2(filePath, source, line, column, cases);
+    if (!hover) return null;
+    const lines = [];
+    if (hover.absMultiline) {
+      lines.push("```nudo", hover.absMultiline, "```");
+    } else if (hover.abs) {
+      lines.push("```nudo", hover.abs, "```");
+    }
+    if (hover.intension && hover.intension !== hover.abs) {
+      lines.push("```nudo", hover.intension, "```");
+    }
+    if (hover.typeText && hover.typeText !== hover.intension && hover.typeText !== hover.abs) {
+      lines.push("```nudo", `ext: ${hover.typeText}`, "```");
+    }
+    if (lines.length === 0) {
+      lines.push("```nudo", hover.typeText, "```");
+    }
     return {
       contents: {
         kind: MarkupKind.Markdown,
-        value: `\`\`\`nudo
-${typeValueToString2(tv)}
-\`\`\``
+        value: lines.join("\n")
       }
     };
   } catch {
@@ -44048,89 +44633,195 @@ connection.languages.inlayHint.on((params) => {
         paddingLeft: true
       });
     }
+    try {
+      for (const abs of collectAbsInlays2(source, {
+        loadModule: lspLoadModule,
+        fromFile: filePath
+      })) {
+        const lineIdx = abs.line - 1;
+        if (lineIdx < 0 || lineIdx >= lines.length) continue;
+        hints.push({
+          position: { line: lineIdx, character: abs.character },
+          label: abs.label,
+          kind: abs.kind === "parameter" ? InlayHintKind.Parameter : InlayHintKind.Type,
+          paddingLeft: true
+        });
+      }
+    } catch {
+    }
     return hints;
   } catch {
     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);
@@ -44153,14 +44844,6 @@ connection.onCodeAction((params) => {
         }
       });
     }
-    if (diag.code === "nudo-assertion-failed") {
-      actions.push({
-        title: "Update @nudo:returns to match inferred type",
-        kind: "quickfix",
-        diagnostics: [diag],
-        isPreferred: false
-      });
-    }
   }
   return actions;
 });
@@ -44174,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);
@@ -44239,7 +44922,12 @@ connection.languages.semanticTokens.on((params) => {
   const document2 = documents.get(params.textDocument.uri);
   if (!document2) return { data: [] };
   if (!isNudoFile(params.textDocument.uri)) return { data: [] };
-  return { data: [] };
+  try {
+    const filePath = uriToFilePath(document2.uri);
+    return { data: buildSemanticTokens(filePath, document2.getText()) };
+  } catch {
+    return { data: [] };
+  }
 });
 function uriForFileOrUri(params) {
   if (params.uri) return params.uri;
@@ -44281,6 +44969,12 @@ function dispatchNudoCommand(command, arg) {
       return suggestCase(arg, agentToolDeps);
     case "nudo.trace":
       return trace(arg, agentToolDeps);
+    case "nudo.check":
+      return checkTool(arg, agentToolDeps);
+    case "nudo.hover":
+      return hoverTool(arg, agentToolDeps);
+    case "nudo.infer":
+      return inferTool(arg, agentToolDeps);
     case "nudo.selectCase":
       return handleSelectCase(arg);
     case "nudo.getActiveCases":
@@ -44300,6 +44994,9 @@ function dispatchAgentRequest(command, params) {
 connection.onRequest("nudo/whatIf", (params) => dispatchAgentRequest("nudo.whatIf", params));
 connection.onRequest("nudo/suggestCase", (params) => dispatchAgentRequest("nudo.suggestCase", params));
 connection.onRequest("nudo/trace", (params) => dispatchAgentRequest("nudo.trace", params));
+connection.onRequest("nudo/check", (params) => dispatchAgentRequest("nudo.check", params));
+connection.onRequest("nudo/hover", (params) => dispatchAgentRequest("nudo.hover", params));
+connection.onRequest("nudo/infer", (params) => dispatchAgentRequest("nudo.infer", params));
 connection.languages.diagnostics.on((params) => {
   const document2 = documents.get(params.textDocument.uri);
   if (!document2) return { kind: "full", items: [] };
@@ -44317,7 +45014,7 @@ connection.languages.diagnostics.on((params) => {
 });
 var nudoFileCache = /* @__PURE__ */ new Map();
 function isNudoFile(uri) {
-  if (!uri.endsWith(".js") && !uri.endsWith(".ts") && !uri.endsWith(".mjs")) return false;
+  if (!isNudoTargetPath(uriToFilePath(uri))) return false;
   const cached = nudoFileCache.get(uri);
   if (cached !== void 0) return cached;
   const doc = documents.get(uri);