chainlesschain 0.162.148 → 0.162.150

package/src/lib/lsp/__tests__/jsonrpc-stream.test.js

@@ -0,0 +1,104 @@
+/**
+ * jsonrpc-stream tests — LSP Content-Length framing. Pure, no IO. Pins the
+ * split-chunk / multi-message / multibyte-length / lenient-LF edge cases that a
+ * naive framer gets wrong.
+ */
+
+import { describe, it, expect } from "vitest";
+import {
+  encodeMessage,
+  parseContentLength,
+  MessageBuffer,
+} from "../jsonrpc-stream.js";
+
+describe("encodeMessage", () => {
+  it("frames a message with a byte-accurate Content-Length", () => {
+    const buf = encodeMessage({ jsonrpc: "2.0", id: 1, method: "ping" });
+    const text = buf.toString("utf8");
+    const body = JSON.stringify({ jsonrpc: "2.0", id: 1, method: "ping" });
+    expect(text).toBe(
+      `Content-Length: ${Buffer.byteLength(body)}\r\n\r\n${body}`,
+    );
+  });
+
+  it("counts BYTES not characters for multibyte content", () => {
+    const buf = encodeMessage({ text: "你好" }); // 6 UTF-8 bytes for the two chars
+    const headerLen = Number(
+      /Content-Length: (\d+)/.exec(buf.toString("utf8"))[1],
+    );
+    const body = JSON.stringify({ text: "你好" });
+    expect(headerLen).toBe(Buffer.byteLength(body, "utf8"));
+    // round-trips through the buffer intact
+    const mb = new MessageBuffer().append(buf);
+    expect(mb.read()).toEqual({ text: "你好" });
+  });
+});
+
+describe("parseContentLength", () => {
+  it("reads the header case-insensitively", () => {
+    expect(parseContentLength("content-length: 42")).toBe(42);
+    expect(parseContentLength("Content-Length:   7\r\nContent-Type: x")).toBe(
+      7,
+    );
+  });
+  it("returns null when absent or invalid", () => {
+    expect(parseContentLength("Content-Type: application/json")).toBeNull();
+    expect(parseContentLength("Content-Length: abc")).toBeNull();
+  });
+});
+
+describe("MessageBuffer", () => {
+  it("decodes a single framed message", () => {
+    const mb = new MessageBuffer();
+    mb.append(encodeMessage({ id: 1, result: "ok" }));
+    expect(mb.read()).toEqual({ id: 1, result: "ok" });
+    expect(mb.read()).toBeNull();
+  });
+
+  it("decodes multiple messages in one chunk", () => {
+    const mb = new MessageBuffer();
+    const chunk = Buffer.concat([
+      encodeMessage({ id: 1 }),
+      encodeMessage({ id: 2 }),
+      encodeMessage({ id: 3 }),
+    ]);
+    mb.append(chunk);
+    expect(mb.readAll().map((m) => m.id)).toEqual([1, 2, 3]);
+  });
+
+  it("reassembles a message split across chunks (header and body)", () => {
+    const full = encodeMessage({ id: 7, method: "textDocument/definition" });
+    const mb = new MessageBuffer();
+    // split mid-header and mid-body
+    for (let i = 0; i < full.length; i += 5) {
+      mb.append(full.slice(i, i + 5));
+    }
+    expect(mb.read()).toEqual({ id: 7, method: "textDocument/definition" });
+    expect(mb.hasPartial).toBe(false);
+  });
+
+  it("retains a partial frame until the rest arrives", () => {
+    const full = encodeMessage({ id: 9 });
+    const mb = new MessageBuffer();
+    mb.append(full.slice(0, full.length - 3));
+    expect(mb.read()).toBeNull();
+    expect(mb.hasPartial).toBe(true);
+    mb.append(full.slice(full.length - 3));
+    expect(mb.read()).toEqual({ id: 9 });
+  });
+
+  it("tolerates LF-only header separators", () => {
+    const body = JSON.stringify({ id: 5 });
+    const mb = new MessageBuffer();
+    mb.append(`Content-Length: ${body.length}\n\n${body}`);
+    expect(mb.read()).toEqual({ id: 5 });
+  });
+
+  it("skips a body that isn't valid JSON but stays aligned for the next frame", () => {
+    const mb = new MessageBuffer();
+    const bad = "Content-Length: 3\r\n\r\n{{{";
+    mb.append(bad + encodeMessage({ id: 2 }).toString("utf8"));
+    // bad frame dropped, good one still decoded
+    expect(mb.read()).toEqual({ id: 2 });
+  });
+});

package/src/lib/lsp/__tests__/lsp-client.test.js

@@ -0,0 +1,269 @@
+/**
+ * LSPClient tests — JSON-RPC handshake, request/response correlation,
+ * notification dispatch, timeouts and crash propagation. A fake child process
+ * is injected through `_deps.spawn`; no real language server is spawned.
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { EventEmitter } from "events";
+import {
+  LSPClient,
+  _deps,
+  pathToFileUri,
+  fileUriToPath,
+  normalizeUri,
+  buildSpawnCommand,
+} from "../lsp-client.js";
+import { encodeMessage, MessageBuffer } from "../jsonrpc-stream.js";
+
+/** A fake language server process. Auto-replies to `initialize`; test controls the rest. */
+class FakeChild extends EventEmitter {
+  constructor({ autoInit = true } = {}) {
+    super();
+    this.stdout = new EventEmitter();
+    this.stderr = new EventEmitter();
+    this._inbound = new MessageBuffer();
+    this.received = [];
+    this.killed = false;
+    // Arrow keeps `this` bound to the FakeChild (no this-alias needed).
+    this.stdin = {
+      writable: true,
+      write: (buf) => {
+        this._inbound.append(buf);
+        for (const msg of this._inbound.readAll()) {
+          this.received.push(msg);
+          if (autoInit && msg.method === "initialize") {
+            this.reply(msg.id, { capabilities: { definitionProvider: true } });
+          }
+        }
+        return true;
+      },
+    };
+  }
+  reply(id, result) {
+    this.stdout.emit("data", encodeMessage({ jsonrpc: "2.0", id, result }));
+  }
+  replyError(id, error) {
+    this.stdout.emit("data", encodeMessage({ jsonrpc: "2.0", id, error }));
+  }
+  notify(method, params) {
+    this.stdout.emit("data", encodeMessage({ jsonrpc: "2.0", method, params }));
+  }
+  kill() {
+    this.killed = true;
+  }
+}
+
+let origSpawn;
+beforeEach(() => {
+  origSpawn = _deps.spawn;
+});
+afterEach(() => {
+  _deps.spawn = origSpawn;
+  vi.restoreAllMocks();
+});
+
+function makeClient(child, opts = {}) {
+  _deps.spawn = vi.fn(() => child);
+  return new LSPClient({
+    command: "fake-lsp",
+    args: ["--stdio"],
+    rootPath: "/proj",
+    ...opts,
+  });
+}
+
+describe("LSPClient handshake", () => {
+  it("spawns, sends initialize, and captures server capabilities", async () => {
+    const child = new FakeChild();
+    const client = makeClient(child);
+    const caps = await client.start();
+    expect(caps).toEqual({ definitionProvider: true });
+    expect(client.running).toBe(true);
+    // sent initialize then initialized notification
+    expect(child.received[0].method).toBe("initialize");
+    expect(child.received[1].method).toBe("initialized");
+    // spawn used shell:false
+    expect(_deps.spawn).toHaveBeenCalledWith(
+      "fake-lsp",
+      ["--stdio"],
+      expect.objectContaining({ shell: false }),
+    );
+  });
+
+  it("kills the spawned server when the initialize handshake times out (no orphan)", async () => {
+    const child = new FakeChild({ autoInit: false }); // never answers initialize
+    const client = makeClient(child);
+    await expect(client.start({ initTimeoutMs: 20 })).rejects.toThrow(
+      /timed out/,
+    );
+    // The spawned process must be torn down, not left running forever.
+    expect(child.killed).toBe(true);
+    expect(client.running).toBe(false);
+  });
+});
+
+describe("LSPClient request/response", () => {
+  it("correlates a request to its response by id", async () => {
+    const child = new FakeChild();
+    const client = makeClient(child);
+    await client.start();
+    const p = client.request("textDocument/definition", { x: 1 });
+    // server replies to the definition request (id follows initialize=1 → 2)
+    const req = child.received.find(
+      (m) => m.method === "textDocument/definition",
+    );
+    child.reply(req.id, [
+      {
+        uri: "file:///proj/a.ts",
+        range: {
+          start: { line: 0, character: 0 },
+          end: { line: 0, character: 3 },
+        },
+      },
+    ]);
+    const result = await p;
+    expect(result[0].uri).toBe("file:///proj/a.ts");
+  });
+
+  it("rejects a request whose response carries an error", async () => {
+    const child = new FakeChild();
+    const client = makeClient(child);
+    await client.start();
+    const p = client.request("bad/method", {});
+    const req = child.received.find((m) => m.method === "bad/method");
+    child.replyError(req.id, { code: -32601, message: "method not found" });
+    await expect(p).rejects.toThrow(/method not found/);
+  });
+
+  it("times out a request with no response", async () => {
+    const child = new FakeChild();
+    const client = makeClient(child);
+    await client.start();
+    await expect(
+      client.request("slow/op", {}, { timeoutMs: 20 }),
+    ).rejects.toThrow(/timed out/);
+  });
+});
+
+describe("LSPClient notifications", () => {
+  it("emits server notifications by method", async () => {
+    const child = new FakeChild();
+    const client = makeClient(child);
+    await client.start();
+    const got = vi.fn();
+    client.on("notify:textDocument/publishDiagnostics", got);
+    child.notify("textDocument/publishDiagnostics", {
+      uri: "file:///proj/a.ts",
+      diagnostics: [],
+    });
+    expect(got).toHaveBeenCalledWith({
+      uri: "file:///proj/a.ts",
+      diagnostics: [],
+    });
+  });
+
+  it("auto-replies null to server→client requests so the server never blocks", async () => {
+    const child = new FakeChild();
+    const client = makeClient(child);
+    await client.start();
+    child.stdout.emit(
+      "data",
+      encodeMessage({
+        jsonrpc: "2.0",
+        id: 999,
+        method: "workspace/configuration",
+        params: {},
+      }),
+    );
+    const reply = child.received.find((m) => m.id === 999 && m.method == null);
+    expect(reply).toEqual({ jsonrpc: "2.0", id: 999, result: null });
+  });
+});
+
+describe("LSPClient lifecycle", () => {
+  it("fails all pending requests when the process exits", async () => {
+    const child = new FakeChild();
+    const client = makeClient(child);
+    await client.start();
+    const p = client.request("op", {});
+    child.emit("exit", 1, null);
+    await expect(p).rejects.toThrow(/exited|stopped/);
+    expect(client.running).toBe(false);
+  });
+
+  it("stop() shuts down gracefully and is idempotent", async () => {
+    const child = new FakeChild();
+    const client = makeClient(child);
+    await client.start();
+    // auto-reply to shutdown
+    child.stdin.write = (buf) => {
+      const mb = new MessageBuffer().append(buf);
+      for (const m of mb.readAll()) {
+        child.received.push(m);
+        if (m.method === "shutdown") child.reply(m.id, null);
+      }
+      return true;
+    };
+    await client.stop();
+    await client.stop(); // no throw second time
+    expect(child.killed).toBe(true);
+  });
+});
+
+describe("uri <-> path", () => {
+  it("round-trips a POSIX path", () => {
+    expect(fileUriToPath(pathToFileUri("/home/u/a b.ts"))).toBe(
+      process.platform === "win32" ? "\\home\\u\\a b.ts" : "/home/u/a b.ts",
+    );
+  });
+  it("builds a windows drive URI", () => {
+    expect(pathToFileUri("C:\\proj\\a.ts")).toBe("file:///C%3A/proj/a.ts");
+  });
+});
+
+describe("normalizeUri", () => {
+  it("lowercases the windows drive letter so client/server keys match", () => {
+    // path.resolve yields C:, servers echo c: — must collapse to one key
+    expect(normalizeUri("file:///C%3A/proj/a.ts")).toBe(
+      "file:///c%3A/proj/a.ts",
+    );
+    expect(normalizeUri("file:///c%3A/proj/a.ts")).toBe(
+      "file:///c%3A/proj/a.ts",
+    );
+    expect(normalizeUri("file:///C:/proj/a.ts")).toBe("file:///c:/proj/a.ts");
+  });
+  it("leaves POSIX file URIs unchanged", () => {
+    expect(normalizeUri("file:///home/u/a.ts")).toBe("file:///home/u/a.ts");
+  });
+});
+
+describe("buildSpawnCommand", () => {
+  const isWin = process.platform === "win32";
+  it("passes non-batch commands through verbatim", () => {
+    const spec = buildSpawnCommand("/usr/bin/gopls", []);
+    expect(spec).toEqual({
+      file: "/usr/bin/gopls",
+      args: [],
+      windowsVerbatimArguments: false,
+    });
+  });
+  it.runIf(isWin)(
+    "routes a .cmd shim through cmd.exe /d /s /c with a quoted path",
+    () => {
+      const spec = buildSpawnCommand(
+        "C:\\proj\\node_modules\\.bin\\typescript-language-server.cmd",
+        ["--stdio"],
+      );
+      expect(spec.windowsVerbatimArguments).toBe(true);
+      expect(spec.args.slice(0, 3)).toEqual(["/d", "/s", "/c"]);
+      expect(spec.args[3]).toBe(
+        '"C:\\proj\\node_modules\\.bin\\typescript-language-server.cmd" --stdio',
+      );
+    },
+  );
+  it.runIf(isWin)("quotes a path containing spaces", () => {
+    const spec = buildSpawnCommand("C:\\Program Files\\svr.cmd", []);
+    expect(spec.args[3]).toBe('"C:\\Program Files\\svr.cmd"');
+  });
+});

package/src/lib/lsp/__tests__/lsp-manager.test.js

@@ -0,0 +1,333 @@
+/**
+ * LSPManager tests — server pooling, document open/change sync, diagnostics
+ * collection, and position conversion. A fake client is injected via
+ * `_deps.createClient`; the registry resolves a server via `_deps.existsSync`.
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { EventEmitter } from "events";
+import path from "path";
+import {
+  LSPManager,
+  toLspPosition,
+  fromLspPosition,
+  _deps,
+} from "../lsp-manager.js";
+import { _deps as regDeps } from "../lsp-server-registry.js";
+
+/** Minimal fake LSPClient: records notifications, canned requests, emits events. */
+class FakeClient extends EventEmitter {
+  constructor(opts) {
+    super();
+    this.rootPath = opts.rootPath;
+    this.running = true;
+    this.notifications = [];
+    this.started = false;
+  }
+  async start() {
+    this.started = true;
+    return { definitionProvider: true };
+  }
+  notify(method, params) {
+    this.notifications.push({ method, params });
+  }
+  async request() {
+    return null;
+  }
+  async stop() {
+    this.running = false;
+  }
+}
+
+let origCreate, origRead, origExistsMgr, origExistsReg;
+let lastClient;
+
+beforeEach(() => {
+  origCreate = _deps.createClient;
+  origRead = _deps.readFileSync;
+  origExistsMgr = _deps.existsSync;
+  origExistsReg = regDeps.existsSync;
+
+  _deps.createClient = (opts) => {
+    lastClient = new FakeClient(opts);
+    return lastClient;
+  };
+  _deps.readFileSync = () => "const x = 1;\n";
+  // root inference: pretend the nearest /proj ancestor has package.json.
+  // Suffix match tolerates path.resolve prepending a drive letter on Windows.
+  _deps.existsSync = (p) =>
+    String(p).replace(/\\/g, "/").endsWith("/proj/package.json");
+  // registry: pretend the TS server bin exists in <root>/node_modules/.bin
+  const isWin = process.platform === "win32";
+  const binName = isWin
+    ? "typescript-language-server.cmd"
+    : "typescript-language-server";
+  regDeps.existsSync = (p) =>
+    String(p).replace(/\\/g, "/").endsWith(`/node_modules/.bin/${binName}`);
+});
+
+afterEach(() => {
+  _deps.createClient = origCreate;
+  _deps.readFileSync = origRead;
+  _deps.existsSync = origExistsMgr;
+  regDeps.existsSync = origExistsReg;
+  vi.restoreAllMocks();
+});
+
+describe("position helpers", () => {
+  it("converts 1-based ⇄ 0-based", () => {
+    expect(toLspPosition({ line: 1, col: 1 })).toEqual({
+      line: 0,
+      character: 0,
+    });
+    expect(toLspPosition({ line: 10, col: 5 })).toEqual({
+      line: 9,
+      character: 4,
+    });
+    expect(fromLspPosition({ line: 0, character: 0 })).toEqual({
+      line: 1,
+      col: 1,
+    });
+    expect(fromLspPosition({ line: 9, character: 4 })).toEqual({
+      line: 10,
+      col: 5,
+    });
+  });
+  it("clamps below 1 to 0 (no negatives to the server)", () => {
+    expect(toLspPosition({ line: 0, col: 0 })).toEqual({
+      line: 0,
+      character: 0,
+    });
+  });
+});
+
+describe("ensureFor", () => {
+  it("starts a server and sends didOpen the first time", async () => {
+    const mgr = new LSPManager();
+    const ready = await mgr.ensureFor("/proj/src/a.ts");
+    expect(ready.languageId).toBe("typescript");
+    expect(ready.root.replace(/\\/g, "/")).toMatch(/\/proj$/);
+    expect(lastClient.started).toBe(true);
+    const open = lastClient.notifications.find(
+      (n) => n.method === "textDocument/didOpen",
+    );
+    expect(open.params.textDocument.text).toBe("const x = 1;\n");
+    await mgr.disposeAll();
+  });
+
+  it("sends didChange (not a second didOpen) on the next access", async () => {
+    const mgr = new LSPManager();
+    await mgr.ensureFor("/proj/src/a.ts");
+    await mgr.ensureFor("/proj/src/a.ts");
+    const opens = lastClient.notifications.filter(
+      (n) => n.method === "textDocument/didOpen",
+    );
+    const changes = lastClient.notifications.filter(
+      (n) => n.method === "textDocument/didChange",
+    );
+    expect(opens).toHaveLength(1);
+    expect(changes).toHaveLength(1);
+    expect(changes[0].params.textDocument.version).toBe(2);
+    await mgr.disposeAll();
+  });
+
+  it("reuses one server for two files in the same project/language", async () => {
+    const mgr = new LSPManager();
+    await mgr.ensureFor("/proj/src/a.ts");
+    const first = lastClient;
+    await mgr.ensureFor("/proj/src/b.ts");
+    expect(lastClient).toBe(first); // same client instance
+    expect(mgr.activeServerCount).toBe(1);
+    await mgr.disposeAll();
+  });
+
+  it("spawns only ONE server when two concurrent calls race the same key", async () => {
+    // Regression: ensureFor did Map.get(miss)→await start→Map.set with no
+    // in-flight dedupe, so two concurrent calls (the read-only agent batch fires
+    // several code_intelligence calls at once) both spawned a server; the second
+    // set() orphaned the first process. Gate start() so both calls interleave
+    // inside the await window, then assert a single spawn.
+    let created = 0;
+    let releaseStart;
+    const gate = new Promise((r) => {
+      releaseStart = r;
+    });
+    _deps.createClient = (opts) => {
+      created += 1;
+      lastClient = new FakeClient(opts);
+      const origStart = lastClient.start.bind(lastClient);
+      lastClient.start = async () => {
+        await gate; // hold both starts open until released
+        return origStart();
+      };
+      return lastClient;
+    };
+    const mgr = new LSPManager();
+    const p1 = mgr.ensureFor("/proj/src/a.ts");
+    const p2 = mgr.ensureFor("/proj/src/b.ts");
+    releaseStart();
+    const [r1, r2] = await Promise.all([p1, p2]);
+    expect(created).toBe(1); // NOT two — the race is deduped
+    expect(mgr.activeServerCount).toBe(1);
+    expect(r1.client).toBe(r2.client);
+    await mgr.disposeAll();
+  });
+
+  it("returns unavailable for an unsupported extension", async () => {
+    const mgr = new LSPManager();
+    const ready = await mgr.ensureFor("/proj/readme.txt");
+    expect(ready.unavailable).toBe(true);
+    expect(ready.reason).toMatch(/no language mapping/);
+    await mgr.disposeAll();
+  });
+
+  it("returns unavailable when no server bin is installed", async () => {
+    regDeps.existsSync = () => false; // nothing installed
+    const mgr = new LSPManager();
+    const ready = await mgr.ensureFor("/proj/src/a.ts");
+    expect(ready.unavailable).toBe(true);
+    expect(ready.reason).toMatch(/no language server installed/);
+    await mgr.disposeAll();
+  });
+});
+
+describe("crash-loop restart guard", () => {
+  // Simulate a language server process dying: the client marks itself not
+  // running and emits `exit`, exactly as the real LSPClient does on child exit.
+  function crash(client) {
+    client.running = false;
+    client.emit("exit", 1, null);
+  }
+
+  it("re-spawns a crashed server on the next request (auto-restart)", async () => {
+    const mgr = new LSPManager();
+    await mgr.ensureFor("/proj/src/a.ts");
+    const first = lastClient;
+    crash(first);
+    const ready = await mgr.ensureFor("/proj/src/a.ts");
+    expect(ready.unavailable).toBeUndefined();
+    expect(lastClient).not.toBe(first); // a FRESH client was spawned
+    expect(lastClient.started).toBe(true);
+    expect(ready.client).toBe(lastClient);
+    await mgr.disposeAll();
+  });
+
+  it("quarantines a server that crash-loops past maxRestarts within the window", async () => {
+    let t = 1000;
+    const mgr = new LSPManager({
+      maxRestarts: 3,
+      restartWindowMs: 30000,
+      now: () => t,
+    });
+    for (let i = 0; i < 3; i++) {
+      await mgr.ensureFor("/proj/src/a.ts");
+      t += 100;
+      crash(lastClient);
+    }
+    // 3 crashes are now inside the window → the next request quarantines the
+    // server (degrade to text search) rather than thrash-respawning it.
+    const before = lastClient;
+    const ready = await mgr.ensureFor("/proj/src/a.ts");
+    expect(ready.unavailable).toBe(true);
+    expect(ready.quarantined).toBe(true);
+    expect(ready.reason).toMatch(/crash-looped/);
+    expect(lastClient).toBe(before); // did NOT spawn yet another
+    await mgr.disposeAll();
+  });
+
+  it("recovers and re-spawns once the crash window clears", async () => {
+    let t = 1000;
+    const mgr = new LSPManager({
+      maxRestarts: 3,
+      restartWindowMs: 30000,
+      now: () => t,
+    });
+    for (let i = 0; i < 3; i++) {
+      await mgr.ensureFor("/proj/src/a.ts");
+      t += 100;
+      crash(lastClient);
+    }
+    expect((await mgr.ensureFor("/proj/src/a.ts")).quarantined).toBe(true);
+    // Stay healthy past the window → crash history prunes → a fresh start is
+    // allowed again (a server isn't quarantined forever).
+    t += 30001;
+    const quarantined = lastClient;
+    const ready = await mgr.ensureFor("/proj/src/a.ts");
+    expect(ready.unavailable).toBeUndefined();
+    expect(lastClient).not.toBe(quarantined);
+    await mgr.disposeAll();
+  });
+});
+
+describe("diagnostics", () => {
+  it("collects pushed diagnostics keyed by file", async () => {
+    const mgr = new LSPManager();
+    await mgr.ensureFor("/proj/src/a.ts");
+    lastClient.emit("notify:textDocument/publishDiagnostics", {
+      uri: (await import("../lsp-client.js")).pathToFileUri(
+        path.resolve("/proj/src/a.ts"),
+      ),
+      diagnostics: [
+        {
+          message: "boom",
+          severity: 1,
+          range: {
+            start: { line: 0, character: 0 },
+            end: { line: 0, character: 1 },
+          },
+        },
+      ],
+    });
+    const diags = mgr.getDiagnostics("/proj/src/a.ts");
+    expect(diags).toHaveLength(1);
+    expect(diags[0].message).toBe("boom");
+    await mgr.disposeAll();
+  });
+
+  it("clears stale diagnostics + readiness state when the server crashes", async () => {
+    const { pathToFileUri } = await import("../lsp-client.js");
+    const mgr = new LSPManager();
+    await mgr.ensureFor("/proj/src/a.ts");
+    lastClient.emit("notify:textDocument/publishDiagnostics", {
+      uri: pathToFileUri(path.resolve("/proj/src/a.ts")),
+      diagnostics: [
+        {
+          message: "boom",
+          severity: 1,
+          range: {
+            start: { line: 0, character: 0 },
+            end: { line: 0, character: 1 },
+          },
+        },
+      ],
+    });
+    expect(mgr.getDiagnostics("/proj/src/a.ts")).toHaveLength(1);
+
+    // Server crashes. Its diagnostics + publish bookkeeping must NOT survive —
+    // otherwise the readiness waiters resolve on the pre-crash publish and a
+    // post-restart query returns these stale results.
+    lastClient.running = false;
+    lastClient.emit("exit", 1, null);
+    expect(mgr.getDiagnostics("/proj/src/a.ts")).toEqual([]);
+
+    // A fresh query re-spawns the server; before it publishes, waitForDiagnostics
+    // must not hand back the stale set (returns empty within the timeout budget).
+    await mgr.ensureFor("/proj/src/a.ts");
+    const afterRestart = await mgr.waitForDiagnostics("/proj/src/a.ts", {
+      timeoutMs: 60,
+      settleMs: 20,
+    });
+    expect(afterRestart).toEqual([]);
+    await mgr.disposeAll();
+  });
+});
+
+describe("disposeAll", () => {
+  it("stops all servers and blocks further use", async () => {
+    const mgr = new LSPManager();
+    await mgr.ensureFor("/proj/src/a.ts");
+    await mgr.disposeAll();
+    expect(lastClient.running).toBe(false);
+    await expect(mgr.ensureFor("/proj/src/a.ts")).rejects.toThrow(/disposed/);
+  });
+});