@nudojs/lsp 0.8.0 → 0.8.1

package/dist/public-api.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Freeze inventory for `@nudojs/lsp` public surface (A1/A7).
+ *
+ * Pure constants — importable without starting the language server
+ * (`server.ts` has side effects on import). Human-readable inventory:
+ * `packages/lsp/PUBLIC_API.md`.
+ *
+ * Protocol contract:
+ * - executeCommand uses **dot** form: `nudo.check`
+ * - custom requests use **slash** form: `nudo/check` (canonical protocol)
+ * - every slash-form agent request has a matching executeCommand name
+ */
+/** workspace/executeCommand names (dot form) — declared on initialize */
+declare const NUDO_EXECUTE_COMMANDS: readonly ["nudo.whatIf", "nudo.suggestCase", "nudo.trace", "nudo.check", "nudo.hover", "nudo.infer", "nudo.interface", "nudo.interface.draft", "nudo.interfaceDraft", "nudo.interfaceEmit", "nudo.interface.emit", "nudo.selectCase", "nudo.getActiveCases"];
+/**
+ * Custom LSP request method names (slash form) — the protocol contract.
+ * Agent tools also register the dot-form method as an alias for MCP bridges.
+ */
+declare const NUDO_SLASH_REQUESTS: readonly ["nudo/selectCase", "nudo/getActiveCases", "nudo/whatIf", "nudo/suggestCase", "nudo/trace", "nudo/check", "nudo/hover", "nudo/infer", "nudo/interface", "nudo/interface.draft", "nudo/interface.emit"];
+/**
+ * Agent-tool names shared by executeCommand / slash requests / AGENT_TOOL_SOURCES.
+ * `codeLens` is server-computed only (no command/request); `selectCase` /
+ * `getActiveCases` are editor commands, not agent tools.
+ */
+declare const NUDO_AGENT_TOOL_NAMES: readonly ["whatIf", "suggestCase", "trace", "check", "hover", "infer", "interface", "interface.draft", "interface.emit"];
+/** executeCommand aliases kept for CodeLens / Marketplace command palette */
+declare const NUDO_COMMAND_ALIASES: Readonly<Record<string, string>>;
+/** Capability keys declared in connection.onInitialize */
+declare const NUDO_INITIALIZE_CAPABILITIES: readonly ["textDocumentSync", "hoverProvider", "completionProvider", "codeLensProvider", "inlayHintProvider", "definitionProvider", "referencesProvider", "renameProvider", "documentSymbolProvider", "workspaceSymbolProvider", "codeActionProvider", "signatureHelpProvider", "semanticTokensProvider", "executeCommandProvider", "diagnosticProvider"];
+/** Slash-form → matching executeCommand (dot form) */
+declare function slashToExecuteCommand(slash: string): string;
+/** npm package public surface (mirrors packages/lsp/package.json) */
+declare const NUDO_LSP_PACKAGE_SURFACE: {
+    readonly name: "@nudojs/lsp";
+    readonly bin: "nudo-lsp";
+    readonly entry: ".";
+    readonly entryPath: "./dist/server.js";
+    readonly files: readonly ["dist"];
+    /** Machine-readable freeze inventory (no server side effects). */
+    readonly publicApiExport: "./public-api";
+    readonly publicApiPath: "./dist/public-api.js";
+};
+
+export { NUDO_AGENT_TOOL_NAMES, NUDO_COMMAND_ALIASES, NUDO_EXECUTE_COMMANDS, NUDO_INITIALIZE_CAPABILITIES, NUDO_LSP_PACKAGE_SURFACE, NUDO_SLASH_REQUESTS, slashToExecuteCommand };

package/dist/public-api.js

@@ -0,0 +1,89 @@
+import { createRequire as __nudoCreateRequire } from "module";
+import { fileURLToPath as __nudoFileURLToPath } from "url";
+const require = __nudoCreateRequire(import.meta.url);
+const __filename = __nudoFileURLToPath(import.meta.url);
+const __dirname = __nudoFileURLToPath(new URL(".", import.meta.url));
+
+// src/public-api.ts
+var NUDO_EXECUTE_COMMANDS = [
+  "nudo.whatIf",
+  "nudo.suggestCase",
+  "nudo.trace",
+  "nudo.check",
+  "nudo.hover",
+  "nudo.infer",
+  "nudo.interface",
+  "nudo.interface.draft",
+  "nudo.interfaceDraft",
+  "nudo.interfaceEmit",
+  "nudo.interface.emit",
+  "nudo.selectCase",
+  "nudo.getActiveCases"
+];
+var NUDO_SLASH_REQUESTS = [
+  "nudo/selectCase",
+  "nudo/getActiveCases",
+  "nudo/whatIf",
+  "nudo/suggestCase",
+  "nudo/trace",
+  "nudo/check",
+  "nudo/hover",
+  "nudo/infer",
+  "nudo/interface",
+  "nudo/interface.draft",
+  "nudo/interface.emit"
+];
+var NUDO_AGENT_TOOL_NAMES = [
+  "whatIf",
+  "suggestCase",
+  "trace",
+  "check",
+  "hover",
+  "infer",
+  "interface",
+  "interface.draft",
+  "interface.emit"
+];
+var NUDO_COMMAND_ALIASES = {
+  "nudo.interfaceDraft": "nudo.interface.draft",
+  "nudo.interfaceEmit": "nudo.interface.emit"
+};
+var NUDO_INITIALIZE_CAPABILITIES = [
+  "textDocumentSync",
+  "hoverProvider",
+  "completionProvider",
+  "codeLensProvider",
+  "inlayHintProvider",
+  "definitionProvider",
+  "referencesProvider",
+  "renameProvider",
+  "documentSymbolProvider",
+  "workspaceSymbolProvider",
+  "codeActionProvider",
+  "signatureHelpProvider",
+  "semanticTokensProvider",
+  "executeCommandProvider",
+  "diagnosticProvider"
+];
+function slashToExecuteCommand(slash) {
+  return slash.replace(/^nudo\//, "nudo.");
+}
+var NUDO_LSP_PACKAGE_SURFACE = {
+  name: "@nudojs/lsp",
+  bin: "nudo-lsp",
+  entry: ".",
+  entryPath: "./dist/server.js",
+  files: ["dist"],
+  /** Machine-readable freeze inventory (no server side effects). */
+  publicApiExport: "./public-api",
+  publicApiPath: "./dist/public-api.js"
+};
+export {
+  NUDO_AGENT_TOOL_NAMES,
+  NUDO_COMMAND_ALIASES,
+  NUDO_EXECUTE_COMMANDS,
+  NUDO_INITIALIZE_CAPABILITIES,
+  NUDO_LSP_PACKAGE_SURFACE,
+  NUDO_SLASH_REQUESTS,
+  slashToExecuteCommand
+};

package/dist/server.js

@@ -52430,7 +52430,7 @@ var require_util2 = __commonJS({
       return path;
     }
     exports.normalize = normalize;
-    function join10(aRoot, aPath) {
+    function join11(aRoot, aPath) {
       if (aRoot === "") {
         aRoot = ".";
       }
@@ -52462,7 +52462,7 @@ var require_util2 = __commonJS({
       }
       return joined;
     }
-    exports.join = join10;
+    exports.join = join11;
     exports.isAbsolute = function(aPath) {
       return aPath.charAt(0) === "/" || urlRegexp.test(aPath);
     };
@@ -52635,7 +52635,7 @@ var require_util2 = __commonJS({
             parsed.path = parsed.path.substring(0, index + 1);
           }
         }
-        sourceURL = join10(urlGenerate(parsed), sourceURL);
+        sourceURL = join11(urlGenerate(parsed), sourceURL);
       }
       return normalize(sourceURL);
     }
@@ -63161,7 +63161,7 @@ ${lanes.join("\n")}
               return process.memoryUsage().heapUsed;
             },
             getFileSize(path) {
-              const stat = statSync10(path);
+              const stat = statSync11(path);
               if (stat == null ? void 0 : stat.isFile()) {
                 return stat.size;
               }
@@ -63205,7 +63205,7 @@ ${lanes.join("\n")}
             }
           };
           return nodeSystem;
-          function statSync10(path) {
+          function statSync11(path) {
             try {
               return _fs.statSync(path, statSyncOptions);
             } catch {
@@ -63264,7 +63264,7 @@ ${lanes.join("\n")}
               activeSession.post("Profiler.stop", (err, { profile }) => {
                 var _a;
                 if (!err) {
-                  if ((_a = statSync10(profilePath)) == null ? void 0 : _a.isDirectory()) {
+                  if ((_a = statSync11(profilePath)) == null ? void 0 : _a.isDirectory()) {
                     profilePath = _path.join(profilePath, `${(/* @__PURE__ */ new Date()).toISOString().replace(/:/g, "-")}+P${process.pid}.cpuprofile`);
                   }
                   try {
@@ -63384,7 +63384,7 @@ ${lanes.join("\n")}
                 let stat;
                 if (typeof dirent === "string" || dirent.isSymbolicLink()) {
                   const name = combinePaths(path, entry);
-                  stat = statSync10(name);
+                  stat = statSync11(name);
                   if (!stat) {
                     continue;
                   }
@@ -63408,7 +63408,7 @@ ${lanes.join("\n")}
             return matchFiles(path, extensions, excludes, includes, useCaseSensitiveFileNames2, process.cwd(), depth, getAccessibleFileSystemEntries, realpath);
           }
           function fileSystemEntryExists(path, entryKind) {
-            const stat = statSync10(path);
+            const stat = statSync11(path);
             if (!stat) {
               return false;
             }
@@ -63450,7 +63450,7 @@ ${lanes.join("\n")}
           }
           function getModifiedTime3(path) {
             var _a;
-            return (_a = statSync10(path)) == null ? void 0 : _a.mtime;
+            return (_a = statSync11(path)) == null ? void 0 : _a.mtime;
           }
           function setModifiedTime(path, time) {
             try {
@@ -265681,7 +265681,12 @@ function isRelFn(a) {
   if (!s || s.k !== "fn") return false;
   if (s.returnType === void 0) return false;
   if (s.paramTypes === void 0) return s.params.length === 0;
-  return s.paramTypes.length === s.params.length;
+  if (s.paramTypes.length === s.params.length) return true;
+  let required = 0;
+  for (const p of s.params) {
+    if (p && !p.startsWith("...") && !p.endsWith("?")) required++;
+  }
+  return s.paramTypes.length === required;
 }
 function litOfTerm(t) {
   return t.op === "lit" ? t.value : void 0;
@@ -268166,6 +268171,15 @@ function ok() {
 function fail(reason) {
   return { ok: false, reason };
 }
+function requiredFnArity(params) {
+  if (!params) return 0;
+  let n = 0;
+  for (const p of params) {
+    if (!p || p.startsWith("...") || p.endsWith("?")) continue;
+    n++;
+  }
+  return n;
+}
 function leqAbs(src, tgt, opts = {}) {
   const phi2 = opts.phi ?? pTrue;
   return leqWithPred(src, tgt, phi2, opts.env ?? null, 0);
@@ -268318,8 +268332,12 @@ function leqShape(src, tgt, phi2, env, depth) {
   }
   if (t.k === "fn") {
     if (s.k !== "fn") return fail(`shape ${s.k} \u22AD fn`);
-    if (s.params.length !== t.params.length) {
-      return fail(`fn arity ${s.params.length} \u22AD ${t.params.length}`);
+    const sReq = requiredFnArity(s.params);
+    const tReq = requiredFnArity(t.params);
+    if (sReq > tReq) {
+      return fail(
+        `fn arity required ${sReq} \u22AD target required ${tReq} (params ${s.params.length} / ${t.params.length})`
+      );
     }
     if (t.returnType !== void 0) {
       const sr = s.returnType;
@@ -270515,13 +270533,39 @@ function formatShape(a) {
     case "tuple":
       return `[${s.elements.map(formatShape).join(", ")}]`;
     case "fn": {
-      if (s.paramTypes && s.paramTypes.length > 0) {
-        const ps = s.paramTypes.map((p) => formatShapeSlot(p));
-        const ret2 = s.returnType !== void 0 ? formatShapeSlot(s.returnType) : "?";
-        return `(${ps.join(", ")}) => ${ret2}`;
-      }
       const ret = s.returnType !== void 0 ? formatShapeSlot(s.returnType) : "?";
-      return `(${s.params.join(", ")}) => ${ret}`;
+      const labels = s.params ?? [];
+      const paramTypes = s.paramTypes;
+      const hasMarkers = labels.some(
+        (p) => p.startsWith("...") || p.endsWith("?")
+      );
+      const renderLabeled = () => {
+        const ps = [];
+        const n = paramTypes ? Math.max(paramTypes.length, labels.length) : labels.length;
+        for (let i = 0; i < n; i++) {
+          const label = labels[i];
+          const type = paramTypes?.[i];
+          const typeText = type !== void 0 ? formatShapeSlot(type) : void 0;
+          if (label?.startsWith("...")) {
+            ps.push(typeText ? `...${label.slice(3)}: ${typeText}` : label);
+          } else if (label?.endsWith("?")) {
+            ps.push(typeText ? `${label.slice(0, -1)}?: ${typeText}` : label);
+          } else if (typeText !== void 0) {
+            ps.push(typeText);
+          } else if (label) {
+            ps.push(label);
+          }
+        }
+        return ps;
+      };
+      if (hasMarkers) {
+        return `(${renderLabeled().join(", ")}) => ${ret}`;
+      }
+      if (paramTypes && paramTypes.length > 0) {
+        const ps = paramTypes.map((p) => formatShapeSlot(p));
+        return `(${ps.join(", ")}) => ${ret}`;
+      }
+      return `(${labels.join(", ")}) => ${ret}`;
     }
     case "brand":
       return `${s.name}`;
@@ -280651,6 +280695,19 @@ function envFn(paramTypes, returnType, apply, opts) {
   if (opts?.conf && opts.conf !== "exact") a.conf = opts.conf;
   return a;
 }
+function envFnVariadic(restType, returnType, opts) {
+  const required = opts?.required ?? [];
+  const restName = opts?.restName ?? "...rest";
+  const paramTypes = [...required, restType];
+  const params = [
+    ...required.map((_, i) => `x${i}`),
+    restName
+  ];
+  return envFn(paramTypes, returnType, opts?.apply, {
+    params,
+    ...opts?.name ? { name: opts.name } : {}
+  });
+}
 function slotsOf(entries) {
   const out = {};
   for (const [k, v2] of Object.entries(entries)) {
@@ -281398,6 +281455,106 @@ function defineEnv3() {
     chmodSync: envFn([prim.str(), prim.num()], undef2()),
     chownSync: envFn([prim.str(), prim.num(), prim.num()], undef2()),
     accessSync: envFn([prim.str(), prim.num()], undef2()),
+    // Callback-style async on `fs` / `node:fs` (Node actual API).
+    // Promise APIs live only under fs.promises / node:fs/promises.
+    readFile: envFn(
+      [prim.str(), prim.unknown, prim.unknown],
+      undef2(),
+      void 0,
+      { params: ["path", "options?", "callback"] }
+    ),
+    writeFile: envFn(
+      [prim.str(), unionOf(prim.str(), bufferBrand), prim.unknown],
+      undef2(),
+      void 0,
+      { params: ["path", "data", "callback"] }
+    ),
+    mkdir: envFn(
+      [prim.str(), prim.unknown, prim.unknown],
+      undef2(),
+      void 0,
+      { params: ["path", "options?", "callback"] }
+    ),
+    rm: envFn(
+      [prim.str(), prim.unknown, prim.unknown],
+      undef2(),
+      void 0,
+      { params: ["path", "options?", "callback"] }
+    ),
+    stat: envFn(
+      [prim.str(), prim.unknown, prim.unknown],
+      undef2(),
+      void 0,
+      { params: ["path", "options?", "callback"] }
+    ),
+    readdir: envFn(
+      [prim.str(), prim.unknown, prim.unknown],
+      undef2(),
+      void 0,
+      { params: ["path", "options?", "callback"] }
+    ),
+    access: envFn(
+      [prim.str(), prim.unknown, prim.unknown],
+      undef2(),
+      void 0,
+      { params: ["path", "mode?", "callback"] }
+    ),
+    appendFile: envFn(
+      [prim.str(), unionOf(prim.str(), bufferBrand), prim.unknown],
+      undef2(),
+      void 0,
+      { params: ["path", "data", "callback"] }
+    ),
+    unlink: envFn(
+      [prim.str(), prim.unknown, prim.unknown],
+      undef2(),
+      void 0,
+      { params: ["path", "options?", "callback"] }
+    ),
+    rename: envFn(
+      [prim.str(), prim.str(), prim.unknown],
+      undef2(),
+      void 0,
+      { params: ["oldPath", "newPath", "callback"] }
+    ),
+    copyFile: envFn(
+      [prim.str(), prim.str(), prim.unknown],
+      undef2(),
+      void 0,
+      { params: ["src", "dest", "callback"] }
+    ),
+    realpath: envFn(
+      [prim.str(), prim.unknown, prim.unknown],
+      undef2(),
+      void 0,
+      { params: ["path", "options?", "callback"] }
+    ),
+    readlink: envFn(
+      [prim.str(), prim.unknown, prim.unknown],
+      undef2(),
+      void 0,
+      { params: ["path", "options?", "callback"] }
+    ),
+    symlink: envFn(
+      [prim.str(), prim.str(), prim.unknown, prim.unknown],
+      undef2(),
+      void 0,
+      { params: ["target", "path", "type?", "callback"] }
+    ),
+    chmod: envFn(
+      [prim.str(), prim.num(), prim.unknown],
+      undef2(),
+      void 0,
+      { params: ["path", "mode", "callback"] }
+    ),
+    open: envFn(
+      [prim.str(), prim.unknown, prim.unknown],
+      undef2(),
+      void 0,
+      { params: ["path", "flags?", "callback"] }
+    )
+  };
+  const fsPromisesModule = {
     readFile: envFn(
       [prim.str(), prim.unknown],
       promiseOf(unionOf(prim.str(), bufferBrand))
@@ -281416,7 +281573,19 @@ function defineEnv3() {
       [prim.str(), prim.unknown],
       promiseOf(arrOf(prim.unknown))
     ),
-    access: envFn([prim.str(), prim.num()], promiseOf(undef2()))
+    access: envFn([prim.str(), prim.num()], promiseOf(undef2())),
+    appendFile: envFn(
+      [prim.str(), unionOf(prim.str(), bufferBrand)],
+      promiseOf(undef2())
+    ),
+    unlink: envFn([prim.str()], promiseOf(undef2())),
+    rename: envFn([prim.str(), prim.str()], promiseOf(undef2())),
+    copyFile: envFn([prim.str(), prim.str()], promiseOf(undef2())),
+    realpath: envFn([prim.str()], promiseOf(prim.str())),
+    readlink: envFn([prim.str()], promiseOf(prim.str())),
+    symlink: envFn([prim.str(), prim.str()], promiseOf(undef2())),
+    chmod: envFn([prim.str(), prim.num()], promiseOf(undef2())),
+    open: envFn([prim.str(), prim.str()], promiseOf(prim.unknown))
   };
   const strImpl1Abs = (fn2) => (args) => {
     const a = absStr2(args[0]);
@@ -281446,10 +281615,21 @@ function defineEnv3() {
     return p !== void 0 ? boolLit(nodePath.isAbsolute(p)) : void 0;
   };
   const pathModule = {
-    join: envFn([prim.str(), prim.str()], prim.str(), pathJoinAbs),
-    resolve: envFn([prim.str()], prim.str(), pathResolveAbs),
+    // Node variadic: declare min required arity + rest label (not n fixed slots).
+    join: envFnVariadic(prim.str(), prim.str(), {
+      apply: pathJoinAbs,
+      required: [prim.str()],
+      restName: "...paths"
+    }),
+    resolve: envFnVariadic(prim.str(), prim.str(), {
+      apply: pathResolveAbs,
+      restName: "...paths"
+    }),
     dirname: envFn([prim.str()], prim.str(), strImpl1Abs(nodePath.dirname)),
-    basename: envFn([prim.str(), prim.str()], prim.str(), pathBasenameAbs),
+    // ext is optional in Node — required arity 1; label+type render `ext?: string`.
+    basename: envFn([prim.str(), prim.str()], prim.str(), pathBasenameAbs, {
+      params: ["path", "ext?"]
+    }),
     extname: envFn([prim.str()], prim.str(), strImpl1Abs(nodePath.extname)),
     relative: envFn([prim.str(), prim.str()], prim.str(), pathRelativeAbs),
     normalize: envFn([prim.str()], prim.str(), strImpl1Abs(nodePath.normalize)),
@@ -281527,6 +281707,7 @@ function defineEnv3() {
     toJSON: envFn([], prim.str())
   });
   const urlModule = {
+    // base is optional in Node — required arity 1; label+type render `base?: string`.
     URL: envFn(
       [prim.str(), prim.str()],
       nodeUrlObj,
@@ -281554,7 +281735,8 @@ function defineEnv3() {
         } catch {
           return void 0;
         }
-      }
+      },
+      { params: ["href", "base?"] }
     ),
     URLSearchParams: envFn(
       [prim.unknown],
@@ -281652,15 +281834,27 @@ function defineEnv3() {
     fork: envFn([prim.str(), arrOf(prim.str()), prim.unknown], prim.unknown)
   };
   const utilModule = {
-    promisify: envFn([prim.unknown], prim.unknown),
+    // Signature-level: promisify preserves fn-ness only as unknown (no generic).
+    promisify: envFn([prim.unknown], prim.unknown, void 0, { name: "util.promisify" }),
     inspect: envFn([prim.unknown, prim.unknown], prim.str()),
-    format: envFn([prim.str()], prim.str()),
+    format: envFnVariadic(prim.unknown, prim.str(), {
+      // util.format() with zero args is valid in Node.
+      restName: "...args",
+      name: "util.format"
+    }),
+    callbackify: envFn([prim.unknown], prim.unknown),
+    deprecate: envFn([prim.unknown, prim.str()], prim.unknown),
+    inherits: envFn([prim.unknown, prim.unknown], undef2()),
+    isDeepStrictEqual: envFn([prim.unknown, prim.unknown], prim.bool()),
     types: objAbs({
       isDate: envFn([prim.unknown], prim.bool()),
       isRegExp: envFn([prim.unknown], prim.bool()),
       isPromise: envFn([prim.unknown], prim.bool()),
       isArrayBuffer: envFn([prim.unknown], prim.bool()),
-      isTypedArray: envFn([prim.unknown], prim.bool())
+      isTypedArray: envFn([prim.unknown], prim.bool()),
+      isNativeError: envFn([prim.unknown], prim.bool()),
+      isAsyncFunction: envFn([prim.unknown], prim.bool()),
+      isGeneratorFunction: envFn([prim.unknown], prim.bool())
     }),
     TextEncoder: envFn(
       [],
@@ -281671,6 +281865,79 @@ function defineEnv3() {
       objAbs({ decode: envFn([prim.unknown], prim.str()) })
     )
   };
+  const eventEmitterShape = objAbs({
+    on: envFn([prim.str(), prim.unknown], prim.unknown),
+    once: envFn([prim.str(), prim.unknown], prim.unknown),
+    off: envFn([prim.str(), prim.unknown], prim.unknown),
+    emit: envFn([prim.str()], prim.bool()),
+    addListener: envFn([prim.str(), prim.unknown], prim.unknown),
+    removeListener: envFn([prim.str(), prim.unknown], prim.unknown),
+    removeAllListeners: envFn([prim.str()], prim.unknown),
+    listeners: envFn([prim.str()], arrOf(prim.unknown)),
+    listenerCount: envFn([prim.str()], prim.num()),
+    eventNames: envFn([], arrOf(prim.str()))
+  });
+  const eventEmitterInstance = brandOf2("EventEmitter", eventEmitterShape);
+  const EventEmitterCtor = envFn([prim.unknown], eventEmitterInstance, void 0, {
+    params: ["options?"]
+  });
+  const eventsModule = {
+    EventEmitter: EventEmitterCtor,
+    once: envFn(
+      [prim.unknown, prim.str()],
+      promiseOf(arrOf(prim.unknown))
+    ),
+    on: envFn([prim.unknown, prim.str()], prim.unknown),
+    listenerCount: envFn([prim.unknown, prim.str()], prim.num())
+  };
+  const streamIoMethods = {
+    on: envFn([prim.str(), prim.unknown], prim.unknown),
+    once: envFn([prim.str(), prim.unknown], prim.unknown),
+    off: envFn([prim.str(), prim.unknown], prim.unknown),
+    emit: envFn([prim.str()], prim.bool()),
+    pipe: envFn([prim.unknown], prim.unknown),
+    destroy: envFn([prim.unknown], undef2()),
+    read: envFn([prim.num()], prim.unknown),
+    write: envFn([unionOf(prim.str(), bufferBrand)], prim.bool()),
+    end: envFn([prim.unknown], undef2()),
+    pause: envFn([], prim.unknown),
+    resume: envFn([], prim.unknown),
+    setEncoding: envFn([prim.str()], prim.unknown)
+  };
+  const streamCtor = (brandName) => envFn([prim.unknown], brandOf2(brandName, objAbs(streamIoMethods)), void 0, {
+    params: ["options?"]
+  });
+  const streamModule = {
+    Readable: streamCtor("Readable"),
+    Writable: streamCtor("Writable"),
+    Duplex: streamCtor("Duplex"),
+    Transform: streamCtor("Transform"),
+    pipeline: envFnVariadic(prim.unknown, promiseOf(undef2()), {
+      restName: "...streams"
+    }),
+    finished: envFn([prim.unknown], promiseOf(undef2()))
+  };
+  const parsedQueryString = brandOf2(
+    "ParsedQueryString",
+    objAbs({})
+  );
+  const querystringModule = {
+    // sep/eq/options optional — required arity 1; labels+types render `sep?: string` etc.
+    parse: envFn(
+      [prim.str(), prim.str(), prim.str(), prim.unknown],
+      parsedQueryString,
+      void 0,
+      { params: ["str", "sep?", "eq?", "options?"] }
+    ),
+    stringify: envFn(
+      [prim.unknown, prim.str(), prim.str(), prim.unknown],
+      prim.str(),
+      void 0,
+      { params: ["obj", "sep?", "eq?", "options?"] }
+    ),
+    escape: envFn([prim.str()], prim.str()),
+    unescape: envFn([prim.str()], prim.str())
+  };
   const nodeGlobals = {
     process: objAbs({
       env: objAbs({}),
@@ -281740,15 +282007,8 @@ function defineEnv3() {
   const modules = {
     fs: fsModule,
     "node:fs": fsModule,
-    "node:fs/promises": {
-      readFile: fsModule.readFile,
-      writeFile: fsModule.writeFile,
-      mkdir: fsModule.mkdir,
-      rm: fsModule.rm,
-      stat: fsModule.stat,
-      readdir: fsModule.readdir,
-      access: fsModule.access
-    },
+    "fs/promises": fsPromisesModule,
+    "node:fs/promises": fsPromisesModule,
     path: pathModule,
     "node:path": pathModule,
     os: osModule,
@@ -281760,7 +282020,13 @@ function defineEnv3() {
     child_process: childProcessModule,
     "node:child_process": childProcessModule,
     util: utilModule,
-    "node:util": utilModule
+    "node:util": utilModule,
+    events: eventsModule,
+    "node:events": eventsModule,
+    stream: streamModule,
+    "node:stream": streamModule,
+    querystring: querystringModule,
+    "node:querystring": querystringModule
   };
   return {
     globals: { ...esEnv.globals, ...nodeGlobals },
@@ -283676,6 +283942,47 @@ function collectEnvModules(envNames) {
   }
   return out;
 }
+var envHarvestConflictCollector = null;
+function setEnvHarvestConflictCollector(collector2) {
+  const prev = envHarvestConflictCollector;
+  envHarvestConflictCollector = collector2;
+  return prev;
+}
+function mergeHarvestUnderEnv(harvestModules, envModules, opts) {
+  const out = {};
+  for (const [mod2, exports] of Object.entries(harvestModules)) {
+    const named = { ...exports.named };
+    out[mod2] = exports.default !== void 0 ? { named, default: exports.default } : { named };
+  }
+  const notify = opts?.onConflict ?? envHarvestConflictCollector;
+  for (const [mod2, envExports] of Object.entries(envModules)) {
+    const existing = out[mod2];
+    if (!existing) {
+      const named2 = { ...envExports.named };
+      out[mod2] = envExports.default !== void 0 ? { named: named2, default: envExports.default } : { named: named2 };
+      continue;
+    }
+    const overwritten = [];
+    for (const key of Object.keys(envExports.named)) {
+      if (existing.named[key] !== void 0) overwritten.push(key);
+    }
+    const defaultOverwritten = envExports.default !== void 0 && existing.default !== void 0;
+    if (notify && (overwritten.length > 0 || defaultOverwritten)) {
+      try {
+        notify({
+          module: mod2,
+          exports: overwritten,
+          defaultOverwritten
+        });
+      } catch {
+      }
+    }
+    const named = { ...existing.named, ...envExports.named };
+    const defaultAbs = envExports.default !== void 0 ? envExports.default : existing.default;
+    out[mod2] = defaultAbs !== void 0 ? { named, default: defaultAbs } : { named };
+  }
+  return out;
+}
 function collectBPathReplacements(source) {
   const targets = [];
   const values = {};
@@ -283790,7 +284097,7 @@ function tryRunBPath(source, filePath, opts = {}) {
     try {
       const { modules: graphMods, issues } = evalAbsModuleGraph(source, filePath);
       const envMods = collectEnvModules(opts.envNames ?? []);
-      const modules = { ...envMods, ...graphMods };
+      const modules = mergeHarvestUnderEnv(graphMods, envMods);
       const { targets, values, asTargets, asValues } = collectBPathReplacements(source);
       const envGlobals = {
         ...collectEnvGlobals(opts.envNames ?? []),
@@ -284616,6 +284923,24 @@ function analyzeFileUncached(filePath, source, activeCases2, externalCallRecords
     () => analyzeFileUncachedInner(filePath, source, activeCases2, externalCallRecords, loadModule)
   );
 }
+function findModuleImportLoc(source, module) {
+  const bare = module.startsWith("node:") ? module.slice("node:".length) : module;
+  const alts = [.../* @__PURE__ */ new Set([module, bare, `node:${bare}`])];
+  const lines = source.split(/\r?\n/);
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    for (const alt of alts) {
+      const re = new RegExp(
+        `["'\`]${alt.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}["'\`]`
+      );
+      const m = re.exec(line);
+      if (m && m.index !== void 0) {
+        return { line: i, column: m.index, length: m[0].length };
+      }
+    }
+  }
+  return null;
+}
 function analyzeFileUncachedInner(filePath, source, activeCases2, externalCallRecords, loadModule) {
   const ast = parse(source);
   const functions = extractDirectives(ast);
@@ -284624,6 +284949,18 @@ function analyzeFileUncachedInner(filePath, source, activeCases2, externalCallRe
   const nodeAbsMap = /* @__PURE__ */ new Map();
   const functionResults = [];
   const caseHints = [];
+  const envHarvestConflicts = [];
+  const prevHarvestConflictCollector = setEnvHarvestConflictCollector((c) => {
+    if (!envHarvestConflicts.some((x) => x.module === c.module)) {
+      envHarvestConflicts.push(c);
+    } else {
+      const prev = envHarvestConflicts.find((x) => x.module === c.module);
+      for (const e of c.exports) {
+        if (!prev.exports.includes(e)) prev.exports.push(e);
+      }
+      prev.defaultOverwritten ||= c.defaultOverwritten;
+    }
+  });
   const fileDirectives = extractFileDirectives(ast);
   const fileEnvNames = fileDirectives.filter((d) => d.kind === "env").flatMap((d) => d.envs);
   const projectConfig = findProjectConfig(dirname9(filePath));
@@ -284713,7 +285050,7 @@ function analyzeFileUncachedInner(filePath, source, activeCases2, externalCallRe
         seedFns: seeds.seedFns,
         ...loadModule ? { loadModule } : {}
       });
-      absGraphModules = { ...collectEnvModules(envNames), ...g.modules };
+      absGraphModules = mergeHarvestUnderEnv(g.modules, collectEnvModules(envNames));
       pushBModuleIssues(g.issues);
     } catch {
     }
@@ -285319,6 +285656,24 @@ function analyzeFileUncachedInner(filePath, source, activeCases2, externalCallRe
     filePath,
     analysisConfig(projectConfig?.config).callSiteBudget
   );
+  setEnvHarvestConflictCollector(prevHarvestConflictCollector);
+  for (const c of envHarvestConflicts) {
+    const parts = [];
+    if (c.exports.length > 0) parts.push(`export(s) ${c.exports.join(", ")}`);
+    if (c.defaultOverwritten) parts.push("default");
+    const detail = parts.length > 0 ? ` \u2014 ${parts.join("; ")}` : "";
+    const loc = findModuleImportLoc(source, c.module);
+    const range = loc ? {
+      start: { line: loc.line, column: loc.column },
+      end: { line: loc.line, column: loc.column + loc.length }
+    } : { start: { line: 0, column: 0 }, end: { line: 0, column: 0 } };
+    diagnostics.push({
+      range,
+      severity: "warning",
+      message: `handwritten @nudo:env wins over harvest on module "${c.module}"${detail}; harvest only fills missing slots (B8). code=nudo:env-harvest-conflict`,
+      code: "nudo:env-harvest-conflict"
+    });
+  }
   return {
     functions: functionResults,
     diagnostics,
@@ -285431,7 +285786,7 @@ function collectAbsCallRecords(source, seeds, filePath, precomputedModules, envN
       }
     }
     if (envNames.length > 0) {
-      modules = { ...collectEnvModules(envNames), ...modules ?? {} };
+      modules = mergeHarvestUnderEnv(modules ?? {}, collectEnvModules(envNames));
     }
     try {
       importLocals = buildAbsImportLocalMap(source, filePath);
@@ -286436,7 +286791,8 @@ function collectLoadDepContents(filePath, source, loadModule) {
 }
 
 // ../service/src/harvest-node.ts
-import { existsSync as existsSync11 } from "fs";
+import { existsSync as existsSync11, statSync as statSync8 } from "fs";
+import { join as join7 } from "path";
 
 // ../service/src/semantic-tokens.ts
 var SEMANTIC_TOKEN_TYPES = [
@@ -287343,7 +287699,7 @@ function joinSections(base, sectionTexts) {
 
 // ../service/src/interface-draft.ts
 import { existsSync as existsSync14, readFileSync as readFileSync13, writeFileSync as writeFileSync4, realpathSync as realpathSync2 } from "fs";
-import { basename as basename3, dirname as dirname15, isAbsolute as isAbsolute2, join as join7, relative as relative4 } from "path";
+import { basename as basename3, dirname as dirname15, isAbsolute as isAbsolute2, join as join8, relative as relative4 } from "path";
 function collectParamBodyAccesses(source) {
   const out = /* @__PURE__ */ new Map();
   let ast;
@@ -287860,7 +288216,7 @@ function safeRealpath(p) {
     return realpathSync2(p);
   } catch {
     try {
-      return join7(realpathSync2(dirname15(p)), basename3(p));
+      return join8(realpathSync2(dirname15(p)), basename3(p));
     } catch {
       return p;
     }
@@ -287945,8 +288301,8 @@ import { basename as basename4, dirname as dirname16, relative as relative5, res
 
 // src/symbols.ts
 var import_traverse3 = __toESM(require_lib8(), 1);
-import { existsSync as existsSync16, readFileSync as readFileSync15, readdirSync as readdirSync2, statSync as statSync8 } from "fs";
-import { dirname as dirname17, join as join8, resolve as resolve12 } from "path";
+import { existsSync as existsSync16, readFileSync as readFileSync15, readdirSync as readdirSync2, statSync as statSync9 } from "fs";
+import { dirname as dirname17, join as join9, resolve as resolve12 } from "path";
 function locFromNode2(node) {
   return {
     start: { line: node.loc?.start.line ?? 1, column: node.loc?.start.column ?? 0 },
@@ -288147,12 +288503,12 @@ function resolveRelativeModule(spec, fromFile) {
     `${base}.ts`,
     `${base}.mts`,
     `${base}.cts`,
-    join8(base, "index.js"),
-    join8(base, "index.mjs"),
-    join8(base, "index.ts")
+    join9(base, "index.js"),
+    join9(base, "index.mjs"),
+    join9(base, "index.ts")
   ]) {
     try {
-      if (existsSync16(cand) && statSync8(cand).isFile()) return cand;
+      if (existsSync16(cand) && statSync9(cand).isFile()) return cand;
     } catch {
     }
   }
@@ -288280,9 +288636,9 @@ function collectJsFiles(dir, out, max, depth) {
   }
   for (const name of entries) {
     if (name === "node_modules" || name === ".git" || name === "dist") continue;
-    const full = join8(dir, name);
+    const full = join9(dir, name);
     try {
-      const st = statSync8(full);
+      const st = statSync9(full);
       if (st.isDirectory()) {
         collectJsFiles(full, out, max, depth + 1);
       } else if (/\.(js|mjs|cjs|ts|mts)$/.test(name) && !/\.d\.ts$/.test(name)) {
@@ -289511,6 +289867,34 @@ function computeInterfaceLenses(source, filePath, deps = {}) {
   return lenses;
 }
 
+// src/public-api.ts
+var NUDO_EXECUTE_COMMANDS = [
+  "nudo.whatIf",
+  "nudo.suggestCase",
+  "nudo.trace",
+  "nudo.check",
+  "nudo.hover",
+  "nudo.infer",
+  "nudo.interface",
+  "nudo.interface.draft",
+  "nudo.interfaceDraft",
+  "nudo.interfaceEmit",
+  "nudo.interface.emit",
+  "nudo.selectCase",
+  "nudo.getActiveCases"
+];
+var NUDO_AGENT_TOOL_NAMES = [
+  "whatIf",
+  "suggestCase",
+  "trace",
+  "check",
+  "hover",
+  "infer",
+  "interface",
+  "interface.draft",
+  "interface.emit"
+];
+
 // src/a6-relax.ts
 function escapeRegExp2(s) {
   return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -289608,21 +289992,7 @@ function relaxSidecarConstraint(sidecarSource, fnName, param, constraintText) {
 }
 
 // src/server.ts
-var NUDO_COMMANDS = [
-  "nudo.whatIf",
-  "nudo.suggestCase",
-  "nudo.trace",
-  "nudo.check",
-  "nudo.hover",
-  "nudo.infer",
-  "nudo.interface",
-  "nudo.interface.draft",
-  "nudo.interfaceDraft",
-  "nudo.interfaceEmit",
-  "nudo.interface.emit",
-  "nudo.selectCase",
-  "nudo.getActiveCases"
-];
+var NUDO_COMMANDS = NUDO_EXECUTE_COMMANDS;
 if (!process.argv.some(
   (a) => a === "--stdio" || a === "--node-ipc" || a.startsWith("--socket=")
 )) {
@@ -290572,7 +290942,7 @@ connection.onRequest("nudo/getActiveCases", handleGetActiveCases);
 function dispatchAgentRequest(command, params) {
   return dispatchNudoCommand(command, params);
 }
-for (const name of ["whatIf", "suggestCase", "trace", "check", "hover", "infer", "interface", "interface.draft", "interface.emit"]) {
+for (const name of NUDO_AGENT_TOOL_NAMES) {
   const command = `nudo.${name}`;
   const handler = (params) => dispatchAgentRequest(command, params);
   connection.onRequest(`nudo/${name}`, handler);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nudojs/lsp",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "engines": {
     "node": ">=20"
   },
@@ -23,6 +23,10 @@
     ".": {
       "types": "./dist/server.d.ts",
       "default": "./dist/server.js"
+    },
+    "./public-api": {
+      "types": "./dist/public-api.d.ts",
+      "default": "./dist/public-api.js"
     }
   },
   "files": [
@@ -43,9 +47,9 @@
   "dependencies": {
     "vscode-languageserver": "^9.0.0",
     "vscode-languageserver-textdocument": "^1.0.0",
-    "@nudojs/core": "2.0.0",
-    "@nudojs/service": "2.0.0",
-    "@nudojs/parser": "0.5.0"
+    "@nudojs/service": "3.0.0",
+    "@nudojs/parser": "0.5.1",
+    "@nudojs/core": "2.0.1"
   },
   "scripts": {
     "build": "tsup"