pybao-cli 1.3.82 → 1.3.84

package/dist/chunk-42L6OJOC.js

@@ -0,0 +1,1832 @@
+import { createRequire as __pybCreateRequire } from "node:module";
+const require = __pybCreateRequire(import.meta.url);
+import {
+  loadSettingsWithLegacyFallback
+} from "./chunk-6WOCAHEK.js";
+import {
+  debug
+} from "./chunk-MN5A3I5G.js";
+import {
+  env,
+  getCwd,
+  getPybBaseDir
+} from "./chunk-WPA4GCGG.js";
+import {
+  __require
+} from "./chunk-I3J4JYES.js";
+
+// src/tools/search/LspTool/registry.ts
+import { join as join2, dirname, basename } from "path";
+import { fileURLToPath } from "url";
+import { existsSync as existsSync2, mkdirSync, mkdtempSync, rmSync, readdirSync, writeFileSync, chmodSync, renameSync } from "fs";
+import { tmpdir } from "os";
+
+// src/tools/search/LspTool/utils.ts
+import { join, relative } from "path";
+import { existsSync } from "fs";
+import { minimatch } from "minimatch";
+function getToolsDir() {
+  return join(getPybBaseDir(), "tools");
+}
+function getLspBinDir() {
+  return join(getToolsDir(), "bin");
+}
+async function findNearestRoot(startDir, markers, options) {
+  const filePath = options?.filePath;
+  if (filePath) {
+    const normalizedFile = filePath.replace(/\\/g, "/");
+    const relativeToStart = relative(startDir, filePath).replace(/\\/g, "/");
+    const matchesAny = (patterns) => patterns.some((pattern) => {
+      if (minimatch(normalizedFile, pattern, { dot: true })) return true;
+      if (relativeToStart && !relativeToStart.startsWith("..")) {
+        return minimatch(relativeToStart, pattern, { dot: true });
+      }
+      return false;
+    });
+    if (options?.exclude && matchesAny(options.exclude)) return void 0;
+    if (options?.include && !matchesAny(options.include)) return void 0;
+  }
+  if (options?.branches && options.branches.length > 0) {
+    for (const branch of options.branches) {
+      const resolved = await findNearestRoot(startDir, branch, {
+        ...options,
+        branches: void 0
+      });
+      if (resolved) return resolved;
+    }
+  }
+  let current = startDir;
+  while (true) {
+    for (const marker of markers) {
+      const p = join(current, marker);
+      if (existsSync(p)) {
+        return current;
+      }
+    }
+    const parent = join(current, "..");
+    if (parent === current) {
+      break;
+    }
+    current = parent;
+  }
+  return void 0;
+}
+
+// src/tools/search/LspTool/registry.ts
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+var lspInstallDir = getLspBinDir();
+function parseBoolean(value) {
+  if (value === void 0) return void 0;
+  const normalized = value.trim().toLowerCase();
+  if (!normalized) return void 0;
+  if (["1", "true", "yes", "on"].includes(normalized)) return true;
+  if (["0", "false", "no", "off"].includes(normalized)) return false;
+  return void 0;
+}
+async function isAutoInstallEnabled() {
+  const disabled = parseBoolean(
+    process.env.PYB_DISABLE_LSP_DOWNLOAD ?? process.env.PYB_DISABLE_LSP_INSTALL ?? process.env.OPENCODE_DISABLE_LSP_DOWNLOAD
+  );
+  if (disabled === true) return false;
+  const enabled = parseBoolean(
+    process.env.PYB_LSP_AUTO_INSTALL ?? process.env.PYB_ENABLE_LSP_AUTO_INSTALL
+  );
+  if (enabled === false) return false;
+  return env.hasInternetAccess();
+}
+function ensureInstallDir() {
+  if (!existsSync2(lspInstallDir)) {
+    mkdirSync(lspInstallDir, { recursive: true });
+  }
+}
+function resolveBinInDir(dir, binName) {
+  const exts = process.platform === "win32" ? [".cmd", ".exe", ".ps1", ""] : [""];
+  for (const ext of exts) {
+    const binPath = join2(dir, `${binName}${ext}`);
+    if (existsSync2(binPath)) {
+      return binPath;
+    }
+  }
+  return "";
+}
+async function bunInstall(packages, cwd = lspInstallDir) {
+  const bunBin = Bun.which("bun") ?? process.execPath;
+  if (!existsSync2(cwd)) {
+    mkdirSync(cwd, { recursive: true });
+  }
+  const proc = Bun.spawn({
+    cmd: [bunBin, "install", ...packages],
+    cwd,
+    env: {
+      ...process.env,
+      BUN_BE_BUN: "1"
+    },
+    stdout: "pipe",
+    stderr: "pipe",
+    stdin: "pipe"
+  });
+  const exitCode = await proc.exited;
+  return exitCode === 0;
+}
+async function runBinary(cmd, extraEnv, cwd = lspInstallDir) {
+  const proc = Bun.spawn({
+    cmd,
+    cwd,
+    env: {
+      ...process.env,
+      ...extraEnv
+    },
+    stdout: "pipe",
+    stderr: "pipe",
+    stdin: "pipe"
+  });
+  const [stdout, stderr, exitCode] = await Promise.all([
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+    proc.exited
+  ]);
+  if (exitCode === 0) {
+    return { ok: true };
+  }
+  return { ok: false, error: stderr || stdout };
+}
+async function getJavaMajorVersion() {
+  const proc = Bun.spawn({
+    cmd: ["java", "-version"],
+    stdout: "pipe",
+    stderr: "pipe",
+    stdin: "pipe"
+  });
+  const [stdout, stderr, exitCode] = await Promise.all([
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+    proc.exited
+  ]);
+  if (exitCode !== 0) return null;
+  const output = `${stderr}
+${stdout}`;
+  const match = /"(\d+)(?:\.\d+)?(?:\.\d+)?"?/.exec(output);
+  if (!match) return null;
+  const major = Number.parseInt(match[1], 10);
+  return Number.isNaN(major) ? null : major;
+}
+var ESLINT_ARCHIVE_URL = "https://github.com/microsoft/vscode-eslint/archive/refs/heads/main.zip";
+function getEslintInstallDir(installDir = lspInstallDir) {
+  return join2(installDir, "vscode-eslint");
+}
+function getEslintServerPath(installDir = lspInstallDir) {
+  return join2(getEslintInstallDir(installDir), "server", "out", "eslintServer.js");
+}
+async function installEslintServer(installDir = lspInstallDir) {
+  const serverPath = getEslintServerPath(installDir);
+  if (existsSync2(serverPath)) return true;
+  const canInstall = await isAutoInstallEnabled();
+  if (!canInstall) return false;
+  if (!existsSync2(installDir)) {
+    mkdirSync(installDir, { recursive: true });
+  }
+  debug.info("LSP_INSTALL", { server: "eslint", action: "start" });
+  try {
+    await downloadAndExtractArchive({
+      url: ESLINT_ARCHIVE_URL,
+      archiveType: "zip",
+      installDir,
+      expectedFiles: ["vscode-eslint-main"]
+    });
+    const extractedPath = join2(installDir, "vscode-eslint-main");
+    const finalPath = getEslintInstallDir(installDir);
+    if (!existsSync2(extractedPath)) {
+      debug.error("LSP_INSTALL_FAILED", { server: "eslint", error: "extracted path missing" });
+      return false;
+    }
+    if (existsSync2(finalPath)) {
+      rmSync(finalPath, { recursive: true, force: true });
+    }
+    renameSync(extractedPath, finalPath);
+    const npmCmd = process.platform === "win32" ? "npm.cmd" : "npm";
+    if (!Bun.which(npmCmd)) {
+      debug.error("LSP_MISSING_DEP", { server: "eslint", error: `${npmCmd} not found` });
+      return false;
+    }
+    const installResult = await runBinary([npmCmd, "install"], void 0, finalPath);
+    if (!installResult.ok) {
+      debug.error("LSP_INSTALL_FAILED", { server: "eslint", error: installResult.error });
+      return false;
+    }
+    const compileResult = await runBinary([npmCmd, "run", "compile"], void 0, finalPath);
+    if (!compileResult.ok) {
+      debug.error("LSP_INSTALL_FAILED", { server: "eslint", error: compileResult.error });
+      return false;
+    }
+    if (!existsSync2(serverPath)) {
+      debug.error("LSP_INSTALL_FAILED", { server: "eslint", error: "eslintServer.js not found" });
+      return false;
+    }
+    debug.info("LSP_INSTALL", { server: "eslint", action: "success" });
+    return true;
+  } catch (e) {
+    debug.error("LSP_INSTALL_ERROR", { server: "eslint", error: String(e) });
+    return false;
+  }
+}
+var DEFAULT_LANGUAGE_MAP = {
+  ".sh": "shellscript",
+  ".bash": "shellscript",
+  ".zsh": "shellscript",
+  ".ksh": "shellscript",
+  ".ps1": "powershell",
+  ".psm1": "powershell",
+  ".bat": "bat",
+  ".cmd": "bat",
+  ".js": "javascript",
+  ".mjs": "javascript",
+  ".cjs": "javascript",
+  ".jsx": "javascriptreact",
+  ".ts": "typescript",
+  ".mts": "typescript",
+  ".cts": "typescript",
+  ".ets": "typescript",
+  ".tsx": "typescriptreact",
+  ".mtsx": "typescriptreact",
+  ".ctsx": "typescriptreact",
+  ".vue": "vue",
+  ".svelte": "svelte",
+  ".astro": "astro",
+  ".html": "html",
+  ".htm": "html",
+  ".css": "css",
+  ".scss": "scss",
+  ".sass": "sass",
+  ".less": "less",
+  ".json": "json",
+  ".yml": "yaml",
+  ".yaml": "yaml",
+  ".py": "python",
+  ".go": "go",
+  ".java": "java",
+  ".kt": "kotlin",
+  ".kts": "kotlin",
+  ".rb": "ruby",
+  ".rake": "ruby",
+  ".gemspec": "ruby",
+  ".ru": "ruby",
+  ".erb": "erb",
+  ".php": "php",
+  ".rs": "rust",
+  ".c": "c",
+  ".cpp": "cpp",
+  ".cxx": "cpp",
+  ".cc": "cpp",
+  ".hpp": "cpp",
+  ".h": "c",
+  ".cs": "csharp",
+  ".fs": "fsharp",
+  ".fsi": "fsharp",
+  ".fsx": "fsharp",
+  ".fsscript": "fsharp",
+  ".scala": "scala",
+  ".swift": "swift",
+  ".dart": "dart",
+  ".dockerfile": "dockerfile",
+  "dockerfile": "dockerfile",
+  ".tf": "terraform",
+  ".tfvars": "terraform",
+  ".hcl": "hcl",
+  ".nix": "nix",
+  ".makefile": "makefile",
+  "makefile": "makefile",
+  ".md": "markdown",
+  ".markdown": "markdown",
+  ".sql": "sql",
+  ".xml": "xml",
+  ".xsl": "xml",
+  ".tex": "latex",
+  ".latex": "latex",
+  ".bib": "bibtex",
+  ".bibtex": "bibtex",
+  ".diff": "diff",
+  ".patch": "diff",
+  ".clj": "clojure",
+  ".cljs": "clojure",
+  ".cljc": "clojure",
+  ".edn": "clojure",
+  ".ex": "elixir",
+  ".exs": "elixir",
+  ".erl": "erlang",
+  ".hrl": "erlang",
+  ".hs": "haskell",
+  ".lhs": "haskell",
+  ".ml": "ocaml",
+  ".mli": "ocaml",
+  ".zig": "zig",
+  ".zon": "zig",
+  ".gleam": "gleam",
+  ".typ": "typst",
+  ".typc": "typst"
+};
+var DEFAULT_LANGUAGE_CATEGORIES = {
+  javascript: "web",
+  javascriptreact: "web",
+  typescript: "web",
+  typescriptreact: "web",
+  vue: "web",
+  svelte: "web",
+  astro: "web",
+  html: "web",
+  css: "web",
+  scss: "web",
+  sass: "web",
+  less: "web",
+  python: "backend",
+  go: "backend",
+  java: "backend",
+  kotlin: "backend",
+  ruby: "backend",
+  php: "backend",
+  rust: "backend",
+  csharp: "backend",
+  fsharp: "backend",
+  scala: "backend",
+  swift: "backend",
+  dart: "backend",
+  elixir: "backend",
+  erlang: "backend",
+  haskell: "backend",
+  ocaml: "backend",
+  c: "system",
+  cpp: "system",
+  zig: "system",
+  shellscript: "system",
+  powershell: "system",
+  makefile: "system",
+  sql: "data",
+  json: "data",
+  yaml: "data",
+  xml: "data",
+  latex: "data",
+  bibtex: "data",
+  dockerfile: "infra",
+  terraform: "infra",
+  hcl: "infra",
+  nix: "infra",
+  markdown: "docs",
+  diff: "docs"
+};
+var EXPERIMENTAL_SWITCHES = {
+  ty: { enable: ["ty"], disable: ["pyright"] }
+};
+function isRecord(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function normalizeStringArray(value) {
+  if (!Array.isArray(value)) return void 0;
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const entry of value) {
+    if (typeof entry !== "string") continue;
+    const trimmed = entry.trim();
+    if (!trimmed || seen.has(trimmed)) continue;
+    seen.add(trimmed);
+    out.push(trimmed);
+  }
+  return out.length ? out : void 0;
+}
+function normalizeStringRecord(value) {
+  if (!isRecord(value)) return void 0;
+  const out = {};
+  for (const [key, raw] of Object.entries(value)) {
+    if (typeof raw === "string") {
+      out[key] = raw;
+    }
+  }
+  return Object.keys(out).length ? out : void 0;
+}
+function normalizeBooleanRecord(value) {
+  if (!isRecord(value)) return void 0;
+  const out = {};
+  for (const [key, raw] of Object.entries(value)) {
+    if (typeof raw === "boolean") {
+      out[key] = raw;
+    }
+  }
+  return Object.keys(out).length ? out : void 0;
+}
+function normalizeInitializationOptions(value) {
+  if (!isRecord(value)) return void 0;
+  return Object.keys(value).length ? value : void 0;
+}
+function normalizeServerOverrides(value) {
+  if (!isRecord(value)) return void 0;
+  const out = {};
+  for (const [id, raw] of Object.entries(value)) {
+    if (!isRecord(raw)) continue;
+    const entry = {};
+    if (typeof raw.disabled === "boolean") entry.disabled = raw.disabled;
+    entry.extensions = normalizeStringArray(raw.extensions);
+    entry.rootMarkers = normalizeStringArray(raw.rootMarkers);
+    if (typeof raw.command === "string" && raw.command.trim()) entry.command = raw.command;
+    entry.args = normalizeStringArray(raw.args);
+    entry.env = normalizeStringRecord(raw.env);
+    entry.initializationOptions = normalizeInitializationOptions(raw.initializationOptions);
+    if (isRecord(raw.root)) {
+      const include = normalizeStringArray(raw.root.include);
+      const exclude = normalizeStringArray(raw.root.exclude);
+      const branches = Array.isArray(raw.root.branches) ? raw.root.branches.map((branch) => normalizeStringArray(branch)).filter((branch) => Boolean(branch && branch.length)) : void 0;
+      if (include || exclude || branches) {
+        entry.root = { include, exclude, branches };
+      }
+    }
+    if (typeof raw.languageId === "string" && raw.languageId.trim()) entry.languageId = raw.languageId;
+    if (typeof raw.priority === "number" && Number.isFinite(raw.priority)) entry.priority = raw.priority;
+    if (typeof raw.group === "string" && raw.group.trim()) entry.group = raw.group;
+    out[id] = entry;
+  }
+  return Object.keys(out).length ? out : void 0;
+}
+function normalizeServerGroups(value) {
+  if (!Array.isArray(value)) return void 0;
+  const out = [];
+  for (const entry of value) {
+    if (!isRecord(entry)) continue;
+    const id = typeof entry.id === "string" ? entry.id.trim() : "";
+    const strategy = entry.strategy === "parallel" || entry.strategy === "exclusive" || entry.strategy === "fallback" ? entry.strategy : void 0;
+    const serverIds = normalizeStringArray(entry.serverIds);
+    if (!id || !strategy || !serverIds || serverIds.length === 0) continue;
+    out.push({
+      id,
+      strategy,
+      serverIds,
+      extensions: normalizeStringArray(entry.extensions)
+    });
+  }
+  return out.length ? out : void 0;
+}
+function mergeOverrides(base, next) {
+  if (!base && !next) return void 0;
+  const out = { ...base ?? {} };
+  if (next) {
+    for (const [key, value] of Object.entries(next)) {
+      out[key] = { ...out[key] ?? {}, ...value };
+    }
+  }
+  return out;
+}
+function mergeStringArrays(base, next) {
+  if (!base && !next) return void 0;
+  return normalizeStringArray([...base ?? [], ...next ?? []]);
+}
+function mergeStringRecords(base, next) {
+  if (!base && !next) return void 0;
+  return { ...base ?? {}, ...next ?? {} };
+}
+function mergeBooleanRecords(base, next) {
+  if (!base && !next) return void 0;
+  return { ...base ?? {}, ...next ?? {} };
+}
+function mergeLspSettings(base, next) {
+  if (!base && !next) return void 0;
+  const merged = { ...base ?? {} };
+  merged.disabledServers = mergeStringArrays(base?.disabledServers, next?.disabledServers);
+  merged.servers = mergeOverrides(base?.servers, next?.servers);
+  merged.experimental = mergeBooleanRecords(base?.experimental, next?.experimental);
+  merged.languageMap = mergeStringRecords(base?.languageMap, next?.languageMap);
+  merged.languageCategories = mergeStringRecords(base?.languageCategories, next?.languageCategories);
+  merged.serverGroups = next?.serverGroups ?? base?.serverGroups;
+  merged.initializationOptions = mergeInitializationOptions(base?.initializationOptions, next?.initializationOptions);
+  merged.env = mergeStringRecords(base?.env, next?.env);
+  return merged;
+}
+function mergeInitializationOptions(base, next) {
+  if (!base && !next) return void 0;
+  return { ...base ?? {}, ...next ?? {} };
+}
+function hasDenoConfig(rootPath) {
+  return ["deno.json", "deno.jsonc"].some((name) => existsSync2(join2(rootPath, name)));
+}
+function resolveTyBinary(rootPath) {
+  const direct = Bun.which("ty");
+  if (direct) return direct;
+  const venvPaths = [process.env.VIRTUAL_ENV, join2(rootPath, ".venv"), join2(rootPath, "venv")].filter(
+    (value) => Boolean(value)
+  );
+  for (const venvPath of venvPaths) {
+    const binary = process.platform === "win32" ? join2(venvPath, "Scripts", "ty.exe") : join2(venvPath, "bin", "ty");
+    if (existsSync2(binary)) return binary;
+  }
+  return null;
+}
+function hasTyBinary(rootPath) {
+  return Boolean(resolveTyBinary(rootPath));
+}
+function applyExperimentalSwitches(settings) {
+  if (!settings) return void 0;
+  if (!settings.experimental) return settings;
+  const disabled = new Set(settings.disabledServers ?? []);
+  for (const [key, enabled] of Object.entries(settings.experimental)) {
+    if (!enabled) continue;
+    const rule = EXPERIMENTAL_SWITCHES[key];
+    if (!rule) continue;
+    const canDisable = key !== "ty" || hasTyBinary(getCwd());
+    for (const id of rule.enable) {
+      disabled.delete(id);
+    }
+    for (const id of rule.disable) {
+      if (canDisable) {
+        disabled.add(id);
+      }
+    }
+  }
+  return {
+    ...settings,
+    disabledServers: disabled.size ? Array.from(disabled) : void 0
+  };
+}
+function normalizeLspSettings(value) {
+  if (!isRecord(value)) return void 0;
+  return {
+    disabledServers: normalizeStringArray(value.disabledServers),
+    servers: normalizeServerOverrides(value.servers),
+    experimental: normalizeBooleanRecord(value.experimental),
+    languageMap: normalizeStringRecord(value.languageMap),
+    languageCategories: normalizeStringRecord(value.languageCategories),
+    serverGroups: normalizeServerGroups(value.serverGroups),
+    initializationOptions: normalizeInitializationOptions(value.initializationOptions),
+    env: normalizeStringRecord(value.env)
+  };
+}
+function loadLspSettingsFromFiles(options) {
+  const projectDir = options?.projectDir ?? getCwd();
+  const homeDir = options?.homeDir;
+  const user = loadSettingsWithLegacyFallback({
+    destination: "userSettings",
+    projectDir,
+    homeDir,
+    migrateToPrimary: true
+  }).settings;
+  const project = loadSettingsWithLegacyFallback({
+    destination: "projectSettings",
+    projectDir,
+    homeDir,
+    migrateToPrimary: true
+  }).settings;
+  const local = loadSettingsWithLegacyFallback({
+    destination: "localSettings",
+    projectDir,
+    homeDir,
+    migrateToPrimary: true
+  }).settings;
+  const userSettings = normalizeLspSettings(user?.lsp);
+  const projectSettings = normalizeLspSettings(project?.lsp);
+  const localSettings = normalizeLspSettings(local?.lsp);
+  return mergeLspSettings(mergeLspSettings(userSettings, projectSettings), localSettings);
+}
+function detectPythonVenv(rootPath) {
+  const envVenv = process.env.VIRTUAL_ENV?.trim();
+  const candidates = process.platform === "win32" ? [
+    ...envVenv ? [join2(envVenv, "Scripts", "python.exe")] : [],
+    join2(rootPath, ".venv", "Scripts", "python.exe"),
+    join2(rootPath, "venv", "Scripts", "python.exe")
+  ] : [
+    ...envVenv ? [join2(envVenv, "bin", "python")] : [],
+    join2(rootPath, ".venv", "bin", "python"),
+    join2(rootPath, "venv", "bin", "python")
+  ];
+  for (const candidate of candidates) {
+    if (existsSync2(candidate)) return candidate;
+  }
+  return null;
+}
+async function npmInstallIfMissing(packages, cwd = lspInstallDir) {
+  const missing = packages.filter((pkg) => !existsSync2(join2(cwd, "node_modules", pkg, "package.json")));
+  if (missing.length === 0) return true;
+  return bunInstall(missing, cwd);
+}
+function multiResolveBinary(options) {
+  const cwd = options.cwd ?? process.cwd();
+  const localBinDir = join2(cwd, "node_modules", ".bin");
+  for (const binName of options.binNames) {
+    if (Bun.which(binName)) {
+      return { command: binName, args: options.args ?? [] };
+    }
+    const localBin = resolveBinInDir(localBinDir, binName);
+    if (localBin) {
+      return { command: localBin, args: options.args ?? [] };
+    }
+    const lspBin = resolveBinInDir(join2(lspInstallDir, "node_modules", ".bin"), binName);
+    if (lspBin) {
+      return { command: lspBin, args: options.args ?? [] };
+    }
+  }
+  if (options.packageName) {
+    const bunBin = Bun.which("bun") ?? process.execPath;
+    return { command: bunBin, args: ["x", options.packageName, ...options.args ?? []] };
+  }
+  return null;
+}
+function planLuaLsDownload(installDir) {
+  const version = process.env.PYB_LUA_LS_VERSION?.trim() || "3.13.5";
+  const platform = process.platform === "win32" ? "win32" : process.platform === "darwin" ? "darwin" : "linux";
+  const arch = process.arch === "arm64" ? "arm64" : "x64";
+  const archiveType = process.platform === "win32" ? "zip" : "tar.gz";
+  const filename = `lua-language-server-${version}-${platform}-${arch}.${archiveType}`;
+  return {
+    url: `https://github.com/LuaLS/lua-language-server/releases/download/${version}/${filename}`,
+    archiveType,
+    installDir,
+    expectedFiles: [process.platform === "win32" ? "bin/lua-language-server.exe" : "bin/lua-language-server"]
+  };
+}
+function planZlsDownload(installDir) {
+  const version = process.env.PYB_ZLS_VERSION?.trim() || "0.13.0";
+  const platform = process.platform === "win32" ? "windows" : process.platform === "darwin" ? "macos" : "linux";
+  const arch = process.arch === "arm64" ? "aarch64" : "x86_64";
+  const archiveType = process.platform === "win32" ? "zip" : "tar.gz";
+  const filename = `zls-${platform}-${arch}.${archiveType}`;
+  return {
+    url: `https://github.com/zls/zls/releases/download/${version}/${filename}`,
+    archiveType,
+    installDir,
+    expectedFiles: [process.platform === "win32" ? "zls.exe" : "zls"]
+  };
+}
+function planElixirLsDownload(installDir) {
+  const version = process.env.PYB_ELIXIR_LS_VERSION?.trim() || "0.18.2";
+  const archiveType = "zip";
+  const filename = `elixir-ls-${version}.zip`;
+  return {
+    url: `https://github.com/elixir-lsp/elixir-ls/releases/download/${version}/${filename}`,
+    archiveType,
+    installDir,
+    expectedFiles: ["language_server.sh"]
+  };
+}
+function planJdtlsDownload(installDir) {
+  const version = process.env.PYB_JDTLS_VERSION?.trim() || "1.34.0";
+  const platform = process.platform === "win32" ? "win32" : process.platform === "darwin" ? "mac" : "linux";
+  const archiveType = "tar.gz";
+  const filename = `jdtls-${version}-${platform}.tar.gz`;
+  return {
+    url: `https://download.eclipse.org/jdtls/milestones/${version}/${filename}`,
+    archiveType,
+    installDir,
+    expectedFiles: ["plugins", "configuration"]
+  };
+}
+async function extractArchive(buffer, archiveType, targetDir) {
+  if (archiveType === "zip") {
+    const { unzipSync } = await import("fflate");
+    const files = unzipSync(buffer);
+    for (const [name, data] of Object.entries(files)) {
+      const targetPath = join2(targetDir, name);
+      const targetDirPath = dirname(targetPath);
+      if (!existsSync2(targetDirPath)) {
+        mkdirSync(targetDirPath, { recursive: true });
+      }
+      writeFileSync(targetPath, data);
+    }
+    return;
+  }
+  const archiveName = `archive-${Date.now()}.tar.gz`;
+  const tempDir = mkdtempSync(join2(targetDir, "tmp-"));
+  const archivePath = join2(tempDir, archiveName);
+  writeFileSync(archivePath, buffer);
+  await runBinary(["tar", "-xzf", archivePath, "-C", targetDir], void 0, tempDir);
+  rmSync(tempDir, { recursive: true, force: true });
+}
+async function downloadAndExtractArchive(plan) {
+  if (!existsSync2(plan.installDir)) {
+    mkdirSync(plan.installDir, { recursive: true });
+  }
+  const response = await fetch(plan.url);
+  if (!response.ok) {
+    throw new Error(`Failed to download ${plan.url}: ${response.status}`);
+  }
+  const buffer = new Uint8Array(await response.arrayBuffer());
+  await extractArchive(buffer, plan.archiveType, plan.installDir);
+}
+function findFileRecursive(root, filename) {
+  const entries = readdirSync(root, { withFileTypes: true });
+  for (const entry of entries) {
+    const full = join2(root, entry.name);
+    if (entry.isDirectory()) {
+      const found = findFileRecursive(full, filename);
+      if (found) return found;
+    } else if (entry.isFile() && entry.name === filename) {
+      return full;
+    }
+  }
+  return null;
+}
+async function installLuaLs(installDir) {
+  const plan = planLuaLsDownload(installDir);
+  await downloadAndExtractArchive(plan);
+  const expected = plan.expectedFiles.find((file) => findFileRecursive(installDir, basename(file)));
+  if (!expected) {
+    throw new Error("LuaLS binary not found after extraction");
+  }
+  if (process.platform !== "win32") {
+    chmodSync(expected, 493);
+  }
+  return true;
+}
+async function installZls(installDir) {
+  if (!Bun.which("zig")) {
+    throw new Error("zig not found");
+  }
+  const plan = planZlsDownload(installDir);
+  await downloadAndExtractArchive(plan);
+  const expected = plan.expectedFiles.find((file) => findFileRecursive(installDir, basename(file)));
+  if (!expected) {
+    throw new Error("zls binary not found after extraction");
+  }
+  if (process.platform !== "win32") {
+    chmodSync(expected, 493);
+  }
+  return true;
+}
+async function installElixirLs(installDir) {
+  if (!Bun.which("elixir") || !Bun.which("mix")) {
+    throw new Error("elixir or mix not found");
+  }
+  const plan = planElixirLsDownload(installDir);
+  await downloadAndExtractArchive(plan);
+  const script = findFileRecursive(
+    installDir,
+    process.platform === "win32" ? "language_server.bat" : "language_server.sh"
+  ) ?? findFileRecursive(installDir, "language_server.sh");
+  if (!script) {
+    throw new Error("language_server script not found after extraction");
+  }
+  await runBinary(["mix", "deps.get"], void 0, installDir);
+  await runBinary(["mix", "compile"], void 0, installDir);
+  if (process.platform !== "win32") {
+    chmodSync(script, 493);
+  }
+  return true;
+}
+async function installJdtls(installDir) {
+  if (!Bun.which("java")) {
+    throw new Error("java not found");
+  }
+  const javaMajor = await getJavaMajorVersion();
+  if (!javaMajor || javaMajor < 21) {
+    throw new Error("java 21 or newer required");
+  }
+  const plan = planJdtlsDownload(installDir);
+  await downloadAndExtractArchive(plan);
+  const pluginsDir = join2(installDir, "plugins");
+  const configDir = join2(installDir, "configuration");
+  if (!existsSync2(pluginsDir) || !existsSync2(configDir)) {
+    throw new Error("jdtls install incomplete");
+  }
+  return true;
+}
+function getJdtlsLauncherJar(installDir) {
+  const pluginsDir = join2(installDir, "plugins");
+  if (!existsSync2(pluginsDir)) return null;
+  const launcher = readdirSync(pluginsDir).find(
+    (name) => name.startsWith("org.eclipse.equinox.launcher_") && name.endsWith(".jar")
+  );
+  if (!launcher) return null;
+  const launcherPath = join2(pluginsDir, launcher);
+  return existsSync2(launcherPath) ? launcherPath : null;
+}
+function getJdtlsConfigDir(installDir) {
+  const suffix = process.platform === "darwin" ? "mac" : process.platform === "win32" ? "win" : "linux";
+  const baseConfig = join2(installDir, "configuration");
+  const candidates = [
+    join2(installDir, `config_${suffix}`),
+    join2(baseConfig, `config_${suffix}`),
+    baseConfig
+  ];
+  for (const candidate of candidates) {
+    if (existsSync2(candidate)) return candidate;
+  }
+  return null;
+}
+var BaseLspServer = class {
+  isInPath(cmd) {
+    return Boolean(Bun.which(cmd));
+  }
+  getLocalBinPath(binName, npmPackageName) {
+    const localNodeModulesBin = join2(process.cwd(), "node_modules", ".bin");
+    const localBin = resolveBinInDir(localNodeModulesBin, binName);
+    if (localBin) return localBin;
+    try {
+      const pkgName = npmPackageName || binName;
+      const pkgEntry = __require.resolve(pkgName, { paths: [process.cwd(), __dirname] });
+      let current = pkgEntry;
+      let pkgRoot = "";
+      for (let i = 0; i < 5; i++) {
+        current = join2(current, "..");
+        if (existsSync2(join2(current, "package.json"))) {
+          pkgRoot = current;
+          break;
+        }
+      }
+      if (pkgRoot) {
+        const nodeModulesRoot = join2(pkgRoot, "..");
+        const resolved = resolveBinInDir(join2(nodeModulesRoot, ".bin"), binName);
+        if (resolved) return resolved;
+      }
+    } catch (e) {
+    }
+    const lspBin = resolveBinInDir(join2(lspInstallDir, "node_modules", ".bin"), binName);
+    if (lspBin) return lspBin;
+    return "";
+  }
+  getRuntimeCommand() {
+    if (process.execPath && existsSync2(process.execPath)) {
+      return process.execPath;
+    }
+    const nodeBin = Bun.which("node");
+    if (nodeBin && existsSync2(nodeBin)) {
+      return nodeBin;
+    }
+    const bunBin = Bun.which("bun");
+    if (bunBin && existsSync2(bunBin)) {
+      return bunBin;
+    }
+    return "node";
+  }
+};
+var ServerDefinition = class extends BaseLspServer {
+  id;
+  extensions;
+  rootMarkers;
+  installStrategy;
+  spawnStrategy;
+  resolveRoot;
+  priority;
+  group;
+  constructor(options) {
+    super();
+    this.id = options.id;
+    this.extensions = options.extensions;
+    this.rootMarkers = options.rootMarkers;
+    this.installStrategy = options.install;
+    this.spawnStrategy = options.spawn;
+    this.resolveRoot = options.resolveRoot;
+    this.priority = options.priority;
+    this.group = options.group;
+  }
+  async prepare() {
+    if (this.installStrategy) {
+      return this.installStrategy();
+    }
+    return true;
+  }
+  async getCommand(rootPath) {
+    if (this.spawnStrategy) {
+      return this.spawnStrategy(rootPath);
+    }
+    return null;
+  }
+};
+var OverriddenServer = class {
+  constructor(base, override, globalEnv, globalInitializationOptions) {
+    this.base = base;
+    this.id = base.id;
+    this.extensions = override?.extensions ?? base.extensions;
+    this.rootMarkers = override?.rootMarkers ?? base.rootMarkers;
+    this.resolveRoot = base.resolveRoot;
+    this.env = mergeStringRecords(mergeStringRecords(base.env, globalEnv), override?.env);
+    this.initializationOptions = mergeInitializationOptions(
+      mergeInitializationOptions(base.initializationOptions, globalInitializationOptions),
+      override?.initializationOptions
+    );
+    this.languageId = override?.languageId ?? base.languageId;
+    this.rootInclude = override?.root?.include ?? base.rootInclude;
+    this.rootExclude = override?.root?.exclude ?? base.rootExclude;
+    this.rootBranches = override?.root?.branches ?? base.rootBranches;
+    this.priority = override?.priority ?? base.priority;
+    this.group = override?.group ?? base.group;
+    this.disabled = override?.disabled ?? base.disabled;
+    this.overrideCommand = override?.command;
+    this.overrideArgs = override?.args;
+  }
+  id;
+  extensions;
+  rootMarkers;
+  resolveRoot;
+  env;
+  initializationOptions;
+  languageId;
+  rootInclude;
+  rootExclude;
+  rootBranches;
+  priority;
+  group;
+  disabled;
+  overrideCommand;
+  overrideArgs;
+  async prepare() {
+    return this.base.prepare();
+  }
+  async getCommand(rootPath) {
+    if (this.overrideCommand) {
+      return { command: this.overrideCommand, args: this.overrideArgs ?? [] };
+    }
+    if (this.base.id && this.base.id.length > 0) {
+      return this.base.getCommand(rootPath);
+    }
+    return null;
+  }
+};
+var GenericNpmServer = class extends BaseLspServer {
+  id;
+  extensions;
+  rootMarkers;
+  npmPackage;
+  binName;
+  args;
+  constructor(id, extensions, rootMarkers, npmPackage, binName, args) {
+    super();
+    this.id = id;
+    this.extensions = extensions;
+    this.rootMarkers = rootMarkers;
+    this.npmPackage = npmPackage;
+    this.binName = binName;
+    this.args = args;
+  }
+  async prepare() {
+    if (this.isInPath(this.binName)) {
+      return true;
+    }
+    const localBin = this.getLocalBinPath(this.binName, this.npmPackage);
+    if (existsSync2(localBin)) {
+      return true;
+    }
+    const canInstall = await isAutoInstallEnabled();
+    if (!canInstall) {
+      return false;
+    }
+    debug.info("LSP_INSTALL", { server: this.id, action: "start" });
+    const ok = await bunInstall([this.npmPackage]);
+    if (!ok) {
+      debug.error("LSP_INSTALL_FAILED", { server: this.id });
+      return false;
+    }
+    debug.info("LSP_INSTALL", { server: this.id, action: "success" });
+    return true;
+  }
+  async getCommand(rootPath) {
+    if (process.platform === "win32") {
+      const pkgJsonPaths = [];
+      try {
+        const resolvedPath = __require.resolve(`${this.npmPackage}/package.json`, { paths: [process.cwd(), __dirname] });
+        if (resolvedPath) {
+          pkgJsonPaths.push(resolvedPath);
+        }
+      } catch (e) {
+      }
+      const localPkgJson = join2(lspInstallDir, "node_modules", ...this.npmPackage.split("/"), "package.json");
+      if (existsSync2(localPkgJson)) {
+        pkgJsonPaths.push(localPkgJson);
+      }
+      for (const pkgJsonPath of pkgJsonPaths) {
+        try {
+          const pkgJson = __require(pkgJsonPath);
+          let binScript = "";
+          if (typeof pkgJson.bin === "string") {
+            binScript = pkgJson.bin;
+          } else if (typeof pkgJson.bin === "object" && pkgJson.bin[this.binName]) {
+            binScript = pkgJson.bin[this.binName];
+          }
+          if (binScript) {
+            if (this.npmPackage === "pyright" && binScript.endsWith("langserver.index.js")) {
+              const distScript = join2(dirname(pkgJsonPath), "dist", "pyright-langserver.js");
+              if (existsSync2(distScript)) {
+                return { command: this.getRuntimeCommand(), args: [distScript, ...this.args] };
+              }
+            }
+            const scriptPath = join2(dirname(pkgJsonPath), binScript);
+            if (existsSync2(scriptPath)) {
+              return { command: this.getRuntimeCommand(), args: [scriptPath, ...this.args] };
+            }
+          }
+        } catch (e) {
+        }
+      }
+    }
+    if (this.isInPath(this.binName)) {
+      return { command: this.binName, args: this.args };
+    }
+    const localBin = this.getLocalBinPath(this.binName, this.npmPackage);
+    if (existsSync2(localBin)) {
+      return { command: localBin, args: this.args };
+    }
+    return null;
+  }
+};
+var GenericBinaryServer = class extends BaseLspServer {
+  id;
+  extensions;
+  rootMarkers;
+  binNames;
+  args;
+  constructor(id, extensions, rootMarkers, binNames, args) {
+    super();
+    this.id = id;
+    this.extensions = extensions;
+    this.rootMarkers = rootMarkers;
+    this.binNames = Array.isArray(binNames) ? binNames : [binNames];
+    this.args = args;
+  }
+  async prepare() {
+    return this.binNames.some((bin) => this.isInPath(bin));
+  }
+  async getCommand(rootPath) {
+    for (const bin of this.binNames) {
+      if (this.isInPath(bin)) {
+        return { command: bin, args: this.args };
+      }
+    }
+    return null;
+  }
+};
+var GoplsServer = class extends BaseLspServer {
+  id = "gopls";
+  extensions = [".go", ".mod"];
+  rootMarkers = ["go.mod", "go.work", ".git"];
+  async prepare() {
+    if (this.isInPath("gopls")) {
+      return true;
+    }
+    if (!this.isInPath("go")) {
+      debug.error("LSP_MISSING_DEP", { server: this.id, error: "go command not found" });
+      return false;
+    }
+    const canInstall = await isAutoInstallEnabled();
+    if (!canInstall) {
+      return false;
+    }
+    return this.installGo();
+  }
+  async getCommand(rootPath) {
+    if (this.isInPath("gopls")) {
+      return { command: "gopls", args: ["serve"] };
+    }
+    const localBin = resolveBinInDir(lspInstallDir, "gopls");
+    if (localBin) {
+      return { command: localBin, args: ["serve"] };
+    }
+    return null;
+  }
+  async installGo() {
+    try {
+      debug.info("LSP_INSTALL", { server: this.id, action: "start" });
+      const result = await runBinary(
+        ["go", "install", "golang.org/x/tools/gopls@latest"],
+        {
+          GOBIN: lspInstallDir,
+          PATH: process.env.PATH ? `${lspInstallDir}${process.platform === "win32" ? ";" : ":"}${process.env.PATH}` : lspInstallDir
+        }
+      );
+      if (!result.ok) {
+        debug.error("LSP_INSTALL_FAILED", { server: this.id, error: result.error });
+        return false;
+      }
+      if (!this.isInPath("gopls") && !resolveBinInDir(lspInstallDir, "gopls")) {
+        debug.warn("LSP_INSTALL_WARNING", { server: this.id, message: "gopls installed but not found in PATH." });
+      }
+      debug.info("LSP_INSTALL", { server: this.id, action: "success" });
+      return true;
+    } catch (e) {
+      debug.error("LSP_INSTALL_ERROR", { server: this.id, error: String(e) });
+      return false;
+    }
+  }
+};
+var RustAnalyzerServer = class extends BaseLspServer {
+  id = "rust-analyzer";
+  extensions = [".rs"];
+  rootMarkers = ["Cargo.toml", "rust-project.json", ".git"];
+  async prepare() {
+    if (this.isInPath("rust-analyzer")) {
+      return true;
+    }
+    if (this.isInPath("rustup")) {
+      const canInstall = await isAutoInstallEnabled();
+      if (!canInstall) {
+        return false;
+      }
+      return this.installRustup();
+    }
+    debug.warn("LSP_MISSING_DEP", { server: this.id, message: "rust-analyzer not found and rustup not available. Please install rust-analyzer manually." });
+    return false;
+  }
+  async getCommand(rootPath) {
+    if (this.isInPath("rust-analyzer")) {
+      return { command: "rust-analyzer", args: [] };
+    }
+    return null;
+  }
+  async installRustup() {
+    try {
+      debug.info("LSP_INSTALL", { server: this.id, action: "start" });
+      const result = await runBinary(["rustup", "component", "add", "rust-analyzer"]);
+      if (!result.ok) {
+        debug.error("LSP_INSTALL_FAILED", { server: this.id, error: result.error });
+        return false;
+      }
+      debug.info("LSP_INSTALL", { server: this.id, action: "success" });
+      return true;
+    } catch (e) {
+      debug.error("LSP_INSTALL_ERROR", { server: this.id, error: String(e) });
+      return false;
+    }
+  }
+};
+var LspServerRegistry = class _LspServerRegistry {
+  static instance;
+  servers = [];
+  baseServers = [];
+  globalSettings;
+  constructor() {
+    this.register(new GenericNpmServer(
+      "pyright",
+      [".py", ".pyi"],
+      ["pyrightconfig.json", "pyproject.toml", "setup.py", "requirements.txt", "Pipfile"],
+      "pyright",
+      "pyright-langserver",
+      ["--stdio"]
+    ));
+    this.register(new ServerDefinition({
+      id: "ty",
+      extensions: [".py", ".pyi"],
+      rootMarkers: ["pyproject.toml", "ty.toml", "setup.py", "setup.cfg", "requirements.txt", "Pipfile", "pyrightconfig.json"],
+      spawn: async (rootPath) => {
+        const binary = resolveTyBinary(rootPath);
+        if (!binary) return null;
+        return { command: binary, args: ["server"] };
+      },
+      priority: -1
+    }));
+    this.register(new GoplsServer());
+    this.register(new RustAnalyzerServer());
+    this.register(new GenericNpmServer(
+      "bash-language-server",
+      [".sh", ".bash", ".zsh"],
+      [".git"],
+      "bash-language-server",
+      "bash-language-server",
+      ["start"]
+    ));
+    this.register(new ServerDefinition({
+      id: "deno",
+      extensions: [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".mts", ".cts"],
+      rootMarkers: ["deno.json", "deno.jsonc"],
+      spawn: async (rootPath) => {
+        if (!hasDenoConfig(rootPath)) return null;
+        const deno = Bun.which("deno");
+        if (!deno) return null;
+        return { command: deno, args: ["lsp"] };
+      },
+      priority: 5
+    }));
+    this.register(new GenericNpmServer(
+      "typescript-language-server",
+      [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"],
+      ["tsconfig.json", "package.json", "jsconfig.json"],
+      "typescript-language-server",
+      "typescript-language-server",
+      ["--stdio"]
+    ));
+    this.register(new GenericNpmServer(
+      "yaml-language-server",
+      [".yaml", ".yml"],
+      [],
+      "yaml-language-server",
+      "yaml-language-server",
+      ["--stdio"]
+    ));
+    this.register(new GenericNpmServer(
+      "dockerfile-language-server",
+      ["Dockerfile", ".dockerfile"],
+      [],
+      "dockerfile-language-server-nodejs",
+      "docker-langserver",
+      ["--stdio"]
+    ));
+    this.register(new ServerDefinition({
+      id: "vue-language-server",
+      extensions: [".vue"],
+      rootMarkers: ["package.json"],
+      install: async () => {
+        const canInstall = await isAutoInstallEnabled();
+        if (!canInstall) return false;
+        ensureInstallDir();
+        return npmInstallIfMissing(["@vue/language-server"]);
+      },
+      spawn: async (rootPath) => multiResolveBinary({
+        binNames: ["vue-language-server"],
+        args: ["--stdio"],
+        packageName: "@vue/language-server",
+        cwd: rootPath
+      })
+    }));
+    this.register(new ServerDefinition({
+      id: "eslint",
+      extensions: [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".mts", ".cts", ".vue"],
+      rootMarkers: [
+        "package-lock.json",
+        "bun.lockb",
+        "bun.lock",
+        "pnpm-lock.yaml",
+        "yarn.lock",
+        "package.json"
+      ],
+      install: async () => installEslintServer(),
+      spawn: async (rootPath) => {
+        const serverPath = getEslintServerPath();
+        if (!existsSync2(serverPath)) return null;
+        try {
+          await Bun.resolve("eslint", rootPath);
+        } catch {
+          return null;
+        }
+        const bunBin = Bun.which("bun") ?? process.execPath;
+        return { command: bunBin, args: [serverPath, "--stdio"] };
+      },
+      priority: -10,
+      group: "lint"
+    }));
+    this.register(new ServerDefinition({
+      id: "oxlint",
+      extensions: [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".mts", ".cts", ".vue", ".astro", ".svelte"],
+      rootMarkers: [
+        ".oxlintrc.json",
+        "package-lock.json",
+        "bun.lockb",
+        "bun.lock",
+        "pnpm-lock.yaml",
+        "yarn.lock",
+        "package.json"
+      ],
+      spawn: async (rootPath) => {
+        const lintCommand = multiResolveBinary({
+          binNames: ["oxlint"],
+          args: ["--lsp"],
+          cwd: rootPath
+        });
+        if (lintCommand) return lintCommand;
+        const serverCommand = multiResolveBinary({
+          binNames: ["oxc_language_server"],
+          cwd: rootPath
+        });
+        if (serverCommand) return serverCommand;
+        return multiResolveBinary({
+          binNames: ["oxlint"],
+          args: ["--lsp"],
+          packageName: "oxlint",
+          cwd: rootPath
+        });
+      },
+      priority: -5,
+      group: "lint"
+    }));
+    this.register(new ServerDefinition({
+      id: "biome",
+      extensions: [
+        ".ts",
+        ".tsx",
+        ".js",
+        ".jsx",
+        ".mjs",
+        ".cjs",
+        ".mts",
+        ".cts",
+        ".json",
+        ".jsonc",
+        ".vue",
+        ".astro",
+        ".svelte",
+        ".css",
+        ".graphql",
+        ".gql",
+        ".html"
+      ],
+      rootMarkers: [
+        "biome.json",
+        "biome.jsonc",
+        "package-lock.json",
+        "bun.lockb",
+        "bun.lock",
+        "pnpm-lock.yaml",
+        "yarn.lock"
+      ],
+      spawn: async (rootPath) => multiResolveBinary({
+        binNames: ["biome"],
+        args: ["lsp-proxy", "--stdio"],
+        packageName: "biome",
+        cwd: rootPath
+      }),
+      priority: -5,
+      group: "lint"
+    }));
+    this.register(new GenericNpmServer(
+      "html-language-server",
+      [".html", ".htm"],
+      [],
+      "vscode-langservers-extracted",
+      "vscode-html-language-server",
+      ["--stdio"]
+    ));
+    this.register(new GenericNpmServer(
+      "css-language-server",
+      [".css", ".scss", ".less"],
+      [],
+      "vscode-langservers-extracted",
+      "vscode-css-language-server",
+      ["--stdio"]
+    ));
+    this.register(new GenericNpmServer(
+      "json-language-server",
+      [".json", ".jsonc"],
+      [],
+      "vscode-langservers-extracted",
+      "vscode-json-language-server",
+      ["--stdio"]
+    ));
+    this.register(new GenericNpmServer(
+      "intelephense",
+      [".php"],
+      ["composer.json"],
+      "intelephense",
+      "intelephense",
+      ["--stdio"]
+    ));
+    this.register(new ServerDefinition({
+      id: "svelte-language-server",
+      extensions: [".svelte"],
+      rootMarkers: ["package.json"],
+      install: async () => {
+        const canInstall = await isAutoInstallEnabled();
+        if (!canInstall) return false;
+        ensureInstallDir();
+        return npmInstallIfMissing(["svelte-language-server"]);
+      },
+      spawn: async (rootPath) => multiResolveBinary({
+        binNames: ["svelte-language-server"],
+        args: ["--stdio"],
+        packageName: "svelte-language-server",
+        cwd: rootPath
+      })
+    }));
+    this.register(new ServerDefinition({
+      id: "astro-ls",
+      extensions: [".astro"],
+      rootMarkers: ["package.json"],
+      install: async () => {
+        const canInstall = await isAutoInstallEnabled();
+        if (!canInstall) return false;
+        ensureInstallDir();
+        return npmInstallIfMissing(["@astrojs/language-server"]);
+      },
+      spawn: async (rootPath) => multiResolveBinary({
+        binNames: ["astro-ls"],
+        args: ["--stdio"],
+        packageName: "@astrojs/language-server",
+        cwd: rootPath
+      })
+    }));
+    this.register(new GenericNpmServer(
+      "prisma-language-server",
+      [".prisma"],
+      ["schema.prisma"],
+      "@prisma/language-server",
+      "prisma-language-server",
+      ["--stdio"]
+    ));
+    this.register(new GenericNpmServer(
+      "graphql-lsp",
+      [".graphql", ".gql"],
+      [".graphqlrc", "graphql.config.js"],
+      "graphql-language-service-cli",
+      "graphql-lsp",
+      ["server", "-m", "stream"]
+    ));
+    this.register(new ServerDefinition({
+      id: "jdtls",
+      extensions: [".java"],
+      rootMarkers: ["pom.xml", "build.gradle", "build.gradle.kts", ".project", ".classpath"],
+      install: async () => {
+        const installDir = join2(lspInstallDir, "jdtls");
+        const launcherJar = getJdtlsLauncherJar(installDir);
+        const configDir = getJdtlsConfigDir(installDir);
+        if (launcherJar && configDir) return true;
+        const canInstall = await isAutoInstallEnabled();
+        if (!canInstall) return false;
+        ensureInstallDir();
+        try {
+          await installJdtls(installDir);
+          return true;
+        } catch (error) {
+          debug.error("LSP_INSTALL_FAILED", { server: "jdtls", error: String(error) });
+          return false;
+        }
+      },
+      spawn: async () => {
+        const java = Bun.which("java");
+        if (!java) return null;
+        const javaMajor = await getJavaMajorVersion();
+        if (!javaMajor || javaMajor < 21) return null;
+        const installDir = join2(lspInstallDir, "jdtls");
+        const launcherJar = getJdtlsLauncherJar(installDir);
+        const configDir = getJdtlsConfigDir(installDir);
+        if (!launcherJar || !configDir) return null;
+        const dataDir = mkdtempSync(join2(tmpdir(), "pyb-jdtls-"));
+        return {
+          command: java,
+          args: [
+            "-jar",
+            launcherJar,
+            "-configuration",
+            configDir,
+            "-data",
+            dataDir,
+            "-Declipse.application=org.eclipse.jdt.ls.core.id1",
+            "-Dosgi.bundles.defaultStartLevel=4",
+            "-Declipse.product=org.eclipse.jdt.ls.core.product",
+            "-Dlog.level=ALL",
+            "--add-modules=ALL-SYSTEM",
+            "--add-opens",
+            "java.base/java.util=ALL-UNNAMED",
+            "--add-opens",
+            "java.base/java.lang=ALL-UNNAMED"
+          ]
+        };
+      }
+    }));
+    this.register(new GenericBinaryServer(
+      "clangd",
+      [".c", ".cpp", ".h", ".hpp", ".cc"],
+      ["compile_commands.json", ".clang-format"],
+      "clangd",
+      ["--stdio"]
+    ));
+    this.register(new GenericBinaryServer(
+      "ruby-lsp",
+      [".rb", ".rake"],
+      ["Gemfile", ".ruby-version"],
+      "ruby-lsp",
+      ["--stdio"]
+    ));
+    this.register(new ServerDefinition({
+      id: "lua-language-server",
+      extensions: [".lua"],
+      rootMarkers: [
+        ".luarc.json",
+        ".luarc.jsonc",
+        ".luacheckrc",
+        ".stylua.toml",
+        "stylua.toml",
+        "selene.toml",
+        "selene.yml"
+      ],
+      install: async () => {
+        const installDir = join2(lspInstallDir, "lua-language-server");
+        const existing = findFileRecursive(
+          installDir,
+          process.platform === "win32" ? "lua-language-server.exe" : "lua-language-server"
+        );
+        if (existing) return true;
+        if (Bun.which("lua-language-server") || Bun.which("lua-ls")) return true;
+        const canInstall = await isAutoInstallEnabled();
+        if (!canInstall) return false;
+        ensureInstallDir();
+        try {
+          await installLuaLs(installDir);
+          return true;
+        } catch (error) {
+          debug.error("LSP_INSTALL_FAILED", { server: "lua-language-server", error: String(error) });
+          return false;
+        }
+      },
+      spawn: async (rootPath) => {
+        const direct = multiResolveBinary({
+          binNames: ["lua-language-server", "lua-ls"],
+          cwd: rootPath
+        });
+        if (direct) return direct;
+        const installDir = join2(lspInstallDir, "lua-language-server");
+        const binary = findFileRecursive(
+          installDir,
+          process.platform === "win32" ? "lua-language-server.exe" : "lua-language-server"
+        );
+        if (!binary) return null;
+        return { command: binary, args: [] };
+      }
+    }));
+    this.register(new GenericBinaryServer(
+      "terraform-ls",
+      [".tf", ".tfvars"],
+      [],
+      "terraform-ls",
+      ["serve"]
+    ));
+    this.register(new GenericBinaryServer(
+      "kotlin-language-server",
+      [".kt", ".kts"],
+      ["build.gradle.kts"],
+      ["kotlin-ls", "kotlin-language-server"],
+      []
+    ));
+    this.register(new ServerDefinition({
+      id: "elixir-ls",
+      extensions: [".ex", ".exs"],
+      rootMarkers: ["mix.exs", "mix.lock"],
+      install: async () => {
+        const installDir = join2(lspInstallDir, "elixir-ls");
+        const existing = findFileRecursive(
+          installDir,
+          process.platform === "win32" ? "language_server.bat" : "language_server.sh"
+        );
+        if (existing) return true;
+        if (Bun.which("elixir-ls")) return true;
+        const canInstall = await isAutoInstallEnabled();
+        if (!canInstall) return false;
+        ensureInstallDir();
+        try {
+          await installElixirLs(installDir);
+          return true;
+        } catch (error) {
+          debug.error("LSP_INSTALL_FAILED", { server: "elixir-ls", error: String(error) });
+          return false;
+        }
+      },
+      spawn: async (rootPath) => {
+        if (Bun.which("elixir-ls")) {
+          return { command: "elixir-ls", args: [] };
+        }
+        const installDir = join2(lspInstallDir, "elixir-ls");
+        const binary = findFileRecursive(installDir, process.platform === "win32" ? "language_server.bat" : "language_server.sh") ?? findFileRecursive(installDir, "language_server.sh");
+        if (!binary) return null;
+        return { command: binary, args: [] };
+      }
+    }));
+    this.register(new ServerDefinition({
+      id: "zls",
+      extensions: [".zig", ".zon"],
+      rootMarkers: ["build.zig"],
+      install: async () => {
+        const installDir = join2(lspInstallDir, "zls");
+        const existing = findFileRecursive(installDir, process.platform === "win32" ? "zls.exe" : "zls");
+        if (existing) return true;
+        if (Bun.which("zls")) return true;
+        const canInstall = await isAutoInstallEnabled();
+        if (!canInstall) return false;
+        ensureInstallDir();
+        try {
+          await installZls(installDir);
+          return true;
+        } catch (error) {
+          debug.error("LSP_INSTALL_FAILED", { server: "zls", error: String(error) });
+          return false;
+        }
+      },
+      spawn: async (rootPath) => {
+        const direct = multiResolveBinary({ binNames: ["zls"], cwd: rootPath });
+        if (direct) return direct;
+        const installDir = join2(lspInstallDir, "zls");
+        const binary = findFileRecursive(installDir, process.platform === "win32" ? "zls.exe" : "zls");
+        if (!binary) return null;
+        return { command: binary, args: [] };
+      }
+    }));
+    this.register(new GenericBinaryServer(
+      "csharp-ls",
+      [".cs"],
+      [".csproj", ".sln"],
+      "csharp-ls",
+      []
+    ));
+    this.register(new GenericBinaryServer(
+      "fsautocomplete",
+      [".fs", ".fsi", ".fsx"],
+      [".fsproj", ".sln"],
+      "fsautocomplete",
+      ["--background-service-enabled"]
+    ));
+    this.register(new GenericBinaryServer(
+      "sourcekit-lsp",
+      [".swift"],
+      ["Package.swift"],
+      "sourcekit-lsp",
+      []
+    ));
+    this.register(new GenericBinaryServer(
+      "dart",
+      [".dart"],
+      ["pubspec.yaml"],
+      "dart",
+      ["language-server"]
+    ));
+    this.register(new GenericBinaryServer(
+      "ocamllsp",
+      [".ml", ".mli"],
+      ["dune-project"],
+      ["ocaml-lsp", "ocamllsp"],
+      []
+    ));
+    this.register(new GenericBinaryServer(
+      "gleam",
+      [".gleam"],
+      ["gleam.toml"],
+      "gleam",
+      ["lsp"]
+    ));
+    this.register(new GenericBinaryServer(
+      "clojure-lsp",
+      [".clj", ".cljs", ".cljc", ".edn"],
+      ["deps.edn", "project.clj"],
+      "clojure-lsp",
+      []
+    ));
+    this.register(new GenericBinaryServer(
+      "nixd",
+      [".nix"],
+      ["flake.nix"],
+      "nixd",
+      []
+    ));
+    this.register(new GenericBinaryServer(
+      "tinymist",
+      [".typ"],
+      [],
+      "tinymist",
+      []
+    ));
+    this.register(new GenericBinaryServer(
+      "metals",
+      [".scala", ".sbt", ".sc"],
+      ["build.sbt"],
+      "metals",
+      []
+    ));
+    this.register(new GenericBinaryServer(
+      "haskell-language-server",
+      [".hs", ".lhs"],
+      ["stack.yaml", "cabal.project", "*.cabal"],
+      "haskell-language-server-wrapper",
+      ["--lsp"]
+    ));
+    this.register(new GenericBinaryServer(
+      "texlab",
+      [".tex", ".bib"],
+      [],
+      "texlab",
+      []
+    ));
+    this.applyConfigOverrides(loadLspSettingsFromFiles());
+  }
+  static getInstance() {
+    if (!_LspServerRegistry.instance) {
+      _LspServerRegistry.instance = new _LspServerRegistry();
+    }
+    return _LspServerRegistry.instance;
+  }
+  register(server) {
+    this.baseServers.push(server);
+    this.servers.push(server);
+  }
+  getServerForExtension(ext) {
+    const servers = this.getServersForExtension(ext);
+    return servers[0] ?? null;
+  }
+  getServersForExtension(ext) {
+    const candidates = this.servers.filter((server) => server.extensions.includes(ext));
+    const enabled = candidates.filter((server) => !this.isServerDisabled(server));
+    const grouped = this.applyGroupStrategies(enabled, ext);
+    return grouped.length ? grouped : this.sortByPriority(enabled);
+  }
+  getLanguageIdForExtension(ext) {
+    const map = this.getLanguageMap();
+    return map[ext] ?? "plaintext";
+  }
+  getLanguageCategoryForExtension(ext) {
+    const languageId = this.getLanguageIdForExtension(ext);
+    return this.getLanguageCategoryForLanguageId(languageId);
+  }
+  getLanguageCategoryForLanguageId(languageId) {
+    const categories = this.getLanguageCategories();
+    return categories[languageId];
+  }
+  getSettings() {
+    return this.globalSettings;
+  }
+  reloadSettingsFromFiles(options) {
+    this.applyConfigOverrides(loadLspSettingsFromFiles(options));
+  }
+  applyConfigOverrides(settings) {
+    const merged = mergeLspSettings(this.globalSettings, settings);
+    const withExperiments = applyExperimentalSwitches(merged);
+    this.globalSettings = withExperiments;
+    const overrides = withExperiments?.servers;
+    const baseIds = new Set(this.baseServers.map((server) => server.id));
+    const customServers = [];
+    if (overrides) {
+      for (const [id, override] of Object.entries(overrides)) {
+        if (baseIds.has(id)) continue;
+        if (!override.command) continue;
+        if (!override.extensions || override.extensions.length === 0) continue;
+        const base = new ServerDefinition({
+          id,
+          extensions: override.extensions,
+          rootMarkers: override.rootMarkers ?? [],
+          spawn: async () => ({ command: override.command ?? "", args: override.args ?? [] }),
+          priority: override.priority,
+          group: override.group
+        });
+        customServers.push(
+          new OverriddenServer(
+            base,
+            override,
+            withExperiments?.env,
+            withExperiments?.initializationOptions
+          )
+        );
+      }
+    }
+    this.servers = [
+      ...this.baseServers.map(
+        (server) => new OverriddenServer(
+          server,
+          withExperiments?.servers?.[server.id],
+          withExperiments?.env,
+          withExperiments?.initializationOptions
+        )
+      ),
+      ...customServers
+    ];
+  }
+  resetOverridesForTests() {
+    this.globalSettings = void 0;
+    this.servers = [...this.baseServers];
+  }
+  getLanguageMap() {
+    return { ...DEFAULT_LANGUAGE_MAP, ...this.globalSettings?.languageMap ?? {} };
+  }
+  getLanguageCategories() {
+    return { ...DEFAULT_LANGUAGE_CATEGORIES, ...this.globalSettings?.languageCategories ?? {} };
+  }
+  isServerDisabled(server) {
+    if (server.disabled) return true;
+    const disabledServers = this.globalSettings?.disabledServers;
+    return Boolean(disabledServers?.includes(server.id));
+  }
+  sortByPriority(servers) {
+    return [...servers].sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0));
+  }
+  applyGroupStrategies(servers, ext) {
+    const groups = this.globalSettings?.serverGroups;
+    if (!groups || groups.length === 0) return [];
+    const byId = new Map(servers.map((server) => [server.id, server]));
+    const results = [];
+    const used = /* @__PURE__ */ new Set();
+    for (const group of groups) {
+      if (group.extensions && !group.extensions.includes(ext)) continue;
+      const groupServers = group.serverIds.map((id) => byId.get(id)).filter((server) => Boolean(server));
+      if (groupServers.length === 0) continue;
+      const sorted = this.sortByPriority(groupServers);
+      if (group.strategy === "parallel") {
+        for (const server of sorted) {
+          if (used.has(server.id)) continue;
+          used.add(server.id);
+          results.push(server);
+        }
+        continue;
+      }
+      const selected = sorted[0];
+      if (selected && !used.has(selected.id)) {
+        used.add(selected.id);
+        results.push(selected);
+      }
+    }
+    return results;
+  }
+};
+
+export {
+  findNearestRoot,
+  getEslintInstallDir,
+  getEslintServerPath,
+  installEslintServer,
+  detectPythonVenv,
+  npmInstallIfMissing,
+  multiResolveBinary,
+  planLuaLsDownload,
+  planZlsDownload,
+  planElixirLsDownload,
+  planJdtlsDownload,
+  downloadAndExtractArchive,
+  installLuaLs,
+  installZls,
+  installElixirLs,
+  installJdtls,
+  ServerDefinition,
+  GenericNpmServer,
+  LspServerRegistry
+};