@ashx-j/lunr 0.2.26 → 0.2.27

package/dist/node-runtime/{lsp-manager-3ASUSO4T.js → lsp-manager-S554V5HR.js}

@@ -390,6 +390,7 @@ var require_main2 = __commonJS({
 import { resolve, join } from "node:path";
 import { pathToFileURL as pathToFileURL2 } from "node:url";
 import { existsSync, readFileSync, readdirSync, unlinkSync } from "node:fs";
+import { setTimeout as delay } from "node:timers/promises";
 import { spawn as spawnChild } from "node:child_process";
 
 // packages/coding-agent/dist/builtin-extensions/pi-lsp-extension/src/lsp-client.js
@@ -408,6 +409,9 @@ var LspClient = class {
   _disposed = !1;
   /** True if connected to a daemon socket (server init handled by daemon) */
   _isDaemonClient = !1;
+  stop = new AbortController();
+  startPromise = null;
+  shutdownPromise = null;
   languageId;
   command;
   rootDir;
@@ -432,8 +436,18 @@ var LspClient = class {
     return new Map(this._diagnostics);
   }
   /** Start the LSP server and perform the initialize handshake */
-  async start() {
-    this._initialized || this._disposed || (this.options.socketPath ? await this.connectToSocket(this.options.socketPath) : await this.spawnDirect());
+  start() {
+    return this._disposed ? Promise.reject(new Error("LSP client shut down")) : this.startPromise ? this.startPromise : (this.startPromise = (this.options.socketPath ? this.connectToSocket(this.options.socketPath) : this.spawnDirect()).catch(async (error) => {
+      throw await this.shutdown(), error;
+    }), this.startPromise);
+  }
+  /** Cancel an owned handshake without waiting for the remote server. */
+  waitForStart(pending) {
+    let signal = this.stop.signal;
+    return signal.throwIfAborted(), new Promise((resolve2, reject) => {
+      let aborted = () => reject(signal.reason);
+      signal.addEventListener("abort", aborted, { once: !0 }), pending.then(resolve2, reject).finally(() => signal.removeEventListener("abort", aborted));
+    });
   }
   /** Register shared connection handlers (diagnostics, workspace/configuration, errors) */
   registerConnectionHandlers() {
@@ -451,64 +465,63 @@ var LspClient = class {
   /** Connect to an existing LSP daemon via Unix socket (no init handshake needed) */
   async connectToSocket(socketPath) {
     return this._isDaemonClient = !0, new Promise((resolve2, reject) => {
-      let settled = !1, settle = (fn) => {
-        settled || (settled = !0, fn());
+      let settled = !1, connected = !1, timeout, settle = (error) => {
+        settled || (settled = !0, clearTimeout(timeout), this.stop.signal.removeEventListener("abort", aborted), error ? reject(error) : resolve2());
+      }, aborted = () => {
+        settle(new Error("LSP client shut down")), socket.destroy();
       }, socket = netConnect(socketPath, () => {
-        this.socket = socket;
-        let reader = new import_node.SocketMessageReader(socket), writer = new import_node.SocketMessageWriter(socket);
-        this.connection = (0, import_node.createMessageConnection)(reader, writer), this.registerConnectionHandlers(), this.connection.listen(), this._initialized = !0, settle(() => resolve2());
+        if (this._disposed || settled) {
+          socket.destroy();
+          return;
+        }
+        try {
+          let reader = new import_node.SocketMessageReader(socket), writer = new import_node.SocketMessageWriter(socket);
+          this.connection = (0, import_node.createMessageConnection)(reader, writer), this.registerConnectionHandlers(), this.connection.listen(), this._initialized = !0, connected = !0, settle();
+        } catch (error) {
+          settle(error instanceof Error ? error : new Error(String(error))), socket.destroy();
+        }
       });
-      socket.on("error", (err) => {
-        this._initialized ? this._initialized = !1 : settle(() => reject(new Error(`Failed to connect to LSP daemon: ${err.message}`)));
+      this.socket = socket, socket.on("error", (err) => {
+        settle(new Error(`Failed to connect to LSP daemon: ${err.message}`)), this._initialized = !1;
       }), socket.on("close", () => {
-        this._disposed || (this._initialized = !1, this.options.onUnexpectedExit?.(null));
-      }), setTimeout(() => {
-        settled || (socket.destroy(), settle(() => reject(new Error("Timeout connecting to LSP daemon socket"))));
-      }, 1e4);
+        settle(new Error("LSP daemon socket closed during startup")), this._disposed || (this._initialized = !1, connected && this.options.onUnexpectedExit?.(null));
+      }), timeout = setTimeout(() => {
+        settle(new Error("Timeout connecting to LSP daemon socket")), socket.destroy();
+      }, 1e4), this.stop.signal.addEventListener("abort", aborted, { once: !0 }), this.stop.signal.aborted && aborted();
     });
   }
   /** Spawn LSP server directly as child process with stdio */
   async spawnDirect() {
     let env = { ...process.env, ...this.options.env };
-    if (this.process = spawn(this.options.command, this.options.args, {
+    this.process = spawn(this.options.command, this.options.args, {
       stdio: ["pipe", "pipe", "pipe"],
       env,
       cwd: this.rootDir
-    }), !this.process.stdout || !this.process.stdin)
+    });
+    let child = this.process;
+    for (let stream of [child.stdin, child.stdout, child.stderr])
+      stream?.on("error", (err) => {
+        this._disposed || console.error(`[LSP ${this.languageId}] Transport error: ${err.message}`);
+      });
+    child.on("error", (err) => {
+      this._disposed || console.error(`[LSP ${this.languageId}] Process error: ${err.message}`), this._initialized = !1, this.disposeConnection();
+    });
+    let wasInitialized = !1;
+    if (child.on("exit", (code) => {
+      this._disposed || (this._initialized = !1, this.disposeConnection(), wasInitialized && this.options.onUnexpectedExit?.(code));
+    }), !child.stdout || !child.stdin)
       throw new Error(`Failed to spawn LSP server: ${this.options.command}`);
-    await new Promise((resolve2, reject) => {
+    await this.waitForStart(new Promise((resolve2, reject) => {
       let onSpawn = () => {
         cleanup(), resolve2();
       }, onError = (err) => {
         cleanup(), reject(new Error(`Failed to spawn LSP server "${this.options.command}": ${err.message}`));
       }, cleanup = () => {
-        this.process?.removeListener("spawn", onSpawn), this.process?.removeListener("error", onError);
+        child.removeListener("spawn", onSpawn), child.removeListener("error", onError), this.stop.signal.removeEventListener("abort", cleanup);
       };
-      this.process.on("spawn", onSpawn), this.process.on("error", onError);
-    }), this.process.stderr?.resume();
-    let stdin = this.process.stdin, originalWrite = stdin.write;
-    stdin.write = function(...args) {
-      if (this.destroyed || this.writableEnded || this.writableFinished) {
-        let cb = args[args.length - 1];
-        return typeof cb == "function" && process.nextTick(cb), !1;
-      }
-      try {
-        return originalWrite.apply(this, args);
-      } catch (err) {
-        if (err?.code === "EPIPE" || err?.code === "ERR_STREAM_DESTROYED") {
-          let cb = args[args.length - 1];
-          return typeof cb == "function" && process.nextTick(cb), !1;
-        }
-        throw err;
-      }
-    }, stdin.on("error", (err) => {
-      err?.code !== "EPIPE" && console.error(`[LSP ${this.languageId}] stdin error: ${err.message}`);
-    }), this.process.on("error", (err) => {
-      console.error(`[LSP ${this.languageId}] Process error: ${err.message}`), this._initialized = !1, this.disposeConnection();
-    }), this.process.on("exit", (code) => {
-      this._disposed || (console.error(`[LSP ${this.languageId}] Server exited with code ${code}`), this._initialized = !1, this.disposeConnection(), this.options.onUnexpectedExit?.(code));
-    });
-    let reader = new import_node.StreamMessageReader(this.process.stdout), writer = new import_node.StreamMessageWriter(this.process.stdin);
+      child.once("spawn", onSpawn), child.once("error", onError), this.stop.signal.addEventListener("abort", cleanup, { once: !0 });
+    })), this.stop.signal.throwIfAborted(), child.stderr?.resume();
+    let reader = new import_node.StreamMessageReader(child.stdout), writer = new import_node.StreamMessageWriter(child.stdin);
     this.connection = (0, import_node.createMessageConnection)(reader, writer), this.registerConnectionHandlers(), this.connection.listen();
     let rootUri = pathToFileURL(this.rootDir).toString(), defaultFolder = { uri: rootUri, name: this.rootDir.split("/").pop() ?? "workspace" }, workspaceFolders = this.options.workspaceFolders && this.options.workspaceFolders.length > 0 ? this.options.workspaceFolders : [defaultFolder], initParams = {
       processId: process.pid,
@@ -547,8 +560,8 @@ var LspClient = class {
       rootUri,
       workspaceFolders,
       ...this.options.initializationOptions ? { initializationOptions: this.options.initializationOptions } : {}
-    }, result = await this.connection.sendRequest("initialize", initParams);
-    this._serverCapabilities = result.capabilities, this.connection.sendNotification("initialized", {}), this._initialized = !0;
+    }, result = await this.waitForStart(this.connection.sendRequest("initialize", initParams));
+    this.stop.signal.throwIfAborted(), this._serverCapabilities = result.capabilities, await this.waitForStart(this.connection.sendNotification("initialized", {})), this.stop.signal.throwIfAborted(), this._initialized = !0, wasInitialized = !0;
   }
   /** Safely dispose the connection without throwing */
   disposeConnection() {
@@ -566,7 +579,17 @@ var LspClient = class {
   }
   /** Send a notification to the LSP server */
   sendNotification(method, params) {
-    !this.connection || !this._initialized || this.connection.sendNotification(method, params);
+    if (!this.connection || !this._initialized)
+      return;
+    let report = (error) => {
+      let message = error instanceof Error ? error.message : String(error);
+      this._disposed || console.error(`[LSP ${this.languageId}] Notification failed: ${message}`);
+    };
+    try {
+      this.connection.sendNotification(method, params).catch(report);
+    } catch (error) {
+      report(error);
+    }
   }
   /** Notify server of a newly opened document */
   didOpen(uri, languageId, version, text) {
@@ -588,31 +611,60 @@ var LspClient = class {
     });
   }
   /** Gracefully shut down or disconnect from the server */
-  async shutdown() {
-    if (!this._disposed) {
-      if (this._disposed = !0, this._initialized = !1, this._isDaemonClient) {
-        this.disposeConnection(), this.socket && this.socket.destroy(), this.socket = null;
-        return;
-      }
+  shutdown() {
+    if (this.shutdownPromise)
+      return this.shutdownPromise;
+    let initialized = this._initialized;
+    return this._disposed = !0, this._initialized = !1, this.stop.abort(new Error("LSP client shut down")), this.shutdownPromise = this.shutdownOwnedTransport(initialized), this.shutdownPromise;
+  }
+  async shutdownOwnedTransport(initialized) {
+    let child = this.process, connection = this.connection;
+    if (this.process = null, this._isDaemonClient) {
+      this.disposeConnection(), this.socket?.destroy(), this.socket = null;
+      return;
+    }
+    if (connection && initialized) {
+      let timeout;
       try {
-        if (this.connection) {
-          let shutdownReq = this.connection.sendRequest("shutdown").catch(() => {
+        let graceful = async () => {
+          await connection.sendRequest("shutdown").catch(() => {
+          }), await connection.sendNotification("exit").catch(() => {
           });
-          await Promise.race([
-            shutdownReq,
-            new Promise((resolve2) => setTimeout(resolve2, 3e3))
-          ]);
-          try {
-            this.connection.sendNotification("exit");
-          } catch {
-          }
-        }
+        };
+        await Promise.race([
+          graceful().catch(() => {
+          }),
+          new Promise((resolve2) => {
+            timeout = setTimeout(resolve2, 3e3);
+          })
+        ]);
       } catch {
+      } finally {
+        clearTimeout(timeout);
       }
-      this.disposeConnection(), this.process && (this.process.kill("SIGTERM"), setTimeout(() => {
-        this.process && !this.process.killed && this.process.kill("SIGKILL");
-      }, 2e3)), this.process = null;
     }
+    this.disposeConnection(), !(!child || child.exitCode !== null || child.signalCode !== null) && await new Promise((resolve2, reject) => {
+      let forceTimer, exitTimer, cleanup = () => {
+        clearTimeout(forceTimer), clearTimeout(exitTimer), child.removeListener("exit", exited);
+      }, exited = () => {
+        cleanup(), resolve2();
+      }, signalChild = (signal) => {
+        try {
+          child.kill(signal);
+        } catch (error) {
+          cleanup(), reject(error);
+        }
+      };
+      child.once("exit", exited), forceTimer = setTimeout(() => {
+        if (child.exitCode !== null || child.signalCode !== null) {
+          exited();
+          return;
+        }
+        exitTimer = setTimeout(() => {
+          cleanup(), reject(new Error(`LSP ${this.languageId} process did not exit after SIGKILL`));
+        }, 1e3), signalChild("SIGKILL");
+      }, 2e3), signalChild("SIGTERM");
+    });
   }
 };
 
@@ -656,6 +708,10 @@ var DEFAULT_SERVERS = {
   _sessionId;
   _lombokJarPath = null;
   _shuttingDown = !1;
+  stop = new AbortController();
+  pendingClients = /* @__PURE__ */ new Set();
+  restartTimers = /* @__PURE__ */ new Set();
+  shutdownPromise = null;
   _restartAttempts = /* @__PURE__ */ new Map();
   _restartBackoff = /* @__PURE__ */ new Map();
   static MAX_RESTART_ATTEMPTS = 3;
@@ -814,17 +870,17 @@ var DEFAULT_SERVERS = {
    * Returns null if no server is configured for this language.
    */
   async getClientForLanguage(languageId) {
+    if (this._shuttingDown)
+      return null;
     let existing = this.clients.get(languageId);
     if (existing && existing.initialized && !existing.disposed)
       return existing;
     if (this.startingServers.get(languageId))
       return null;
     let config = this.serverConfigs.get(languageId);
-    if (!config)
-      return null;
-    let startPromise = this.startServer(languageId, config);
-    return this.startingServers.set(languageId, startPromise), startPromise.catch((err) => {
-      this.startingServers.delete(languageId);
+    return config && this.trackStart(languageId, config).catch((err) => {
+      if (this._shuttingDown)
+        return;
       let message = `Failed to start LSP server for ${languageId}: ${err.message}`;
       this._callbacks.onServerError?.(languageId, message);
     }), null;
@@ -841,18 +897,18 @@ var DEFAULT_SERVERS = {
    * is fire-and-forget — intended for session_start auto-start.
    */
   startEagerly(languageIds) {
-    for (let languageId of languageIds) {
-      let existing = this.clients.get(languageId);
-      if (existing && existing.initialized && !existing.disposed || this.startingServers.has(languageId))
-        continue;
-      let config = this.serverConfigs.get(languageId);
-      if (!config)
-        continue;
-      let startPromise = this.startServer(languageId, config);
-      this.startingServers.set(languageId, startPromise), startPromise.catch((err) => {
-        this.startingServers.delete(languageId), this._callbacks.onServerError?.(languageId, `Auto-start failed: ${err.message}`);
-      });
-    }
+    if (!this._shuttingDown)
+      for (let languageId of languageIds) {
+        let existing = this.clients.get(languageId);
+        if (existing && existing.initialized && !existing.disposed || this.startingServers.has(languageId))
+          continue;
+        let config = this.serverConfigs.get(languageId);
+        if (!config)
+          continue;
+        this.trackStart(languageId, config).catch((err) => {
+          this._shuttingDown || this._callbacks.onServerError?.(languageId, `Auto-start failed: ${err.message}`);
+        });
+      }
   }
   /**
    * Ensure workspace provider is ready (one-time per session).
@@ -862,88 +918,98 @@ var DEFAULT_SERVERS = {
     if (this._workspaceReady)
       return;
     if (this._workspaceReadying) {
-      await this._workspaceReadying;
+      await this.waitForStart(this._workspaceReadying);
       return;
     }
-    this._callbacks.onWorkspaceSetupStart?.();
+    this._callbacks.onWorkspaceSetupStart?.(), this.stop.signal.throwIfAborted();
     let start = Date.now();
     this._workspaceReadying = this._workspace.ensureReady(this._sessionId);
     try {
-      let success = await this._workspaceReadying;
+      let success = await this.waitForStart(this._workspaceReadying);
       this._callbacks.onWorkspaceSetupEnd?.(success, Date.now() - start);
     } finally {
       this._workspaceReady = !0, this._workspaceReadying = null;
     }
   }
+  /** Keep starts registered until their owned clients have either attached or closed. */
+  trackStart(languageId, config) {
+    this.stop.signal.throwIfAborted();
+    let existing = this.startingServers.get(languageId);
+    if (existing)
+      return existing;
+    let pending = Promise.resolve().then(() => this.startServer(languageId, config)).finally(() => {
+      this.startingServers.get(languageId) === pending && this.startingServers.delete(languageId);
+    });
+    return this.startingServers.set(languageId, pending), pending;
+  }
+  waitForStart(pending) {
+    let signal = this.stop.signal;
+    return signal.throwIfAborted(), new Promise((resolve2, reject) => {
+      let aborted = () => reject(signal.reason);
+      signal.addEventListener("abort", aborted, { once: !0 }), pending.then(resolve2, reject).finally(() => signal.removeEventListener("abort", aborted));
+    });
+  }
   async startServer(languageId, config) {
-    await this.ensureWorkspace();
+    this.stop.signal.throwIfAborted(), await this.ensureWorkspace(), this.stop.signal.throwIfAborted();
     let stateDir = this._workspace.stateDir, folders = this._workspace.getWorkspaceFolders(), workspaceFolders = folders.length > 0 ? folders : void 0, initializationOptions = config.initializationOptions ?? (languageId === "java" ? this.getJavaInitializationOptions() : void 0), effectiveArgs = config.args;
     if (languageId === "java") {
       let lombokJar = this.findLombokJar();
       lombokJar && (effectiveArgs = [`--jvm-arg=-javaagent:${lombokJar}`, ...config.args]);
     }
-    let onUnexpectedExit = (code) => this.handleUnexpectedExit(languageId, code), socketPath = this.getSocketPath(languageId);
+    let onUnexpectedExit = (code) => this.handleUnexpectedExit(languageId, code), connectClient = async (socketPath2) => {
+      this.stop.signal.throwIfAborted();
+      let client = new LspClient({
+        command: config.command,
+        args: effectiveArgs,
+        rootDir: this.rootDir,
+        languageId,
+        socketPath: socketPath2,
+        env: config.env,
+        workspaceFolders,
+        initializationOptions,
+        settings: config.settings,
+        onUnexpectedExit
+      });
+      this.pendingClients.add(client);
+      try {
+        if (await this.waitForStart(client.start()), this.stop.signal.throwIfAborted(), !client.initialized || client.disposed)
+          throw new Error("LSP client closed during startup");
+        return this.clients.set(languageId, client), this._callbacks.onServerReady?.(languageId), this._restartAttempts.delete(languageId), this._restartBackoff.delete(languageId), this.triggerPostInit(languageId, client), client;
+      } catch (error) {
+        throw await client.shutdown(), error;
+      } finally {
+        this.pendingClients.delete(client);
+      }
+    }, socketPath = this.getSocketPath(languageId);
     if (socketPath && this.isDaemonAlive(languageId)) {
       this._callbacks.onServerStart?.(languageId, `${config.command} (shared)`);
       try {
-        let client2 = new LspClient({
-          command: config.command,
-          args: effectiveArgs,
-          rootDir: this.rootDir,
-          languageId,
-          socketPath,
-          initializationOptions,
-          settings: config.settings,
-          onUnexpectedExit
-        });
-        return await client2.start(), this.clients.set(languageId, client2), this.startingServers.delete(languageId), this._callbacks.onServerReady?.(languageId), this._restartAttempts.delete(languageId), this._restartBackoff.delete(languageId), this.triggerPostInit(languageId, client2), client2;
+        return await connectClient(socketPath);
       } catch {
+        this.stop.signal.throwIfAborted();
       }
     }
-    if (this._callbacks.onServerStart?.(languageId, config.command), stateDir)
+    if (this.stop.signal.throwIfAborted(), this._callbacks.onServerStart?.(languageId, config.command), stateDir)
       try {
-        await this.spawnDaemon(languageId, config, effectiveArgs, workspaceFolders, initializationOptions), await new Promise((r) => setTimeout(r, 500));
-        let daemonSocket = this.getSocketPath(languageId), lastErr = null;
-        for (let attempt = 0; attempt < 60; attempt++)
+        await this.spawnDaemon(languageId, config, effectiveArgs, workspaceFolders, initializationOptions), await delay(500, void 0, { signal: this.stop.signal });
+        let daemonSocket = this.getSocketPath(languageId), lastErr;
+        for (let attempt = 0; attempt < 60; attempt++) {
+          this.stop.signal.throwIfAborted();
           try {
-            let client2 = new LspClient({
-              command: config.command,
-              args: effectiveArgs,
-              rootDir: this.rootDir,
-              languageId,
-              socketPath: daemonSocket,
-              initializationOptions,
-              settings: config.settings,
-              onUnexpectedExit
-            });
-            return await client2.start(), this.clients.set(languageId, client2), this.startingServers.delete(languageId), this._callbacks.onServerReady?.(languageId), this._restartAttempts.delete(languageId), this._restartBackoff.delete(languageId), this.triggerPostInit(languageId, client2), client2;
-          } catch (err) {
-            if (lastErr = err, !this.isDaemonAlive(languageId))
-              throw new Error(`Daemon for ${languageId} died during startup: ${err.message}`);
-            await new Promise((r) => setTimeout(r, 5e3));
+            return await connectClient(daemonSocket);
+          } catch (error) {
+            if (this.stop.signal.throwIfAborted(), lastErr = error, !this.isDaemonAlive(languageId))
+              throw error;
+            await delay(5e3, void 0, { signal: this.stop.signal });
           }
+        }
         throw lastErr ?? new Error("Failed to connect to daemon");
-      } catch (err) {
-        this._callbacks.onServerError?.(languageId, `Daemon mode failed, falling back to direct: ${err.message}`), this.startingServers.delete(languageId);
+      } catch (error) {
+        this.stop.signal.throwIfAborted();
+        let message = error instanceof Error ? error.message : String(error);
+        this._callbacks.onServerError?.(languageId, `Daemon mode failed, falling back to direct: ${message}`);
       }
-    let client = new LspClient({
-      command: config.command,
-      args: effectiveArgs,
-      rootDir: this.rootDir,
-      languageId,
-      env: config.env,
-      workspaceFolders,
-      initializationOptions,
-      settings: config.settings,
-      onUnexpectedExit
-    });
-    try {
-      return await client.start(), this.clients.set(languageId, client), this.startingServers.delete(languageId), this._callbacks.onServerReady?.(languageId), this._restartAttempts.delete(languageId), this._restartBackoff.delete(languageId), this.triggerPostInit(languageId, client), client;
-    } catch (err) {
-      this.startingServers.delete(languageId);
-      let message = `Failed to start LSP server for ${languageId} (${config.command}): ${err.message}`;
-      throw this._callbacks.onServerError?.(languageId, message), new Error(message);
-    }
+    return connectClient();
   }
   /**
    * Post-initialization hook for language-specific setup.
@@ -976,6 +1042,7 @@ var DEFAULT_SERVERS = {
   }
   /** Spawn an LSP daemon as a detached background process */
   async spawnDaemon(languageId, config, effectiveArgs, workspaceFolders, initializationOptions) {
+    this.stop.signal.throwIfAborted();
     let socketPath = this.getSocketPath(languageId), daemonScript = new URL("./lsp-daemon.ts", new URL("../builtin-extensions/pi-lsp-extension/src/lsp-manager.js", import.meta.url).href).pathname, launcherScript = new URL("./lsp-daemon-launcher.cjs", new URL("../builtin-extensions/pi-lsp-extension/src/lsp-manager.js", import.meta.url).href).pathname, jitiPath;
     try {
       jitiPath = __require.resolve("jiti");
@@ -992,7 +1059,8 @@ var DEFAULT_SERVERS = {
       LSP_ROOT_DIR: this.rootDir,
       LSP_LANGUAGE_ID: languageId
     };
-    workspaceFolders && workspaceFolders.length > 0 && (env.LSP_WORKSPACE_FOLDERS = JSON.stringify(workspaceFolders)), initializationOptions && (env.LSP_INITIALIZATION_OPTIONS = JSON.stringify(initializationOptions)), config.settings && (env.LSP_SETTINGS = JSON.stringify(config.settings)), spawnChild(
+    workspaceFolders && workspaceFolders.length > 0 && (env.LSP_WORKSPACE_FOLDERS = JSON.stringify(workspaceFolders)), initializationOptions && (env.LSP_INITIALIZATION_OPTIONS = JSON.stringify(initializationOptions)), config.settings && (env.LSP_SETTINGS = JSON.stringify(config.settings));
+    let child = spawnChild(
       process.execPath,
       // node
       [launcherScript, jitiPath, daemonScript, socketPath, config.command, ...effectiveArgs],
@@ -1002,7 +1070,12 @@ var DEFAULT_SERVERS = {
         detached: !0,
         stdio: "ignore"
       }
-    ).unref();
+    );
+    child.unref(), await this.waitForStart(new Promise((resolve2, reject) => {
+      child.on("error", (error) => {
+        reject(error), this._shuttingDown || this._callbacks.onServerError?.(languageId, error.message);
+      }), child.once("spawn", resolve2);
+    }));
   }
   /** Get status of all configured/running servers */
   getStatus() {
@@ -1030,31 +1103,42 @@ var DEFAULT_SERVERS = {
   handleUnexpectedExit(languageId, code) {
     if (this._shuttingDown)
       return;
-    this.clients.delete(languageId), this.startingServers.delete(languageId);
+    this.clients.delete(languageId);
     let attempts = this._restartAttempts.get(languageId) ?? 0;
     if (attempts >= _LspManager.MAX_RESTART_ATTEMPTS) {
       this._callbacks.onServerError?.(languageId, `LSP server for ${languageId} crashed ${attempts} times \u2014 giving up auto-restart`), this._callbacks.onServerCrash?.(languageId, !1, attempts);
       return;
     }
     let backoff = this._restartBackoff.get(languageId) ?? _LspManager.INITIAL_BACKOFF_MS;
-    this._restartAttempts.set(languageId, attempts + 1), this._restartBackoff.set(languageId, Math.min(backoff * 2, _LspManager.MAX_BACKOFF_MS)), this._callbacks.onServerCrash?.(languageId, !0, attempts + 1), setTimeout(() => {
-      if (this._shuttingDown)
+    this._restartAttempts.set(languageId, attempts + 1), this._restartBackoff.set(languageId, Math.min(backoff * 2, _LspManager.MAX_BACKOFF_MS)), this._callbacks.onServerCrash?.(languageId, !0, attempts + 1);
+    let timer = setTimeout(() => {
+      if (this.restartTimers.delete(timer), this._shuttingDown)
         return;
       let config = this.serverConfigs.get(languageId);
       if (!config)
         return;
-      let startPromise = this.startServer(languageId, config);
-      this.startingServers.set(languageId, startPromise), startPromise.catch((err) => {
-        this.startingServers.delete(languageId), this._callbacks.onServerError?.(languageId, `Auto-restart failed for ${languageId}: ${err.message}`), this.handleUnexpectedExit(languageId, null);
+      this.trackStart(languageId, config).catch((err) => {
+        this._shuttingDown || (this._callbacks.onServerError?.(languageId, `Auto-restart failed for ${languageId}: ${err.message}`), this.handleUnexpectedExit(languageId, null));
       });
     }, backoff);
+    this.restartTimers.add(timer);
   }
   /** Shut down all clients (disconnect from daemons, kill direct servers) */
-  async shutdownAll() {
-    this._workspace.shutdown(), this._shuttingDown = !0;
-    let shutdowns = [...this.clients.values()].map((client) => client.shutdown().catch(() => {
-    }));
-    await Promise.all(shutdowns), this.clients.clear(), this.startingServers.clear();
+  shutdownAll() {
+    if (this.shutdownPromise)
+      return this.shutdownPromise;
+    this._shuttingDown = !0, this.stop.abort(new Error("LSP manager shut down"));
+    for (let timer of this.restartTimers)
+      clearTimeout(timer);
+    return this.restartTimers.clear(), this.shutdownPromise = this.shutdownClients(), this.shutdownPromise;
+  }
+  async shutdownClients() {
+    try {
+      this._workspace.shutdown();
+    } finally {
+      let clients = /* @__PURE__ */ new Set([...this.clients.values(), ...this.pendingClients]);
+      await Promise.allSettled([...clients].map((client) => client.shutdown())), await Promise.allSettled([...this.startingServers.values()]), this.clients.clear(), this.startingServers.clear();
+    }
   }
   /**
    * Restart a specific language server. Shuts down the existing client
@@ -1062,16 +1146,17 @@ var DEFAULT_SERVERS = {
    * Returns once the new server is initialized, or throws on failure.
    */
   async restartServer(languageId) {
+    this.stop.signal.throwIfAborted();
+    let pending = this.startingServers.get(languageId);
+    pending && await pending.catch(() => {
+    }), this.stop.signal.throwIfAborted();
     let existing = this.clients.get(languageId);
     existing && (await existing.shutdown().catch(() => {
-    }), this.clients.delete(languageId)), this.killDaemon(languageId);
-    let pending = this.startingServers.get(languageId);
-    pending && (await pending.catch(() => {
-    }), this.startingServers.delete(languageId));
+    }), this.clients.get(languageId) === existing && this.clients.delete(languageId)), this.stop.signal.throwIfAborted(), this.killDaemon(languageId);
     let config = this.serverConfigs.get(languageId);
     if (!config)
       throw new Error(`No server configured for ${languageId}`);
-    await this.startServer(languageId, config);
+    await this.trackStart(languageId, config);
   }
   /** Kill a running daemon for a language (if any) */
   killDaemon(languageId) {

package/dist/node-runtime/{lunr-browser-IR7TL3J7.js → lunr-browser-H4FDOR3C.js}

@@ -1,15 +1,15 @@
 import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
 import {
   toolStatusDotFromContext
-} from "./chunk-5ZQXRPMC.js";
+} from "./chunk-6ZZHGUSA.js";
 import {
   onBrowserEnabledChange,
   readBrowserSettings
-} from "./chunk-UOEDI7RP.js";
-import "./chunk-2HMIRK7W.js";
-import "./chunk-CSFI6YXL.js";
-import "./chunk-B4HP6ZWM.js";
-import "./chunk-FQMM2EZ2.js";
+} from "./chunk-4KNKQGHM.js";
+import "./chunk-LHV3V67B.js";
+import "./chunk-ES6PBSIE.js";
+import "./chunk-RHCGYWO7.js";
+import "./chunk-64XTQNLA.js";
 import "./chunk-Q4Q6D4IY.js";
 import "./chunk-BRJX2PRC.js";
 
@@ -159,7 +159,7 @@ function browserExtension(pi) {
     async execute(_id, input, signal) {
       if (!enabled)
         throw await close(), new Error("Browser is disabled. The user can enable Browser in /settings.");
-      let current = generation, { BrowserSession } = await import("./runtime-4VA6JKNF.js");
+      let current = generation, { BrowserSession } = await import("./runtime-EDUUGAQD.js");
       if (current !== generation || signal?.aborted)
         throw new Error("Browser call cancelled during initialization.");
       return session ??= new BrowserSession(readBrowserSettings().allowPrivate), session.run(input, signal);