@duckmind/dm-darwin-x64 0.66.4 → 0.66.6

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

@@ -0,0 +1,2943 @@
+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);
+  countPublication(state, normalizedPath);
+}
+function countPublication(state, normalizedPath) {
+  const counts = state.publicationStoreCountsByPath;
+  if (!counts)
+    return;
+  const { sent } = publicationCountsForPath(state, normalizedPath);
+  if (sent === 0)
+    return;
+  counts.set(normalizedPath, Math.min((counts.get(normalizedPath) ?? 0) + 1, sent));
+}
+export function rebaselineForRulesRefresh(state) {
+  const counts = state.publicationStoreCountsByPath;
+  for (const [normalizedPath, published] of counts) {
+    counts.set(normalizedPath, published - 1);
+  }
+  for (const normalizedPath of state.pendingDiagnostics.keys()) {
+    if (counts.has(normalizedPath) || publicationCountsForPath(state, normalizedPath).sent === 0)
+      continue;
+    counts.set(normalizedPath, -1);
+  }
+  logLatency({
+    type: "phase",
+    phase: "lsp_rules_refreshed",
+    filePath: state.root,
+    durationMs: 0,
+    metadata: { serverId: state.serverId, rebaselinedPaths: counts.size }
+  });
+}
+export function publicationCountsForPath(state, normalizedPath) {
+  const lastSent = state.documentVersions.get(normalizedPath);
+  return {
+    sent: (lastSent === undefined ? 0 : lastSent + 1) + (state.expectedPublicationsBeyondSends?.get(normalizedPath) ?? 0),
+    published: state.publicationStoreCountsByPath?.get(normalizedPath) ?? 0
+  };
+}
+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);
+    countPublication(state, normalizedPath);
+  }
+  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);
+  const hash = hashDiagnosticContent(content);
+  state.documentContentHashes.set(normalizedPath, {
+    version,
+    hash,
+    changedAtMs: previous?.hash === hash ? previous.changedAtMs : Date.now(),
+    openedAtMs: previous?.openedAtMs ?? Date.now(),
+    openedHash: previous === undefined ? hash : previous.openedHash,
+    ...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,
+        changedAtMs: binding.changedAtMs,
+        openedAtMs: binding.openedAtMs,
+        openedHash: binding.openedHash
+      });
+      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);
+    const docVersion = params.version;
+    if (docVersion === undefined && getStrategy(state.serverId, state.launchVariant).publishesOnClose) {
+      return;
+    }
+    if (state.closedDocuments?.has(normalizedPath)) {
+      countPublication(state, normalizedPath);
+      return;
+    }
+    onDiagnosticsPublished?.(state.serverId);
+    const newDiags = normalizeLspDiagnostics(params.diagnostics || []);
+    const fence = state.diagnosticFences.get(normalizedPath);
+    if (docVersion === undefined && fence) {
+      fence.dropped += 1;
+      countPublication(state, normalizedPath);
+      if (getStrategy(state.serverId, state.launchVariant).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: "indexing",
+            via: "fence-drop",
+            pubVersion: "push-unversioned"
+          }
+        });
+      }
+      return;
+    }
+    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()) {
+        countPublication(state, normalizedPath);
+        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);
+      countPublication(state, normalizedPath);
+    }
+    const timer = setTimeout(() => {
+      state.pendingDiagnostics.delete(normalizedPath);
+      if (isSupersededPush()) {
+        countPublication(state, normalizedPath);
+        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 () => {});
+  state.connection.onNotification("semgrep/rulesRefreshed", () => rebaselineForRulesRefresh(state));
+  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 ?? []);
+      const sent = state.openDocuments.has(normalizedPath) ? state.documentContentHashes.get(normalizedPath) : undefined;
+      const contentHash = sent !== undefined && sent.version === item.version ? sent.hash : 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);
+}
+function expectSaveRescan(state, normalizedPath) {
+  if (!getStrategy(state.serverId, state.launchVariant).rescansOnSave)
+    return;
+  const beyond = state.expectedPublicationsBeyondSends;
+  beyond?.set(normalizedPath, (beyond.get(normalizedPath) ?? 0) + 1);
+}
+async function sendDidSave(state, normalizedPath, uri, content) {
+  const save = state.saveOptions;
+  if (!save)
+    return;
+  if (!isClientAlive(state))
+    return;
+  expectSaveRescan(state, normalizedPath);
+  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 sendDidSaveForHeldDocument(state, normalizedPath) {
+  if (!state.saveOptions || !isClientAlive(state))
+    return;
+  if (!state.openDocuments.has(normalizedPath))
+    return;
+  const uri = state.openDocumentUris?.get(normalizedPath);
+  if (uri === undefined)
+    return;
+  expectSaveRescan(state, normalizedPath);
+  try {
+    await safeSendNotification(state.connection, "textDocument/didSave", {
+      textDocument: { uri }
+    });
+  } catch {}
+}
+async function handleNotifyOpenOnce(state, filePath, content, languageId, preserveDiagnostics = false, silent = false, coalescedCount = 0, saved = false) {
+  if (!isClientAlive(state))
+    return false;
+  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 false;
+      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, normalizedPath, uri, content);
+      return reopenSent;
+    }
+    const changeSent = await sendFenced(state, normalizedPath, uri, "textDocument/didChange", {
+      textDocument: { uri, version },
+      contentChanges: buildContentChanges(state, normalizedPath, content)
+    });
+    if (changeSent)
+      recordSentContent(state, normalizedPath, version, content, coalescedCount);
+    if (saved && changeSent)
+      await sendDidSave(state, normalizedPath, uri, content);
+    return changeSent;
+  }
+  if (await closedAndGone(state, filePath, normalizedPath))
+    return false;
+  state.pendingOpens.add(normalizedPath);
+  state.documentVersions.set(normalizedPath, 0);
+  state.documentOpenedAt.set(normalizedPath, Date.now());
+  state.diagnosticPublicationCounts.set(normalizedPath, 0);
+  clearDiagnosticsForPath(state, normalizedPath);
+  if (!state.expectedPublicationsBeyondSends?.has(normalizedPath))
+    state.publicationStoreCountsByPath?.delete(normalizedPath);
+  if (!silent) {
+    let fileExists = true;
+    try {
+      await access(filePath);
+    } catch {
+      fileExists = false;
+    }
+    state.watchQueue.enqueue(uri, fileExists ? 2 : 1);
+  }
+  if (!isClientAlive(state))
+    return false;
+  const openSent = await sendFenced(state, normalizedPath, uri, "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, normalizedPath, 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)
+    }
+  });
+  return openSent;
+}
+function enqueueDocumentNotify(state, normalizedPath, run, saved = false, readStamp, close = false) {
+  let queue = state.notifyChangeQueues.get(normalizedPath);
+  if (!queue) {
+    queue = { running: false };
+    state.notifyChangeQueues.set(normalizedPath, queue);
+  }
+  return new Promise((resolve, reject) => {
+    if (queue.closing && !close) {
+      resolve(false);
+      return;
+    }
+    const previous = queue?.pending;
+    const waiters = previous?.waiters ?? [];
+    if (close) {
+      for (const waiter of waiters)
+        waiter.stale = true;
+      queue.closing = true;
+    }
+    const lastSent = state.sentReadStamps.get(normalizedPath);
+    const before = (a, b) => a !== undefined && b !== undefined && a < b;
+    const stale = previous !== undefined && (before(readStamp, previous.readStamp) || before(readStamp, lastSent));
+    const heldStamp = before(previous?.readStamp, lastSent) ? undefined : previous?.readStamp;
+    waiters.push({ resolve, reject, stale });
+    queue.pending = {
+      run: stale ? previous.run : run,
+      waiters,
+      coalescedCount: (previous?.coalescedCount ?? 0) + (previous ? 1 : 0),
+      saved: saved || previous?.saved === true,
+      readStamp: close ? undefined : stale ? previous.readStamp : readStamp ?? heldStamp
+    };
+    if (queue.running)
+      return;
+    queue.running = true;
+    Promise.resolve().then(async () => {
+      try {
+        for (;; ) {
+          const next = queue.pending;
+          if (!next)
+            break;
+          queue.pending = undefined;
+          const lastSent = state.sentReadStamps.get(normalizedPath);
+          if (next.readStamp !== undefined && lastSent !== undefined && next.readStamp < lastSent) {
+            if (next.saved)
+              await sendDidSaveForHeldDocument(state, normalizedPath);
+            for (const waiter of next.waiters)
+              waiter.resolve(false);
+            continue;
+          }
+          if (next.readStamp !== undefined)
+            state.sentReadStamps.set(normalizedPath, next.readStamp);
+          try {
+            const sent = await next.run(next.coalescedCount, next.saved);
+            for (const waiter of next.waiters)
+              waiter.resolve(sent !== false && !waiter.stale);
+          } 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(false);
+    queue.pending = undefined;
+  }
+  state.notifyChangeQueues.clear();
+}
+export function handleNotifyOpen(state, filePath, content, languageId, preserveDiagnostics = false, silent = false, saved = false, readStamp) {
+  const normalizedPath = normalizeMapKey(filePath);
+  return enqueueDocumentNotify(state, normalizedPath, (coalescedCount, queuedSaved) => handleNotifyOpenOnce(state, filePath, content, languageId, preserveDiagnostics, silent, coalescedCount, queuedSaved), saved, readStamp);
+}
+async function handleNotifyChangeOnce(state, filePath, content, normalizedPath, coalescedCount = 0, saved = false) {
+  if (!isClientAlive(state))
+    return false;
+  const uri = state.openDocumentUris?.get(normalizedPath) ?? pathToFileURL(filePath).href;
+  if (!state.openDocuments.has(normalizedPath)) {
+    if (await closedAndGone(state, filePath, normalizedPath))
+      return false;
+    const fallbackOpenSent = await sendFenced(state, normalizedPath, uri, "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.closedDocuments?.delete(normalizedPath);
+    state.openDocumentUris?.set(normalizedPath, uri);
+    if (saved && fallbackOpenSent)
+      await sendDidSave(state, normalizedPath, uri, content);
+    return fallbackOpenSent;
+  }
+  const version = (state.documentVersions.get(normalizedPath) ?? 0) + 1;
+  state.documentVersions.set(normalizedPath, version);
+  clearDiagnosticsForPath(state, normalizedPath);
+  const changeSent = await sendFenced(state, normalizedPath, uri, "textDocument/didChange", {
+    textDocument: { uri, version },
+    contentChanges: buildContentChanges(state, normalizedPath, content)
+  });
+  if (changeSent)
+    recordSentContent(state, normalizedPath, version, content, coalescedCount);
+  if (saved && changeSent)
+    await sendDidSave(state, normalizedPath, uri, content);
+  return changeSent;
+}
+export function handleNotifyChange(state, filePath, content) {
+  const normalizedPath = normalizeMapKey(filePath);
+  return enqueueDocumentNotify(state, normalizedPath, (coalescedCount, queuedSaved) => handleNotifyChangeOnce(state, filePath, content, normalizedPath, coalescedCount, queuedSaved));
+}
+async function closedAndGone(state, filePath, normalizedPath) {
+  if (!state.closedDocuments?.has(normalizedPath))
+    return false;
+  try {
+    await access(filePath);
+    return false;
+  } catch {
+    return true;
+  }
+}
+export async function closeDocument(state, filePath) {
+  if (!isClientAlive(state))
+    return;
+  const normalizedPath = normalizeMapKey(filePath);
+  await enqueueDocumentNotify(state, normalizedPath, () => closeDocumentOnce(state, filePath, normalizedPath), false, undefined, true);
+}
+async function closeDocumentOnce(state, filePath, normalizedPath) {
+  if (!isClientAlive(state))
+    return;
+  if (!state.openDocuments.has(normalizedPath)) {
+    state.closedDocuments?.add(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.expectedPublicationsBeyondSends?.set(normalizedPath, publicationCountsForPath(state, normalizedPath).sent);
+  state.documentVersions.delete(normalizedPath);
+  state.sentReadStamps.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,
+    startedAtMs: Date.now(),
+    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,
+    publicationStoreCountsByPath: new Map,
+    expectedPublicationsBeyondSends: new Map,
+    documentVersions: new Map,
+    notifyChangeQueues: new Map,
+    sentReadStamps: 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,
+    diagnosticFences: new Map,
+    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, readStamp) {
+        return handleNotifyOpen(state, filePath, content, languageId, preserveDiagnostics, silent, saved, readStamp);
+      },
+      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));
+    },
+    getPublicationCountsForPath(filePath) {
+      return publicationCountsForPath(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 ?? [];
+    },
+    getSaveOptions() {
+      return state.saveOptions ? { ...state.saveOptions } : undefined;
+    },
+    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];
+    },
+    getSentContent(filePath) {
+      const sent = state.documentContentHashes.get(normalizeMapKey(filePath));
+      return sent && {
+        hash: sent.hash,
+        changedAtMs: sent.changedAtMs,
+        openedAtMs: sent.openedAtMs,
+        openedHash: sent.openedHash,
+        clientStartedAtMs: state.startedAtMs
+      };
+    },
+    isBusy() {
+      return isConnectionBusy(connection);
+    },
+    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);
+    }
+  };
+}
+function sendFenced(state, normalizedPath, uri, method, params) {
+  const sent = safeSendNotification(state.connection, method, params);
+  armDiagnosticsFence(state, normalizedPath, uri);
+  return sent;
+}
+function armDiagnosticsFence(state, normalizedPath, uri) {
+  if (getStrategy(state.serverId, state.launchVariant).diagnosticsFence !== "reply-first") {
+    return;
+  }
+  if (state.operationSupport?.documentSymbol !== true) {
+    if (!state.fenceSkipRecorded) {
+      state.fenceSkipRecorded = true;
+      logLatency({
+        type: "phase",
+        phase: "lsp_diagnostics_fence",
+        filePath: normalizedPath,
+        durationMs: 0,
+        metadata: { serverId: state.serverId, outcome: "no-request" }
+      });
+    }
+    return;
+  }
+  const armedAt = Date.now();
+  const cancellation = new CancellationTokenSource;
+  const end = (outcome) => {
+    if (ended)
+      return;
+    ended = true;
+    clearTimeout(bound);
+    state.diagnosticFences.delete(normalizedPath);
+    cancellation.cancel();
+    cancellation.dispose();
+    if (outcome === "timeout" || fence.dropped > 0) {
+      logLatency({
+        type: "phase",
+        phase: "lsp_diagnostics_fence",
+        filePath: normalizedPath,
+        durationMs: Date.now() - armedAt,
+        metadata: {
+          serverId: state.serverId,
+          outcome,
+          droppedPublishes: fence.dropped
+        }
+      });
+    }
+  };
+  let ended = false;
+  const fence = {
+    dropped: 0,
+    supersede: () => end("superseded")
+  };
+  state.diagnosticFences.get(normalizedPath)?.supersede();
+  state.diagnosticFences.set(normalizedPath, fence);
+  const bound = setTimeout(() => end("timeout"), DIAGNOSTICS_WAIT_TIMEOUT_MS);
+  bound.unref?.();
+  let reply;
+  try {
+    reply = Promise.resolve(state.connection.sendRequest("textDocument/documentSymbol", { textDocument: { uri } }, cancellation.token));
+  } catch (thrown) {
+    reply = Promise.reject(thrown);
+  }
+  reply.then(() => end("reply"), () => end("reply"));
+}
+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;
+export function isConnectionBusy(connection) {
+  return (activeRequestsByConnection.get(connection) ?? 0) > 0;
+}
+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;
+}