@duckmind/dm-linux-x64 0.65.8 → 0.66.2

package/extensions/dm-lens/dist/clients/lsp/client.js

@@ -1,2709 +0,0 @@
-import { spawn as nodeSpawn } from "node:child_process";
-import { EventEmitter } from "node:events";
-import { access, lstat, readFile } from "node:fs/promises";
-import * as os from "node:os";
-import { pathToFileURL } from "node:url";
-import { emitBounded } from "../bounded-telemetry.js";
-import { withTimeout } from "../deadline-utils.js";
-import { minimatch } from "../deps/minimatch.js";
-import { mapWithConcurrency } from "../map-with-concurrency.js";
-import { incrementDegradationCount, recordDegradationOnce } from "../degradation-ledger.js";
-import { CancellationTokenSource, createMessageConnection, StreamMessageReader, StreamMessageWriter } from "../deps/vscode-jsonrpc.js";
-import { logExtension } from "../extension-log.js";
-import { recordLspChild, removeLspChild } from "../instance-registry.js";
-import { workspaceDiagnosticsCacheSessionStart } from "./workspace-diagnostics-session.js";
-import { logLatency } from "../latency-logger.js";
-import { newLspMutationCorrelationId } from "../lsp-mutation.js";
-import { getProcessSingleton } from "../process-singletons.js";
-import { getAmbientAbortSignal, isOwnLiveChild, releaseOwnChildPid } from "../safe-spawn.js";
-import { raceToCompletion } from "./aggregation.js";
-import { hashDiagnosticContent } from "./diagnostic-binding.js";
-import { applyWorkspaceEdit, normalizeWorkspaceEditToUtf16 } from "./edits.js";
-import { normalizeMapKey, uriToPath } from "./path-utils.js";
-import { ADVERTISED_POSITION_ENCODINGS, convertCharacterOffset, lineTextAt, negotiatePositionEncoding } from "./position-encoding.js";
-import { negotiateSaveOptions, negotiateSyncKind, TEXT_DOCUMENT_SYNC_KIND_FULL, TEXT_DOCUMENT_SYNC_KIND_INCREMENTAL } from "./sync-kind.js";
-import { exceedsLspSyncLimits } from "./content-limits.js";
-import { probeTsserverProjectIdentity } from "./tsserver-sync.js";
-import { getStrategy } from "./wait-policy/index.js";
-import { WatchedFilesQueue } from "./watch-queue.js";
-import { clearAllWorkspaceDiagnosticsCaches, clearWorkspaceDiagnosticsCacheAtAndAbove } from "./workspace-diagnostics-cache.js";
-const PUB_DEBUG = Boolean(process.env.PILENS_PUB_DEBUG);
-function extractSpawnMarker(args) {
-  if (!args)
-    return;
-  const tmpDir = os.tmpdir();
-  for (let i = 0;i < args.length - 1; i++) {
-    const flag = args[i];
-    if (flag === "--config" || flag === "-c") {
-      const value = args[i + 1];
-      if (value?.startsWith(tmpDir))
-        return value;
-    }
-  }
-  return;
-}
-export const INITIALIZE_TIMEOUT_MS = positiveIntFromEnv("DM_LENS_LSP_INIT_TIMEOUT_MS", 15000);
-export const CLIENT_CAPABILITIES = {
-  general: { positionEncodings: ADVERTISED_POSITION_ENCODINGS },
-  window: {},
-  workspace: {
-    workspaceFolders: true,
-    configuration: true,
-    didChangeWatchedFiles: { dynamicRegistration: true },
-    fileOperations: {
-      dynamicRegistration: false,
-      willRename: true,
-      didRename: true
-    }
-  },
-  textDocument: {
-    synchronization: {
-      dynamicRegistration: false,
-      willSave: false,
-      willSaveWaitUntil: false,
-      didSave: true
-    },
-    completion: {
-      dynamicRegistration: false,
-      completionItem: { snippetSupport: false }
-    },
-    hover: { dynamicRegistration: false },
-    signatureHelp: { dynamicRegistration: false },
-    definition: { dynamicRegistration: false },
-    typeDefinition: { dynamicRegistration: false },
-    implementation: { dynamicRegistration: false },
-    references: { dynamicRegistration: false },
-    documentSymbol: { dynamicRegistration: false },
-    codeAction: {
-      dynamicRegistration: false,
-      dataSupport: true,
-      resolveSupport: { properties: ["edit", "command"] },
-      codeActionLiteralSupport: {
-        codeActionKind: {
-          valueSet: [
-            "quickfix",
-            "refactor",
-            "refactor.extract",
-            "refactor.inline",
-            "refactor.rewrite",
-            "source",
-            "source.organizeImports"
-          ]
-        }
-      }
-    },
-    rename: { dynamicRegistration: false },
-    publishDiagnostics: {
-      relatedInformation: true,
-      versionSupport: true
-    }
-  }
-};
-const NAV_REQUEST_TIMEOUT_MS = positiveIntFromEnv("DM_LENS_LSP_NAV_REQUEST_TIMEOUT_MS", 1e4);
-const DIAGNOSTICS_WAIT_TIMEOUT_MS = positiveIntFromEnv("DM_LENS_LSP_DIAGNOSTICS_WAIT_MS", 1e4);
-const PULL_DIAGNOSTICS_RETRY_INTERVAL_MS = positiveIntFromEnv("DM_LENS_LSP_PULL_RETRY_INTERVAL_MS", 250);
-const PULL_REQUEST_TIMEOUT_MS = positiveIntFromEnv("DM_LENS_LSP_PULL_REQUEST_TIMEOUT_MS", 1e4);
-const PULL_MIN_USABLE_BUDGET_MS = 5;
-const SHUTDOWN_REQUEST_TIMEOUT_MS = positiveIntFromEnv("DM_LENS_LSP_SHUTDOWN_TIMEOUT_MS", 1000);
-const EXIT_NOTIFY_TIMEOUT_MS = positiveIntFromEnv("DM_LENS_LSP_EXIT_NOTIFY_TIMEOUT_MS", 1000);
-const LIVENESS_PING_TIMEOUT_MS = positiveIntFromEnv("DM_LENS_LSP_LIVENESS_PING_TIMEOUT_MS", 300);
-const LIVENESS_PING_QUERY = "__dm_lens_liveness_ping__";
-const WORKSPACE_PULL_RESULT_CACHE_MAX = 4096;
-const WORKSPACE_PULL_SCOPE = "*workspace*";
-const REFRESH_REPULL_CONCURRENCY = 4;
-const EXECUTE_COMMAND_TIMEOUT_MS = positiveIntFromEnv("DM_LENS_LSP_EXECUTE_COMMAND_TIMEOUT_MS", 30000);
-const PROBE_COMMAND_TIMEOUT_MS = positiveIntFromEnv("DM_LENS_LSP_PROJECT_IDENTITY_PROBE_TIMEOUT_MS", 2500);
-const LSP_CRASH_CODES = new Set([
-  "ERR_STREAM_DESTROYED",
-  "ERR_STREAM_WRITE_AFTER_END",
-  "EPIPE",
-  "ECONNRESET"
-]);
-let crashGuardInstalled = false;
-function isIgnorableLspRuntimeCrash(err) {
-  if (!(err instanceof Error))
-    return false;
-  const code = err.code;
-  if (code && LSP_CRASH_CODES.has(code))
-    return true;
-  const msg = err.message.toLowerCase();
-  const stack = (err.stack ?? "").toLowerCase();
-  return msg.includes("stream") || msg.includes("write after end") || stack.includes("vscode-jsonrpc/lib/node/ril.js");
-}
-function installCrashGuard() {
-  if (crashGuardInstalled)
-    return;
-  crashGuardInstalled = true;
-  process.on("uncaughtException", (err) => {
-    if (isIgnorableLspRuntimeCrash(err)) {
-      return;
-    }
-    throw err;
-  });
-  process.on("unhandledRejection", (reason) => {
-    if (isIgnorableLspRuntimeCrash(reason)) {
-      return;
-    }
-    throw reason instanceof Error ? reason : new Error(String(reason));
-  });
-}
-export const MAX_INCREMENTAL_TEXT_RETAINED_ENTRIES = 128;
-export const MAX_INCREMENTAL_TEXT_RETAINED_BYTES = 64 * 1024 * 1024;
-const ACTIVE_CLIENTS_FAMILY = "lsp-client.active-clients";
-const ACTIVE_CLIENTS_VERSION = 1;
-function activeLspClientSet() {
-  return getProcessSingleton(ACTIVE_CLIENTS_FAMILY, ACTIVE_CLIENTS_VERSION, () => new Set);
-}
-export function getLspDocumentTextRetentionSnapshot() {
-  let entries = 0;
-  let bytes = 0;
-  const roots = new Set;
-  const active = activeLspClientSet();
-  for (const state of active) {
-    entries += state.incrementalTextRetainedEntries ?? 0;
-    bytes += state.incrementalTextRetainedBytes ?? 0;
-    if (typeof state.root === "string" && state.root.length > 0) {
-      roots.add(state.root);
-    }
-  }
-  return { clients: active.size, entries, bytes, roots: roots.size };
-}
-function isClientAlive(state) {
-  return state.isConnected && !state.isDestroyed && !state.lspProcess.process.killed;
-}
-function disposeClientConnection(state) {
-  if (state.connectionDisposed)
-    return;
-  state.connectionDisposed = true;
-  activeLspClientSet().delete(state);
-  try {
-    state.connection.dispose();
-  } catch {}
-}
-export async function killProcessTree(proc, pid, options = {}) {
-  if ((proc.exitCode != null || proc.signalCode != null) && !options.processExiting) {
-    releaseOwnChildPid(pid);
-    proc.unref?.();
-    return;
-  }
-  if (process.platform === "win32" && pid > 0) {
-    if (options.processExiting) {
-      try {
-        proc.kill();
-      } catch {}
-      proc.unref?.();
-      return;
-    }
-    try {
-      const taskkill = `${process.env.SystemRoot ?? "C:\\Windows"}\\System32\\taskkill.exe`;
-      const killer = nodeSpawn(taskkill, ["/F", "/T", "/PID", String(pid)], {
-        shell: false,
-        windowsHide: true,
-        stdio: "ignore",
-        detached: !!options.fast
-      });
-      if (options.fast) {
-        killer.unref();
-        proc.unref?.();
-        return;
-      }
-      await new Promise((resolve) => {
-        killer.once("close", () => resolve());
-        killer.once("error", (err) => {
-          logLatency({
-            type: "phase",
-            phase: "lsp_kill_escalation",
-            filePath: "",
-            durationMs: 0,
-            metadata: { pid, platform: "win32", taskkillError: String(err) }
-          });
-          resolve();
-        });
-      });
-    } catch (err) {
-      logLatency({
-        type: "phase",
-        phase: "lsp_kill_escalation",
-        filePath: "",
-        durationMs: 0,
-        metadata: { pid, platform: "win32", taskkillSpawnError: String(err) }
-      });
-    }
-    return;
-  }
-  const killPosixProcessGroup = (signal) => {
-    if (!isOwnLiveChild(pid, "lsp-stop-posix-group"))
-      return false;
-    try {
-      process.kill(-pid, signal);
-      return true;
-    } catch {
-      return false;
-    }
-  };
-  const killDirectChild = (signal) => {
-    try {
-      proc.kill(signal);
-    } catch {}
-  };
-  try {
-    let exited = proc.exitCode != null || proc.signalCode != null;
-    proc.once?.("exit", () => {
-      exited = true;
-    });
-    if (!killPosixProcessGroup("SIGTERM")) {
-      killDirectChild("SIGTERM");
-    }
-    if (options.fast) {
-      const timer = setTimeout(() => {
-        if (!exited) {
-          logLatency({
-            type: "phase",
-            phase: "lsp_kill_escalation",
-            filePath: "",
-            durationMs: 1500,
-            metadata: { pid, platform: "posix", method: "SIGKILL", fast: true }
-          });
-          if (!killPosixProcessGroup("SIGKILL")) {
-            killDirectChild("SIGKILL");
-          }
-        }
-        releaseOwnChildPid(pid);
-      }, 1500);
-      timer.unref?.();
-      proc.unref?.();
-      return;
-    }
-    const exitedInTime = await new Promise((resolve) => {
-      if (proc.exitCode != null || proc.signalCode != null) {
-        resolve(true);
-        return;
-      }
-      const onExit = () => {
-        clearTimeout(timer);
-        resolve(true);
-      };
-      const timer = setTimeout(() => {
-        proc.off?.("exit", onExit);
-        resolve(false);
-      }, 1500);
-      proc.once?.("exit", onExit);
-    });
-    if (!exitedInTime && !exited) {
-      logLatency({
-        type: "phase",
-        phase: "lsp_kill_escalation",
-        filePath: "",
-        durationMs: 1500,
-        metadata: { pid, platform: "posix", method: "SIGKILL", fast: false }
-      });
-      if (!killPosixProcessGroup("SIGKILL")) {
-        killDirectChild("SIGKILL");
-      }
-    }
-    releaseOwnChildPid(pid);
-  } catch {}
-}
-export function stripDiagnosticNoiseLines(message) {
-  const cleaned = message.split(/\r?\n/).filter((line) => {
-    const trimmed = line.trim();
-    if (/^for further information visit\b/i.test(trimmed))
-      return false;
-    if (/^https?:\/\/\S+$/i.test(trimmed))
-      return false;
-    return true;
-  }).join(`
-`).trim();
-  return cleaned || message.trim() || message;
-}
-function normalizeLspDiagnostic(diagnostic) {
-  const message = stripDiagnosticNoiseLines(diagnostic.message);
-  return message === diagnostic.message ? diagnostic : { ...diagnostic, message };
-}
-function normalizeLspDiagnostics(diagnostics) {
-  return diagnostics.map(normalizeLspDiagnostic);
-}
-function mergeDiagnosticLists(...lists) {
-  const merged = [];
-  const seen = new Set;
-  for (const diagnostic of lists.flatMap((list) => list ?? [])) {
-    const key = [
-      diagnostic.range.start.line,
-      diagnostic.range.start.character,
-      diagnostic.range.end.line,
-      diagnostic.range.end.character,
-      diagnostic.code ?? "",
-      diagnostic.source ?? "",
-      diagnostic.message
-    ].join(":");
-    if (seen.has(key))
-      continue;
-    seen.add(key);
-    merged.push(diagnostic);
-  }
-  return merged;
-}
-function getMergedDiagnosticsForPath(state, normalizedPath) {
-  const legacy = state;
-  return mergeDiagnosticLists(state.pushDiagnostics?.get(normalizedPath) ?? legacy.diagnostics?.get(normalizedPath), state.documentPullDiagnostics?.get(normalizedPath));
-}
-const PULL_SOURCE_KEY_SEPARATOR = "\x00";
-const BARE_PULL_SOURCE = "";
-function pullSourceKey(normalizedPath, identifier) {
-  return identifier === undefined ? normalizedPath : `${normalizedPath}${PULL_SOURCE_KEY_SEPARATOR}${identifier}`;
-}
-function pullSourceKeysForPath(state, normalizedPath) {
-  const prefix = `${normalizedPath}${PULL_SOURCE_KEY_SEPARATOR}`;
-  return [
-    normalizedPath,
-    ...[...state.pullResultIds?.keys() ?? []].filter((key) => key.startsWith(prefix))
-  ];
-}
-function pullSourcesFor(state, normalizedPath) {
-  if (!state.documentPullDiagnosticsBySource) {
-    state.documentPullDiagnosticsBySource = new Map;
-  }
-  let sources = state.documentPullDiagnosticsBySource.get(normalizedPath);
-  if (!sources) {
-    sources = new Map;
-    state.documentPullDiagnosticsBySource.set(normalizedPath, sources);
-  }
-  return sources;
-}
-function pullSourceDiagnostics(state, normalizedPath, identifier) {
-  const sources = state.documentPullDiagnosticsBySource?.get(normalizedPath);
-  const stored = sources?.get(identifier ?? BARE_PULL_SOURCE);
-  if (stored)
-    return stored;
-  return sources && sources.size > 0 ? [] : state.documentPullDiagnostics.get(normalizedPath) ?? [];
-}
-function storePullSourceDiagnostics(state, normalizedPath, identifier, diagnostics) {
-  const sources = pullSourcesFor(state, normalizedPath);
-  sources.set(identifier ?? BARE_PULL_SOURCE, diagnostics);
-  state.documentPullDiagnostics.set(normalizedPath, mergeDiagnosticLists(...sources.values()));
-}
-function pullGenerationFor(state, normalizedPath) {
-  return state.pullGenerations?.get(normalizedPath) ?? 0;
-}
-function bumpPullGeneration(state, normalizedPath) {
-  if (!state.pullGenerations)
-    state.pullGenerations = new Map;
-  state.pullGenerations.set(normalizedPath, (state.pullGenerations.get(normalizedPath) ?? 0) + 1);
-}
-function claimPullRequestSequence(state, sourceKey) {
-  if (!state.pullRequestSequences)
-    state.pullRequestSequences = new Map;
-  const next = (state.pullRequestSequences.get(sourceKey) ?? 0) + 1;
-  state.pullRequestSequences.set(sourceKey, next);
-  return next;
-}
-function isNewestPullRequest(state, sourceKey, sequence) {
-  return (state.pullRequestSequences?.get(sourceKey) ?? 0) === sequence;
-}
-function retirePullSource(state, identifier) {
-  const suffix = `${PULL_SOURCE_KEY_SEPARATOR}${identifier}`;
-  for (const source of [state.pullResultIds, state.pullRequestSequences]) {
-    if (!source)
-      continue;
-    for (const key of source.keys()) {
-      if (key.endsWith(suffix))
-        source.delete(key);
-    }
-  }
-  for (const [normalizedPath, sources] of state.documentPullDiagnosticsBySource ?? []) {
-    if (!sources.delete(identifier))
-      continue;
-    state.documentPullDiagnostics.set(normalizedPath, mergeDiagnosticLists(...sources.values()));
-    bumpDiagnosticsVersion(state, normalizedPath);
-    state.diagnosticEmitter.emit("diagnostics", normalizedPath);
-  }
-}
-export function pullDiagnosticSources(state) {
-  const identifiers = new Set;
-  for (const registration of state.dynamicRegistrations?.values() ?? []) {
-    if (registration.method !== "textDocument/diagnostic")
-      continue;
-    if (registration.identifier)
-      identifiers.add(registration.identifier);
-  }
-  return [undefined, ...[...identifiers].sort((a, b) => a.localeCompare(b))];
-}
-export function bumpDiagnosticsVersion(state, normalizedPath) {
-  state.diagnosticsVersion += 1;
-  state.diagnosticsVersionsByPath?.set(normalizedPath, state.diagnosticsVersion);
-}
-export function diagnosticsVersionForPath(state, normalizedPath) {
-  return state.diagnosticsVersionsByPath?.get(normalizedPath) ?? 0;
-}
-export function clearDiagnosticsForPath(state, normalizedPath) {
-  const legacy = state;
-  state.pushDiagnostics?.delete(normalizedPath);
-  const pending = state.pendingDiagnostics?.get(normalizedPath);
-  if (pending)
-    clearTimeout(pending);
-  state.pendingDiagnostics?.delete(normalizedPath);
-  state.pushDiagnosticTimestamps?.delete(normalizedPath);
-  state.documentPullDiagnostics?.delete(normalizedPath);
-  state.documentPullDiagnosticTimestamps?.delete(normalizedPath);
-  state.diagnosticDocVersions?.delete(normalizedPath);
-  state.diagnosticBindings?.delete(normalizedPath);
-  state.diagnosticsVersionsByPath?.delete(normalizedPath);
-  for (const key of pullSourceKeysForPath(state, normalizedPath)) {
-    state.pullResultIds?.delete(key);
-  }
-  state.documentPullDiagnosticsBySource?.delete(normalizedPath);
-  bumpPullGeneration(state, normalizedPath);
-  state.workspacePullResultCache?.delete(normalizedPath);
-  legacy.diagnostics?.delete(normalizedPath);
-  legacy.diagnosticTimestamps?.delete(normalizedPath);
-}
-function logTypeScriptPullSettle(state, normalizedPath, durationMs, pullSettleSource) {
-  if (state.serverId !== "typescript")
-    return;
-  const diagnostics = state.documentPullDiagnostics.get(normalizedPath) ?? [];
-  const elapsedSinceDidOpenMs = Math.max(0, Date.now() - (state.documentOpenedAt.get(normalizedPath) ?? Date.now()));
-  const diagnosticCodes = [
-    ...new Set(diagnostics.map((diagnostic) => diagnostic.code).filter((code) => code !== undefined).map(String))
-  ].slice(0, 8);
-  const trackedVersion = state.diagnosticsVersionsByPath?.get(normalizedPath);
-  logLatency({
-    type: "phase",
-    phase: "lsp_typescript_diagnostic_sequence",
-    filePath: normalizedPath,
-    durationMs,
-    metadata: {
-      serverId: state.serverId,
-      outcome: "settled",
-      launchVariant: state.launchVariant ?? "unknown",
-      publicationIndex: state.diagnosticPublicationCounts.get(normalizedPath) ?? 0,
-      version: trackedVersion ?? "pull-unversioned",
-      diagnosticCount: diagnostics.length,
-      diagnosticCodes,
-      elapsedSinceDidOpenMs,
-      settledReturn: true,
-      settleSource: pullSettleSource
-    }
-  });
-}
-function scanSentContent(content) {
-  let lfNewlineCount = 0;
-  let index = 0;
-  let start = 0;
-  for (let i = 0;i < content.length; i++) {
-    const code = content.charCodeAt(i);
-    if (code !== 10 && code !== 13)
-      continue;
-    if (code === 10) {
-      lfNewlineCount++;
-    } else if (content.charCodeAt(i + 1) === 10) {
-      lfNewlineCount++;
-      i++;
-    }
-    index++;
-    start = i + 1;
-  }
-  return { lfNewlineCount, lastLine: { index, start } };
-}
-function recordSentContent(state, normalizedPath, version, content, coalescedCount = 0) {
-  const scan = scanSentContent(content);
-  const previous = state.documentContentHashes.get(normalizedPath);
-  if (previous && previous.version > version) {
-    incrementDegradationCount({
-      kind: "lsp-document-send-order",
-      subject: `${state.serverId}:${normalizedPath}`,
-      reason: `recorded version ${version} after newer version ${previous.version}`
-    });
-    return;
-  }
-  if (previous?.text !== undefined) {
-    state.incrementalTextRetainedEntries = Math.max(0, (state.incrementalTextRetainedEntries ?? 1) - 1);
-    state.incrementalTextRetainedBytes = Math.max(0, (state.incrementalTextRetainedBytes ?? previous.text.length * 2) - previous.text.length * 2);
-    state.incrementalTextBearingPaths?.delete(normalizedPath);
-  }
-  state.documentContentHashes.delete(normalizedPath);
-  state.documentContentHashes.set(normalizedPath, {
-    version,
-    hash: hashDiagnosticContent(content),
-    ...state.syncKind === TEXT_DOCUMENT_SYNC_KIND_INCREMENTAL && {
-      text: content,
-      lastLine: scan.lastLine
-    }
-  });
-  if (state.syncKind === TEXT_DOCUMENT_SYNC_KIND_INCREMENTAL) {
-    state.incrementalTextRetainedEntries = (state.incrementalTextRetainedEntries ?? 0) + 1;
-    state.incrementalTextRetainedBytes = (state.incrementalTextRetainedBytes ?? 0) + content.length * 2;
-    if (!state.incrementalTextBearingPaths) {
-      state.incrementalTextBearingPaths = new Set;
-    }
-    state.incrementalTextBearingPaths.add(normalizedPath);
-    while ((state.incrementalTextRetainedEntries ?? 0) > MAX_INCREMENTAL_TEXT_RETAINED_ENTRIES || (state.incrementalTextRetainedBytes ?? 0) > MAX_INCREMENTAL_TEXT_RETAINED_BYTES) {
-      const oldestPath = state.incrementalTextBearingPaths?.values().next().value;
-      if (oldestPath === undefined)
-        break;
-      const binding = state.documentContentHashes.get(oldestPath);
-      state.incrementalTextBearingPaths.delete(oldestPath);
-      if (!binding || binding.text === undefined)
-        continue;
-      state.documentContentHashes.set(oldestPath, {
-        version: binding.version,
-        hash: binding.hash
-      });
-      state.incrementalTextRetainedEntries = Math.max(0, (state.incrementalTextRetainedEntries ?? 1) - 1);
-      state.incrementalTextRetainedBytes = Math.max(0, (state.incrementalTextRetainedBytes ?? 0) - binding.text.length * 2);
-    }
-  }
-  logLatency({
-    type: "phase",
-    phase: "lsp_document_send",
-    filePath: normalizedPath,
-    durationMs: 0,
-    metadata: {
-      version,
-      contentLength: content.length,
-      contentLineCount: scan.lfNewlineCount + 1,
-      ...coalescedCount > 0 && { coalescedCount }
-    }
-  });
-}
-function buildContentChanges(state, normalizedPath, content) {
-  if (state.syncKind !== TEXT_DOCUMENT_SYNC_KIND_INCREMENTAL) {
-    return [{ text: content }];
-  }
-  const previous = state.documentContentHashes.get(normalizedPath);
-  if (previous?.text === undefined) {
-    return [{ text: content }];
-  }
-  const previousText = previous.text;
-  const lastLine = previous.lastLine ?? scanSentContent(previousText).lastLine;
-  const lastLineText = previousText.slice(lastLine.start);
-  return [
-    {
-      range: {
-        start: { line: 0, character: 0 },
-        end: {
-          line: lastLine.index,
-          character: convertCharacterOffset(state.positionEncoding, lastLineText, lastLineText.length)
-        }
-      },
-      text: content
-    }
-  ];
-}
-const DYNAMIC_OPERATION_METHOD_MAP = {
-  "textDocument/definition": "definition",
-  "textDocument/typeDefinition": "typeDefinition",
-  "textDocument/declaration": "declaration",
-  "textDocument/references": "references",
-  "textDocument/hover": "hover",
-  "textDocument/signatureHelp": "signatureHelp",
-  "textDocument/documentSymbol": "documentSymbol",
-  "workspace/symbol": "workspaceSymbol",
-  "textDocument/codeAction": "codeAction",
-  "textDocument/rename": "rename",
-  "textDocument/implementation": "implementation",
-  "textDocument/prepareCallHierarchy": "callHierarchy"
-};
-export function applyDynamicCapabilities(state) {
-  const registrations = [...state.dynamicRegistrations.values()];
-  const registeredMethods = new Set(registrations.map((r) => r.method));
-  const hasDynamicPull = registeredMethods.has("textDocument/diagnostic") || registeredMethods.has("workspace/diagnostic");
-  if (hasDynamicPull) {
-    state.workspaceDiagnosticsSupport = {
-      advertised: true,
-      mode: "pull",
-      workspaceDiagnostics: registrations.some((r) => r.workspaceDiagnostics === true) || registeredMethods.has("workspace/diagnostic"),
-      diagnosticProviderKind: "dynamic"
-    };
-  } else if (state.staticDiagnosticsMode === "push-only" && state.workspaceDiagnosticsSupport.diagnosticProviderKind === "dynamic") {
-    state.workspaceDiagnosticsSupport = {
-      advertised: false,
-      mode: "push-only",
-      workspaceDiagnostics: false,
-      diagnosticProviderKind: "none"
-    };
-  }
-  for (const [method, key] of Object.entries(DYNAMIC_OPERATION_METHOD_MAP)) {
-    if (registeredMethods.has(method)) {
-      state.operationSupport[key] = true;
-    }
-  }
-}
-export function resolveConfigurationSection(initialization, section) {
-  if (!initialization)
-    return {};
-  if (!section)
-    return initialization;
-  let cur = initialization;
-  for (const part of section.split(".")) {
-    if (typeof cur !== "object" || cur === null || !Object.hasOwn(cur, part)) {
-      return {};
-    }
-    cur = cur[part];
-  }
-  return cur;
-}
-export function setupIncomingHandlers(state, initialization, onDiagnosticsPublished) {
-  state.connection.onNotification("textDocument/publishDiagnostics", (params) => {
-    const publishReceivedAt = Date.now();
-    const filePath = uriToPath(params.uri);
-    const normalizedPath = normalizeMapKey(filePath);
-    if (state.closedDocuments?.has(normalizedPath))
-      return;
-    onDiagnosticsPublished?.(state.serverId);
-    const newDiags = normalizeLspDiagnostics(params.diagnostics || []);
-    const docVersion = params.version;
-    if (PUB_DEBUG) {
-      logExtension({
-        subsystem: "lsp-pub",
-        level: "debug",
-        message: `server=${state.serverId} pubVersion=${docVersion} docVersion=${state.documentVersions?.get(normalizedPath)} diags=${newDiags.length}`
-      });
-    }
-    const strategy = getStrategy(state.serverId, state.launchVariant);
-    const isTypeScriptTelemetry = state.serverId === "typescript";
-    const publicationIndex = isTypeScriptTelemetry ? (state.diagnosticPublicationCounts.get(normalizedPath) ?? 0) + 1 : 0;
-    if (isTypeScriptTelemetry) {
-      state.diagnosticPublicationCounts.set(normalizedPath, publicationIndex);
-    }
-    const diagnosticCodes = isTypeScriptTelemetry ? [
-      ...new Set(newDiags.map((diagnostic) => diagnostic.code).filter((code) => code !== undefined).map(String))
-    ].slice(0, 8) : [];
-    const logSequence = (settledReturn, settleSource, durationMs) => {
-      if (state.serverId !== "typescript")
-        return;
-      const elapsedSinceDidOpenMs = Math.max(0, Date.now() - (state.documentOpenedAt.get(normalizedPath) ?? Date.now()));
-      logLatency({
-        type: "phase",
-        phase: "lsp_typescript_diagnostic_sequence",
-        filePath: normalizedPath,
-        durationMs,
-        metadata: {
-          serverId: state.serverId,
-          outcome: settledReturn ? "settled" : "published",
-          launchVariant: state.launchVariant ?? "unknown",
-          publicationIndex,
-          version: docVersion ?? "push-unversioned",
-          diagnosticCount: newDiags.length,
-          diagnosticCodes,
-          elapsedSinceDidOpenMs,
-          settledReturn,
-          settleSource
-        }
-      });
-    };
-    const recordDocVersion = () => {
-      if (docVersion !== undefined) {
-        state.diagnosticDocVersions.set(normalizedPath, docVersion);
-      }
-      recordBinding();
-    };
-    const recordBinding = () => {
-      if (docVersion === undefined) {
-        state.diagnosticBindings.delete(normalizedPath);
-        return;
-      }
-      const sent = state.documentContentHashes.get(normalizedPath);
-      state.diagnosticBindings.set(normalizedPath, {
-        version: docVersion,
-        contentHash: sent && sent.version === docVersion ? sent.hash : undefined
-      });
-    };
-    const isSupersededPush = () => {
-      if (docVersion === undefined)
-        return false;
-      const currentVersion = state.documentVersions.get(normalizedPath);
-      return currentVersion !== undefined && docVersion < currentVersion;
-    };
-    if (strategy.emptyFirstPublish === "indexing" && !state.emptyFirstPublishHoldSpent && newDiags.length === 0 && !state.pushDiagnostics.has(normalizedPath) && !state.pendingDiagnostics.has(normalizedPath)) {
-      state.emptyFirstPublishHoldSpent = true;
-      logLatency({
-        type: "phase",
-        phase: "lsp_empty_first_publish_held",
-        filePath: normalizedPath,
-        durationMs: Math.max(0, publishReceivedAt - (state.documentOpenedAt.get(normalizedPath) ?? publishReceivedAt)),
-        metadata: {
-          serverId: state.serverId,
-          emptyFirstPublish: strategy.emptyFirstPublish,
-          pubVersion: docVersion ?? "push-unversioned"
-        }
-      });
-      return;
-    }
-    if (strategy.seedFirstPush && !state.pushDiagnostics.has(normalizedPath)) {
-      if (isSupersededPush())
-        return;
-      state.pushDiagnostics.set(normalizedPath, newDiags);
-      state.pushDiagnosticTimestamps.set(normalizedPath, Date.now());
-      recordDocVersion();
-      bumpDiagnosticsVersion(state, normalizedPath);
-      state.diagnosticEmitter.emit("diagnostics", normalizedPath);
-      logSequence(true, "first-push", 0);
-      return;
-    }
-    logSequence(false, "publication", 0);
-    const existingTimer = state.pendingDiagnostics.get(normalizedPath);
-    if (existingTimer)
-      clearTimeout(existingTimer);
-    const timer = setTimeout(() => {
-      state.pendingDiagnostics.delete(normalizedPath);
-      if (isSupersededPush())
-        return;
-      state.pushDiagnostics.set(normalizedPath, newDiags);
-      state.pushDiagnosticTimestamps.set(normalizedPath, Date.now());
-      recordDocVersion();
-      bumpDiagnosticsVersion(state, normalizedPath);
-      state.diagnosticEmitter.emit("diagnostics", normalizedPath);
-      logSequence(true, "quiet-window", Date.now() - publishReceivedAt);
-    }, strategy.debounceMs);
-    state.pendingDiagnostics.set(normalizedPath, timer);
-  });
-  state.connection.onRequest("workspace/workspaceFolders", () => [
-    { name: "workspace", uri: pathToFileURL(state.root).href }
-  ]);
-  state.connection.onRequest("client/registerCapability", async (params) => {
-    for (const reg of params?.registrations ?? []) {
-      const options = reg.registerOptions;
-      const commands = Array.isArray(options?.commands) ? options.commands.filter((cmd) => typeof cmd === "string") : undefined;
-      if (reg.id && reg.method) {
-        state.dynamicRegistrations.set(reg.id, {
-          method: reg.method,
-          ...typeof options?.identifier === "string" && options.identifier ? { identifier: options.identifier } : {},
-          ...typeof options?.workspaceDiagnostics === "boolean" ? { workspaceDiagnostics: options.workspaceDiagnostics } : {},
-          ...commands ? { commands } : {}
-        });
-      }
-      if (reg.method === "workspace/executeCommand" && commands) {
-        for (const cmd of commands)
-          state.advertisedCommands.add(cmd);
-      }
-    }
-    applyDynamicCapabilities(state);
-  });
-  state.connection.onRequest("client/unregisterCapability", async (params) => {
-    const retiredIdentifiers = new Set;
-    for (const unreg of params?.unregisterations ?? []) {
-      if (!unreg.id)
-        continue;
-      const registration = state.dynamicRegistrations.get(unreg.id);
-      state.dynamicRegistrations.delete(unreg.id);
-      if (registration?.method === "textDocument/diagnostic" && registration.identifier) {
-        retiredIdentifiers.add(registration.identifier);
-      }
-    }
-    const stillRegistered = new Set([...state.dynamicRegistrations.values()].filter((r) => r.method === "textDocument/diagnostic").map((r) => r.identifier));
-    for (const identifier of retiredIdentifiers) {
-      if (!stillRegistered.has(identifier)) {
-        retirePullSource(state, identifier);
-      }
-    }
-    applyDynamicCapabilities(state);
-  });
-  state.connection.onRequest("workspace/applyEdit", async (params) => {
-    if (state.serverEditsAllowed <= 0 || !params?.edit) {
-      return { applied: false, failureReason: "edit not solicited" };
-    }
-    const context = state.activeMutationContext;
-    const telemetryContext = context ?? {
-      cwd: state.root,
-      correlationId: newLspMutationCorrelationId(),
-      tool: "lsp-workspace-applyEdit",
-      source: "lsp-execute-command"
-    };
-    try {
-      await applyWorkspaceEdit(params.edit, state.root, {
-        positionEncoding: state.positionEncoding,
-        documentVersions: state.documentVersions,
-        mutationContext: telemetryContext
-      });
-      return { applied: true };
-    } catch (err) {
-      return {
-        applied: false,
-        failureReason: err instanceof Error ? err.message : String(err)
-      };
-    }
-  });
-  state.connection.onRequest("workspace/configuration", async (params) => {
-    const items = params?.items ?? [];
-    return items.map((item) => resolveConfigurationSection(initialization, item?.section));
-  });
-  state.connection.onRequest("window/workDoneProgress/create", async () => {});
-  let refreshRepullRunning = false;
-  let refreshRepullRerunRequested = false;
-  const runRefreshRepullPool = async () => {
-    do {
-      refreshRepullRerunRequested = false;
-      const toRepull = state.workspaceDiagnosticsSupport.mode === "pull" ? [...state.openDocuments] : [];
-      if (toRepull.length > 0) {
-        try {
-          await mapWithConcurrency(toRepull, REFRESH_REPULL_CONCURRENCY, async (normalizedPath) => {
-            const uri = state.openDocumentUris?.get(normalizedPath);
-            const filePath = uri ? uriToPath(uri) : normalizedPath;
-            await clientRequestPullDiagnostics(state, filePath);
-          });
-        } catch (err) {
-          incrementDegradationCount({
-            kind: "lsp-pull-unconfirmed",
-            subject: state.serverId,
-            reason: `refresh re-pull threw: ${err instanceof Error ? err.message : String(err)}`
-          });
-        }
-      }
-    } while (refreshRepullRerunRequested);
-    refreshRepullRunning = false;
-  };
-  state.connection.onRequest("workspace/diagnostic/refresh", async () => {
-    state.workspacePullResultCache.clear();
-    clearAllWorkspaceDiagnosticsCaches();
-    clearWorkspaceDiagnosticsCacheAtAndAbove(state.root);
-    for (const normalizedPath of state.openDocuments) {
-      clearDiagnosticsForPath(state, normalizedPath);
-    }
-    if (state.workspaceDiagnosticsSupport.mode === "pull" && state.openDocuments.size > 0) {
-      if (refreshRepullRunning) {
-        refreshRepullRerunRequested = true;
-      } else {
-        refreshRepullRunning = true;
-        setImmediate(() => {
-          runRefreshRepullPool();
-        });
-      }
-    }
-    return null;
-  });
-}
-function markExitedIfUnset(state) {
-  if (state.exitedAt === undefined) {
-    state.exitedAt = Date.now();
-  }
-}
-function setupConnectionLifecycle(state, recentStderr) {
-  state.connection.onError(([error]) => {
-    state.lastError = error instanceof Error ? error : new Error(String(error));
-    state.isConnected = false;
-    state.isDestroyed = true;
-    markExitedIfUnset(state);
-    disposeClientConnection(state);
-  });
-  state.connection.onClose(() => {
-    state.isConnected = false;
-    state.isDestroyed = true;
-    markExitedIfUnset(state);
-    disposeClientConnection(state);
-  });
-  state.lspProcess.process.on("exit", (code, signal) => {
-    const wasIntentional = state.shutdownRequested;
-    state.isConnected = false;
-    state.isDestroyed = true;
-    markExitedIfUnset(state);
-    disposeClientConnection(state);
-    if (!wasIntentional) {
-      logLatency({
-        type: "phase",
-        phase: "lsp_server_unexpected_exit",
-        filePath: state.root,
-        durationMs: 0,
-        metadata: {
-          serverId: state.serverId,
-          pid: state.lspProcess.pid,
-          exitCode: code ?? null,
-          exitSignal: signal ?? null,
-          stderrTail: recentStderr(20)
-        }
-      });
-    }
-  });
-  state.lspProcess.process.on("close", (code, signal) => {
-    if (state.shutdownRequested)
-      return;
-    try {
-      const stderrTail = recentStderr(20);
-      incrementDegradationCount({
-        kind: "lsp-server-unexpected-close",
-        subject: state.serverId,
-        reason: `closed unprompted: code=${code ?? "none"} signal=${signal ?? "none"} ` + `stderr=${stderrTail.length > 0 ? `present(${stderrTail.length}b)` : "empty"} root=${state.root}`
-      });
-    } catch {}
-  });
-}
-const PULL_RACE_BACKSTOP_MARGIN_MS = 25;
-async function clientRequestPullDiagnostics(state, filePath, budgetMs = PULL_REQUEST_TIMEOUT_MS) {
-  if (!isClientAlive(state))
-    return { status: "unavailable" };
-  const sources = pullDiagnosticSources(state);
-  if (sources.length === 1) {
-    return aggregatePullOutcomes(state, filePath, [
-      await pullDiagnosticSource(state, filePath, budgetMs, undefined)
-    ]);
-  }
-  const attempts = sources.map((identifier) => pullDiagnosticSource(state, filePath, budgetMs, identifier));
-  const settled = await raceToCompletion(attempts, (results) => results.some((r) => r.status === "found" && r.primaryCount > 0), {
-    timeoutMs: Math.max(1, Math.min(PULL_REQUEST_TIMEOUT_MS, budgetMs)) + PULL_RACE_BACKSTOP_MARGIN_MS
-  });
-  return aggregatePullOutcomes(state, filePath, settled);
-}
-function aggregatePullOutcomes(state, filePath, outcomes) {
-  const found = outcomes.filter((o) => o.status === "found");
-  if (found.length > 0) {
-    const normalizedPath = normalizeMapKey(filePath);
-    const unionCount = state.documentPullDiagnostics.get(normalizedPath)?.length ?? 0;
-    return {
-      status: "found",
-      count: Math.max(unionCount, ...found.map((o) => o.count))
-    };
-  }
-  if (outcomes.some((o) => o.status === "unavailable")) {
-    return { status: "unavailable" };
-  }
-  return outcomes.some((o) => o.status === "clean") ? { status: "clean" } : { status: "unavailable" };
-}
-async function pullDiagnosticSource(state, filePath, budgetMs, identifier) {
-  if (!isClientAlive(state))
-    return { status: "unavailable" };
-  const normalizedPath = normalizeMapKey(filePath);
-  if (budgetMs < PULL_MIN_USABLE_BUDGET_MS) {
-    emitBounded("lsp_pull_skipped_budget_exhausted", `${state.serverId}::${pullSourceKey(normalizedPath, identifier)}`, {
-      type: "phase",
-      filePath: normalizedPath,
-      durationMs: 0,
-      metadata: {
-        identifier: identifier ?? "bare",
-        remainingBudgetMs: budgetMs,
-        server: state.serverId
-      }
-    }, {
-      ledgerKind: "lsp-pull-skipped-budget-exhausted",
-      reason: `pull skipped on ${state.serverId}: budget already exhausted (${budgetMs}ms remaining)`
-    });
-    return { status: "unavailable" };
-  }
-  const uri = pathToFileURL(filePath).href;
-  const sourceKey = pullSourceKey(normalizedPath, identifier);
-  if (state.abandonedPullRequests?.has(sourceKey)) {
-    return { status: "unavailable" };
-  }
-  const previousResultId = state.pullResultIds.get(sourceKey);
-  const generation = pullGenerationFor(state, normalizedPath);
-  const requestSequence = claimPullRequestSequence(state, sourceKey);
-  const requestStartedAt = Date.now();
-  const effectiveTimeoutMs = Math.max(1, Math.min(PULL_REQUEST_TIMEOUT_MS, budgetMs));
-  const pullAbort = new AbortController;
-  const pullSettlement = { cancelled: false };
-  const requestPromise = safeSendRequest(state.connection, "textDocument/diagnostic", {
-    textDocument: { uri },
-    ...identifier !== undefined && { identifier },
-    ...previousResultId !== undefined && { previousResultId }
-  }, pullAbort.signal, pullSettlement);
-  try {
-    const report = await withTimeout(requestPromise, effectiveTimeoutMs);
-    if (!report) {
-      recordPullFailure(state, "textDocument/diagnostic", new Error("empty response"));
-      return { status: "unavailable" };
-    }
-    const now = Date.now();
-    const sentHash = state.documentContentHashes.get(normalizedPath)?.hash;
-    if (pullGenerationFor(state, normalizedPath) !== generation || !isNewestPullRequest(state, sourceKey, requestSequence)) {
-      return { status: "unavailable" };
-    }
-    let primaryCount;
-    if (report.kind === "unchanged") {
-      primaryCount = pullSourceDiagnostics(state, normalizedPath, identifier).length;
-      state.documentPullDiagnosticTimestamps.set(normalizedPath, now);
-    } else {
-      const primaryItems = normalizeLspDiagnostics(report.items ?? []);
-      storePullSourceDiagnostics(state, normalizedPath, identifier, primaryItems);
-      state.documentPullDiagnosticTimestamps.set(normalizedPath, now);
-      bumpDiagnosticsVersion(state, normalizedPath);
-      state.diagnosticBindings.set(normalizedPath, { contentHash: sentHash });
-      primaryCount = primaryItems.length;
-    }
-    let totalCount = primaryCount;
-    if (report.resultId !== undefined) {
-      state.pullResultIds.set(sourceKey, report.resultId);
-    } else {
-      state.pullResultIds.delete(sourceKey);
-    }
-    if (report.relatedDocuments) {
-      for (const [relatedUri, related] of Object.entries(report.relatedDocuments)) {
-        const relatedPath = uriToPath(relatedUri);
-        const relatedNormalized = normalizeMapKey(relatedPath);
-        if (related?.kind === "unchanged") {
-          totalCount += pullSourceDiagnostics(state, relatedNormalized, identifier).length;
-          state.documentPullDiagnosticTimestamps.set(relatedNormalized, now);
-        } else {
-          const relatedItems = normalizeLspDiagnostics(related?.items ?? []);
-          storePullSourceDiagnostics(state, relatedNormalized, identifier, relatedItems);
-          state.documentPullDiagnosticTimestamps.set(relatedNormalized, now);
-          state.diagnosticBindings.delete(relatedNormalized);
-          totalCount += relatedItems.length;
-        }
-        if (related?.resultId !== undefined) {
-          state.pullResultIds.set(pullSourceKey(relatedNormalized, identifier), related.resultId);
-        }
-      }
-    }
-    state.diagnosticEmitter.emit("diagnostics", normalizedPath);
-    return totalCount > 0 ? { status: "found", count: totalCount, primaryCount } : { status: "clean" };
-  } catch (err) {
-    if (isPullTimeoutError(err, effectiveTimeoutMs)) {
-      trackAbandonedPullRequest(state, sourceKey, requestPromise);
-      pullAbort.abort();
-      recordPullTimeoutTelemetry({
-        scope: normalizedPath,
-        identifier,
-        effectiveBudgetMs: effectiveTimeoutMs,
-        hadPreviousResultId: previousResultId !== undefined,
-        elapsedMs: Date.now() - requestStartedAt,
-        server: state.serverId
-      });
-      armLateAnswerTelemetry({
-        requestPromise,
-        scope: normalizedPath,
-        identifier,
-        subject: sourceKey,
-        requestStartedAt,
-        server: state.serverId,
-        settlement: pullSettlement
-      });
-    }
-    recordPullFailure(state, "textDocument/diagnostic", err);
-    return { status: "unavailable" };
-  }
-}
-function trackAbandonedPullRequest(state, sourceKey, requestPromise) {
-  if (!state.abandonedPullRequests)
-    state.abandonedPullRequests = new Map;
-  state.abandonedPullRequests.set(sourceKey, requestPromise);
-  const release = () => {
-    if (state.abandonedPullRequests?.get(sourceKey) === requestPromise) {
-      state.abandonedPullRequests.delete(sourceKey);
-    }
-  };
-  requestPromise.then(release, release);
-}
-function isPullTimeoutError(err, timeoutMs) {
-  return err instanceof Error && err.message === `Timeout after ${timeoutMs}ms`;
-}
-function recordPullTimeoutTelemetry(args) {
-  emitBounded("lsp_pull_diagnostic_timeout", `${args.server}::${args.scope}::${args.identifier ?? "bare"}`, {
-    type: "phase",
-    filePath: args.scope,
-    durationMs: args.elapsedMs,
-    metadata: {
-      identifier: args.identifier ?? "bare",
-      effectiveBudgetMs: args.effectiveBudgetMs,
-      hadPreviousResultId: args.hadPreviousResultId,
-      server: args.server
-    }
-  }, {
-    ledgerKind: "lsp-pull-diagnostic-timeout",
-    reason: `pull timeout on ${args.server} after ${args.elapsedMs}ms (budget ${args.effectiveBudgetMs}ms)`
-  });
-}
-function armLateAnswerTelemetry(args) {
-  args.requestPromise.then(() => {
-    if (args.settlement.cancelled)
-      return;
-    try {
-      const elapsedMs = Date.now() - args.requestStartedAt;
-      emitBounded("lsp_pull_late_answer_discarded", args.subject, {
-        type: "phase",
-        filePath: args.scope,
-        durationMs: elapsedMs,
-        metadata: { identifier: args.identifier ?? "bare" }
-      }, {
-        ledgerKind: "lsp-pull-late-answer",
-        reason: `late pull answer discarded after ${elapsedMs}ms`
-      });
-    } catch {}
-  }, (err) => {
-    try {
-      const elapsedMs = Date.now() - args.requestStartedAt;
-      const candidate = err;
-      const code = typeof candidate?.code === "number" || typeof candidate?.code === "string" ? candidate.code : undefined;
-      emitBounded("lsp_pull_late_rejection", `${args.server}::${args.subject}`, {
-        type: "phase",
-        filePath: args.scope,
-        durationMs: elapsedMs,
-        metadata: {
-          identifier: args.identifier ?? "bare",
-          server: args.server,
-          ...code !== undefined && { code }
-        }
-      }, {
-        ledgerKind: "lsp-pull-late-rejection",
-        reason: `late pull rejection ${elapsedMs}ms after timeout${code !== undefined ? ` (code ${code})` : ""}`
-      });
-    } catch {}
-  });
-}
-const PULL_FAILURE_HISTORY_LIMIT = 10;
-function recordPullFailure(state, method, error) {
-  const candidate = error;
-  const message = typeof candidate.message === "string" ? candidate.message : "";
-  const unsupportedMessage = /^(?:method not found|unknown method|unsupported method)(?::|$)/i;
-  if (candidate.code === -32601 || candidate.code === "-32601" || unsupportedMessage.test(message.trim()))
-    return;
-  state.pullFailureHistory.push({
-    timestamp: Date.now(),
-    method,
-    ...typeof candidate.code === "number" || typeof candidate.code === "string" ? { code: candidate.code } : {},
-    message: typeof candidate.message === "string" ? candidate.message : String(error)
-  });
-  if (state.pullFailureHistory.length > PULL_FAILURE_HISTORY_LIMIT) {
-    state.pullFailureHistory.splice(0, state.pullFailureHistory.length - PULL_FAILURE_HISTORY_LIMIT);
-  }
-}
-export async function clientRequestWorkspaceDiagnostics(state, budgetMs) {
-  if (!isClientAlive(state))
-    return;
-  if (!state.workspaceDiagnosticsSupport.workspaceDiagnostics)
-    return;
-  if (state.abandonedPullRequests?.has(WORKSPACE_PULL_SCOPE))
-    return;
-  const previousResultIds = Array.from(state.workspacePullResultCache.values()).map((entry) => ({ uri: entry.uri, value: entry.resultId }));
-  if (budgetMs < PULL_MIN_USABLE_BUDGET_MS) {
-    emitBounded("lsp_pull_skipped_budget_exhausted", `${state.serverId}::${WORKSPACE_PULL_SCOPE}`, {
-      type: "phase",
-      filePath: WORKSPACE_PULL_SCOPE,
-      durationMs: 0,
-      metadata: {
-        identifier: "bare",
-        remainingBudgetMs: budgetMs,
-        server: state.serverId
-      }
-    }, {
-      ledgerKind: "lsp-pull-skipped-budget-exhausted",
-      reason: `workspace pull skipped on ${state.serverId}: budget already exhausted (${budgetMs}ms remaining)`
-    });
-    return;
-  }
-  const workspacePullStartedAt = Date.now();
-  const workspacePullTimeoutMs = Math.max(1, budgetMs);
-  const workspacePullAbort = new AbortController;
-  const workspacePullSettlement = { cancelled: false };
-  const workspaceRequestPromise = safeSendRequest(state.connection, "workspace/diagnostic", { previousResultIds }, workspacePullAbort.signal, workspacePullSettlement);
-  try {
-    const report = await withTimeout(workspaceRequestPromise, workspacePullTimeoutMs);
-    if (!report || !Array.isArray(report.items))
-      return;
-    const out = [];
-    const fallbackPullDeadline = Date.now() + Math.max(1, budgetMs);
-    for (const item of report.items) {
-      if (!item?.uri)
-        continue;
-      const filePath = uriToPath(item.uri);
-      const normalizedPath = normalizeMapKey(filePath);
-      if (item.kind === "unchanged") {
-        const prior = state.workspacePullResultCache.get(normalizedPath);
-        if (!prior) {
-          const remainingMs = fallbackPullDeadline - Date.now();
-          if (remainingMs <= 0) {
-            incrementDegradationCount({
-              kind: "lsp-pull-unconfirmed",
-              subject: state.serverId,
-              reason: "unchanged report with no workspacePullResultCache basis; the shared fallback-pull deadline was already exhausted by earlier files this sweep"
-            });
-            continue;
-          }
-          const outcome = await clientRequestPullDiagnostics(state, filePath, remainingMs);
-          if (outcome.status === "found") {
-            out.push({
-              filePath,
-              diagnostics: state.documentPullDiagnostics.get(normalizedPath) ?? [],
-              contentHash: state.diagnosticBindings.get(normalizedPath)?.contentHash
-            });
-          } else if (outcome.status === "unavailable") {
-            incrementDegradationCount({
-              kind: "lsp-pull-unconfirmed",
-              subject: state.serverId,
-              reason: "unchanged report with no workspacePullResultCache basis, and the per-file fallback pull was unavailable"
-            });
-          }
-          continue;
-        }
-        if (item.resultId !== undefined) {
-          state.workspacePullResultCache.set(normalizedPath, {
-            ...prior,
-            resultId: item.resultId
-          });
-        }
-        out.push({
-          filePath,
-          diagnostics: prior.diagnostics,
-          contentHash: prior.contentHash
-        });
-        continue;
-      }
-      const diagnostics = normalizeLspDiagnostics(item.items ?? []);
-      let contentHash;
-      try {
-        contentHash = hashDiagnosticContent(await readFile(filePath, "utf-8"));
-      } catch {
-        contentHash = undefined;
-      }
-      if (item.resultId !== undefined) {
-        if (state.workspacePullResultCache.size >= WORKSPACE_PULL_RESULT_CACHE_MAX) {
-          state.workspacePullResultCache.clear();
-        }
-        state.workspacePullResultCache.set(normalizedPath, {
-          uri: item.uri,
-          resultId: item.resultId,
-          diagnostics,
-          contentHash
-        });
-      } else {
-        state.workspacePullResultCache.delete(normalizedPath);
-      }
-      out.push({ filePath, diagnostics, contentHash });
-    }
-    return out;
-  } catch (err) {
-    if (isPullTimeoutError(err, workspacePullTimeoutMs)) {
-      trackAbandonedPullRequest(state, WORKSPACE_PULL_SCOPE, workspaceRequestPromise);
-      workspacePullAbort.abort();
-      recordPullTimeoutTelemetry({
-        scope: WORKSPACE_PULL_SCOPE,
-        identifier: undefined,
-        effectiveBudgetMs: workspacePullTimeoutMs,
-        hadPreviousResultId: previousResultIds.length > 0,
-        elapsedMs: Date.now() - workspacePullStartedAt,
-        server: state.serverId
-      });
-      armLateAnswerTelemetry({
-        requestPromise: workspaceRequestPromise,
-        scope: WORKSPACE_PULL_SCOPE,
-        identifier: undefined,
-        subject: WORKSPACE_PULL_SCOPE,
-        requestStartedAt: workspacePullStartedAt,
-        server: state.serverId,
-        settlement: workspacePullSettlement
-      });
-    }
-    recordPullFailure(state, "workspace/diagnostic", err);
-    return;
-  }
-}
-export async function clientWaitForDiagnostics(state, filePath, timeoutMs, options = {}) {
-  const normalizedPath = normalizeMapKey(filePath);
-  const minVersion = options.minVersion;
-  const pullSettleSource = options.pullSettleSource ?? "pull";
-  const hasFreshDiagnostics = () => minVersion === undefined || diagnosticsVersionForPath(state, normalizedPath) > minVersion;
-  const isVersionStale = () => {
-    const cachedVersion = state.diagnosticDocVersions?.get(normalizedPath);
-    if (cachedVersion === undefined)
-      return false;
-    const currentVersion = state.documentVersions?.get(normalizedPath);
-    return currentVersion !== undefined && cachedVersion < currentVersion;
-  };
-  if (state.workspaceDiagnosticsSupport.mode === "pull") {
-    const pullSettleStartedAt = Date.now();
-    let outcome = await clientRequestPullDiagnostics(state, filePath, timeoutMs);
-    if (outcome.status === "found") {
-      logTypeScriptPullSettle(state, normalizedPath, Date.now() - pullSettleStartedAt, pullSettleSource);
-      return;
-    }
-    let sawClean = outcome.status === "clean";
-    const strategy = getStrategy(state.serverId, state.launchVariant);
-    const retryBudgetMs = strategy.pullRetryBudgetMs > 0 ? Math.min(timeoutMs, strategy.pullRetryBudgetMs) : 0;
-    const startedAt = Date.now();
-    while (outcome.status !== "found" && Date.now() - startedAt < retryBudgetMs) {
-      await new Promise((resolve) => setTimeout(resolve, PULL_DIAGNOSTICS_RETRY_INTERVAL_MS));
-      outcome = await clientRequestPullDiagnostics(state, filePath, Math.max(0, retryBudgetMs - (Date.now() - startedAt)));
-      if (outcome.status === "clean")
-        sawClean = true;
-    }
-    if (options.pullOnly) {
-      if (outcome.status === "found" || sawClean) {
-        logTypeScriptPullSettle(state, normalizedPath, Date.now() - pullSettleStartedAt, pullSettleSource);
-      }
-      return;
-    }
-    if (outcome.status === "found" || sawClean) {
-      logTypeScriptPullSettle(state, normalizedPath, Date.now() - pullSettleStartedAt, pullSettleSource);
-      return;
-    }
-  }
-  if (hasFreshDiagnostics() && !isVersionStale() && getMergedDiagnosticsForPath(state, normalizedPath).length > 0) {
-    return;
-  }
-  return new Promise((resolve) => {
-    let debounceTimer;
-    const onDiagnostics = (fp) => {
-      if (normalizeMapKey(fp) !== normalizedPath)
-        return;
-      if (!hasFreshDiagnostics() || isVersionStale())
-        return;
-      if (debounceTimer)
-        clearTimeout(debounceTimer);
-      const strategy = getStrategy(state.serverId, state.launchVariant);
-      const hit = state.pushDiagnosticTimestamps.get(normalizedPath);
-      const timeSincePush = hit ? Date.now() - hit : 1 / 0;
-      const remaining = Math.max(0, strategy.debounceMs - timeSincePush);
-      debounceTimer = setTimeout(() => {
-        state.diagnosticEmitter.off("diagnostics", onDiagnostics);
-        clearTimeout(timeout);
-        resolve();
-      }, remaining);
-    };
-    state.diagnosticEmitter.on("diagnostics", onDiagnostics);
-    const timeout = setTimeout(() => {
-      if (debounceTimer)
-        clearTimeout(debounceTimer);
-      state.diagnosticEmitter.off("diagnostics", onDiagnostics);
-      resolve();
-    }, timeoutMs);
-  });
-}
-export function handleNotifyExternalChange(state, filePath, type) {
-  if (!isClientAlive(state))
-    return;
-  const normalizedPath = normalizeMapKey(filePath);
-  const uri = state.openDocumentUris?.get(normalizedPath) ?? pathToFileURL(filePath).href;
-  state.watchQueue.enqueue(uri, type);
-}
-async function sendDidSave(state, uri, content) {
-  const save = state.saveOptions;
-  if (!save)
-    return;
-  if (!isClientAlive(state))
-    return;
-  const limit = save.includeText ? exceedsLspSyncLimits(content) : { tooLarge: false, reason: "" };
-  if (limit.tooLarge) {
-    recordDegradationOnce({
-      kind: "lsp-did-save-text-omitted",
-      subject: state.serverId,
-      reason: limit.reason
-    });
-  }
-  await safeSendNotification(state.connection, "textDocument/didSave", {
-    textDocument: { uri },
-    ...save.includeText && !limit.tooLarge ? { text: content } : {}
-  });
-}
-async function handleNotifyOpenOnce(state, filePath, content, languageId, preserveDiagnostics = false, silent = false, coalescedCount = 0, saved = false) {
-  if (!isClientAlive(state))
-    return;
-  const normalizedPath = normalizeMapKey(filePath);
-  const uri = state.openDocumentUris?.get(normalizedPath) ?? pathToFileURL(filePath).href;
-  if (state.openDocuments.has(normalizedPath) || state.pendingOpens.has(normalizedPath)) {
-    const version = (state.documentVersions.get(normalizedPath) ?? 0) + 1;
-    state.documentVersions.set(normalizedPath, version);
-    if (!preserveDiagnostics) {
-      clearDiagnosticsForPath(state, normalizedPath);
-    }
-    if (getStrategy(state.serverId, state.launchVariant).reopenOnResync) {
-      await safeSendNotification(state.connection, "textDocument/didClose", {
-        textDocument: { uri }
-      });
-      state.openDocuments.delete(normalizedPath);
-      state.openDocumentUris?.delete(normalizedPath);
-      state.documentVersions.set(normalizedPath, version);
-      state.documentOpenedAt.set(normalizedPath, Date.now());
-      state.diagnosticPublicationCounts.set(normalizedPath, 0);
-      if (!isClientAlive(state))
-        return;
-      const reopenSent = await safeSendNotification(state.connection, "textDocument/didOpen", { textDocument: { uri, languageId, version, text: content } });
-      if (reopenSent)
-        recordSentContent(state, normalizedPath, version, content, coalescedCount);
-      state.openDocuments.add(normalizedPath);
-      state.openDocumentUris?.set(normalizedPath, uri);
-      if (saved && reopenSent)
-        await sendDidSave(state, uri, content);
-      return;
-    }
-    const changeSent = await safeSendNotification(state.connection, "textDocument/didChange", {
-      textDocument: { uri, version },
-      contentChanges: buildContentChanges(state, normalizedPath, content)
-    });
-    if (changeSent)
-      recordSentContent(state, normalizedPath, version, content, coalescedCount);
-    if (saved && changeSent)
-      await sendDidSave(state, uri, content);
-    return;
-  }
-  state.pendingOpens.add(normalizedPath);
-  state.documentVersions.set(normalizedPath, 0);
-  state.documentOpenedAt.set(normalizedPath, Date.now());
-  state.diagnosticPublicationCounts.set(normalizedPath, 0);
-  clearDiagnosticsForPath(state, normalizedPath);
-  if (!silent) {
-    let fileExists = true;
-    try {
-      await access(filePath);
-    } catch {
-      fileExists = false;
-    }
-    state.watchQueue.enqueue(uri, fileExists ? 2 : 1);
-  }
-  if (!isClientAlive(state))
-    return;
-  const openSent = await safeSendNotification(state.connection, "textDocument/didOpen", { textDocument: { uri, languageId, version: 0, text: content } });
-  if (openSent)
-    recordSentContent(state, normalizedPath, 0, content, coalescedCount);
-  state.pendingOpens.delete(normalizedPath);
-  state.openDocuments.add(normalizedPath);
-  state.closedDocuments?.delete(normalizedPath);
-  state.openDocumentUris?.set(normalizedPath, uri);
-  if (saved && openSent)
-    await sendDidSave(state, uri, content);
-  probeTsserverProjectIdentity({
-    serverId: state.serverId,
-    launchVariant: state.launchVariant,
-    clientRoot: state.root,
-    file: filePath,
-    normalizedFile: normalizedPath,
-    probedFiles: state.projectIdentityProbedFiles ?? (state.projectIdentityProbedFiles = new Set),
-    commandChannel: {
-      executeCommand: (command, args) => runReadOnlyServerCommand(state, command, args)
-    }
-  });
-}
-function enqueueDocumentNotify(state, normalizedPath, run, saved = false) {
-  let queue = state.notifyChangeQueues.get(normalizedPath);
-  if (!queue) {
-    queue = { running: false };
-    state.notifyChangeQueues.set(normalizedPath, queue);
-  }
-  return new Promise((resolve, reject) => {
-    const previous = queue?.pending;
-    const waiters = previous?.waiters ?? [];
-    waiters.push({ resolve, reject });
-    queue.pending = {
-      run,
-      waiters,
-      coalescedCount: (previous?.coalescedCount ?? 0) + (previous ? 1 : 0),
-      saved: saved || previous?.saved === true
-    };
-    if (queue.running)
-      return;
-    queue.running = true;
-    Promise.resolve().then(async () => {
-      try {
-        for (;; ) {
-          const next = queue.pending;
-          if (!next)
-            break;
-          queue.pending = undefined;
-          try {
-            await next.run(next.coalescedCount, next.saved);
-            for (const waiter of next.waiters)
-              waiter.resolve();
-          } catch (error) {
-            for (const waiter of next.waiters)
-              waiter.reject(error);
-          }
-        }
-      } finally {
-        queue.running = false;
-        if (!queue.pending && state.notifyChangeQueues.get(normalizedPath) === queue) {
-          state.notifyChangeQueues.delete(normalizedPath);
-        }
-      }
-    });
-  });
-}
-function cancelDocumentNotifyQueues(state) {
-  for (const queue of state.notifyChangeQueues.values()) {
-    for (const waiter of queue.pending?.waiters ?? [])
-      waiter.resolve();
-    queue.pending = undefined;
-  }
-  state.notifyChangeQueues.clear();
-}
-export function handleNotifyOpen(state, filePath, content, languageId, preserveDiagnostics = false, silent = false, saved = false) {
-  if (!isClientAlive(state))
-    return Promise.resolve();
-  const normalizedPath = normalizeMapKey(filePath);
-  return enqueueDocumentNotify(state, normalizedPath, (coalescedCount, queuedSaved) => handleNotifyOpenOnce(state, filePath, content, languageId, preserveDiagnostics, silent, coalescedCount, queuedSaved), saved);
-}
-async function handleNotifyChangeOnce(state, filePath, content, normalizedPath, coalescedCount = 0) {
-  if (!isClientAlive(state))
-    return;
-  const uri = state.openDocumentUris?.get(normalizedPath) ?? pathToFileURL(filePath).href;
-  if (!state.openDocuments.has(normalizedPath)) {
-    const fallbackOpenSent = await safeSendNotification(state.connection, "textDocument/didOpen", {
-      textDocument: {
-        uri,
-        languageId: "plaintext",
-        version: 0,
-        text: content
-      }
-    });
-    state.documentVersions.set(normalizedPath, 0);
-    state.documentOpenedAt.set(normalizedPath, Date.now());
-    state.diagnosticPublicationCounts.set(normalizedPath, 0);
-    if (fallbackOpenSent)
-      recordSentContent(state, normalizedPath, 0, content, coalescedCount);
-    state.openDocuments.add(normalizedPath);
-    state.openDocumentUris?.set(normalizedPath, uri);
-    return;
-  }
-  const version = (state.documentVersions.get(normalizedPath) ?? 0) + 1;
-  state.documentVersions.set(normalizedPath, version);
-  clearDiagnosticsForPath(state, normalizedPath);
-  const changeSent = await safeSendNotification(state.connection, "textDocument/didChange", {
-    textDocument: { uri, version },
-    contentChanges: buildContentChanges(state, normalizedPath, content)
-  });
-  if (changeSent)
-    recordSentContent(state, normalizedPath, version, content, coalescedCount);
-}
-export function handleNotifyChange(state, filePath, content) {
-  if (!isClientAlive(state))
-    return Promise.resolve();
-  const normalizedPath = normalizeMapKey(filePath);
-  return enqueueDocumentNotify(state, normalizedPath, (coalescedCount) => handleNotifyChangeOnce(state, filePath, content, normalizedPath, coalescedCount));
-}
-export async function closeDocument(state, filePath) {
-  if (!isClientAlive(state))
-    return;
-  const normalizedPath = normalizeMapKey(filePath);
-  if (!state.openDocuments.has(normalizedPath))
-    return;
-  await safeSendNotification(state.connection, "textDocument/didClose", {
-    textDocument: {
-      uri: state.openDocumentUris?.get(normalizedPath) ?? pathToFileURL(filePath).href
-    }
-  });
-  state.openDocuments.delete(normalizedPath);
-  state.closedDocuments?.add(normalizedPath);
-  state.openDocumentUris?.delete(normalizedPath);
-  state.documentVersions.delete(normalizedPath);
-  state.documentOpenedAt.delete(normalizedPath);
-  state.diagnosticPublicationCounts.delete(normalizedPath);
-  state.projectIdentityProbedFiles?.delete(normalizedPath);
-  const retained = state.documentContentHashes.get(normalizedPath);
-  if (retained?.text !== undefined) {
-    state.incrementalTextRetainedEntries = Math.max(0, (state.incrementalTextRetainedEntries ?? 1) - 1);
-    state.incrementalTextRetainedBytes = Math.max(0, (state.incrementalTextRetainedBytes ?? retained.text.length * 2) - retained.text.length * 2);
-    state.incrementalTextBearingPaths?.delete(normalizedPath);
-  }
-  state.documentContentHashes.delete(normalizedPath);
-  clearDiagnosticsForPath(state, normalizedPath);
-}
-function isAtLeastAsAggressiveShutdown(existing, requested) {
-  return !!existing.fast >= !!requested.fast && !!existing.processExiting >= !!requested.processExiting;
-}
-export function clientShutdown(state, options = {}) {
-  if (state.shutdownPromise && state.shutdownOptions && isAtLeastAsAggressiveShutdown(state.shutdownOptions, options)) {
-    return state.shutdownPromise;
-  }
-  state.shutdownOptions = options;
-  const attempt = clientShutdownOnce(state, options);
-  state.shutdownPromise = attempt;
-  attempt.catch(() => {
-    if (state.shutdownPromise === attempt) {
-      state.shutdownPromise = undefined;
-      state.shutdownOptions = undefined;
-    }
-  });
-  return attempt;
-}
-async function clientShutdownOnce(state, options) {
-  const shutdownStart = Date.now();
-  state.shutdownRequested = true;
-  state.isConnected = false;
-  state.isDestroyed = true;
-  for (const timer of state.pendingDiagnostics.values()) {
-    clearTimeout(timer);
-  }
-  state.pendingDiagnostics.clear();
-  state.pendingOpens.clear();
-  state.openDocuments.clear();
-  state.openDocumentUris?.clear();
-  cancelDocumentNotifyQueues(state);
-  state.projectIdentityProbedFiles?.clear();
-  state.watchQueue?.cancel();
-  state.diagnosticEmitter.removeAllListeners();
-  let shutdownRequestTimedOut = false;
-  let exitNotifyTimedOut = false;
-  let shutdownRequestUndelivered = false;
-  let exitNotifyUndelivered = false;
-  try {
-    if (!options.fast) {
-      try {
-        const shutdownAck = await withTimeout(safeSendRequest(state.connection, "shutdown", {}), SHUTDOWN_REQUEST_TIMEOUT_MS);
-        if (shutdownAck === undefined)
-          shutdownRequestUndelivered = true;
-      } catch (err) {
-        if (isShutdownTimeoutError(err, SHUTDOWN_REQUEST_TIMEOUT_MS)) {
-          shutdownRequestTimedOut = true;
-        } else {
-          shutdownRequestUndelivered = true;
-        }
-      }
-      try {
-        const exitSent = await withTimeout(safeSendNotification(state.connection, "exit", {}), EXIT_NOTIFY_TIMEOUT_MS);
-        if (exitSent === false)
-          exitNotifyUndelivered = true;
-      } catch (err) {
-        if (isShutdownTimeoutError(err, EXIT_NOTIFY_TIMEOUT_MS)) {
-          exitNotifyTimedOut = true;
-        } else {
-          exitNotifyUndelivered = true;
-        }
-      }
-    }
-  } finally {
-    disposeClientConnection(state);
-    const pid = state.lspProcess.pid;
-    logLatency({
-      type: "phase",
-      phase: "lsp_client_shutdown",
-      filePath: state.root,
-      durationMs: Date.now() - shutdownStart,
-      metadata: {
-        serverId: state.serverId,
-        pid,
-        fast: !!options.fast,
-        processExiting: !!options.processExiting,
-        shutdownRequestTimedOut,
-        exitNotifyTimedOut,
-        shutdownRequestUndelivered,
-        exitNotifyUndelivered,
-        shutdownOutcome: options.fast ? "fast" : shutdownRequestTimedOut || exitNotifyTimedOut || shutdownRequestUndelivered || exitNotifyUndelivered ? "forced" : "graceful"
-      }
-    });
-    removeLspChild(pid, extractSpawnMarker(state.lspProcess.args)).catch((err) => {
-      logLatency({
-        type: "phase",
-        phase: "lsp_registry_write_failed",
-        filePath: "",
-        durationMs: 0,
-        metadata: { op: "remove", pid, error: String(err) }
-      });
-    });
-    await killProcessTree(state.lspProcess.process, pid, options);
-  }
-}
-async function toWirePosition(state, filePath, line, character) {
-  if (state.positionEncoding === "utf-16")
-    return { line, character };
-  try {
-    const content = await readFile(filePath, "utf8");
-    return {
-      line,
-      character: convertCharacterOffset(state.positionEncoding, lineTextAt(content, line), character)
-    };
-  } catch {
-    return { line, character };
-  }
-}
-function navStaleDropEnabled() {
-  return process.env.DM_LENS_LSP_NAV_STALE_DROP !== "0";
-}
-export async function navRequest(state, method, params, staleCheckPath, timeoutMs = NAV_REQUEST_TIMEOUT_MS, signal = getAmbientAbortSignal()) {
-  if (!isClientAlive(state))
-    return null;
-  const normalizedPath = staleCheckPath !== undefined ? normalizeMapKey(staleCheckPath) : undefined;
-  const requestVersion = normalizedPath !== undefined ? state.documentVersions.get(normalizedPath) : undefined;
-  const requestStartedAt = Date.now();
-  const requestPromise = safeSendRequest(state.connection, method, params, signal);
-  const result = await withTimeout(requestPromise, timeoutMs).catch((err) => {
-    if (isNavTimeoutError(err, timeoutMs)) {
-      recordNavTimeoutTelemetry({
-        method,
-        scope: normalizedPath,
-        budgetMs: timeoutMs,
-        elapsedMs: Date.now() - requestStartedAt
-      });
-      armNavLateAnswerTelemetry({
-        requestPromise,
-        method,
-        scope: normalizedPath,
-        requestStartedAt
-      });
-      return;
-    }
-    if (err instanceof Error && err.message.startsWith("Timeout after")) {
-      return;
-    }
-    throw err;
-  });
-  if (normalizedPath !== undefined && requestVersion !== undefined && navStaleDropEnabled()) {
-    const currentVersion = state.documentVersions.get(normalizedPath);
-    if (currentVersion !== undefined && currentVersion > requestVersion) {
-      return;
-    }
-  }
-  return result;
-}
-function isNavTimeoutError(err, timeoutMs) {
-  return err instanceof Error && err.message === `Timeout after ${timeoutMs}ms`;
-}
-function isShutdownTimeoutError(err, timeoutMs) {
-  return err instanceof Error && err.message === `Timeout after ${timeoutMs}ms`;
-}
-const NAV_REQUEST_NO_PATH_SCOPE = "*no-path*";
-function recordNavTimeoutTelemetry(args) {
-  emitBounded("lsp_nav_request_timeout", `${args.method}:${args.scope ?? NAV_REQUEST_NO_PATH_SCOPE}`, {
-    type: "phase",
-    filePath: args.scope ?? NAV_REQUEST_NO_PATH_SCOPE,
-    durationMs: args.elapsedMs,
-    metadata: { method: args.method, effectiveBudgetMs: args.budgetMs }
-  }, {
-    ledgerKind: "lsp-nav-request-timeout",
-    risingEdgePer: "identity",
-    reason: `timeout budget=${args.budgetMs}ms elapsed=${args.elapsedMs}ms`
-  });
-}
-function armNavLateAnswerTelemetry(args) {
-  args.requestPromise.then(() => {
-    try {
-      const elapsedMs = Date.now() - args.requestStartedAt;
-      emitBounded("lsp_nav_late_answer_discarded", `${args.method}:${args.scope ?? NAV_REQUEST_NO_PATH_SCOPE}`, {
-        type: "phase",
-        filePath: args.scope ?? NAV_REQUEST_NO_PATH_SCOPE,
-        durationMs: elapsedMs,
-        metadata: { method: args.method }
-      }, {
-        ledgerKind: "lsp-nav-late-answer",
-        risingEdgePer: "identity",
-        reason: `late nav answer discarded after ${elapsedMs}ms`
-      });
-    } catch {}
-  }, () => {});
-}
-function chooseLivenessProbe(state) {
-  if (state.operationSupport?.workspaceSymbol === true) {
-    return {
-      method: "workspace/symbol",
-      params: { query: LIVENESS_PING_QUERY }
-    };
-  }
-  const openUri = firstOpenDocumentUri(state);
-  if (openUri === undefined)
-    return;
-  if (state.operationSupport?.documentSymbol === true) {
-    return {
-      method: "textDocument/documentSymbol",
-      params: { textDocument: { uri: openUri } }
-    };
-  }
-  if (state.operationSupport?.hover === true) {
-    return {
-      method: "textDocument/hover",
-      params: {
-        textDocument: { uri: openUri },
-        position: { line: 0, character: 0 }
-      }
-    };
-  }
-  return;
-}
-function firstOpenDocumentUri(state) {
-  for (const normalizedPath of state.openDocuments) {
-    const uri = state.openDocumentUris?.get(normalizedPath);
-    if (uri !== undefined)
-      return uri;
-  }
-  return;
-}
-async function clientPingLiveness(state, timeoutMs = LIVENESS_PING_TIMEOUT_MS) {
-  if (!isClientAlive(state))
-    return false;
-  const probe = chooseLivenessProbe(state);
-  if (probe === undefined) {
-    try {
-      incrementDegradationCount({
-        kind: "lsp-liveness-probe-unsupported",
-        subject: state.serverId,
-        reason: "no advertised request method to probe with (no " + "workspaceSymbolProvider, and no open document with " + "documentSymbolProvider or hoverProvider); liveness from " + "process and connection state only"
-      });
-    } catch {}
-    return isClientAlive(state);
-  }
-  try {
-    await withTimeout(safeSendRequest(state.connection, probe.method, probe.params), timeoutMs);
-  } catch (err) {
-    if (err instanceof Error && err.message.startsWith("Timeout after")) {
-      return false;
-    }
-  }
-  return isClientAlive(state);
-}
-function syncMutationContextSlot(state) {
-  state.activeMutationContext = state.activeMutationDepth === 1 ? state.mutationContextOwner : undefined;
-}
-export async function runServerCommand(state, command, args, timeoutMs = EXECUTE_COMMAND_TIMEOUT_MS, mutationContext) {
-  if (!isClientAlive(state)) {
-    return { executed: false, reason: "lsp client not alive" };
-  }
-  if (!state.advertisedCommands.has(command)) {
-    return {
-      executed: false,
-      reason: `command "${command}" is not advertised by the ${state.serverId} server`
-    };
-  }
-  state.serverEditsAllowed += 1;
-  state.activeMutationDepth = (state.activeMutationDepth ?? 0) + 1;
-  const isMutationContextOwner = state.activeMutationDepth === 1;
-  if (isMutationContextOwner) {
-    state.mutationContextOwner = mutationContext;
-  }
-  syncMutationContextSlot(state);
-  try {
-    let result;
-    try {
-      result = await withTimeout(safeSendRequest(state.connection, "workspace/executeCommand", {
-        command,
-        arguments: args ?? []
-      }), timeoutMs);
-    } catch (err) {
-      if (err instanceof Error && err.message.startsWith("Timeout after")) {
-        return {
-          executed: false,
-          reason: `workspace/executeCommand timed out after ${timeoutMs}ms — the command may still be applying server-side`
-        };
-      }
-      throw err;
-    }
-    return { executed: true, result };
-  } finally {
-    state.serverEditsAllowed -= 1;
-    state.activeMutationDepth = Math.max(0, (state.activeMutationDepth ?? 0) - 1);
-    if (isMutationContextOwner) {
-      state.mutationContextOwner = undefined;
-    }
-    syncMutationContextSlot(state);
-  }
-}
-export async function runReadOnlyServerCommand(state, command, args, timeoutMs = PROBE_COMMAND_TIMEOUT_MS) {
-  if (!isClientAlive(state)) {
-    return { executed: false, reason: "lsp client not alive" };
-  }
-  if (!state.advertisedCommands.has(command)) {
-    return {
-      executed: false,
-      reason: `command "${command}" is not advertised by the ${state.serverId} server`
-    };
-  }
-  try {
-    const result = await withTimeout(safeSendRequest(state.connection, "workspace/executeCommand", {
-      command,
-      arguments: args ?? []
-    }), timeoutMs);
-    return { executed: true, result };
-  } catch (err) {
-    if (err instanceof Error && err.message.startsWith("Timeout after")) {
-      return {
-        executed: false,
-        reason: `workspace/executeCommand timed out after ${timeoutMs}ms`
-      };
-    }
-    throw err;
-  }
-}
-function validateWorkspaceEditVersions(state, edit) {
-  for (const change of edit.documentChanges ?? []) {
-    if (typeof change !== "object" || change === null || !("textDocument" in change))
-      continue;
-    const textDocument = change.textDocument;
-    if (!textDocument || typeof textDocument.uri !== "string" || textDocument.version == null)
-      continue;
-    const current = state.documentVersions.get(normalizeMapKey(uriToPath(textDocument.uri)));
-    if (current === undefined || current !== textDocument.version) {
-      throw new Error(`stale workspace edit document version for ${textDocument.uri}`);
-    }
-  }
-}
-function stripDocumentVersions(edit) {
-  if (!Array.isArray(edit.documentChanges))
-    return edit;
-  const documentChanges = edit.documentChanges.map((change) => {
-    if (typeof change === "object" && change !== null && "textDocument" in change && "edits" in change) {
-      const textDocument = change.textDocument;
-      if (textDocument && typeof textDocument.version === "number") {
-        return {
-          ...change,
-          textDocument: { ...textDocument, version: null }
-        };
-      }
-    }
-    return change;
-  });
-  return { ...edit, documentChanges };
-}
-export async function normalizeClientWorkspaceEdit(state, edit) {
-  validateWorkspaceEditVersions(state, edit);
-  const normalized = await normalizeWorkspaceEditToUtf16(edit, state.positionEncoding, state.root);
-  return stripDocumentVersions(normalized);
-}
-async function resolveCodeActionBestEffort(state, action) {
-  if (!isClientAlive(state))
-    return action;
-  if (action.edit) {
-    return {
-      ...action,
-      edit: await normalizeClientWorkspaceEdit(state, action.edit)
-    };
-  }
-  if (!state.operationSupport.codeActionResolve) {
-    recordDegradationOnce({
-      kind: "lsp-capability-skip",
-      subject: `${state.serverId}:codeAction/resolve`,
-      reason: "server did not advertise codeActionProvider.resolveProvider"
-    });
-    return action;
-  }
-  let resolved;
-  try {
-    resolved = await withTimeout(safeSendRequest(state.connection, "codeAction/resolve", action), NAV_REQUEST_TIMEOUT_MS);
-  } catch {
-    return action;
-  }
-  if (!resolved || typeof resolved !== "object")
-    return action;
-  const merged = { ...action, ...resolved };
-  return merged.edit ? {
-    ...merged,
-    edit: await normalizeClientWorkspaceEdit(state, merged.edit)
-  } : merged;
-}
-export async function createLSPClient(options) {
-  installCrashGuard();
-  const { serverId, process: lspProcess, root, sessionCwd, initialization, initializeTimeoutMs = INITIALIZE_TIMEOUT_MS, launchVariant, onDiagnosticsPublished } = options;
-  recordLspChild({
-    pid: lspProcess.pid,
-    serverId,
-    command: lspProcess.command,
-    marker: extractSpawnMarker(lspProcess.args),
-    sessionIdentity: {
-      projectRoot: sessionCwd ?? process.cwd(),
-      rootSource: sessionCwd ? "service-cwd" : "lsp-fallback",
-      startedAt: new Date(workspaceDiagnosticsCacheSessionStart()).toISOString()
-    }
-  }).catch((err) => {
-    logLatency({
-      type: "phase",
-      phase: "lsp_registry_write_failed",
-      filePath: "",
-      durationMs: 0,
-      metadata: { op: "record", pid: lspProcess.pid, error: String(err) }
-    });
-  });
-  const startupState = {
-    exitCode: null,
-    exitSignal: null,
-    closeCode: null,
-    closeSignal: null,
-    stderr: ""
-  };
-  const stderrRing = [];
-  const MAX_STDERR_LINES = 100;
-  const onStderr = (chunk) => {
-    stderrRing.push(chunk.toString());
-    if (stderrRing.length > MAX_STDERR_LINES)
-      stderrRing.shift();
-    if (startupState.stderr.length < 4096) {
-      startupState.stderr += chunk.toString();
-    }
-  };
-  const recentStderr = (lines = 10) => stderrRing.slice(-lines).join("").trim();
-  const checkProcessAlive = () => {
-    const exited = lspProcess.process.exitCode;
-    if (exited !== null) {
-      const tail = recentStderr(20);
-      return `LSP server ${serverId} exited with code ${exited}${tail ? `. stderr: ${tail}` : ""}`;
-    }
-    if (lspProcess.process.killed) {
-      return `LSP server ${serverId} was killed`;
-    }
-    return;
-  };
-  const onProcessExit = (code, signal) => {
-    startupState.exitCode = code;
-    startupState.exitSignal = signal;
-  };
-  const onProcessClose = (code, signal) => {
-    startupState.closeCode = code;
-    startupState.closeSignal = signal;
-  };
-  lspProcess.stderr.on("data", onStderr);
-  lspProcess.process.on("exit", onProcessExit);
-  lspProcess.process.on("close", onProcessClose);
-  const streamErrorHandler = (_label) => (err) => {
-    if (err.code === "ERR_STREAM_DESTROYED" || err.code === "ERR_STREAM_WRITE_AFTER_END" || err.code === "EPIPE" || err.code === "ECONNRESET")
-      return;
-  };
-  lspProcess.stdin.on("error", streamErrorHandler("stdin"));
-  lspProcess.stdout.on("error", streamErrorHandler("stdout"));
-  lspProcess.stderr.on("error", streamErrorHandler("stderr"));
-  const connection = createMessageConnection(new StreamMessageReader(lspProcess.stdout), new StreamMessageWriter(lspProcess.stdin));
-  const diagnosticEmitter = new EventEmitter;
-  diagnosticEmitter.setMaxListeners(50);
-  const state = {
-    isConnected: true,
-    isDestroyed: false,
-    shutdownRequested: false,
-    shutdownPromise: undefined,
-    shutdownOptions: undefined,
-    exitedAt: undefined,
-    connectionDisposed: false,
-    lastError: undefined,
-    connection,
-    pushDiagnostics: new Map,
-    pushDiagnosticTimestamps: new Map,
-    documentPullDiagnostics: new Map,
-    documentPullDiagnosticTimestamps: new Map,
-    pullFailureHistory: [],
-    pendingDiagnostics: new Map,
-    diagnosticPublicationCounts: new Map,
-    documentOpenedAt: new Map,
-    diagnosticEmitter,
-    diagnosticsVersion: 0,
-    diagnosticsVersionsByPath: new Map,
-    documentVersions: new Map,
-    notifyChangeQueues: new Map,
-    diagnosticDocVersions: new Map,
-    documentContentHashes: new Map,
-    incrementalTextRetainedEntries: 0,
-    incrementalTextBearingPaths: new Set,
-    incrementalTextRetainedBytes: 0,
-    diagnosticBindings: new Map,
-    pullResultIds: new Map,
-    documentPullDiagnosticsBySource: new Map,
-    pullGenerations: new Map,
-    pullRequestSequences: new Map,
-    workspacePullResultCache: new Map,
-    openDocuments: new Set,
-    emptyFirstPublishHoldSpent: false,
-    closedDocuments: new Set,
-    openDocumentUris: new Map,
-    pendingOpens: new Set,
-    projectIdentityProbedFiles: new Set,
-    workspaceDiagnosticsSupport: undefined,
-    operationSupport: undefined,
-    staticDiagnosticsMode: "push-only",
-    positionEncoding: "utf-16",
-    syncKind: TEXT_DOCUMENT_SYNC_KIND_FULL,
-    dynamicRegistrations: new Map,
-    advertisedCommands: new Set,
-    serverEditsAllowed: 0,
-    activeMutationDepth: 0,
-    serverId,
-    launchVariant,
-    root,
-    lspProcess,
-    watchQueue: undefined
-  };
-  activeLspClientSet().add(state);
-  state.watchQueue = new WatchedFilesQueue((changes) => {
-    if (!isClientAlive(state))
-      return;
-    safeSendNotification(state.connection, "workspace/didChangeWatchedFiles", { changes });
-  });
-  setupIncomingHandlers(state, initialization, onDiagnosticsPublished);
-  connection.listen();
-  setupConnectionLifecycle(state, recentStderr);
-  let initResult;
-  try {
-    initResult = await withTimeout(safeSendRequest(connection, "initialize", {
-      processId: process.pid,
-      rootUri: pathToFileURL(root).href,
-      workspaceFolders: [
-        { name: "workspace", uri: pathToFileURL(root).href }
-      ],
-      capabilities: CLIENT_CAPABILITIES,
-      initializationOptions: initialization
-    }), initializeTimeoutMs);
-  } catch (err) {
-    state.shutdownRequested = true;
-    const pid = lspProcess.pid;
-    killProcessTree(lspProcess.process, pid);
-    removeLspChild(pid, extractSpawnMarker(lspProcess.args)).catch((err) => {
-      logLatency({
-        type: "phase",
-        phase: "lsp_registry_write_failed",
-        filePath: "",
-        durationMs: 0,
-        metadata: { op: "remove", pid, error: String(err) }
-      });
-    });
-    setTimeout(() => {
-      if (lspProcess.process.exitCode === null && lspProcess.process.signalCode === null && process.platform !== "win32") {
-        lspProcess.process.kill("SIGKILL");
-      }
-    }, 2000);
-    throw err;
-  } finally {
-    lspProcess.stderr.off("data", onStderr);
-  }
-  if (initResult === undefined) {
-    const compactStderr = startupState.stderr.replace(/\s+/g, " ").trim().slice(0, 320);
-    const reinstallHint = serverId === "cpp" ? "Install clangd (LLVM/clang-tools) and ensure clangd.exe is on PATH." : `Try reinstalling: npm install -g ${serverId}-language-server.`;
-    const telemetry = [
-      `pid=${lspProcess.pid}`,
-      `exitCode=${startupState.exitCode ?? "none"}`,
-      `exitSignal=${startupState.exitSignal ?? "none"}`,
-      `closeCode=${startupState.closeCode ?? "none"}`,
-      `closeSignal=${startupState.closeSignal ?? "none"}`,
-      `root=${root}`,
-      compactStderr ? `stderr=${compactStderr}` : "stderr=<empty>"
-    ].join(" ");
-    throw new Error(`[lsp] ${serverId} failed to initialize - stream may have been destroyed. ` + `The server binary may be missing or crashed immediately. ${reinstallHint} ` + `telemetry: ${telemetry}`);
-  }
-  state.workspaceDiagnosticsSupport = detectWorkspaceDiagnosticsSupport(initResult);
-  state.operationSupport = detectOperationSupport(initResult);
-  const capabilities = initResult?.capabilities ?? {};
-  const workspace = isCapabilityRecord(capabilities.workspace) ? capabilities.workspace : undefined;
-  const fileOperations = isCapabilityRecord(workspace) ? workspace.fileOperations : undefined;
-  const malformedFileOperationRegistrations = new Set;
-  if (isCapabilityRecord(fileOperations)) {
-    for (const operation of ["willRename", "didRename"]) {
-      if (fileOperations[operation] !== undefined && parseFileOperationFilters(fileOperations[operation]) === undefined) {
-        malformedFileOperationRegistrations.add(operation);
-      }
-    }
-  }
-  state.fileOperationMalformedRegistrations = malformedFileOperationRegistrations;
-  if (isCapabilityRecord(fileOperations)) {
-    state.fileOperationFilters = {
-      willRename: parseFileOperationFilters(fileOperations.willRename),
-      didRename: parseFileOperationFilters(fileOperations.didRename)
-    };
-  }
-  state.positionEncoding = negotiatePositionEncoding(initResult?.capabilities);
-  state.syncKind = negotiateSyncKind(initResult?.capabilities);
-  state.saveOptions = negotiateSaveOptions(initResult?.capabilities);
-  state.rawCapabilityKeys = Object.keys(initResult?.capabilities ?? {}).sort((a, b) => a.localeCompare(b));
-  for (const cmd of detectExecuteCommands(initResult)) {
-    state.advertisedCommands.add(cmd);
-  }
-  state.staticDiagnosticsMode = state.workspaceDiagnosticsSupport.mode;
-  await safeSendNotification(connection, "initialized", {});
-  if (initialization) {
-    await safeSendNotification(connection, "workspace/didChangeConfiguration", {
-      settings: initialization
-    });
-  }
-  return {
-    serverId,
-    root,
-    connection,
-    isAlive: () => isClientAlive(state),
-    processExited: () => lspProcess.process.exitCode !== null || lspProcess.process.killed === true,
-    wasShutdownIntentional: () => state.shutdownRequested,
-    getExitedAt: () => state.exitedAt,
-    recentStderr: (lines) => recentStderr(lines),
-    getPullFailureHistory: () => state.pullFailureHistory.map((entry) => ({
-      ...entry,
-      message: entry.message.slice(0, 200)
-    })),
-    checkAlive: () => checkProcessAlive(),
-    pingLiveness: (timeoutMs) => clientPingLiveness(state, timeoutMs),
-    getProcessPid: () => lspProcess.pid,
-    notify: {
-      async open(filePath, content, languageId, preserveDiagnostics, silent, saved) {
-        return handleNotifyOpen(state, filePath, content, languageId, preserveDiagnostics, silent, saved);
-      },
-      async change(filePath, content) {
-        return handleNotifyChange(state, filePath, content);
-      },
-      watchedFileChange(filePath, type) {
-        handleNotifyExternalChange(state, filePath, type);
-      }
-    },
-    getDiagnostics(filePath) {
-      return getMergedDiagnosticsForPath(state, normalizeMapKey(filePath));
-    },
-    getDiagnosticBinding(filePath) {
-      return state.diagnosticBindings.get(normalizeMapKey(filePath));
-    },
-    getDiagnosticsVersionForPath(filePath) {
-      return diagnosticsVersionForPath(state, normalizeMapKey(filePath));
-    },
-    getAllDiagnostics() {
-      const result = new Map;
-      const keys = new Set([
-        ...state.pushDiagnostics.keys(),
-        ...state.documentPullDiagnostics.keys()
-      ]);
-      for (const key of keys) {
-        result.set(key, {
-          diags: getMergedDiagnosticsForPath(state, key),
-          ts: Math.max(state.pushDiagnosticTimestamps.get(key) ?? 0, state.documentPullDiagnosticTimestamps.get(key) ?? 0),
-          binding: state.diagnosticBindings.get(key)
-        });
-      }
-      return result;
-    },
-    getTrackedDiagnosticPaths() {
-      return [
-        ...new Set([
-          ...state.pushDiagnostics.keys(),
-          ...state.documentPullDiagnostics.keys()
-        ])
-      ].map((filePath) => process.platform === "win32" ? filePath.replace(/\//g, "\\") : filePath);
-    },
-    pruneDiagnostics(predicate) {
-      let removed = 0;
-      const keys = new Set([
-        ...state.pushDiagnostics.keys(),
-        ...state.documentPullDiagnostics.keys()
-      ]);
-      for (const key of keys) {
-        const diags = getMergedDiagnosticsForPath(state, key);
-        const ts = Math.max(state.pushDiagnosticTimestamps.get(key) ?? 0, state.documentPullDiagnosticTimestamps.get(key) ?? 0);
-        if (!predicate(key, ts, diags))
-          continue;
-        clearDiagnosticsForPath(state, key);
-        removed++;
-      }
-      return removed;
-    },
-    getWorkspaceDiagnosticsSupport() {
-      return state.workspaceDiagnosticsSupport;
-    },
-    requestWorkspaceDiagnostics(budgetMs) {
-      return clientRequestWorkspaceDiagnostics(state, budgetMs);
-    },
-    getOperationSupport() {
-      return state.operationSupport;
-    },
-    getMalformedFileOperationRegistrations() {
-      return state.fileOperationMalformedRegistrations ?? new Set;
-    },
-    getAdvertisedCommands() {
-      return [...state.advertisedCommands];
-    },
-    getRawCapabilityKeys() {
-      return state.rawCapabilityKeys ?? [];
-    },
-    getLaunchVariant() {
-      return state.launchVariant;
-    },
-    async executeCommand(command, args, mutationContext) {
-      return runServerCommand(state, command, args, EXECUTE_COMMAND_TIMEOUT_MS, mutationContext);
-    },
-    async executeReadOnlyCommand(command, args) {
-      return runReadOnlyServerCommand(state, command, args);
-    },
-    get diagnosticsVersion() {
-      return state.diagnosticsVersion;
-    },
-    async waitForDiagnostics(filePath, timeoutMs = DIAGNOSTICS_WAIT_TIMEOUT_MS, options) {
-      return clientWaitForDiagnostics(state, filePath, timeoutMs, options);
-    },
-    async definition(filePath, line, character) {
-      const result = await navRequest(state, "textDocument/definition", {
-        textDocument: { uri: pathToFileURL(filePath).href },
-        position: await toWirePosition(state, filePath, line, character)
-      }, filePath);
-      if (!result)
-        return [];
-      return Array.isArray(result) ? result : [result];
-    },
-    async typeDefinition(filePath, line, character) {
-      const result = await navRequest(state, "textDocument/typeDefinition", {
-        textDocument: { uri: pathToFileURL(filePath).href },
-        position: await toWirePosition(state, filePath, line, character)
-      }, filePath);
-      if (!result)
-        return [];
-      return Array.isArray(result) ? result : [result];
-    },
-    async declaration(filePath, line, character) {
-      const result = await navRequest(state, "textDocument/declaration", {
-        textDocument: { uri: pathToFileURL(filePath).href },
-        position: await toWirePosition(state, filePath, line, character)
-      }, filePath);
-      if (!result)
-        return [];
-      return Array.isArray(result) ? result : [result];
-    },
-    async references(filePath, line, character, includeDeclaration = true) {
-      const result = await navRequest(state, "textDocument/references", {
-        textDocument: { uri: pathToFileURL(filePath).href },
-        position: await toWirePosition(state, filePath, line, character),
-        context: { includeDeclaration }
-      }, filePath);
-      return result ?? [];
-    },
-    async hover(filePath, line, character) {
-      const result = await navRequest(state, "textDocument/hover", {
-        textDocument: { uri: pathToFileURL(filePath).href },
-        position: await toWirePosition(state, filePath, line, character)
-      }, filePath);
-      return result ?? null;
-    },
-    async signatureHelp(filePath, line, character) {
-      const result = await navRequest(state, "textDocument/signatureHelp", {
-        textDocument: { uri: pathToFileURL(filePath).href },
-        position: await toWirePosition(state, filePath, line, character)
-      }, filePath);
-      return result ?? null;
-    },
-    async documentSymbol(filePath) {
-      const result = await navRequest(state, "textDocument/documentSymbol", { textDocument: { uri: pathToFileURL(filePath).href } }, filePath);
-      return result ?? [];
-    },
-    isDocumentOpen(filePath) {
-      return state.openDocuments.has(normalizeMapKey(filePath));
-    },
-    openDocumentPaths() {
-      return [...state.openDocuments];
-    },
-    isBusy() {
-      return (activeRequestsByConnection.get(connection) ?? 0) > 0;
-    },
-    getDocumentUri(filePath) {
-      return state.openDocumentUris?.get(normalizeMapKey(filePath));
-    },
-    async workspaceSymbol(query) {
-      if (!isClientAlive(state))
-        return [];
-      const result = await navRequest(state, "workspace/symbol", {
-        query
-      });
-      return result ?? [];
-    },
-    async codeAction(filePath, line, character, endLine, endCharacter) {
-      if (!isClientAlive(state))
-        return [];
-      const uri = pathToFileURL(filePath).href;
-      const result = await navRequest(state, "textDocument/codeAction", {
-        textDocument: { uri },
-        range: {
-          start: await toWirePosition(state, filePath, line, character),
-          end: await toWirePosition(state, filePath, endLine, endCharacter)
-        },
-        context: {
-          diagnostics: getMergedDiagnosticsForPath(state, normalizeMapKey(filePath))
-        }
-      }, filePath);
-      if (!result || !Array.isArray(result))
-        return [];
-      const actions = result.filter((item) => typeof item === "object" && item !== null && ("title" in item));
-      return Promise.all(actions.map((action) => resolveCodeActionBestEffort(state, action)));
-    },
-    async rename(filePath, line, character, newName) {
-      const result = await navRequest(state, "textDocument/rename", {
-        textDocument: { uri: pathToFileURL(filePath).href },
-        position: await toWirePosition(state, filePath, line, character),
-        newName
-      }, filePath);
-      return result ? await normalizeClientWorkspaceEdit(state, result) : null;
-    },
-    closeDocument: (filePath) => closeDocument(state, filePath),
-    async willRenameFiles(oldFilePath, newFilePath) {
-      if (!isClientAlive(state))
-        return null;
-      const oldUri = pathToFileURL(oldFilePath).href;
-      const newUri = pathToFileURL(newFilePath).href;
-      if (!await fileOperationFiltersMatch(state.fileOperationFilters?.willRename, oldUri, newUri, oldFilePath, newFilePath)) {
-        recordDegradationOnce({
-          kind: "lsp-capability-skip",
-          subject: `${state.serverId}:workspace/willRenameFiles:filter`,
-          reason: "filter-mismatch"
-        });
-        return null;
-      }
-      const result = await navRequest(state, "workspace/willRenameFiles", {
-        files: [
-          {
-            oldUri,
-            newUri
-          }
-        ]
-      });
-      return result ? await normalizeClientWorkspaceEdit(state, result) : null;
-    },
-    async didRenameFiles(oldFilePath, newFilePath, oldUri, newUri) {
-      if (!isClientAlive(state))
-        return;
-      const wireOldUri = oldUri ?? pathToFileURL(oldFilePath).href;
-      const wireNewUri = newUri ?? pathToFileURL(newFilePath).href;
-      if (!await fileOperationFiltersMatch(state.fileOperationFilters?.didRename, wireOldUri, wireNewUri, oldFilePath, newFilePath)) {
-        recordDegradationOnce({
-          kind: "lsp-capability-skip",
-          subject: `${state.serverId}:workspace/didRenameFiles:filter`,
-          reason: "filter-mismatch"
-        });
-        return;
-      }
-      await safeSendNotification(state.connection, "workspace/didRenameFiles", {
-        files: [
-          {
-            oldUri: wireOldUri,
-            newUri: wireNewUri
-          }
-        ]
-      });
-    },
-    async implementation(filePath, line, character) {
-      const result = await navRequest(state, "textDocument/implementation", {
-        textDocument: { uri: pathToFileURL(filePath).href },
-        position: await toWirePosition(state, filePath, line, character)
-      }, filePath);
-      if (!result)
-        return [];
-      return Array.isArray(result) ? result : [result];
-    },
-    async prepareCallHierarchy(filePath, line, character) {
-      const result = await navRequest(state, "textDocument/prepareCallHierarchy", {
-        textDocument: { uri: pathToFileURL(filePath).href },
-        position: await toWirePosition(state, filePath, line, character)
-      }, filePath);
-      if (!result)
-        return [];
-      return Array.isArray(result) ? result : [result];
-    },
-    async incomingCalls(item) {
-      const result = await navRequest(state, "callHierarchy/incomingCalls", { item });
-      return result ?? [];
-    },
-    async outgoingCalls(item) {
-      const result = await navRequest(state, "callHierarchy/outgoingCalls", { item });
-      return result ?? [];
-    },
-    async shutdown(options) {
-      return clientShutdown(state, options);
-    }
-  };
-}
-async function safeSendNotification(connection, method, params) {
-  try {
-    await connection.sendNotification(method, params);
-    return true;
-  } catch (err) {
-    if (isStreamError(err)) {
-      return false;
-    }
-    throw err;
-  }
-}
-const activeRequestsByConnection = new WeakMap;
-async function safeSendRequest(connection, method, params, signal, settlement) {
-  if (signal?.aborted)
-    return;
-  let tokenSource;
-  let onAbort;
-  if (signal) {
-    tokenSource = new CancellationTokenSource;
-    onAbort = () => tokenSource?.cancel();
-    signal.addEventListener("abort", onAbort, { once: true });
-  }
-  const send = () => tokenSource ? connection.sendRequest(method, params, tokenSource.token) : connection.sendRequest(method, params);
-  activeRequestsByConnection.set(connection, (activeRequestsByConnection.get(connection) ?? 0) + 1);
-  try {
-    const MAX_ATTEMPTS = 2;
-    for (let attempt = 1;; attempt++) {
-      try {
-        return await send();
-      } catch (err) {
-        if (isCancellationError(err)) {
-          if (settlement)
-            settlement.cancelled = true;
-          return;
-        }
-        if (isStreamError(err)) {
-          return;
-        }
-        if (isContentModifiedError(err)) {
-          if (attempt < MAX_ATTEMPTS && !signal?.aborted)
-            continue;
-          return;
-        }
-        throw err;
-      }
-    }
-  } finally {
-    const remaining = (activeRequestsByConnection.get(connection) ?? 1) - 1;
-    if (remaining > 0)
-      activeRequestsByConnection.set(connection, remaining);
-    else
-      activeRequestsByConnection.delete(connection);
-    if (signal && onAbort)
-      signal.removeEventListener("abort", onAbort);
-    tokenSource?.dispose();
-  }
-}
-function isCancellationError(err) {
-  const code = err?.code;
-  return code === -32800 || code === -32802;
-}
-function isContentModifiedError(err) {
-  return err?.code === -32801;
-}
-function isStreamError(err) {
-  if (!(err instanceof Error))
-    return false;
-  const msg = err.message.toLowerCase();
-  return msg.includes("stream") || msg.includes("destroyed") || msg.includes("closed") || msg.includes("disposed") || msg.includes("cancelled") || err.code === "ERR_STREAM_DESTROYED" || err.code === "ERR_STREAM_WRITE_AFTER_END" || err.code === "EPIPE";
-}
-function positiveIntFromEnv(name, fallback) {
-  const raw = process.env[name];
-  if (!raw)
-    return fallback;
-  const parsed = Number.parseInt(raw, 10);
-  if (!Number.isFinite(parsed) || parsed <= 0)
-    return fallback;
-  return parsed;
-}
-function detectWorkspaceDiagnosticsSupport(initResult) {
-  const capabilities = typeof initResult === "object" && initResult !== null ? initResult.capabilities : undefined;
-  const diagnosticProvider = capabilities?.diagnosticProvider;
-  if (!diagnosticProvider) {
-    return {
-      advertised: false,
-      mode: "push-only",
-      workspaceDiagnostics: false,
-      diagnosticProviderKind: "none"
-    };
-  }
-  if (typeof diagnosticProvider === "boolean") {
-    return {
-      advertised: diagnosticProvider,
-      mode: diagnosticProvider ? "pull" : "push-only",
-      workspaceDiagnostics: false,
-      diagnosticProviderKind: "boolean"
-    };
-  }
-  if (typeof diagnosticProvider === "object") {
-    return {
-      advertised: true,
-      mode: "pull",
-      workspaceDiagnostics: diagnosticProvider.workspaceDiagnostics === true,
-      diagnosticProviderKind: "object"
-    };
-  }
-  return {
-    advertised: false,
-    mode: "push-only",
-    workspaceDiagnostics: false,
-    diagnosticProviderKind: typeof diagnosticProvider
-  };
-}
-function detectExecuteCommands(initResult) {
-  const capabilities = typeof initResult === "object" && initResult !== null ? initResult.capabilities : undefined;
-  const provider = capabilities?.executeCommandProvider;
-  if (typeof provider !== "object" || provider === null)
-    return [];
-  const commands = provider.commands;
-  if (!Array.isArray(commands))
-    return [];
-  return commands.filter((cmd) => typeof cmd === "string");
-}
-function detectOperationSupport(initResult) {
-  const capabilities = typeof initResult === "object" && initResult !== null ? initResult.capabilities : undefined;
-  const hasProvider = (key) => {
-    const value = capabilities?.[key];
-    if (value === undefined || value === null)
-      return false;
-    if (typeof value === "boolean")
-      return value;
-    return isCapabilityRecord(value);
-  };
-  const codeActionProvider = capabilities?.codeActionProvider;
-  const workspace = capabilities?.workspace;
-  const fileOperations = isCapabilityRecord(workspace) ? workspace.fileOperations : undefined;
-  return {
-    definition: hasProvider("definitionProvider"),
-    typeDefinition: hasProvider("typeDefinitionProvider"),
-    declaration: hasProvider("declarationProvider"),
-    references: hasProvider("referencesProvider"),
-    hover: hasProvider("hoverProvider"),
-    signatureHelp: hasProvider("signatureHelpProvider"),
-    documentSymbol: hasProvider("documentSymbolProvider"),
-    workspaceSymbol: hasProvider("workspaceSymbolProvider"),
-    codeAction: hasProvider("codeActionProvider"),
-    codeActionResolve: isCapabilityRecord(codeActionProvider) && codeActionProvider.resolveProvider === true,
-    rename: hasProvider("renameProvider"),
-    willRenameFiles: isCapabilityRecord(fileOperations) && isFileOperationRegistrationOptions(fileOperations.willRename),
-    didRenameFiles: isCapabilityRecord(fileOperations) && isFileOperationRegistrationOptions(fileOperations.didRename),
-    implementation: hasProvider("implementationProvider"),
-    callHierarchy: hasProvider("callHierarchyProvider")
-  };
-}
-function isCapabilityRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isFileOperationRegistrationOptions(value) {
-  return parseFileOperationFilters(value) !== undefined;
-}
-function parseFileOperationFilters(value) {
-  if (!isCapabilityRecord(value) || !Array.isArray(value.filters)) {
-    return;
-  }
-  const filters = [];
-  for (const entry of value.filters) {
-    if (!isCapabilityRecord(entry))
-      return;
-    const pattern = entry.pattern;
-    if (!isCapabilityRecord(pattern) || typeof pattern.glob !== "string" || pattern.glob.trim() === "") {
-      return;
-    }
-    if (entry.scheme !== undefined && (typeof entry.scheme !== "string" || entry.scheme.trim() === "" || !/^[A-Za-z][A-Za-z0-9+.-]*$/.test(entry.scheme))) {
-      return;
-    }
-    const matches = pattern.matches;
-    if (matches !== undefined && matches !== "file" && matches !== "folder") {
-      return;
-    }
-    if (pattern.options !== undefined && !isCapabilityRecord(pattern.options)) {
-      return;
-    }
-    const options = isCapabilityRecord(pattern.options) ? pattern.options : undefined;
-    if (options?.ignoreCase !== undefined && typeof options.ignoreCase !== "boolean") {
-      return;
-    }
-    filters.push({
-      scheme: entry.scheme?.toLowerCase(),
-      glob: pattern.glob,
-      matches: matches === "file" || matches === "folder" ? matches : undefined,
-      ignoreCase: options?.ignoreCase === true
-    });
-  }
-  return filters;
-}
-async function fileOperationFiltersMatch(filters, oldUri, newUri, oldFilePath, newFilePath) {
-  if (!filters || filters.length === 0)
-    return false;
-  const candidates = [oldUri, newUri].flatMap(fileOperationUriCandidates);
-  const entityKind = filters.some((filter) => filter.matches !== undefined) ? await probeRenameEntityKind(oldFilePath, newFilePath) : undefined;
-  for (const filter of filters) {
-    if (filter.scheme !== undefined && filter.scheme !== "file")
-      continue;
-    if (filter.matches !== undefined && filter.matches !== entityKind)
-      continue;
-    for (const candidate of candidates) {
-      try {
-        if (minimatch(candidate, filter.glob, {
-          nocase: filter.ignoreCase,
-          dot: true
-        })) {
-          return true;
-        }
-      } catch {}
-    }
-  }
-  return false;
-}
-function fileOperationUriCandidates(uri) {
-  let parsed;
-  try {
-    parsed = new URL(uri);
-  } catch {
-    return [];
-  }
-  if (parsed.protocol.toLowerCase() !== "file:")
-    return [];
-  let uriPath;
-  try {
-    uriPath = decodeURIComponent(parsed.pathname).replace(/\\/g, "/");
-  } catch {
-    return [];
-  }
-  return [uriPath];
-}
-async function probeRenameEntityKind(oldFilePath, newFilePath) {
-  for (const filePath of [oldFilePath, newFilePath]) {
-    try {
-      const info = await lstat(filePath);
-      return info.isDirectory() ? "folder" : "file";
-    } catch {}
-  }
-  return;
-}