pi-lens 4.4.1 → 4.4.3

package/dist/{chunk-MTDRLSI7.js → chunk-M6HSLBWY.js}

@@ -1,7 +1,4 @@
 import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
-import {
-  emitBounded
-} from "./chunk-OZJINN4O.js";
 import {
   createReadGuardEditBatchSummary,
   getReadGuardCorrelationId,
@@ -9,7 +6,7 @@ import {
   normalizeMessage,
   sanitizeCorrelationId,
   stableFindingId
-} from "./chunk-3JSEWUWI.js";
+} from "./chunk-IBGIOBEE.js";
 import {
   mapWithConcurrency
 } from "./chunk-XIMYZ3JA.js";
@@ -28,42 +25,57 @@ import {
   isAuxiliary,
   isDirectLspCommandTemporarilyUnavailable,
   isOutsideAllSessionRoots,
+  isSameOrWithin,
+  refuseUntrustedLspExecution,
   resetClassicTsRepairGuard,
   resetLspLaunchAvailabilityGeneration,
+  resolveAnalysisRoot,
+  resolveAnalysisRootPath,
   resolveLspServerCwd,
-  serverTraits
-} from "./chunk-IQZXOZ7S.js";
+  serverTraits,
+  withLspProjectCodePermission
+} from "./chunk-EU63SDCG.js";
 import {
   findLocalOpengrepConfig
-} from "./chunk-U52SAGRM.js";
+} from "./chunk-VWCXW2E7.js";
+import {
+  emitBounded
+} from "./chunk-FCSOVF55.js";
+import {
+  loadProjectSnapshot,
+  readJsonCache
+} from "./chunk-ZXYDQ3TZ.js";
 import {
   getSharedTreeSitterClient,
   loadWebTreeSitter,
   logTreeSitterDiagnostic,
   resolveTreeSitterLanguage,
   wasmQueryInput
-} from "./chunk-UEAHAMEI.js";
+} from "./chunk-QHJ6DQ2R.js";
 import {
   EXTENSION_TO_GRAMMAR,
   EXTENSION_TO_LSP_ID,
   KIND_TO_GRAMMAR
-} from "./chunk-KJCWXUUS.js";
+} from "./chunk-724UL2TJ.js";
 import {
   js_yaml_default
 } from "./chunk-QOZXJ4NA.js";
 import {
   buildModuleGraph
-} from "./chunk-6XX5HCLK.js";
+} from "./chunk-GBPP5P7X.js";
+import {
+  acquireWorkspaceSweepHold,
+  configureLspServiceLifecycle,
+  getOwnedLspService,
+  peekOwnedLspService,
+  resetOwnedLspService
+} from "./chunk-MQLUAEOC.js";
 import {
   HOOK_WALL_BUDGET_MS,
   bounded,
   withDeadline,
   withTimeout
-} from "./chunk-F5VLZHUW.js";
-import {
-  loadProjectSnapshot,
-  readJsonCache
-} from "./chunk-AXKPQ6ZI.js";
+} from "./chunk-52FUZI6K.js";
 import {
   PathKeyedMap
 } from "./chunk-Z3CCVDUB.js";
@@ -73,19 +85,18 @@ import {
   requestWarmCodeActions,
   requestWarmDiagnostics,
   toRunnerDisplayPath
-} from "./chunk-XGUL4SLQ.js";
+} from "./chunk-L3BLXZG7.js";
 import {
   findLocalZizmorConfig,
   logSessionStart
-} from "./chunk-LD7WFTRX.js";
+} from "./chunk-ACXEQZOU.js";
 import {
-  assertInstallAllowed,
-  isLspSpawnAllowedByTrust,
-  projectTrustDenialReason
-} from "./chunk-D6YF5HKX.js";
+  findLocalBinUpwards,
+  isProjectLocalBinPath
+} from "./chunk-AW7R2GWG.js";
 import {
   getLspCapableKinds
-} from "./chunk-VYKKMYVT.js";
+} from "./chunk-QOBUHWHX.js";
 import {
   createGenerationMap,
   createGenerationSource,
@@ -104,22 +115,27 @@ import {
   removeLspChild,
   sampleProcessTreeCpuPercent,
   selectLivePeerInstances
-} from "./chunk-T54VJRAD.js";
+} from "./chunk-C34ZXZ7O.js";
 import {
   createSingleFlight
 } from "./chunk-BW5KFIQC.js";
 import {
   SPECIAL_FILENAMES,
   getLanguageId
-} from "./chunk-64LU2OVH.js";
+} from "./chunk-PHDMFAKM.js";
 import {
   detectFileRole
-} from "./chunk-N2IRDBZI.js";
+} from "./chunk-2BBLFX75.js";
 import {
   findGoverningTsconfigDir,
   getDirectoryMarkers,
   registerWorkspaceTopologyReset
-} from "./chunk-Z6BB4JLQ.js";
+} from "./chunk-XVF2VVXP.js";
+import {
+  assertInstallAllowed,
+  isLspSpawnAllowedByTrust,
+  projectTrustDenialReason
+} from "./chunk-ZANLILYD.js";
 import {
   writeFileAtomic
 } from "./chunk-2EECBNC5.js";
@@ -128,15 +144,15 @@ import {
   incrementDegradationCount,
   recordDegradation,
   recordDegradationOnce
-} from "./chunk-7ELY2CSM.js";
+} from "./chunk-JAU72XNY.js";
 import {
   logExtension
-} from "./chunk-34OCDWOS.js";
+} from "./chunk-XTMJ7XDT.js";
 import {
   logLatency,
   phaseFinished,
   phaseStarted
-} from "./chunk-3PNFWVHT.js";
+} from "./chunk-QQNQ7SJW.js";
 import {
   createNdjsonLogger,
   getGlobalPiLensLogDir,
@@ -145,7 +161,7 @@ import {
   isTestMode,
   nextModuleEvaluationOrdinal,
   toPositiveFinite
-} from "./chunk-VSMJK3ZJ.js";
+} from "./chunk-AOHZU2BM.js";
 import {
   BoundedFifoMap,
   BoundedLruCache,
@@ -165,7 +181,7 @@ import {
   toProjectRelativePath,
   uriToDiskPath,
   uriToPath
-} from "./chunk-G3RLJYA2.js";
+} from "./chunk-N2H3ZPZY.js";
 import {
   __commonJS,
   __require,
@@ -716,7 +732,7 @@ var require_linkedMap = __commonJS({
         return item.value;
       }
       forEach(callbackfn, thisArg) {
-        const state5 = this._state;
+        const state4 = this._state;
         let current = this._head;
         while (current) {
           if (thisArg) {
@@ -724,21 +740,21 @@ var require_linkedMap = __commonJS({
           } else {
             callbackfn(current.value, current.key, this);
           }
-          if (this._state !== state5) {
+          if (this._state !== state4) {
             throw new Error(`LinkedMap got modified during iteration.`);
           }
           current = current.next;
         }
       }
       keys() {
-        const state5 = this._state;
+        const state4 = this._state;
         let current = this._head;
         const iterator = {
           [Symbol.iterator]: () => {
             return iterator;
           },
           next: () => {
-            if (this._state !== state5) {
+            if (this._state !== state4) {
               throw new Error(`LinkedMap got modified during iteration.`);
             }
             if (current) {
@@ -753,14 +769,14 @@ var require_linkedMap = __commonJS({
         return iterator;
       }
       values() {
-        const state5 = this._state;
+        const state4 = this._state;
         let current = this._head;
         const iterator = {
           [Symbol.iterator]: () => {
             return iterator;
           },
           next: () => {
-            if (this._state !== state5) {
+            if (this._state !== state4) {
               throw new Error(`LinkedMap got modified during iteration.`);
             }
             if (current) {
@@ -775,14 +791,14 @@ var require_linkedMap = __commonJS({
         return iterator;
       }
       entries() {
-        const state5 = this._state;
+        const state4 = this._state;
         let current = this._head;
         const iterator = {
           [Symbol.iterator]: () => {
             return iterator;
           },
           next: () => {
-            if (this._state !== state5) {
+            if (this._state !== state4) {
               throw new Error(`LinkedMap got modified during iteration.`);
             }
             if (current) {
@@ -1869,7 +1885,7 @@ var require_messageBuffer = __commonJS({
         if (this._chunks.length === 0) {
           return void 0;
         }
-        let state5 = 0;
+        let state4 = 0;
         let chunkIndex = 0;
         let offset = 0;
         let chunkBytesRead = 0;
@@ -1880,39 +1896,39 @@ var require_messageBuffer = __commonJS({
             const value = chunk[offset];
             switch (value) {
               case CR:
-                switch (state5) {
+                switch (state4) {
                   case 0:
-                    state5 = 1;
+                    state4 = 1;
                     break;
                   case 2:
-                    state5 = 3;
+                    state4 = 3;
                     break;
                   default:
-                    state5 = 0;
+                    state4 = 0;
                 }
                 break;
               case LF:
-                switch (state5) {
+                switch (state4) {
                   case 1:
-                    state5 = 2;
+                    state4 = 2;
                     break;
                   case 3:
-                    state5 = 4;
+                    state4 = 4;
                     offset++;
                     break row;
                   default:
-                    state5 = 0;
+                    state4 = 0;
                 }
                 break;
               default:
-                state5 = 0;
+                state4 = 0;
             }
             offset++;
           }
           chunkBytesRead += chunk.byteLength;
           chunkIndex++;
         }
-        if (state5 !== 4) {
+        if (state4 !== 4) {
           return void 0;
         }
         const buffer = this._read(chunkBytesRead + offset);
@@ -2286,7 +2302,7 @@ var require_connection = __commonJS({
       let trace = Trace.Off;
       let traceFormat = TraceFormat.Text;
       let tracer;
-      let state5 = ConnectionState.New;
+      let state4 = ConnectionState.New;
       const errorEmitter = new events_1.Emitter();
       const closeEmitter = new events_1.Emitter();
       const unhandledNotificationEmitter = new events_1.Emitter();
@@ -2297,17 +2313,17 @@ var require_connection = __commonJS({
         return void 0;
       }
       function isListening() {
-        return state5 === ConnectionState.Listening;
+        return state4 === ConnectionState.Listening;
       }
       function isClosed() {
-        return state5 === ConnectionState.Closed;
+        return state4 === ConnectionState.Closed;
       }
       function isDisposed() {
-        return state5 === ConnectionState.Disposed;
+        return state4 === ConnectionState.Disposed;
       }
       function closeHandler() {
-        if (state5 === ConnectionState.New || state5 === ConnectionState.Listening) {
-          state5 = ConnectionState.Closed;
+        if (state4 === ConnectionState.New || state4 === ConnectionState.Listening) {
+          state4 = ConnectionState.Closed;
           closeEmitter.fire(void 0);
         }
       }
@@ -3109,7 +3125,7 @@ ${JSON.stringify(message, null, 4)}`);
           if (isDisposed()) {
             return;
           }
-          state5 = ConnectionState.Disposed;
+          state4 = ConnectionState.Disposed;
           disposeEmitter.fire(void 0);
           const error = new messages_1.ResponseError(messages_1.ErrorCodes.PendingResponseRejected, "Pending response rejected since connection got disposed");
           for (const promise of responsePromises.values()) {
@@ -3129,7 +3145,7 @@ ${JSON.stringify(message, null, 4)}`);
         listen: () => {
           throwIfClosedOrDisposed();
           throwIfListening();
-          state5 = ConnectionState.Listening;
+          state4 = ConnectionState.Listening;
           messageReader.listen(callback);
         },
         inspect: () => {
@@ -3969,13 +3985,11 @@ function demotePastEofDiagnostics(args) {
 function resyncDocumentOnPastEof(filePath) {
   void (async () => {
     try {
-      const [{ getLSPService: getLSPService2 }, content] = await Promise.all([
-        import("./chunk-RJFED73B.js"),
+      const [{ getOwnedLspService: getOwnedLspService2 }, content] = await Promise.all([
+        import("./chunk-3JNKMP3B.js"),
         fs.promises.readFile(filePath, "utf-8")
       ]);
-      await getLSPService2().openFile(filePath, content, {
-        preserveDiagnostics: false
-      });
+      await getOwnedLspService2().openFile(filePath, content, { preserveDiagnostics: false });
     } catch {
     }
   })();
@@ -6118,6 +6132,7 @@ function state() {
     secondarySessionCount: 0
   }));
 }
+var SUCCESSOR_HANDOFF_TTL_MS = 24 * 60 * 60 * 1e3;
 function getActiveSessionId() {
   return state().activeSessionId;
 }
@@ -6493,9 +6508,9 @@ var Scope = class {
   }
 };
 function drawTicket() {
-  const state5 = registry();
-  state5.nextTicket += 1;
-  return state5.nextTicket;
+  const state4 = registry();
+  state4.nextTicket += 1;
+  return state4.nextTicket;
 }
 function beginScope(args) {
   return new Scope(args);
@@ -6510,9 +6525,9 @@ function moveBranch(scope) {
   scope.moveBranch();
 }
 function nextOrderTurn() {
-  const state5 = registry();
-  state5.orderTurn += 1;
-  return state5.orderTurn;
+  const state4 = registry();
+  state4.orderTurn += 1;
+  return state4.orderTurn;
 }
 function logScopeTransition(scope, args) {
   logLatency({
@@ -7694,6 +7709,16 @@ Re-read the relevant section, then retry the edit using the current line range/c
       this.touchFile(key);
     return this.reads.get(key) ?? [];
   }
+  /**
+   * Whether the current bytes still match the newest full-content read binding.
+   * Undefined means this file has no full-content binding to compare; callers
+   * must preserve their existing uncertainty wording in that case.
+   */
+  contentMatchesLastRead(filePath) {
+    const reads = this.getReadHistory(filePath);
+    const binding = [...reads].reverse().find((read) => read.contentBinding?.fullFile)?.contentBinding;
+    return binding === void 0 ? void 0 : currentContentMatchesBinding(filePath, binding);
+  }
   /**
    * Session-lifetime record-cap trim totals for a file (#1913 review F1).
    * `recordRead` only writes ONE `read_cap_trimmed` read-guard.log line per
@@ -7748,9 +7773,9 @@ Re-read the relevant section, then retry the edit using the current line range/c
    * `sessionStartMs`) names no write, so it imports nothing. Null-safe on a
    * malformed payload; never throws.
    */
-  importAuthorship(state5, onBranch) {
+  importAuthorship(state4, onBranch) {
     const result = { imported: 0, dropped: 0 };
-    const authorship = state5;
+    const authorship = state4;
     const entries = Array.isArray(authorship?.entries) ? authorship.entries : [];
     const withEntry = /* @__PURE__ */ new Set();
     for (const entry of entries) {
@@ -7855,13 +7880,13 @@ Re-read the relevant section, then retry the edit using the current line range/c
    * payload loads as no reads and never throws — a throw here would abort
    * the whole session_start rehydration.
    */
-  importBranch(state5, onBranch) {
+  importBranch(state4, onBranch) {
     const result = { imported: 0, dropped: 0 };
-    if (!state5 || state5.version !== READ_GUARD_STATE_VERSION)
+    if (!state4 || state4.version !== READ_GUARD_STATE_VERSION)
       return result;
-    if (!Array.isArray(state5.reads))
+    if (!Array.isArray(state4.reads))
       return result;
-    for (const entry of state5.reads) {
+    for (const entry of state4.reads) {
       if (!Array.isArray(entry) || entry.length !== 2)
         continue;
       const [rawPath, records] = entry;
@@ -8421,21 +8446,21 @@ function readState(cwd) {
   if (stateCache && stateCache.path === p && !stateCache.missing && stateCache.mtimeMs === stat2.mtimeMs && stateCache.size === stat2.size) {
     return stateCache.state;
   }
-  let state5;
+  let state4;
   try {
     const parsed = JSON.parse(fs8.readFileSync(p, "utf-8"));
-    state5 = parsed && typeof parsed === "object" ? parsed : {};
+    state4 = parsed && typeof parsed === "object" ? parsed : {};
   } catch {
-    state5 = {};
+    state4 = {};
   }
   stateCache = {
     path: p,
     missing: false,
     mtimeMs: stat2.mtimeMs,
     size: stat2.size,
-    state: state5
+    state: state4
   };
-  return state5;
+  return state4;
 }
 function getDisposition(cwd, anchor) {
   return readState(cwd).dispositions?.[anchor];
@@ -8673,14 +8698,14 @@ function migrateEntryStamps(entries, recordTouchedAt) {
     return rest.observedAt == null ? { ...rest, observedAt: recordTouchedAt } : rest;
   });
 }
-function importWidgetState(state5) {
-  if (!state5 || typeof state5.version !== "number" || state5.version < 1 || state5.version > WIDGET_STATE_VERSION) {
+function importWidgetState(state4) {
+  if (!state4 || typeof state4.version !== "number" || state4.version < 1 || state4.version > WIDGET_STATE_VERSION) {
     return false;
   }
   files.clear();
   diagnosticsWriteGuard.clear();
   runnerWriteGuard.clear();
-  for (const f of state5.files ?? []) {
+  for (const f of state4.files ?? []) {
     const recordTouchedAt = f.touchedAt ?? Date.now();
     const migratedAllDiagnostics = migrateEntryStamps(f.allDiagnostics, recordTouchedAt);
     files.set(fileMapKey(f.filePath), {
@@ -8700,7 +8725,7 @@ function importWidgetState(state5) {
     });
   }
   pruneInactiveFileRecords();
-  sessionLanguages = state5.sessionLanguages ?? [];
+  sessionLanguages = state4.sessionLanguages ?? [];
   requestRenderFn?.();
   return true;
 }
@@ -8716,12 +8741,12 @@ var widgetStore = defineSessionStore({
   snapshot: () => exportWidgetState(),
   restore: async (_scope, payload, ctx) => {
     clearWidgetState();
-    const state5 = payload;
-    if (!state5?.files)
+    const state4 = payload;
+    if (!state4?.files)
       return { itemsIn: 0, itemsKept: 0 };
-    const fresh = await dropStaleFiles(state5, ctx.savedAt);
+    const fresh = await dropStaleFiles(state4, ctx.savedAt);
     importWidgetState(fresh);
-    return { itemsIn: state5.files.length, itemsKept: fresh.files.length };
+    return { itemsIn: state4.files.length, itemsKept: fresh.files.length };
   },
   reset: () => clearWidgetState(),
   reason: "the diagnostics a conversation's edits produced, which a resume and a relaunch show again"
@@ -9662,94 +9687,6 @@ function isDeferredLspWorkArmed() {
   return deferredController?.signal.aborted === false;
 }
 
-// dist/clients/lsp/workspace-sweep-hold.js
-var SWEEP_IDLE_SAFETY_MARGIN_MS = 6e4;
-var WORKSPACE_SWEEP_HOLD_FAMILY = "lsp.workspace-sweep-hold";
-var WORKSPACE_SWEEP_HOLD_VERSION = 1;
-function state2() {
-  return getProcessSingleton(WORKSPACE_SWEEP_HOLD_FAMILY, WORKSPACE_SWEEP_HOLD_VERSION, () => ({ holds: /* @__PURE__ */ new Map(), nextHoldId: 1, idleWaiters: [] }));
-}
-function flushIdleWaitersIfEmpty() {
-  const current = state2();
-  if (current.holds.size > 0)
-    return;
-  if (current.idleWaiters.length === 0)
-    return;
-  const waiters = current.idleWaiters;
-  current.idleWaiters = [];
-  for (const waiter of waiters) {
-    try {
-      waiter();
-    } catch {
-    }
-  }
-}
-function getWorkspaceSweepMaxHoldAgeMs() {
-  return getFullScanWallClockMs() + SWEEP_IDLE_SAFETY_MARGIN_MS;
-}
-function reapStaleHolds() {
-  const current = state2();
-  if (current.holds.size === 0)
-    return;
-  const maxAgeMs = getWorkspaceSweepMaxHoldAgeMs();
-  const now = Date.now();
-  for (const [holdId, acquiredAt] of current.holds) {
-    const ageMs = now - acquiredAt;
-    if (ageMs <= maxAgeMs)
-      continue;
-    current.holds.delete(holdId);
-    logLatency({
-      type: "phase",
-      phase: "lsp_workspace_sweep_hold_force_released",
-      filePath: "",
-      durationMs: ageMs,
-      metadata: { holdId, maxHoldAgeMs: maxAgeMs }
-    });
-  }
-  flushIdleWaitersIfEmpty();
-}
-function acquireWorkspaceSweepHold() {
-  const current = state2();
-  const holdId = current.nextHoldId++;
-  current.holds.set(holdId, Date.now());
-  return () => {
-    if (!state2().holds.delete(holdId))
-      return;
-    flushIdleWaitersIfEmpty();
-  };
-}
-function isWorkspaceSweepActive() {
-  reapStaleHolds();
-  return state2().holds.size > 0;
-}
-function runWhenWorkspaceSweepIdle(cb) {
-  reapStaleHolds();
-  const current = state2();
-  if (current.holds.size === 0) {
-    cb();
-    return;
-  }
-  current.idleWaiters.push(cb);
-}
-function clearWorkspaceSweepHoldForSessionStart() {
-  const current = state2();
-  if (current.holds.size === 0)
-    return;
-  logLatency({
-    type: "phase",
-    phase: "lsp_workspace_sweep_hold_session_reset",
-    filePath: "",
-    durationMs: 0,
-    metadata: { clearedHolds: current.holds.size }
-  });
-  current.holds.clear();
-  flushIdleWaitersIfEmpty();
-}
-function getFullScanWallClockMs() {
-  const raw = Number(process.env.PI_LENS_LENS_DIAGNOSTICS_FULL_TIMEOUT_MS);
-  return Number.isFinite(raw) && raw > 0 ? raw : 3e5;
-}
-
 // dist/clients/lsp/document-drift.js
 import { createHash as createHash5 } from "node:crypto";
 import nodeFs from "node:fs";
@@ -10303,7 +10240,7 @@ var OpaqueBaselineStore = class _OpaqueBaselineStore {
    * for a call a `tool_call` handler blocked or Escape aborted before it ran,
    * and on a non-git project the entry holds a whole-tree stat snapshot.
    */
-  record(slot, callId, state5, turn) {
+  record(slot, callId, state4, turn) {
     for (const [staleKey, entry] of this.pending.entriesArray())
       if (entry.turn && !entry.turn.isLive(entry.turn.key)) {
         this.pending.delete(staleKey);
@@ -10311,7 +10248,7 @@ var OpaqueBaselineStore = class _OpaqueBaselineStore {
       }
     const key = _OpaqueBaselineStore.keyOf(slot, callId);
     const overwrote = this.pending.delete(key);
-    const evicted = this.pending.set(key, { state: state5, turn });
+    const evicted = this.pending.set(key, { state: state4, turn });
     if (overwrote)
       recordBaselineLoss("overwrite");
     if (evicted.length > 0)
@@ -10368,7 +10305,7 @@ var OBSERVED_PENDING_MAX = 32;
 var OBSERVED_LEDGER_MAX = 1e3;
 var OBSERVED_FAMILY = "observed-mutation-net";
 var OBSERVED_VERSION = 4;
-function state3() {
+function state2() {
   return getProcessSingleton(OBSERVED_FAMILY, OBSERVED_VERSION, () => ({
     pending: new BoundedFifoMap(OBSERVED_PENDING_MAX),
     ledger: new BoundedFifoMap(OBSERVED_LEDGER_MAX),
@@ -10380,7 +10317,7 @@ function state3() {
   }));
 }
 function resetObservedMutationNet() {
-  const current = state3();
+  const current = state2();
   current.pending.clear();
   current.ledger.clear();
   current.handled.clear();
@@ -10391,7 +10328,7 @@ function resetObservedMutationNet() {
 }
 function noteMutationHandled(filePath) {
   try {
-    const handled = state3().handled;
+    const handled = state2().handled;
     const key = normalizeMapKey(path10.resolve(filePath));
     const evicted = handled.add(key);
     for (const oldest of evicted) {
@@ -10410,7 +10347,7 @@ function noteMutationHandled(filePath) {
         {
           ledgerKind: "observed-mutation-budget",
           reason: `the handled set is full at ${OBSERVED_HANDLED_MAX}; the oldest pi-lens-authored file lost its mark, so its next drift is reported as third-party`,
-          capPerTurn: { limit: 2, turnIndex: state3().turnIndex }
+          capPerTurn: { limit: 2, turnIndex: state2().turnIndex }
         }
       );
     }
@@ -10591,6 +10528,9 @@ function bookkeepLspMutation(context, files2, fileDetails) {
               authorshipUnknown: true
             },
             ...editRanges !== void 0 ? { editRanges } : {},
+            ...context.sessionId !== void 0 && {
+              sessionId: context.sessionId
+            },
             consumer: context.tool,
             provenance: "observed",
             // Real value threaded through, not the bridge's own
@@ -10632,7 +10572,7 @@ function bookkeepLspMutation(context, files2, fileDetails) {
             detail.range ?? { start: 1, end: 1 },
             detail.importsChanged ?? true,
             context.cwd,
-            runtime?.telemetrySessionId,
+            context.sessionId ?? runtime?.telemetrySessionId,
             void 0,
             // #2504 review round 2 (F1). #2504 added a containment
             // filter to `addModifiedRange` and gave it `cwd` as the
@@ -11615,11 +11555,11 @@ async function preflightWorkspaceEdit(planned, cwd, options) {
     virtual.set(key, value);
     return value;
   };
-  const contentFor = async (filePath, state5) => {
-    if (!state5.exists || state5.directory)
+  const contentFor = async (filePath, state4) => {
+    if (!state4.exists || state4.directory)
       throw new Error(`text edit target is not a file: ${filePath}`);
-    if (state5.content !== void 0)
-      return state5.content;
+    if (state4.content !== void 0)
+      return state4.content;
     const physicalPath = resolveVirtualPath(filePath);
     if (!physicalPath)
       throw new Error(`text edit target does not exist: ${filePath}`);
@@ -11628,50 +11568,50 @@ async function preflightWorkspaceEdit(planned, cwd, options) {
     if (expected !== void 0 && expected !== content) {
       refuseStaleWorkspaceEdit(filePath, "the file changed after the edit was computed from it");
     }
-    state5.content = content;
+    state4.content = content;
     return content;
   };
   for (const op of planned) {
     if (op.kind === "text") {
       const filePath2 = await confine(op.uri);
-      const state6 = await stateFor(filePath2);
+      const state5 = await stateFor(filePath2);
       if (op.version !== void 0 && op.version !== null) {
         const current = options.documentVersions?.get(normalizeMapKey(filePath2));
         if (current === void 0 || current !== op.version)
           throw new Error(`stale text document version for ${filePath2}: expected ${op.version}, current ${current ?? "unknown"}`);
       }
-      const content = await contentFor(filePath2, state6);
+      const content = await contentFor(filePath2, state5);
       const encoding = options.positionEncoding ?? "utf-16";
       const normalized = normalizeTextEditsForContent(content, op.edits, encoding);
       text.set(op, normalized);
       for (const origin of op.origins ?? []) {
         textByOrigin.set(textEditOriginKey(origin), normalizeTextEditsForContent(content, origin.edits, encoding));
       }
-      state6.content = applyTextEditsToString(content, normalized);
+      state5.content = applyTextEditsToString(content, normalized);
       continue;
     }
     if (op.kind === "create") {
       const filePath2 = await confine(op.uri);
-      const state6 = await stateFor(filePath2);
+      const state5 = await stateFor(filePath2);
       await assertParentIsUsable(filePath2, stateFor);
-      if (state6.exists) {
+      if (state5.exists) {
         if (op.options?.ignoreIfExists) {
           ignored.add(op);
           continue;
         }
-        if (!op.options?.overwrite || state6.directory)
+        if (!op.options?.overwrite || state5.directory)
           throw new Error(`create target already exists: ${filePath2}`);
-        state6.content = "";
+        state5.content = "";
       } else {
         clearTombstonesUnder(filePath2);
-        state6.exists = true;
-        state6.directory = false;
-        state6.content = "";
+        state5.exists = true;
+        state5.directory = false;
+        state5.content = "";
         const physicalPath = resolveVirtualPath(filePath2);
         if (physicalPath)
-          virtual.set(normalizeMapKey(physicalPath), state6);
+          virtual.set(normalizeMapKey(physicalPath), state5);
         else
-          virtualOverrides.set(normalizeMapKey(filePath2), state6);
+          virtualOverrides.set(normalizeMapKey(filePath2), state5);
       }
       continue;
     }
@@ -11720,18 +11660,18 @@ async function preflightWorkspaceEdit(planned, cwd, options) {
       continue;
     }
     const filePath = await confine(op.uri);
-    const state5 = await stateFor(filePath);
-    if (!state5.exists) {
+    const state4 = await stateFor(filePath);
+    if (!state4.exists) {
       if (op.options?.ignoreIfNotExists)
         ignored.add(op);
       else
         throw new Error(`delete target does not exist: ${filePath}`);
     } else {
-      if (state5.directory && !op.options?.recursive)
+      if (state4.directory && !op.options?.recursive)
         throw new Error(`delete directory requires recursive: ${filePath}`);
-      state5.exists = false;
-      state5.content = void 0;
-      virtualTombstones.push({ path: filePath, directory: state5.directory });
+      state4.exists = false;
+      state4.content = void 0;
+      virtualTombstones.push({ path: filePath, directory: state4.directory });
     }
   }
   return { text, textByOrigin, ignored };
@@ -12751,16 +12691,16 @@ var ACTIVE_CLIENTS_VERSION = 1;
 function activeLspClientSet() {
   return getProcessSingleton(ACTIVE_CLIENTS_FAMILY, ACTIVE_CLIENTS_VERSION, () => /* @__PURE__ */ new Set());
 }
-function isClientAlive(state5) {
-  return state5.isConnected && !state5.isDestroyed && !state5.lspProcess.process.killed;
+function isClientAlive(state4) {
+  return state4.isConnected && !state4.isDestroyed && !state4.lspProcess.process.killed;
 }
-function disposeClientConnection(state5) {
-  if (state5.connectionDisposed)
+function disposeClientConnection(state4) {
+  if (state4.connectionDisposed)
     return;
-  state5.connectionDisposed = true;
-  activeLspClientSet().delete(state5);
+  state4.connectionDisposed = true;
+  activeLspClientSet().delete(state4);
   try {
-    state5.connection.dispose();
+    state4.connection.dispose();
   } catch {
   }
 }
@@ -12929,66 +12869,66 @@ function mergeDiagnosticLists(...lists) {
   }
   return merged;
 }
-function getMergedDiagnosticsForPath(state5, normalizedPath) {
-  const legacy = state5;
-  return mergeDiagnosticLists(state5.pushDiagnostics?.get(normalizedPath) ?? legacy.diagnostics?.get(normalizedPath), state5.documentPullDiagnostics?.get(normalizedPath));
+function getMergedDiagnosticsForPath(state4, normalizedPath) {
+  const legacy = state4;
+  return mergeDiagnosticLists(state4.pushDiagnostics?.get(normalizedPath) ?? legacy.diagnostics?.get(normalizedPath), state4.documentPullDiagnostics?.get(normalizedPath));
 }
 var PULL_SOURCE_KEY_SEPARATOR = "\0";
 var BARE_PULL_SOURCE = "";
 function pullSourceKey(normalizedPath, identifier) {
   return identifier === void 0 ? normalizedPath : `${normalizedPath}${PULL_SOURCE_KEY_SEPARATOR}${identifier}`;
 }
-function pullSourceKeysForPath(state5, normalizedPath) {
+function pullSourceKeysForPath(state4, normalizedPath) {
   const prefix = `${normalizedPath}${PULL_SOURCE_KEY_SEPARATOR}`;
   return [
     normalizedPath,
-    ...[...state5.pullResultIds?.keys() ?? []].filter((key) => key.startsWith(prefix))
+    ...[...state4.pullResultIds?.keys() ?? []].filter((key) => key.startsWith(prefix))
   ];
 }
-function pullSourcesFor(state5, normalizedPath) {
-  if (!state5.documentPullDiagnosticsBySource) {
-    state5.documentPullDiagnosticsBySource = /* @__PURE__ */ new Map();
+function pullSourcesFor(state4, normalizedPath) {
+  if (!state4.documentPullDiagnosticsBySource) {
+    state4.documentPullDiagnosticsBySource = /* @__PURE__ */ new Map();
   }
-  let sources = state5.documentPullDiagnosticsBySource.get(normalizedPath);
+  let sources = state4.documentPullDiagnosticsBySource.get(normalizedPath);
   if (!sources) {
     sources = /* @__PURE__ */ new Map();
-    state5.documentPullDiagnosticsBySource.set(normalizedPath, sources);
+    state4.documentPullDiagnosticsBySource.set(normalizedPath, sources);
   }
   return sources;
 }
-function pullSourceDiagnostics(state5, normalizedPath, identifier) {
-  const sources = state5.documentPullDiagnosticsBySource?.get(normalizedPath);
+function pullSourceDiagnostics(state4, normalizedPath, identifier) {
+  const sources = state4.documentPullDiagnosticsBySource?.get(normalizedPath);
   const stored = sources?.get(identifier ?? BARE_PULL_SOURCE);
   if (stored)
     return stored;
-  return sources && sources.size > 0 ? [] : state5.documentPullDiagnostics.get(normalizedPath) ?? [];
+  return sources && sources.size > 0 ? [] : state4.documentPullDiagnostics.get(normalizedPath) ?? [];
 }
-function storePullSourceDiagnostics(state5, normalizedPath, identifier, diagnostics) {
-  const sources = pullSourcesFor(state5, normalizedPath);
+function storePullSourceDiagnostics(state4, normalizedPath, identifier, diagnostics) {
+  const sources = pullSourcesFor(state4, normalizedPath);
   sources.set(identifier ?? BARE_PULL_SOURCE, diagnostics);
-  state5.documentPullDiagnostics.set(normalizedPath, mergeDiagnosticLists(...sources.values()));
+  state4.documentPullDiagnostics.set(normalizedPath, mergeDiagnosticLists(...sources.values()));
 }
-function pullGenerationFor(state5, normalizedPath) {
-  return state5.pullGenerations?.get(normalizedPath) ?? 0;
+function pullGenerationFor(state4, normalizedPath) {
+  return state4.pullGenerations?.get(normalizedPath) ?? 0;
 }
-function bumpPullGeneration(state5, normalizedPath) {
-  if (!state5.pullGenerations)
-    state5.pullGenerations = /* @__PURE__ */ new Map();
-  state5.pullGenerations.set(normalizedPath, (state5.pullGenerations.get(normalizedPath) ?? 0) + 1);
+function bumpPullGeneration(state4, normalizedPath) {
+  if (!state4.pullGenerations)
+    state4.pullGenerations = /* @__PURE__ */ new Map();
+  state4.pullGenerations.set(normalizedPath, (state4.pullGenerations.get(normalizedPath) ?? 0) + 1);
 }
-function claimPullRequestSequence(state5, sourceKey) {
-  if (!state5.pullRequestSequences)
-    state5.pullRequestSequences = /* @__PURE__ */ new Map();
-  const next = (state5.pullRequestSequences.get(sourceKey) ?? 0) + 1;
-  state5.pullRequestSequences.set(sourceKey, next);
+function claimPullRequestSequence(state4, sourceKey) {
+  if (!state4.pullRequestSequences)
+    state4.pullRequestSequences = /* @__PURE__ */ new Map();
+  const next = (state4.pullRequestSequences.get(sourceKey) ?? 0) + 1;
+  state4.pullRequestSequences.set(sourceKey, next);
   return next;
 }
-function isNewestPullRequest(state5, sourceKey, sequence) {
-  return (state5.pullRequestSequences?.get(sourceKey) ?? 0) === sequence;
+function isNewestPullRequest(state4, sourceKey, sequence) {
+  return (state4.pullRequestSequences?.get(sourceKey) ?? 0) === sequence;
 }
-function retirePullSource(state5, identifier) {
+function retirePullSource(state4, identifier) {
   const suffix = `${PULL_SOURCE_KEY_SEPARATOR}${identifier}`;
-  for (const source of [state5.pullResultIds, state5.pullRequestSequences]) {
+  for (const source of [state4.pullResultIds, state4.pullRequestSequences]) {
     if (!source)
       continue;
     for (const key of source.keys()) {
@@ -12996,17 +12936,17 @@ function retirePullSource(state5, identifier) {
         source.delete(key);
     }
   }
-  for (const [normalizedPath, sources] of state5.documentPullDiagnosticsBySource ?? []) {
+  for (const [normalizedPath, sources] of state4.documentPullDiagnosticsBySource ?? []) {
     if (!sources.delete(identifier))
       continue;
-    state5.documentPullDiagnostics.set(normalizedPath, mergeDiagnosticLists(...sources.values()));
-    bumpDiagnosticsVersion(state5, normalizedPath);
-    state5.diagnosticEmitter.emit("diagnostics", normalizedPath);
+    state4.documentPullDiagnostics.set(normalizedPath, mergeDiagnosticLists(...sources.values()));
+    bumpDiagnosticsVersion(state4, normalizedPath);
+    state4.diagnosticEmitter.emit("diagnostics", normalizedPath);
   }
 }
-function pullDiagnosticSources(state5) {
+function pullDiagnosticSources(state4) {
   const identifiers = /* @__PURE__ */ new Set();
-  for (const registration of state5.dynamicRegistrations?.values() ?? []) {
+  for (const registration of state4.dynamicRegistrations?.values() ?? []) {
     if (registration.method !== "textDocument/diagnostic")
       continue;
     if (registration.identifier)
@@ -13014,91 +12954,91 @@ function pullDiagnosticSources(state5) {
   }
   return [void 0, ...[...identifiers].sort((a, b) => a.localeCompare(b))];
 }
-function bumpDiagnosticsVersion(state5, normalizedPath) {
-  state5.diagnosticsVersion += 1;
-  state5.diagnosticsVersionsByPath?.set(normalizedPath, state5.diagnosticsVersion);
-  countPublication(state5, normalizedPath);
+function bumpDiagnosticsVersion(state4, normalizedPath) {
+  state4.diagnosticsVersion += 1;
+  state4.diagnosticsVersionsByPath?.set(normalizedPath, state4.diagnosticsVersion);
+  countPublication(state4, normalizedPath);
 }
-function countPublication(state5, normalizedPath) {
-  const counts = state5.publicationStoreCountsByPath;
+function countPublication(state4, normalizedPath) {
+  const counts = state4.publicationStoreCountsByPath;
   if (!counts)
     return;
-  const { sent } = publicationCountsForPath(state5, normalizedPath);
+  const { sent } = publicationCountsForPath(state4, normalizedPath);
   if (sent === 0)
     return;
   counts.set(normalizedPath, Math.min((counts.get(normalizedPath) ?? 0) + 1, sent));
 }
-function rebaselineForRulesRefresh(state5) {
-  const counts = state5.publicationStoreCountsByPath;
+function rebaselineForRulesRefresh(state4) {
+  const counts = state4.publicationStoreCountsByPath;
   for (const [normalizedPath, published] of counts) {
     counts.set(normalizedPath, published - 1);
   }
-  for (const normalizedPath of state5.pendingDiagnostics.keys()) {
-    if (counts.has(normalizedPath) || publicationCountsForPath(state5, normalizedPath).sent === 0)
+  for (const normalizedPath of state4.pendingDiagnostics.keys()) {
+    if (counts.has(normalizedPath) || publicationCountsForPath(state4, normalizedPath).sent === 0)
       continue;
     counts.set(normalizedPath, -1);
   }
   logLatency({
     type: "phase",
     phase: "lsp_rules_refreshed",
-    filePath: state5.root,
+    filePath: state4.root,
     durationMs: 0,
-    metadata: { serverId: state5.serverId, rebaselinedPaths: counts.size }
+    metadata: { serverId: state4.serverId, rebaselinedPaths: counts.size }
   });
 }
-function publicationCountsForPath(state5, normalizedPath) {
-  const lastSent = state5.documentVersions.get(normalizedPath);
+function publicationCountsForPath(state4, normalizedPath) {
+  const lastSent = state4.documentVersions.get(normalizedPath);
   return {
-    sent: (lastSent === void 0 ? 0 : lastSent + 1) + (state5.expectedPublicationsBeyondSends?.get(normalizedPath) ?? 0),
-    published: state5.publicationStoreCountsByPath?.get(normalizedPath) ?? 0
+    sent: (lastSent === void 0 ? 0 : lastSent + 1) + (state4.expectedPublicationsBeyondSends?.get(normalizedPath) ?? 0),
+    published: state4.publicationStoreCountsByPath?.get(normalizedPath) ?? 0
   };
 }
-function diagnosticsVersionForPath(state5, normalizedPath) {
-  return state5.diagnosticsVersionsByPath?.get(normalizedPath) ?? 0;
+function diagnosticsVersionForPath(state4, normalizedPath) {
+  return state4.diagnosticsVersionsByPath?.get(normalizedPath) ?? 0;
 }
-function clearDiagnosticsForPath(state5, normalizedPath) {
-  const legacy = state5;
-  state5.pushDiagnostics?.delete(normalizedPath);
-  const pending2 = state5.pendingDiagnostics?.get(normalizedPath);
+function clearDiagnosticsForPath(state4, normalizedPath) {
+  const legacy = state4;
+  state4.pushDiagnostics?.delete(normalizedPath);
+  const pending2 = state4.pendingDiagnostics?.get(normalizedPath);
   if (pending2) {
     clearTimeout(pending2);
-    countPublication(state5, normalizedPath);
-  }
-  state5.pendingDiagnostics?.delete(normalizedPath);
-  state5.pushDiagnosticTimestamps?.delete(normalizedPath);
-  state5.documentPullDiagnostics?.delete(normalizedPath);
-  state5.documentPullDiagnosticTimestamps?.delete(normalizedPath);
-  state5.diagnosticDocVersions?.delete(normalizedPath);
-  state5.diagnosticBindings?.delete(normalizedPath);
-  state5.diagnosticsVersionsByPath?.delete(normalizedPath);
-  for (const key of pullSourceKeysForPath(state5, normalizedPath)) {
-    state5.pullResultIds?.delete(key);
-  }
-  state5.documentPullDiagnosticsBySource?.delete(normalizedPath);
-  bumpPullGeneration(state5, normalizedPath);
-  state5.workspacePullResultCache?.delete(normalizedPath);
+    countPublication(state4, normalizedPath);
+  }
+  state4.pendingDiagnostics?.delete(normalizedPath);
+  state4.pushDiagnosticTimestamps?.delete(normalizedPath);
+  state4.documentPullDiagnostics?.delete(normalizedPath);
+  state4.documentPullDiagnosticTimestamps?.delete(normalizedPath);
+  state4.diagnosticDocVersions?.delete(normalizedPath);
+  state4.diagnosticBindings?.delete(normalizedPath);
+  state4.diagnosticsVersionsByPath?.delete(normalizedPath);
+  for (const key of pullSourceKeysForPath(state4, normalizedPath)) {
+    state4.pullResultIds?.delete(key);
+  }
+  state4.documentPullDiagnosticsBySource?.delete(normalizedPath);
+  bumpPullGeneration(state4, normalizedPath);
+  state4.workspacePullResultCache?.delete(normalizedPath);
   legacy.diagnostics?.delete(normalizedPath);
   legacy.diagnosticTimestamps?.delete(normalizedPath);
 }
-function logTypeScriptPullSettle(state5, normalizedPath, durationMs, pullSettleSource) {
-  if (state5.serverId !== "typescript")
+function logTypeScriptPullSettle(state4, normalizedPath, durationMs, pullSettleSource) {
+  if (state4.serverId !== "typescript")
     return;
-  const diagnostics = state5.documentPullDiagnostics.get(normalizedPath) ?? [];
-  const elapsedSinceDidOpenMs = Math.max(0, Date.now() - (state5.documentOpenedAt.get(normalizedPath) ?? Date.now()));
+  const diagnostics = state4.documentPullDiagnostics.get(normalizedPath) ?? [];
+  const elapsedSinceDidOpenMs = Math.max(0, Date.now() - (state4.documentOpenedAt.get(normalizedPath) ?? Date.now()));
   const diagnosticCodes = [
     ...new Set(diagnostics.map((diagnostic) => diagnostic.code).filter((code) => code !== void 0).map(String))
   ].slice(0, 8);
-  const trackedVersion = state5.diagnosticsVersionsByPath?.get(normalizedPath);
+  const trackedVersion = state4.diagnosticsVersionsByPath?.get(normalizedPath);
   logLatency({
     type: "phase",
     phase: "lsp_typescript_diagnostic_sequence",
     filePath: normalizedPath,
     durationMs,
     metadata: {
-      serverId: state5.serverId,
+      serverId: state4.serverId,
       outcome: "settled",
-      launchVariant: state5.launchVariant ?? "unknown",
-      publicationIndex: state5.diagnosticPublicationCounts.get(normalizedPath) ?? 0,
+      launchVariant: state4.launchVariant ?? "unknown",
+      publicationIndex: state4.diagnosticPublicationCounts.get(normalizedPath) ?? 0,
       version: trackedVersion ?? "pull-unversioned",
       diagnosticCount: diagnostics.length,
       diagnosticCodes,
@@ -13127,25 +13067,25 @@ function scanSentContent(content) {
   }
   return { lfNewlineCount, lastLine: { index, start } };
 }
-function recordSentContent(state5, normalizedPath, version, content, coalescedCount = 0) {
+function recordSentContent(state4, normalizedPath, version, content, coalescedCount = 0) {
   const scan = scanSentContent(content);
-  const previous = state5.documentContentHashes.get(normalizedPath);
+  const previous = state4.documentContentHashes.get(normalizedPath);
   if (previous && previous.version > version) {
     incrementDegradationCount({
       kind: "lsp-document-send-order",
-      subject: `${state5.serverId}:${normalizedPath}`,
+      subject: `${state4.serverId}:${normalizedPath}`,
       reason: `recorded version ${version} after newer version ${previous.version}`
     });
     return;
   }
   if (previous?.text !== void 0) {
-    state5.incrementalTextRetainedEntries = Math.max(0, (state5.incrementalTextRetainedEntries ?? 1) - 1);
-    state5.incrementalTextRetainedBytes = Math.max(0, (state5.incrementalTextRetainedBytes ?? previous.text.length * 2) - previous.text.length * 2);
-    state5.incrementalTextBearingPaths?.delete(normalizedPath);
+    state4.incrementalTextRetainedEntries = Math.max(0, (state4.incrementalTextRetainedEntries ?? 1) - 1);
+    state4.incrementalTextRetainedBytes = Math.max(0, (state4.incrementalTextRetainedBytes ?? previous.text.length * 2) - previous.text.length * 2);
+    state4.incrementalTextBearingPaths?.delete(normalizedPath);
   }
-  state5.documentContentHashes.delete(normalizedPath);
+  state4.documentContentHashes.delete(normalizedPath);
   const hash = hashDiagnosticContent(content);
-  state5.documentContentHashes.set(normalizedPath, {
+  state4.documentContentHashes.set(normalizedPath, {
     version,
     hash,
     changedAtMs: previous?.hash === hash ? previous.changedAtMs : Date.now(),
@@ -13156,35 +13096,35 @@ function recordSentContent(state5, normalizedPath, version, content, coalescedCo
     // what the server last saw; Full/None never read this field.
     // #2066: `lastLine` is that reader's answer, already computed by the
     // scan above — it rides along with the text it describes.
-    ...state5.syncKind === TEXT_DOCUMENT_SYNC_KIND_INCREMENTAL && {
+    ...state4.syncKind === TEXT_DOCUMENT_SYNC_KIND_INCREMENTAL && {
       text: content,
       lastLine: scan.lastLine
     }
   });
-  if (state5.syncKind === TEXT_DOCUMENT_SYNC_KIND_INCREMENTAL) {
-    state5.incrementalTextRetainedEntries = (state5.incrementalTextRetainedEntries ?? 0) + 1;
-    state5.incrementalTextRetainedBytes = (state5.incrementalTextRetainedBytes ?? 0) + content.length * 2;
-    if (!state5.incrementalTextBearingPaths) {
-      state5.incrementalTextBearingPaths = /* @__PURE__ */ new Set();
-    }
-    state5.incrementalTextBearingPaths.add(normalizedPath);
-    while ((state5.incrementalTextRetainedEntries ?? 0) > MAX_INCREMENTAL_TEXT_RETAINED_ENTRIES || (state5.incrementalTextRetainedBytes ?? 0) > MAX_INCREMENTAL_TEXT_RETAINED_BYTES) {
-      const oldestPath = state5.incrementalTextBearingPaths?.values().next().value;
+  if (state4.syncKind === TEXT_DOCUMENT_SYNC_KIND_INCREMENTAL) {
+    state4.incrementalTextRetainedEntries = (state4.incrementalTextRetainedEntries ?? 0) + 1;
+    state4.incrementalTextRetainedBytes = (state4.incrementalTextRetainedBytes ?? 0) + content.length * 2;
+    if (!state4.incrementalTextBearingPaths) {
+      state4.incrementalTextBearingPaths = /* @__PURE__ */ new Set();
+    }
+    state4.incrementalTextBearingPaths.add(normalizedPath);
+    while ((state4.incrementalTextRetainedEntries ?? 0) > MAX_INCREMENTAL_TEXT_RETAINED_ENTRIES || (state4.incrementalTextRetainedBytes ?? 0) > MAX_INCREMENTAL_TEXT_RETAINED_BYTES) {
+      const oldestPath = state4.incrementalTextBearingPaths?.values().next().value;
       if (oldestPath === void 0)
         break;
-      const binding = state5.documentContentHashes.get(oldestPath);
-      state5.incrementalTextBearingPaths.delete(oldestPath);
+      const binding = state4.documentContentHashes.get(oldestPath);
+      state4.incrementalTextBearingPaths.delete(oldestPath);
       if (!binding || binding.text === void 0)
         continue;
-      state5.documentContentHashes.set(oldestPath, {
+      state4.documentContentHashes.set(oldestPath, {
         version: binding.version,
         hash: binding.hash,
         changedAtMs: binding.changedAtMs,
         openedAtMs: binding.openedAtMs,
         openedHash: binding.openedHash
       });
-      state5.incrementalTextRetainedEntries = Math.max(0, (state5.incrementalTextRetainedEntries ?? 1) - 1);
-      state5.incrementalTextRetainedBytes = Math.max(0, (state5.incrementalTextRetainedBytes ?? 0) - binding.text.length * 2);
+      state4.incrementalTextRetainedEntries = Math.max(0, (state4.incrementalTextRetainedEntries ?? 1) - 1);
+      state4.incrementalTextRetainedBytes = Math.max(0, (state4.incrementalTextRetainedBytes ?? 0) - binding.text.length * 2);
     }
   }
   logLatency({
@@ -13200,11 +13140,11 @@ function recordSentContent(state5, normalizedPath, version, content, coalescedCo
     }
   });
 }
-function buildContentChanges(state5, normalizedPath, content) {
-  if (state5.syncKind !== TEXT_DOCUMENT_SYNC_KIND_INCREMENTAL) {
+function buildContentChanges(state4, normalizedPath, content) {
+  if (state4.syncKind !== TEXT_DOCUMENT_SYNC_KIND_INCREMENTAL) {
     return [{ text: content }];
   }
-  const previous = state5.documentContentHashes.get(normalizedPath);
+  const previous = state4.documentContentHashes.get(normalizedPath);
   if (previous?.text === void 0) {
     return [{ text: content }];
   }
@@ -13217,7 +13157,7 @@ function buildContentChanges(state5, normalizedPath, content) {
         start: { line: 0, character: 0 },
         end: {
           line: lastLine.index,
-          character: convertCharacterOffset(state5.positionEncoding, lastLineText, lastLineText.length)
+          character: convertCharacterOffset(state4.positionEncoding, lastLineText, lastLineText.length)
         }
       },
       text: content
@@ -13238,12 +13178,12 @@ var DYNAMIC_OPERATION_METHOD_MAP = {
   "textDocument/implementation": "implementation",
   "textDocument/prepareCallHierarchy": "callHierarchy"
 };
-function applyDynamicCapabilities(state5) {
-  const registrations = [...state5.dynamicRegistrations.values()];
+function applyDynamicCapabilities(state4) {
+  const registrations = [...state4.dynamicRegistrations.values()];
   const registeredMethods = new Set(registrations.map((r) => r.method));
   const hasDynamicPull = registeredMethods.has("textDocument/diagnostic") || registeredMethods.has("workspace/diagnostic");
   if (hasDynamicPull) {
-    state5.workspaceDiagnosticsSupport = {
+    state4.workspaceDiagnosticsSupport = {
       advertised: true,
       mode: "pull",
       // #1667: workspace-pull support is what the REGISTRATION declares. The
@@ -13256,8 +13196,8 @@ function applyDynamicCapabilities(state5) {
       workspaceDiagnostics: registrations.some((r) => r.workspaceDiagnostics === true) || registeredMethods.has("workspace/diagnostic"),
       diagnosticProviderKind: "dynamic"
     };
-  } else if (state5.staticDiagnosticsMode === "push-only" && state5.workspaceDiagnosticsSupport.diagnosticProviderKind === "dynamic") {
-    state5.workspaceDiagnosticsSupport = {
+  } else if (state4.staticDiagnosticsMode === "push-only" && state4.workspaceDiagnosticsSupport.diagnosticProviderKind === "dynamic") {
+    state4.workspaceDiagnosticsSupport = {
       advertised: false,
       mode: "push-only",
       workspaceDiagnostics: false,
@@ -13266,7 +13206,7 @@ function applyDynamicCapabilities(state5) {
   }
   for (const [method, key] of Object.entries(DYNAMIC_OPERATION_METHOD_MAP)) {
     if (registeredMethods.has(method)) {
-      state5.operationSupport[key] = true;
+      state4.operationSupport[key] = true;
     }
   }
 }
@@ -13284,34 +13224,34 @@ function resolveConfigurationSection(initialization, section) {
   }
   return cur;
 }
-function setupIncomingHandlers(state5, initialization, onDiagnosticsPublished) {
-  state5.connection.onNotification("textDocument/publishDiagnostics", (params) => {
+function setupIncomingHandlers(state4, initialization, onDiagnosticsPublished) {
+  state4.connection.onNotification("textDocument/publishDiagnostics", (params) => {
     const publishReceivedAt = Date.now();
     const filePath = uriToPath(params.uri);
     const normalizedPath = normalizeMapKey(filePath);
     const docVersion = params.version;
-    if (docVersion === void 0 && getStrategy(state5.serverId, state5.launchVariant).publishesOnClose) {
+    if (docVersion === void 0 && getStrategy(state4.serverId, state4.launchVariant).publishesOnClose) {
       return;
     }
-    if (state5.closedDocuments?.has(normalizedPath)) {
-      countPublication(state5, normalizedPath);
+    if (state4.closedDocuments?.has(normalizedPath)) {
+      countPublication(state4, normalizedPath);
       return;
     }
-    onDiagnosticsPublished?.(state5.serverId);
+    onDiagnosticsPublished?.(state4.serverId);
     const newDiags = normalizeLspDiagnostics(params.diagnostics || []);
-    const fence = state5.diagnosticFences.get(normalizedPath);
+    const fence = state4.diagnosticFences.get(normalizedPath);
     if (docVersion === void 0 && fence) {
       fence.dropped += 1;
-      countPublication(state5, normalizedPath);
-      if (getStrategy(state5.serverId, state5.launchVariant).emptyFirstPublish === "indexing" && !state5.emptyFirstPublishHoldSpent && newDiags.length === 0 && !state5.pushDiagnostics.has(normalizedPath) && !state5.pendingDiagnostics.has(normalizedPath)) {
-        state5.emptyFirstPublishHoldSpent = true;
+      countPublication(state4, normalizedPath);
+      if (getStrategy(state4.serverId, state4.launchVariant).emptyFirstPublish === "indexing" && !state4.emptyFirstPublishHoldSpent && newDiags.length === 0 && !state4.pushDiagnostics.has(normalizedPath) && !state4.pendingDiagnostics.has(normalizedPath)) {
+        state4.emptyFirstPublishHoldSpent = true;
         logLatency({
           type: "phase",
           phase: "lsp_empty_first_publish_held",
           filePath: normalizedPath,
-          durationMs: Math.max(0, publishReceivedAt - (state5.documentOpenedAt.get(normalizedPath) ?? publishReceivedAt)),
+          durationMs: Math.max(0, publishReceivedAt - (state4.documentOpenedAt.get(normalizedPath) ?? publishReceivedAt)),
           metadata: {
-            serverId: state5.serverId,
+            serverId: state4.serverId,
             emptyFirstPublish: "indexing",
             via: "fence-drop",
             pubVersion: "push-unversioned"
@@ -13324,31 +13264,31 @@ function setupIncomingHandlers(state5, initialization, onDiagnosticsPublished) {
       logExtension({
         subsystem: "lsp-pub",
         level: "debug",
-        message: `server=${state5.serverId} pubVersion=${docVersion} docVersion=${state5.documentVersions?.get(normalizedPath)} diags=${newDiags.length}`
+        message: `server=${state4.serverId} pubVersion=${docVersion} docVersion=${state4.documentVersions?.get(normalizedPath)} diags=${newDiags.length}`
       });
     }
-    const strategy = getStrategy(state5.serverId, state5.launchVariant);
-    const isTypeScriptTelemetry = state5.serverId === "typescript";
-    const publicationIndex = isTypeScriptTelemetry ? (state5.diagnosticPublicationCounts.get(normalizedPath) ?? 0) + 1 : 0;
+    const strategy = getStrategy(state4.serverId, state4.launchVariant);
+    const isTypeScriptTelemetry = state4.serverId === "typescript";
+    const publicationIndex = isTypeScriptTelemetry ? (state4.diagnosticPublicationCounts.get(normalizedPath) ?? 0) + 1 : 0;
     if (isTypeScriptTelemetry) {
-      state5.diagnosticPublicationCounts.set(normalizedPath, publicationIndex);
+      state4.diagnosticPublicationCounts.set(normalizedPath, publicationIndex);
     }
     const diagnosticCodes = isTypeScriptTelemetry ? [
       ...new Set(newDiags.map((diagnostic) => diagnostic.code).filter((code) => code !== void 0).map(String))
     ].slice(0, 8) : [];
     const logSequence = (settledReturn, settleSource, durationMs) => {
-      if (state5.serverId !== "typescript")
+      if (state4.serverId !== "typescript")
         return;
-      const elapsedSinceDidOpenMs = Math.max(0, Date.now() - (state5.documentOpenedAt.get(normalizedPath) ?? Date.now()));
+      const elapsedSinceDidOpenMs = Math.max(0, Date.now() - (state4.documentOpenedAt.get(normalizedPath) ?? Date.now()));
       logLatency({
         type: "phase",
         phase: "lsp_typescript_diagnostic_sequence",
         filePath: normalizedPath,
         durationMs,
         metadata: {
-          serverId: state5.serverId,
+          serverId: state4.serverId,
           outcome: settledReturn ? "settled" : "published",
-          launchVariant: state5.launchVariant ?? "unknown",
+          launchVariant: state4.launchVariant ?? "unknown",
           publicationIndex,
           version: docVersion ?? "push-unversioned",
           diagnosticCount: newDiags.length,
@@ -13361,17 +13301,17 @@ function setupIncomingHandlers(state5, initialization, onDiagnosticsPublished) {
     };
     const recordDocVersion = () => {
       if (docVersion !== void 0) {
-        state5.diagnosticDocVersions.set(normalizedPath, docVersion);
+        state4.diagnosticDocVersions.set(normalizedPath, docVersion);
       }
       recordBinding();
     };
     const recordBinding = () => {
       if (docVersion === void 0) {
-        state5.diagnosticBindings.delete(normalizedPath);
+        state4.diagnosticBindings.delete(normalizedPath);
         return;
       }
-      const sent = state5.documentContentHashes.get(normalizedPath);
-      state5.diagnosticBindings.set(normalizedPath, {
+      const sent = state4.documentContentHashes.get(normalizedPath);
+      state4.diagnosticBindings.set(normalizedPath, {
         version: docVersion,
         contentHash: sent && sent.version === docVersion ? sent.hash : void 0
       });
@@ -13379,18 +13319,18 @@ function setupIncomingHandlers(state5, initialization, onDiagnosticsPublished) {
     const isSupersededPush = () => {
       if (docVersion === void 0)
         return false;
-      const currentVersion = state5.documentVersions.get(normalizedPath);
+      const currentVersion = state4.documentVersions.get(normalizedPath);
       return currentVersion !== void 0 && docVersion < currentVersion;
     };
-    if (strategy.emptyFirstPublish === "indexing" && !state5.emptyFirstPublishHoldSpent && newDiags.length === 0 && !state5.pushDiagnostics.has(normalizedPath) && !state5.pendingDiagnostics.has(normalizedPath)) {
-      state5.emptyFirstPublishHoldSpent = true;
+    if (strategy.emptyFirstPublish === "indexing" && !state4.emptyFirstPublishHoldSpent && newDiags.length === 0 && !state4.pushDiagnostics.has(normalizedPath) && !state4.pendingDiagnostics.has(normalizedPath)) {
+      state4.emptyFirstPublishHoldSpent = true;
       logLatency({
         type: "phase",
         phase: "lsp_empty_first_publish_held",
         filePath: normalizedPath,
-        durationMs: Math.max(0, publishReceivedAt - (state5.documentOpenedAt.get(normalizedPath) ?? publishReceivedAt)),
+        durationMs: Math.max(0, publishReceivedAt - (state4.documentOpenedAt.get(normalizedPath) ?? publishReceivedAt)),
         metadata: {
-          serverId: state5.serverId,
+          serverId: state4.serverId,
           emptyFirstPublish: strategy.emptyFirstPublish,
           // `pubVersion`, the `[lsp-pub]` trace's own field name for the
           // publish's LSP document version — not a lifecycle identity, and
@@ -13400,49 +13340,49 @@ function setupIncomingHandlers(state5, initialization, onDiagnosticsPublished) {
       });
       return;
     }
-    if (strategy.seedFirstPush && !state5.pushDiagnostics.has(normalizedPath)) {
+    if (strategy.seedFirstPush && !state4.pushDiagnostics.has(normalizedPath)) {
       if (isSupersededPush()) {
-        countPublication(state5, normalizedPath);
+        countPublication(state4, normalizedPath);
         return;
       }
-      state5.pushDiagnostics.set(normalizedPath, newDiags);
-      state5.pushDiagnosticTimestamps.set(normalizedPath, Date.now());
+      state4.pushDiagnostics.set(normalizedPath, newDiags);
+      state4.pushDiagnosticTimestamps.set(normalizedPath, Date.now());
       recordDocVersion();
-      bumpDiagnosticsVersion(state5, normalizedPath);
-      state5.diagnosticEmitter.emit("diagnostics", normalizedPath);
+      bumpDiagnosticsVersion(state4, normalizedPath);
+      state4.diagnosticEmitter.emit("diagnostics", normalizedPath);
       logSequence(true, "first-push", 0);
       return;
     }
     logSequence(false, "publication", 0);
-    const existingTimer = state5.pendingDiagnostics.get(normalizedPath);
+    const existingTimer = state4.pendingDiagnostics.get(normalizedPath);
     if (existingTimer) {
       clearTimeout(existingTimer);
-      countPublication(state5, normalizedPath);
+      countPublication(state4, normalizedPath);
     }
     const timer = setTimeout(() => {
-      state5.pendingDiagnostics.delete(normalizedPath);
+      state4.pendingDiagnostics.delete(normalizedPath);
       if (isSupersededPush()) {
-        countPublication(state5, normalizedPath);
+        countPublication(state4, normalizedPath);
         return;
       }
-      state5.pushDiagnostics.set(normalizedPath, newDiags);
-      state5.pushDiagnosticTimestamps.set(normalizedPath, Date.now());
+      state4.pushDiagnostics.set(normalizedPath, newDiags);
+      state4.pushDiagnosticTimestamps.set(normalizedPath, Date.now());
       recordDocVersion();
-      bumpDiagnosticsVersion(state5, normalizedPath);
-      state5.diagnosticEmitter.emit("diagnostics", normalizedPath);
+      bumpDiagnosticsVersion(state4, normalizedPath);
+      state4.diagnosticEmitter.emit("diagnostics", normalizedPath);
       logSequence(true, "quiet-window", Date.now() - publishReceivedAt);
     }, strategy.debounceMs);
-    state5.pendingDiagnostics.set(normalizedPath, timer);
+    state4.pendingDiagnostics.set(normalizedPath, timer);
   });
-  state5.connection.onRequest("workspace/workspaceFolders", () => [
-    { name: "workspace", uri: pathToFileURL2(state5.root).href }
+  state4.connection.onRequest("workspace/workspaceFolders", () => [
+    { name: "workspace", uri: pathToFileURL2(state4.root).href }
   ]);
-  state5.connection.onRequest("client/registerCapability", async (params) => {
+  state4.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") : void 0;
       if (reg.id && reg.method) {
-        state5.dynamicRegistrations.set(reg.id, {
+        state4.dynamicRegistrations.set(reg.id, {
           method: reg.method,
           ...typeof options?.identifier === "string" && options.identifier ? { identifier: options.identifier } : {},
           ...typeof options?.workspaceDiagnostics === "boolean" ? { workspaceDiagnostics: options.workspaceDiagnostics } : {},
@@ -13451,45 +13391,45 @@ function setupIncomingHandlers(state5, initialization, onDiagnosticsPublished) {
       }
       if (reg.method === "workspace/executeCommand" && commands) {
         for (const cmd of commands)
-          state5.advertisedCommands.add(cmd);
+          state4.advertisedCommands.add(cmd);
       }
     }
-    applyDynamicCapabilities(state5);
+    applyDynamicCapabilities(state4);
   });
-  state5.connection.onRequest("client/unregisterCapability", async (params) => {
+  state4.connection.onRequest("client/unregisterCapability", async (params) => {
     const retiredIdentifiers = /* @__PURE__ */ new Set();
     for (const unreg of params?.unregisterations ?? []) {
       if (!unreg.id)
         continue;
-      const registration = state5.dynamicRegistrations.get(unreg.id);
-      state5.dynamicRegistrations.delete(unreg.id);
+      const registration = state4.dynamicRegistrations.get(unreg.id);
+      state4.dynamicRegistrations.delete(unreg.id);
       if (registration?.method === "textDocument/diagnostic" && registration.identifier) {
         retiredIdentifiers.add(registration.identifier);
       }
     }
-    const stillRegistered = new Set([...state5.dynamicRegistrations.values()].filter((r) => r.method === "textDocument/diagnostic").map((r) => r.identifier));
+    const stillRegistered = new Set([...state4.dynamicRegistrations.values()].filter((r) => r.method === "textDocument/diagnostic").map((r) => r.identifier));
     for (const identifier of retiredIdentifiers) {
       if (!stillRegistered.has(identifier)) {
-        retirePullSource(state5, identifier);
+        retirePullSource(state4, identifier);
       }
     }
-    applyDynamicCapabilities(state5);
+    applyDynamicCapabilities(state4);
   });
-  state5.connection.onRequest("workspace/applyEdit", async (params) => {
-    if (state5.serverEditsAllowed <= 0 || !params?.edit) {
+  state4.connection.onRequest("workspace/applyEdit", async (params) => {
+    if (state4.serverEditsAllowed <= 0 || !params?.edit) {
       return { applied: false, failureReason: "edit not solicited" };
     }
-    const context = state5.activeMutationContext;
+    const context = state4.activeMutationContext;
     const telemetryContext = context ?? {
-      cwd: state5.root,
+      cwd: state4.root,
       correlationId: newLspMutationCorrelationId(),
       tool: "lsp-workspace-applyEdit",
       source: "lsp-execute-command"
     };
     try {
-      await applyWorkspaceEdit(params.edit, state5.root, {
-        positionEncoding: state5.positionEncoding,
-        documentVersions: state5.documentVersions,
+      await applyWorkspaceEdit(params.edit, state4.root, {
+        positionEncoding: state4.positionEncoding,
+        documentVersions: state4.documentVersions,
         mutationContext: telemetryContext
       });
       return { applied: true };
@@ -13500,30 +13440,30 @@ function setupIncomingHandlers(state5, initialization, onDiagnosticsPublished) {
       };
     }
   });
-  state5.connection.onRequest("workspace/configuration", async (params) => {
+  state4.connection.onRequest("workspace/configuration", async (params) => {
     const items = params?.items ?? [];
     return items.map((item) => resolveConfigurationSection(initialization, item?.section));
   });
-  state5.connection.onRequest("window/workDoneProgress/create", async () => {
+  state4.connection.onRequest("window/workDoneProgress/create", async () => {
   });
-  state5.connection.onNotification("semgrep/rulesRefreshed", () => rebaselineForRulesRefresh(state5));
+  state4.connection.onNotification("semgrep/rulesRefreshed", () => rebaselineForRulesRefresh(state4));
   let refreshRepullRunning = false;
   let refreshRepullRerunRequested = false;
   const runRefreshRepullPool = async () => {
     do {
       refreshRepullRerunRequested = false;
-      const toRepull = state5.workspaceDiagnosticsSupport.mode === "pull" ? [...state5.openDocuments] : [];
+      const toRepull = state4.workspaceDiagnosticsSupport.mode === "pull" ? [...state4.openDocuments] : [];
       if (toRepull.length > 0) {
         try {
           await mapWithConcurrency(toRepull, REFRESH_REPULL_CONCURRENCY, async (normalizedPath) => {
-            const uri = state5.openDocumentUris?.get(normalizedPath);
+            const uri = state4.openDocumentUris?.get(normalizedPath);
             const filePath = uri ? uriToPath(uri) : normalizedPath;
-            await clientRequestPullDiagnostics(state5, filePath);
+            await clientRequestPullDiagnostics(state4, filePath);
           });
         } catch (err) {
           incrementDegradationCount({
             kind: "lsp-pull-unconfirmed",
-            subject: state5.serverId,
+            subject: state4.serverId,
             reason: `refresh re-pull threw: ${err instanceof Error ? err.message : String(err)}`
           });
         }
@@ -13531,14 +13471,14 @@ function setupIncomingHandlers(state5, initialization, onDiagnosticsPublished) {
     } while (refreshRepullRerunRequested);
     refreshRepullRunning = false;
   };
-  state5.connection.onRequest("workspace/diagnostic/refresh", async () => {
-    state5.workspacePullResultCache.clear();
+  state4.connection.onRequest("workspace/diagnostic/refresh", async () => {
+    state4.workspacePullResultCache.clear();
     clearAllWorkspaceDiagnosticsCaches();
-    clearWorkspaceDiagnosticsCacheAtAndAbove(state5.root);
-    for (const normalizedPath of state5.openDocuments) {
-      clearDiagnosticsForPath(state5, normalizedPath);
+    clearWorkspaceDiagnosticsCacheAtAndAbove(state4.root);
+    for (const normalizedPath of state4.openDocuments) {
+      clearDiagnosticsForPath(state4, normalizedPath);
     }
-    if (state5.workspaceDiagnosticsSupport.mode === "pull" && state5.openDocuments.size > 0) {
+    if (state4.workspaceDiagnosticsSupport.mode === "pull" && state4.openDocuments.size > 0) {
       if (refreshRepullRunning) {
         refreshRepullRerunRequested = true;
       } else {
@@ -13551,40 +13491,40 @@ function setupIncomingHandlers(state5, initialization, onDiagnosticsPublished) {
     return null;
   });
 }
-function markExitedIfUnset(state5) {
-  if (state5.exitedAt === void 0) {
-    state5.exitedAt = Date.now();
+function markExitedIfUnset(state4) {
+  if (state4.exitedAt === void 0) {
+    state4.exitedAt = Date.now();
   }
 }
-function setupConnectionLifecycle(state5, recentStderr) {
-  state5.connection.onError(([error]) => {
-    state5.lastError = error instanceof Error ? error : new Error(String(error));
-    state5.isConnected = false;
-    state5.isDestroyed = true;
-    markExitedIfUnset(state5);
-    disposeClientConnection(state5);
+function setupConnectionLifecycle(state4, recentStderr) {
+  state4.connection.onError(([error]) => {
+    state4.lastError = error instanceof Error ? error : new Error(String(error));
+    state4.isConnected = false;
+    state4.isDestroyed = true;
+    markExitedIfUnset(state4);
+    disposeClientConnection(state4);
   });
-  state5.connection.onClose(() => {
-    state5.isConnected = false;
-    state5.isDestroyed = true;
-    markExitedIfUnset(state5);
-    disposeClientConnection(state5);
+  state4.connection.onClose(() => {
+    state4.isConnected = false;
+    state4.isDestroyed = true;
+    markExitedIfUnset(state4);
+    disposeClientConnection(state4);
   });
-  state5.lspProcess.process.on("exit", (code, signal) => {
-    const wasIntentional = state5.shutdownRequested;
-    state5.isConnected = false;
-    state5.isDestroyed = true;
-    markExitedIfUnset(state5);
-    disposeClientConnection(state5);
+  state4.lspProcess.process.on("exit", (code, signal) => {
+    const wasIntentional = state4.shutdownRequested;
+    state4.isConnected = false;
+    state4.isDestroyed = true;
+    markExitedIfUnset(state4);
+    disposeClientConnection(state4);
     if (!wasIntentional) {
       logLatency({
         type: "phase",
         phase: "lsp_server_unexpected_exit",
-        filePath: state5.root,
+        filePath: state4.root,
         durationMs: 0,
         metadata: {
-          serverId: state5.serverId,
-          pid: state5.lspProcess.pid,
+          serverId: state4.serverId,
+          pid: state4.lspProcess.pid,
           exitCode: code ?? null,
           exitSignal: signal ?? null,
           stderrTail: recentStderr(20)
@@ -13592,44 +13532,44 @@ function setupConnectionLifecycle(state5, recentStderr) {
       });
     }
   });
-  state5.lspProcess.process.on("close", (code, signal) => {
-    if (state5.shutdownRequested)
+  state4.lspProcess.process.on("close", (code, signal) => {
+    if (state4.shutdownRequested)
       return;
     try {
       const stderrTail = recentStderr(20);
       incrementDegradationCount({
         kind: "lsp-server-unexpected-close",
-        subject: state5.serverId,
-        reason: `closed unprompted: code=${code ?? "none"} signal=${signal ?? "none"} stderr=${stderrTail.length > 0 ? `present(${stderrTail.length}b)` : "empty"} root=${state5.root}`
+        subject: state4.serverId,
+        reason: `closed unprompted: code=${code ?? "none"} signal=${signal ?? "none"} stderr=${stderrTail.length > 0 ? `present(${stderrTail.length}b)` : "empty"} root=${state4.root}`
       });
     } catch {
     }
   });
 }
 var PULL_RACE_BACKSTOP_MARGIN_MS = 25;
-async function clientRequestPullDiagnostics(state5, filePath, budgetMs = PULL_REQUEST_TIMEOUT_MS) {
-  if (!isClientAlive(state5))
+async function clientRequestPullDiagnostics(state4, filePath, budgetMs = PULL_REQUEST_TIMEOUT_MS) {
+  if (!isClientAlive(state4))
     return { status: "unavailable" };
-  const sources = pullDiagnosticSources(state5);
+  const sources = pullDiagnosticSources(state4);
   if (sources.length === 1) {
-    return aggregatePullOutcomes(state5, filePath, [
-      await pullDiagnosticSource(state5, filePath, budgetMs, void 0)
+    return aggregatePullOutcomes(state4, filePath, [
+      await pullDiagnosticSource(state4, filePath, budgetMs, void 0)
     ]);
   }
-  const attempts = sources.map((identifier) => pullDiagnosticSource(state5, filePath, budgetMs, identifier));
+  const attempts = sources.map((identifier) => pullDiagnosticSource(state4, filePath, budgetMs, identifier));
   const settled = await raceToCompletion(attempts, (results) => results.some((r) => r.status === "found" && r.primaryCount > 0), {
     // No graceMs: finalize the instant a source answers for this file.
     // The per-request `withTimeout` inside each attempt is the real bound;
     // this deadline is only a backstop, so it sits just past it.
     timeoutMs: Math.max(1, Math.min(PULL_REQUEST_TIMEOUT_MS, budgetMs)) + PULL_RACE_BACKSTOP_MARGIN_MS
   });
-  return aggregatePullOutcomes(state5, filePath, settled);
+  return aggregatePullOutcomes(state4, filePath, settled);
 }
-function aggregatePullOutcomes(state5, filePath, outcomes) {
+function aggregatePullOutcomes(state4, filePath, outcomes) {
   const found = outcomes.filter((o) => o.status === "found");
   if (found.length > 0) {
     const normalizedPath = normalizeMapKey(filePath);
-    const unionCount = state5.documentPullDiagnostics.get(normalizedPath)?.length ?? 0;
+    const unionCount = state4.documentPullDiagnostics.get(normalizedPath)?.length ?? 0;
     return {
       status: "found",
       count: Math.max(unionCount, ...found.map((o) => o.count))
@@ -13640,39 +13580,39 @@ function aggregatePullOutcomes(state5, filePath, outcomes) {
   }
   return outcomes.some((o) => o.status === "clean") ? { status: "clean" } : { status: "unavailable" };
 }
-async function pullDiagnosticSource(state5, filePath, budgetMs, identifier) {
-  if (!isClientAlive(state5))
+async function pullDiagnosticSource(state4, filePath, budgetMs, identifier) {
+  if (!isClientAlive(state4))
     return { status: "unavailable" };
   const normalizedPath = normalizeMapKey(filePath);
   if (budgetMs < PULL_MIN_USABLE_BUDGET_MS) {
-    emitBounded("lsp_pull_skipped_budget_exhausted", `${state5.serverId}::${pullSourceKey(normalizedPath, identifier)}`, {
+    emitBounded("lsp_pull_skipped_budget_exhausted", `${state4.serverId}::${pullSourceKey(normalizedPath, identifier)}`, {
       type: "phase",
       filePath: normalizedPath,
       durationMs: 0,
       metadata: {
         identifier: identifier ?? "bare",
         remainingBudgetMs: budgetMs,
-        server: state5.serverId
+        server: state4.serverId
       }
     }, {
       ledgerKind: "lsp-pull-skipped-budget-exhausted",
-      reason: `pull skipped on ${state5.serverId}: budget already exhausted (${budgetMs}ms remaining)`
+      reason: `pull skipped on ${state4.serverId}: budget already exhausted (${budgetMs}ms remaining)`
     });
     return { status: "unavailable" };
   }
   const uri = pathToFileURL2(filePath).href;
   const sourceKey = pullSourceKey(normalizedPath, identifier);
-  if (state5.abandonedPullRequests?.has(sourceKey)) {
+  if (state4.abandonedPullRequests?.has(sourceKey)) {
     return { status: "unavailable" };
   }
-  const previousResultId = state5.pullResultIds.get(sourceKey);
-  const generation = pullGenerationFor(state5, normalizedPath);
-  const requestSequence = claimPullRequestSequence(state5, sourceKey);
+  const previousResultId = state4.pullResultIds.get(sourceKey);
+  const generation = pullGenerationFor(state4, normalizedPath);
+  const requestSequence = claimPullRequestSequence(state4, 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(state5.connection, "textDocument/diagnostic", {
+  const requestPromise = safeSendRequest(state4.connection, "textDocument/diagnostic", {
     textDocument: { uri },
     // #1667: name the source this request is for, so the server answers
     // from that source instead of its default one.
@@ -13682,56 +13622,56 @@ async function pullDiagnosticSource(state5, filePath, budgetMs, identifier) {
   try {
     const report = await withTimeout(requestPromise, effectiveTimeoutMs);
     if (!report) {
-      recordPullFailure(state5, "textDocument/diagnostic", new Error("empty response"));
+      recordPullFailure(state4, "textDocument/diagnostic", new Error("empty response"));
       return { status: "unavailable" };
     }
     const now = Date.now();
-    const sentHash = state5.documentContentHashes.get(normalizedPath)?.hash;
-    if (pullGenerationFor(state5, normalizedPath) !== generation || !isNewestPullRequest(state5, sourceKey, requestSequence)) {
+    const sentHash = state4.documentContentHashes.get(normalizedPath)?.hash;
+    if (pullGenerationFor(state4, normalizedPath) !== generation || !isNewestPullRequest(state4, sourceKey, requestSequence)) {
       return { status: "unavailable" };
     }
     let primaryCount;
     if (report.kind === "unchanged") {
-      primaryCount = pullSourceDiagnostics(state5, normalizedPath, identifier).length;
-      state5.documentPullDiagnosticTimestamps.set(normalizedPath, now);
+      primaryCount = pullSourceDiagnostics(state4, normalizedPath, identifier).length;
+      state4.documentPullDiagnosticTimestamps.set(normalizedPath, now);
     } else {
       const primaryItems = normalizeLspDiagnostics(report.items ?? []);
-      storePullSourceDiagnostics(state5, normalizedPath, identifier, primaryItems);
-      state5.documentPullDiagnosticTimestamps.set(normalizedPath, now);
-      bumpDiagnosticsVersion(state5, normalizedPath);
-      state5.diagnosticBindings.set(normalizedPath, { contentHash: sentHash });
+      storePullSourceDiagnostics(state4, normalizedPath, identifier, primaryItems);
+      state4.documentPullDiagnosticTimestamps.set(normalizedPath, now);
+      bumpDiagnosticsVersion(state4, normalizedPath);
+      state4.diagnosticBindings.set(normalizedPath, { contentHash: sentHash });
       primaryCount = primaryItems.length;
     }
     let totalCount = primaryCount;
     if (report.resultId !== void 0) {
-      state5.pullResultIds.set(sourceKey, report.resultId);
+      state4.pullResultIds.set(sourceKey, report.resultId);
     } else {
-      state5.pullResultIds.delete(sourceKey);
+      state4.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(state5, relatedNormalized, identifier).length;
-          state5.documentPullDiagnosticTimestamps.set(relatedNormalized, now);
+          totalCount += pullSourceDiagnostics(state4, relatedNormalized, identifier).length;
+          state4.documentPullDiagnosticTimestamps.set(relatedNormalized, now);
         } else {
           const relatedItems = normalizeLspDiagnostics(related?.items ?? []);
-          storePullSourceDiagnostics(state5, relatedNormalized, identifier, relatedItems);
-          state5.documentPullDiagnosticTimestamps.set(relatedNormalized, now);
-          state5.diagnosticBindings.delete(relatedNormalized);
+          storePullSourceDiagnostics(state4, relatedNormalized, identifier, relatedItems);
+          state4.documentPullDiagnosticTimestamps.set(relatedNormalized, now);
+          state4.diagnosticBindings.delete(relatedNormalized);
           totalCount += relatedItems.length;
         }
         if (related?.resultId !== void 0) {
-          state5.pullResultIds.set(pullSourceKey(relatedNormalized, identifier), related.resultId);
+          state4.pullResultIds.set(pullSourceKey(relatedNormalized, identifier), related.resultId);
         }
       }
     }
-    state5.diagnosticEmitter.emit("diagnostics", normalizedPath);
+    state4.diagnosticEmitter.emit("diagnostics", normalizedPath);
     return totalCount > 0 ? { status: "found", count: totalCount, primaryCount } : { status: "clean" };
   } catch (err) {
     if (isPullTimeoutError(err, effectiveTimeoutMs)) {
-      trackAbandonedPullRequest(state5, sourceKey, requestPromise);
+      trackAbandonedPullRequest(state4, sourceKey, requestPromise);
       pullAbort.abort();
       recordPullTimeoutTelemetry({
         scope: normalizedPath,
@@ -13739,7 +13679,7 @@ async function pullDiagnosticSource(state5, filePath, budgetMs, identifier) {
         effectiveBudgetMs: effectiveTimeoutMs,
         hadPreviousResultId: previousResultId !== void 0,
         elapsedMs: Date.now() - requestStartedAt,
-        server: state5.serverId
+        server: state4.serverId
       });
       armLateAnswerTelemetry({
         requestPromise,
@@ -13747,21 +13687,21 @@ async function pullDiagnosticSource(state5, filePath, budgetMs, identifier) {
         identifier,
         subject: sourceKey,
         requestStartedAt,
-        server: state5.serverId,
+        server: state4.serverId,
         settlement: pullSettlement
       });
     }
-    recordPullFailure(state5, "textDocument/diagnostic", err);
+    recordPullFailure(state4, "textDocument/diagnostic", err);
     return { status: "unavailable" };
   }
 }
-function trackAbandonedPullRequest(state5, sourceKey, requestPromise) {
-  if (!state5.abandonedPullRequests)
-    state5.abandonedPullRequests = /* @__PURE__ */ new Map();
-  state5.abandonedPullRequests.set(sourceKey, requestPromise);
+function trackAbandonedPullRequest(state4, sourceKey, requestPromise) {
+  if (!state4.abandonedPullRequests)
+    state4.abandonedPullRequests = /* @__PURE__ */ new Map();
+  state4.abandonedPullRequests.set(sourceKey, requestPromise);
   const release = () => {
-    if (state5.abandonedPullRequests?.get(sourceKey) === requestPromise) {
-      state5.abandonedPullRequests.delete(sourceKey);
+    if (state4.abandonedPullRequests?.get(sourceKey) === requestPromise) {
+      state4.abandonedPullRequests.delete(sourceKey);
     }
   };
   requestPromise.then(release, release);
@@ -13835,43 +13775,43 @@ function armLateAnswerTelemetry(args) {
   });
 }
 var PULL_FAILURE_HISTORY_LIMIT = 10;
-function recordPullFailure(state5, method, error) {
+function recordPullFailure(state4, 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;
-  state5.pullFailureHistory.push({
+  state4.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 (state5.pullFailureHistory.length > PULL_FAILURE_HISTORY_LIMIT) {
-    state5.pullFailureHistory.splice(0, state5.pullFailureHistory.length - PULL_FAILURE_HISTORY_LIMIT);
+  if (state4.pullFailureHistory.length > PULL_FAILURE_HISTORY_LIMIT) {
+    state4.pullFailureHistory.splice(0, state4.pullFailureHistory.length - PULL_FAILURE_HISTORY_LIMIT);
   }
 }
-async function clientRequestWorkspaceDiagnostics(state5, budgetMs) {
-  if (!isClientAlive(state5))
+async function clientRequestWorkspaceDiagnostics(state4, budgetMs) {
+  if (!isClientAlive(state4))
     return void 0;
-  if (!state5.workspaceDiagnosticsSupport.workspaceDiagnostics)
+  if (!state4.workspaceDiagnosticsSupport.workspaceDiagnostics)
     return void 0;
-  if (state5.abandonedPullRequests?.has(WORKSPACE_PULL_SCOPE))
+  if (state4.abandonedPullRequests?.has(WORKSPACE_PULL_SCOPE))
     return void 0;
-  const previousResultIds = Array.from(state5.workspacePullResultCache.values()).map((entry) => ({ uri: entry.uri, value: entry.resultId }));
+  const previousResultIds = Array.from(state4.workspacePullResultCache.values()).map((entry) => ({ uri: entry.uri, value: entry.resultId }));
   if (budgetMs < PULL_MIN_USABLE_BUDGET_MS) {
-    emitBounded("lsp_pull_skipped_budget_exhausted", `${state5.serverId}::${WORKSPACE_PULL_SCOPE}`, {
+    emitBounded("lsp_pull_skipped_budget_exhausted", `${state4.serverId}::${WORKSPACE_PULL_SCOPE}`, {
       type: "phase",
       filePath: WORKSPACE_PULL_SCOPE,
       durationMs: 0,
       metadata: {
         identifier: "bare",
         remainingBudgetMs: budgetMs,
-        server: state5.serverId
+        server: state4.serverId
       }
     }, {
       ledgerKind: "lsp-pull-skipped-budget-exhausted",
-      reason: `workspace pull skipped on ${state5.serverId}: budget already exhausted (${budgetMs}ms remaining)`
+      reason: `workspace pull skipped on ${state4.serverId}: budget already exhausted (${budgetMs}ms remaining)`
     });
     return void 0;
   }
@@ -13879,7 +13819,7 @@ async function clientRequestWorkspaceDiagnostics(state5, budgetMs) {
   const workspacePullTimeoutMs = Math.max(1, budgetMs);
   const workspacePullAbort = new AbortController();
   const workspacePullSettlement = { cancelled: false };
-  const workspaceRequestPromise = safeSendRequest(state5.connection, "workspace/diagnostic", { previousResultIds }, workspacePullAbort.signal, workspacePullSettlement);
+  const workspaceRequestPromise = safeSendRequest(state4.connection, "workspace/diagnostic", { previousResultIds }, workspacePullAbort.signal, workspacePullSettlement);
   try {
     const report = await withTimeout(workspaceRequestPromise, workspacePullTimeoutMs);
     if (!report || !Array.isArray(report.items))
@@ -13892,35 +13832,35 @@ async function clientRequestWorkspaceDiagnostics(state5, budgetMs) {
       const filePath = uriToPath(item.uri);
       const normalizedPath = normalizeMapKey(filePath);
       if (item.kind === "unchanged") {
-        const prior = state5.workspacePullResultCache.get(normalizedPath);
+        const prior = state4.workspacePullResultCache.get(normalizedPath);
         if (!prior) {
           const remainingMs = fallbackPullDeadline - Date.now();
           if (remainingMs <= 0) {
             incrementDegradationCount({
               kind: "lsp-pull-unconfirmed",
-              subject: state5.serverId,
+              subject: state4.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(state5, filePath, remainingMs);
+          const outcome = await clientRequestPullDiagnostics(state4, filePath, remainingMs);
           if (outcome.status === "found") {
             out.push({
               filePath,
-              diagnostics: state5.documentPullDiagnostics.get(normalizedPath) ?? [],
-              contentHash: state5.diagnosticBindings.get(normalizedPath)?.contentHash
+              diagnostics: state4.documentPullDiagnostics.get(normalizedPath) ?? [],
+              contentHash: state4.diagnosticBindings.get(normalizedPath)?.contentHash
             });
           } else if (outcome.status === "unavailable") {
             incrementDegradationCount({
               kind: "lsp-pull-unconfirmed",
-              subject: state5.serverId,
+              subject: state4.serverId,
               reason: "unchanged report with no workspacePullResultCache basis, and the per-file fallback pull was unavailable"
             });
           }
           continue;
         }
         if (item.resultId !== void 0) {
-          state5.workspacePullResultCache.set(normalizedPath, {
+          state4.workspacePullResultCache.set(normalizedPath, {
             ...prior,
             resultId: item.resultId
           });
@@ -13933,27 +13873,27 @@ async function clientRequestWorkspaceDiagnostics(state5, budgetMs) {
         continue;
       }
       const diagnostics = normalizeLspDiagnostics(item.items ?? []);
-      const sent = state5.openDocuments.has(normalizedPath) ? state5.documentContentHashes.get(normalizedPath) : void 0;
+      const sent = state4.openDocuments.has(normalizedPath) ? state4.documentContentHashes.get(normalizedPath) : void 0;
       const contentHash2 = sent !== void 0 && sent.version === item.version ? sent.hash : void 0;
       if (item.resultId !== void 0) {
-        if (state5.workspacePullResultCache.size >= WORKSPACE_PULL_RESULT_CACHE_MAX) {
-          state5.workspacePullResultCache.clear();
+        if (state4.workspacePullResultCache.size >= WORKSPACE_PULL_RESULT_CACHE_MAX) {
+          state4.workspacePullResultCache.clear();
         }
-        state5.workspacePullResultCache.set(normalizedPath, {
+        state4.workspacePullResultCache.set(normalizedPath, {
           uri: item.uri,
           resultId: item.resultId,
           diagnostics,
           contentHash: contentHash2
         });
       } else {
-        state5.workspacePullResultCache.delete(normalizedPath);
+        state4.workspacePullResultCache.delete(normalizedPath);
       }
       out.push({ filePath, diagnostics, contentHash: contentHash2 });
     }
     return out;
   } catch (err) {
     if (isPullTimeoutError(err, workspacePullTimeoutMs)) {
-      trackAbandonedPullRequest(state5, WORKSPACE_PULL_SCOPE, workspaceRequestPromise);
+      trackAbandonedPullRequest(state4, WORKSPACE_PULL_SCOPE, workspaceRequestPromise);
       workspacePullAbort.abort();
       recordPullTimeoutTelemetry({
         scope: WORKSPACE_PULL_SCOPE,
@@ -13961,7 +13901,7 @@ async function clientRequestWorkspaceDiagnostics(state5, budgetMs) {
         effectiveBudgetMs: workspacePullTimeoutMs,
         hadPreviousResultId: previousResultIds.length > 0,
         elapsedMs: Date.now() - workspacePullStartedAt,
-        server: state5.serverId
+        server: state4.serverId
       });
       armLateAnswerTelemetry({
         requestPromise: workspaceRequestPromise,
@@ -13969,55 +13909,55 @@ async function clientRequestWorkspaceDiagnostics(state5, budgetMs) {
         identifier: void 0,
         subject: WORKSPACE_PULL_SCOPE,
         requestStartedAt: workspacePullStartedAt,
-        server: state5.serverId,
+        server: state4.serverId,
         settlement: workspacePullSettlement
       });
     }
-    recordPullFailure(state5, "workspace/diagnostic", err);
+    recordPullFailure(state4, "workspace/diagnostic", err);
     return void 0;
   }
 }
-async function clientWaitForDiagnostics(state5, filePath, timeoutMs, options = {}) {
+async function clientWaitForDiagnostics(state4, filePath, timeoutMs, options = {}) {
   const normalizedPath = normalizeMapKey(filePath);
   const minVersion = options.minVersion;
   const pullSettleSource = options.pullSettleSource ?? "pull";
-  const hasFreshDiagnostics = () => minVersion === void 0 || diagnosticsVersionForPath(state5, normalizedPath) > minVersion;
+  const hasFreshDiagnostics = () => minVersion === void 0 || diagnosticsVersionForPath(state4, normalizedPath) > minVersion;
   const isVersionStale = () => {
-    const cachedVersion = state5.diagnosticDocVersions?.get(normalizedPath);
+    const cachedVersion = state4.diagnosticDocVersions?.get(normalizedPath);
     if (cachedVersion === void 0)
       return false;
-    const currentVersion = state5.documentVersions?.get(normalizedPath);
+    const currentVersion = state4.documentVersions?.get(normalizedPath);
     return currentVersion !== void 0 && cachedVersion < currentVersion;
   };
-  if (state5.workspaceDiagnosticsSupport.mode === "pull") {
+  if (state4.workspaceDiagnosticsSupport.mode === "pull") {
     const pullSettleStartedAt = Date.now();
-    let outcome = await clientRequestPullDiagnostics(state5, filePath, timeoutMs);
+    let outcome = await clientRequestPullDiagnostics(state4, filePath, timeoutMs);
     if (outcome.status === "found") {
-      logTypeScriptPullSettle(state5, normalizedPath, Date.now() - pullSettleStartedAt, pullSettleSource);
+      logTypeScriptPullSettle(state4, normalizedPath, Date.now() - pullSettleStartedAt, pullSettleSource);
       return;
     }
     let sawClean = outcome.status === "clean";
-    const strategy = getStrategy(state5.serverId, state5.launchVariant);
+    const strategy = getStrategy(state4.serverId, state4.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((resolve9) => setTimeout(resolve9, PULL_DIAGNOSTICS_RETRY_INTERVAL_MS));
-      outcome = await clientRequestPullDiagnostics(state5, filePath, Math.max(0, retryBudgetMs - (Date.now() - startedAt)));
+      outcome = await clientRequestPullDiagnostics(state4, filePath, Math.max(0, retryBudgetMs - (Date.now() - startedAt)));
       if (outcome.status === "clean")
         sawClean = true;
     }
     if (options.pullOnly) {
       if (outcome.status === "found" || sawClean) {
-        logTypeScriptPullSettle(state5, normalizedPath, Date.now() - pullSettleStartedAt, pullSettleSource);
+        logTypeScriptPullSettle(state4, normalizedPath, Date.now() - pullSettleStartedAt, pullSettleSource);
       }
       return;
     }
     if (outcome.status === "found" || sawClean) {
-      logTypeScriptPullSettle(state5, normalizedPath, Date.now() - pullSettleStartedAt, pullSettleSource);
+      logTypeScriptPullSettle(state4, normalizedPath, Date.now() - pullSettleStartedAt, pullSettleSource);
       return;
     }
   }
-  if (hasFreshDiagnostics() && !isVersionStale() && getMergedDiagnosticsForPath(state5, normalizedPath).length > 0) {
+  if (hasFreshDiagnostics() && !isVersionStale() && getMergedDiagnosticsForPath(state4, normalizedPath).length > 0) {
     return;
   }
   return new Promise((resolve9) => {
@@ -14029,124 +13969,124 @@ async function clientWaitForDiagnostics(state5, filePath, timeoutMs, options = {
         return;
       if (debounceTimer)
         clearTimeout(debounceTimer);
-      const strategy = getStrategy(state5.serverId, state5.launchVariant);
-      const hit = state5.pushDiagnosticTimestamps.get(normalizedPath);
+      const strategy = getStrategy(state4.serverId, state4.launchVariant);
+      const hit = state4.pushDiagnosticTimestamps.get(normalizedPath);
       const timeSincePush = hit ? Date.now() - hit : Infinity;
       const remaining = Math.max(0, strategy.debounceMs - timeSincePush);
       debounceTimer = setTimeout(() => {
-        state5.diagnosticEmitter.off("diagnostics", onDiagnostics);
+        state4.diagnosticEmitter.off("diagnostics", onDiagnostics);
         clearTimeout(timeout);
         resolve9();
       }, remaining);
     };
-    state5.diagnosticEmitter.on("diagnostics", onDiagnostics);
+    state4.diagnosticEmitter.on("diagnostics", onDiagnostics);
     const timeout = setTimeout(() => {
       if (debounceTimer)
         clearTimeout(debounceTimer);
-      state5.diagnosticEmitter.off("diagnostics", onDiagnostics);
+      state4.diagnosticEmitter.off("diagnostics", onDiagnostics);
       resolve9();
     }, timeoutMs);
   });
 }
-function handleNotifyExternalChange(state5, filePath, type) {
-  if (!isClientAlive(state5))
+function handleNotifyExternalChange(state4, filePath, type) {
+  if (!isClientAlive(state4))
     return;
   const normalizedPath = normalizeMapKey(filePath);
-  const uri = state5.openDocumentUris?.get(normalizedPath) ?? pathToFileURL2(filePath).href;
-  state5.watchQueue.enqueue(uri, type);
+  const uri = state4.openDocumentUris?.get(normalizedPath) ?? pathToFileURL2(filePath).href;
+  state4.watchQueue.enqueue(uri, type);
 }
-function expectSaveRescan(state5, normalizedPath) {
-  if (!getStrategy(state5.serverId, state5.launchVariant).rescansOnSave)
+function expectSaveRescan(state4, normalizedPath) {
+  if (!getStrategy(state4.serverId, state4.launchVariant).rescansOnSave)
     return;
-  const beyond = state5.expectedPublicationsBeyondSends;
+  const beyond = state4.expectedPublicationsBeyondSends;
   beyond?.set(normalizedPath, (beyond.get(normalizedPath) ?? 0) + 1);
 }
-async function sendDidSave(state5, normalizedPath, uri, content) {
-  const save = state5.saveOptions;
+async function sendDidSave(state4, normalizedPath, uri, content) {
+  const save = state4.saveOptions;
   if (!save)
     return;
-  if (!isClientAlive(state5))
+  if (!isClientAlive(state4))
     return;
-  expectSaveRescan(state5, normalizedPath);
+  expectSaveRescan(state4, normalizedPath);
   const limit = save.includeText ? exceedsLspSyncLimits(content) : { tooLarge: false, reason: "" };
   if (limit.tooLarge) {
     recordDegradationOnce({
       kind: "lsp-did-save-text-omitted",
-      subject: state5.serverId,
+      subject: state4.serverId,
       reason: limit.reason
     });
   }
-  await safeSendNotification(state5.connection, "textDocument/didSave", {
+  await safeSendNotification(state4.connection, "textDocument/didSave", {
     textDocument: { uri },
     ...save.includeText && !limit.tooLarge ? { text: content } : {}
   });
 }
-async function sendDidSaveForHeldDocument(state5, normalizedPath) {
-  if (!state5.saveOptions || !isClientAlive(state5))
+async function sendDidSaveForHeldDocument(state4, normalizedPath) {
+  if (!state4.saveOptions || !isClientAlive(state4))
     return;
-  if (!state5.openDocuments.has(normalizedPath))
+  if (!state4.openDocuments.has(normalizedPath))
     return;
-  const uri = state5.openDocumentUris?.get(normalizedPath);
+  const uri = state4.openDocumentUris?.get(normalizedPath);
   if (uri === void 0)
     return;
-  expectSaveRescan(state5, normalizedPath);
+  expectSaveRescan(state4, normalizedPath);
   try {
-    await safeSendNotification(state5.connection, "textDocument/didSave", {
+    await safeSendNotification(state4.connection, "textDocument/didSave", {
       textDocument: { uri }
     });
   } catch {
   }
 }
-async function handleNotifyOpenOnce(state5, filePath, content, languageId, preserveDiagnostics = false, silent = false, coalescedCount = 0, saved = false) {
-  if (!isClientAlive(state5))
+async function handleNotifyOpenOnce(state4, filePath, content, languageId, preserveDiagnostics = false, silent = false, coalescedCount = 0, saved = false) {
+  if (!isClientAlive(state4))
     return false;
   const normalizedPath = normalizeMapKey(filePath);
-  const uri = state5.openDocumentUris?.get(normalizedPath) ?? pathToFileURL2(filePath).href;
-  if (state5.openDocuments.has(normalizedPath) || state5.pendingOpens.has(normalizedPath)) {
-    const version = (state5.documentVersions.get(normalizedPath) ?? 0) + 1;
-    state5.documentVersions.set(normalizedPath, version);
+  const uri = state4.openDocumentUris?.get(normalizedPath) ?? pathToFileURL2(filePath).href;
+  if (state4.openDocuments.has(normalizedPath) || state4.pendingOpens.has(normalizedPath)) {
+    const version = (state4.documentVersions.get(normalizedPath) ?? 0) + 1;
+    state4.documentVersions.set(normalizedPath, version);
     if (!preserveDiagnostics) {
-      clearDiagnosticsForPath(state5, normalizedPath);
+      clearDiagnosticsForPath(state4, normalizedPath);
     }
-    if (getStrategy(state5.serverId, state5.launchVariant).reopenOnResync) {
-      await safeSendNotification(state5.connection, "textDocument/didClose", {
+    if (getStrategy(state4.serverId, state4.launchVariant).reopenOnResync) {
+      await safeSendNotification(state4.connection, "textDocument/didClose", {
         textDocument: { uri }
       });
-      state5.openDocuments.delete(normalizedPath);
-      state5.openDocumentUris?.delete(normalizedPath);
-      state5.documentVersions.set(normalizedPath, version);
-      state5.documentOpenedAt.set(normalizedPath, Date.now());
-      state5.diagnosticPublicationCounts.set(normalizedPath, 0);
-      if (!isClientAlive(state5))
+      state4.openDocuments.delete(normalizedPath);
+      state4.openDocumentUris?.delete(normalizedPath);
+      state4.documentVersions.set(normalizedPath, version);
+      state4.documentOpenedAt.set(normalizedPath, Date.now());
+      state4.diagnosticPublicationCounts.set(normalizedPath, 0);
+      if (!isClientAlive(state4))
         return false;
-      const reopenSent = await safeSendNotification(state5.connection, "textDocument/didOpen", { textDocument: { uri, languageId, version, text: content } });
+      const reopenSent = await safeSendNotification(state4.connection, "textDocument/didOpen", { textDocument: { uri, languageId, version, text: content } });
       if (reopenSent)
-        recordSentContent(state5, normalizedPath, version, content, coalescedCount);
-      state5.openDocuments.add(normalizedPath);
-      state5.openDocumentUris?.set(normalizedPath, uri);
+        recordSentContent(state4, normalizedPath, version, content, coalescedCount);
+      state4.openDocuments.add(normalizedPath);
+      state4.openDocumentUris?.set(normalizedPath, uri);
       if (saved && reopenSent)
-        await sendDidSave(state5, normalizedPath, uri, content);
+        await sendDidSave(state4, normalizedPath, uri, content);
       return reopenSent;
     }
-    const changeSent = await sendFenced(state5, normalizedPath, uri, "textDocument/didChange", {
+    const changeSent = await sendFenced(state4, normalizedPath, uri, "textDocument/didChange", {
       textDocument: { uri, version },
-      contentChanges: buildContentChanges(state5, normalizedPath, content)
+      contentChanges: buildContentChanges(state4, normalizedPath, content)
     });
     if (changeSent)
-      recordSentContent(state5, normalizedPath, version, content, coalescedCount);
+      recordSentContent(state4, normalizedPath, version, content, coalescedCount);
     if (saved && changeSent)
-      await sendDidSave(state5, normalizedPath, uri, content);
+      await sendDidSave(state4, normalizedPath, uri, content);
     return changeSent;
   }
-  if (await closedAndGone(state5, filePath, normalizedPath))
+  if (await closedAndGone(state4, filePath, normalizedPath))
     return false;
-  state5.pendingOpens.add(normalizedPath);
-  state5.documentVersions.set(normalizedPath, 0);
-  state5.documentOpenedAt.set(normalizedPath, Date.now());
-  state5.diagnosticPublicationCounts.set(normalizedPath, 0);
-  clearDiagnosticsForPath(state5, normalizedPath);
-  if (!state5.expectedPublicationsBeyondSends?.has(normalizedPath))
-    state5.publicationStoreCountsByPath?.delete(normalizedPath);
+  state4.pendingOpens.add(normalizedPath);
+  state4.documentVersions.set(normalizedPath, 0);
+  state4.documentOpenedAt.set(normalizedPath, Date.now());
+  state4.diagnosticPublicationCounts.set(normalizedPath, 0);
+  clearDiagnosticsForPath(state4, normalizedPath);
+  if (!state4.expectedPublicationsBeyondSends?.has(normalizedPath))
+    state4.publicationStoreCountsByPath?.delete(normalizedPath);
   if (!silent) {
     let fileExists = true;
     try {
@@ -14154,37 +14094,37 @@ async function handleNotifyOpenOnce(state5, filePath, content, languageId, prese
     } catch {
       fileExists = false;
     }
-    state5.watchQueue.enqueue(uri, fileExists ? 2 : 1);
+    state4.watchQueue.enqueue(uri, fileExists ? 2 : 1);
   }
-  if (!isClientAlive(state5))
+  if (!isClientAlive(state4))
     return false;
-  const openSent = await sendFenced(state5, normalizedPath, uri, "textDocument/didOpen", { textDocument: { uri, languageId, version: 0, text: content } });
+  const openSent = await sendFenced(state4, normalizedPath, uri, "textDocument/didOpen", { textDocument: { uri, languageId, version: 0, text: content } });
   if (openSent)
-    recordSentContent(state5, normalizedPath, 0, content, coalescedCount);
-  state5.pendingOpens.delete(normalizedPath);
-  state5.openDocuments.add(normalizedPath);
-  state5.closedDocuments?.delete(normalizedPath);
-  state5.openDocumentUris?.set(normalizedPath, uri);
+    recordSentContent(state4, normalizedPath, 0, content, coalescedCount);
+  state4.pendingOpens.delete(normalizedPath);
+  state4.openDocuments.add(normalizedPath);
+  state4.closedDocuments?.delete(normalizedPath);
+  state4.openDocumentUris?.set(normalizedPath, uri);
   if (saved && openSent)
-    await sendDidSave(state5, normalizedPath, uri, content);
+    await sendDidSave(state4, normalizedPath, uri, content);
   void probeTsserverProjectIdentity({
-    serverId: state5.serverId,
-    launchVariant: state5.launchVariant,
-    clientRoot: state5.root,
+    serverId: state4.serverId,
+    launchVariant: state4.launchVariant,
+    clientRoot: state4.root,
     file: filePath,
     normalizedFile: normalizedPath,
-    probedFiles: state5.projectIdentityProbedFiles ?? (state5.projectIdentityProbedFiles = /* @__PURE__ */ new Set()),
+    probedFiles: state4.projectIdentityProbedFiles ?? (state4.projectIdentityProbedFiles = /* @__PURE__ */ new Set()),
     commandChannel: {
-      executeCommand: (command, args) => runReadOnlyServerCommand(state5, command, args)
+      executeCommand: (command, args) => runReadOnlyServerCommand(state4, command, args)
     }
   });
   return openSent;
 }
-function enqueueDocumentNotify(state5, normalizedPath, run, saved = false, readStamp, close = false) {
-  let queue = state5.notifyChangeQueues.get(normalizedPath);
+function enqueueDocumentNotify(state4, normalizedPath, run, saved = false, readStamp, close = false) {
+  let queue = state4.notifyChangeQueues.get(normalizedPath);
   if (!queue) {
     queue = { running: false };
-    state5.notifyChangeQueues.set(normalizedPath, queue);
+    state4.notifyChangeQueues.set(normalizedPath, queue);
   }
   return new Promise((resolve9, reject) => {
     if (queue.closing && !close) {
@@ -14198,7 +14138,7 @@ function enqueueDocumentNotify(state5, normalizedPath, run, saved = false, readS
         waiter.stale = true;
       queue.closing = true;
     }
-    const lastSent = state5.sentReadStamps.get(normalizedPath);
+    const lastSent = state4.sentReadStamps.get(normalizedPath);
     const before = (a, b) => a !== void 0 && b !== void 0 && a < b;
     const stale = previous !== void 0 && (before(readStamp, previous.readStamp) || before(readStamp, lastSent));
     const heldStamp = before(previous?.readStamp, lastSent) ? void 0 : previous?.readStamp;
@@ -14224,16 +14164,16 @@ function enqueueDocumentNotify(state5, normalizedPath, run, saved = false, readS
           if (!next)
             break;
           queue.pending = void 0;
-          const lastSent2 = state5.sentReadStamps.get(normalizedPath);
+          const lastSent2 = state4.sentReadStamps.get(normalizedPath);
           if (next.readStamp !== void 0 && lastSent2 !== void 0 && next.readStamp < lastSent2) {
             if (next.saved)
-              await sendDidSaveForHeldDocument(state5, normalizedPath);
+              await sendDidSaveForHeldDocument(state4, normalizedPath);
             for (const waiter of next.waiters)
               waiter.resolve(false);
             continue;
           }
           if (next.readStamp !== void 0)
-            state5.sentReadStamps.set(normalizedPath, next.readStamp);
+            state4.sentReadStamps.set(normalizedPath, next.readStamp);
           try {
             const sent = await next.run(next.coalescedCount, next.saved);
             for (const waiter of next.waiters)
@@ -14245,33 +14185,33 @@ function enqueueDocumentNotify(state5, normalizedPath, run, saved = false, readS
         }
       } finally {
         queue.running = false;
-        if (!queue.pending && state5.notifyChangeQueues.get(normalizedPath) === queue) {
-          state5.notifyChangeQueues.delete(normalizedPath);
+        if (!queue.pending && state4.notifyChangeQueues.get(normalizedPath) === queue) {
+          state4.notifyChangeQueues.delete(normalizedPath);
         }
       }
     });
   });
 }
-function cancelDocumentNotifyQueues(state5) {
-  for (const queue of state5.notifyChangeQueues.values()) {
+function cancelDocumentNotifyQueues(state4) {
+  for (const queue of state4.notifyChangeQueues.values()) {
     for (const waiter of queue.pending?.waiters ?? [])
       waiter.resolve(false);
     queue.pending = void 0;
   }
-  state5.notifyChangeQueues.clear();
+  state4.notifyChangeQueues.clear();
 }
-function handleNotifyOpen(state5, filePath, content, languageId, preserveDiagnostics = false, silent = false, saved = false, readStamp) {
+function handleNotifyOpen(state4, filePath, content, languageId, preserveDiagnostics = false, silent = false, saved = false, readStamp) {
   const normalizedPath = normalizeMapKey(filePath);
-  return enqueueDocumentNotify(state5, normalizedPath, (coalescedCount, queuedSaved) => handleNotifyOpenOnce(state5, filePath, content, languageId, preserveDiagnostics, silent, coalescedCount, queuedSaved), saved, readStamp);
+  return enqueueDocumentNotify(state4, normalizedPath, (coalescedCount, queuedSaved) => handleNotifyOpenOnce(state4, filePath, content, languageId, preserveDiagnostics, silent, coalescedCount, queuedSaved), saved, readStamp);
 }
-async function handleNotifyChangeOnce(state5, filePath, content, normalizedPath, coalescedCount = 0, saved = false) {
-  if (!isClientAlive(state5))
+async function handleNotifyChangeOnce(state4, filePath, content, normalizedPath, coalescedCount = 0, saved = false) {
+  if (!isClientAlive(state4))
     return false;
-  const uri = state5.openDocumentUris?.get(normalizedPath) ?? pathToFileURL2(filePath).href;
-  if (!state5.openDocuments.has(normalizedPath)) {
-    if (await closedAndGone(state5, filePath, normalizedPath))
+  const uri = state4.openDocumentUris?.get(normalizedPath) ?? pathToFileURL2(filePath).href;
+  if (!state4.openDocuments.has(normalizedPath)) {
+    if (await closedAndGone(state4, filePath, normalizedPath))
       return false;
-    const fallbackOpenSent = await sendFenced(state5, normalizedPath, uri, "textDocument/didOpen", {
+    const fallbackOpenSent = await sendFenced(state4, normalizedPath, uri, "textDocument/didOpen", {
       textDocument: {
         uri,
         languageId: "plaintext",
@@ -14279,37 +14219,37 @@ async function handleNotifyChangeOnce(state5, filePath, content, normalizedPath,
         text: content
       }
     });
-    state5.documentVersions.set(normalizedPath, 0);
-    state5.documentOpenedAt.set(normalizedPath, Date.now());
-    state5.diagnosticPublicationCounts.set(normalizedPath, 0);
+    state4.documentVersions.set(normalizedPath, 0);
+    state4.documentOpenedAt.set(normalizedPath, Date.now());
+    state4.diagnosticPublicationCounts.set(normalizedPath, 0);
     if (fallbackOpenSent)
-      recordSentContent(state5, normalizedPath, 0, content, coalescedCount);
-    state5.openDocuments.add(normalizedPath);
-    state5.closedDocuments?.delete(normalizedPath);
-    state5.openDocumentUris?.set(normalizedPath, uri);
+      recordSentContent(state4, normalizedPath, 0, content, coalescedCount);
+    state4.openDocuments.add(normalizedPath);
+    state4.closedDocuments?.delete(normalizedPath);
+    state4.openDocumentUris?.set(normalizedPath, uri);
     if (saved && fallbackOpenSent)
-      await sendDidSave(state5, normalizedPath, uri, content);
+      await sendDidSave(state4, normalizedPath, uri, content);
     return fallbackOpenSent;
   }
-  const version = (state5.documentVersions.get(normalizedPath) ?? 0) + 1;
-  state5.documentVersions.set(normalizedPath, version);
-  clearDiagnosticsForPath(state5, normalizedPath);
-  const changeSent = await sendFenced(state5, normalizedPath, uri, "textDocument/didChange", {
+  const version = (state4.documentVersions.get(normalizedPath) ?? 0) + 1;
+  state4.documentVersions.set(normalizedPath, version);
+  clearDiagnosticsForPath(state4, normalizedPath);
+  const changeSent = await sendFenced(state4, normalizedPath, uri, "textDocument/didChange", {
     textDocument: { uri, version },
-    contentChanges: buildContentChanges(state5, normalizedPath, content)
+    contentChanges: buildContentChanges(state4, normalizedPath, content)
   });
   if (changeSent)
-    recordSentContent(state5, normalizedPath, version, content, coalescedCount);
+    recordSentContent(state4, normalizedPath, version, content, coalescedCount);
   if (saved && changeSent)
-    await sendDidSave(state5, normalizedPath, uri, content);
+    await sendDidSave(state4, normalizedPath, uri, content);
   return changeSent;
 }
-function handleNotifyChange(state5, filePath, content) {
+function handleNotifyChange(state4, filePath, content) {
   const normalizedPath = normalizeMapKey(filePath);
-  return enqueueDocumentNotify(state5, normalizedPath, (coalescedCount, queuedSaved) => handleNotifyChangeOnce(state5, filePath, content, normalizedPath, coalescedCount, queuedSaved));
+  return enqueueDocumentNotify(state4, normalizedPath, (coalescedCount, queuedSaved) => handleNotifyChangeOnce(state4, filePath, content, normalizedPath, coalescedCount, queuedSaved));
 }
-async function closedAndGone(state5, filePath, normalizedPath) {
-  if (!state5.closedDocuments?.has(normalizedPath))
+async function closedAndGone(state4, filePath, normalizedPath) {
+  if (!state4.closedDocuments?.has(normalizedPath))
     return false;
   try {
     await access(filePath);
@@ -14318,76 +14258,76 @@ async function closedAndGone(state5, filePath, normalizedPath) {
     return true;
   }
 }
-async function closeDocument(state5, filePath) {
-  if (!isClientAlive(state5))
+async function closeDocument(state4, filePath) {
+  if (!isClientAlive(state4))
     return;
   const normalizedPath = normalizeMapKey(filePath);
-  await enqueueDocumentNotify(state5, normalizedPath, () => closeDocumentOnce(state5, filePath, normalizedPath), false, void 0, true);
+  await enqueueDocumentNotify(state4, normalizedPath, () => closeDocumentOnce(state4, filePath, normalizedPath), false, void 0, true);
 }
-async function closeDocumentOnce(state5, filePath, normalizedPath) {
-  if (!isClientAlive(state5))
+async function closeDocumentOnce(state4, filePath, normalizedPath) {
+  if (!isClientAlive(state4))
     return;
-  if (!state5.openDocuments.has(normalizedPath)) {
-    state5.closedDocuments?.add(normalizedPath);
+  if (!state4.openDocuments.has(normalizedPath)) {
+    state4.closedDocuments?.add(normalizedPath);
     return;
   }
-  await safeSendNotification(state5.connection, "textDocument/didClose", {
+  await safeSendNotification(state4.connection, "textDocument/didClose", {
     textDocument: {
-      uri: state5.openDocumentUris?.get(normalizedPath) ?? pathToFileURL2(filePath).href
+      uri: state4.openDocumentUris?.get(normalizedPath) ?? pathToFileURL2(filePath).href
     }
   });
-  state5.openDocuments.delete(normalizedPath);
-  state5.closedDocuments?.add(normalizedPath);
-  state5.openDocumentUris?.delete(normalizedPath);
-  state5.expectedPublicationsBeyondSends?.set(normalizedPath, publicationCountsForPath(state5, normalizedPath).sent);
-  state5.documentVersions.delete(normalizedPath);
-  state5.sentReadStamps.delete(normalizedPath);
-  state5.documentOpenedAt.delete(normalizedPath);
-  state5.diagnosticPublicationCounts.delete(normalizedPath);
-  state5.projectIdentityProbedFiles?.delete(normalizedPath);
-  const retained = state5.documentContentHashes.get(normalizedPath);
+  state4.openDocuments.delete(normalizedPath);
+  state4.closedDocuments?.add(normalizedPath);
+  state4.openDocumentUris?.delete(normalizedPath);
+  state4.expectedPublicationsBeyondSends?.set(normalizedPath, publicationCountsForPath(state4, normalizedPath).sent);
+  state4.documentVersions.delete(normalizedPath);
+  state4.sentReadStamps.delete(normalizedPath);
+  state4.documentOpenedAt.delete(normalizedPath);
+  state4.diagnosticPublicationCounts.delete(normalizedPath);
+  state4.projectIdentityProbedFiles?.delete(normalizedPath);
+  const retained = state4.documentContentHashes.get(normalizedPath);
   if (retained?.text !== void 0) {
-    state5.incrementalTextRetainedEntries = Math.max(0, (state5.incrementalTextRetainedEntries ?? 1) - 1);
-    state5.incrementalTextRetainedBytes = Math.max(0, (state5.incrementalTextRetainedBytes ?? retained.text.length * 2) - retained.text.length * 2);
-    state5.incrementalTextBearingPaths?.delete(normalizedPath);
+    state4.incrementalTextRetainedEntries = Math.max(0, (state4.incrementalTextRetainedEntries ?? 1) - 1);
+    state4.incrementalTextRetainedBytes = Math.max(0, (state4.incrementalTextRetainedBytes ?? retained.text.length * 2) - retained.text.length * 2);
+    state4.incrementalTextBearingPaths?.delete(normalizedPath);
   }
-  state5.documentContentHashes.delete(normalizedPath);
-  clearDiagnosticsForPath(state5, normalizedPath);
+  state4.documentContentHashes.delete(normalizedPath);
+  clearDiagnosticsForPath(state4, normalizedPath);
 }
 function isAtLeastAsAggressiveShutdown(existing, requested) {
   return !!existing.fast >= !!requested.fast && !!existing.processExiting >= !!requested.processExiting;
 }
-function clientShutdown(state5, options = {}) {
-  if (state5.shutdownPromise && state5.shutdownOptions && isAtLeastAsAggressiveShutdown(state5.shutdownOptions, options)) {
-    return state5.shutdownPromise;
+function clientShutdown(state4, options = {}) {
+  if (state4.shutdownPromise && state4.shutdownOptions && isAtLeastAsAggressiveShutdown(state4.shutdownOptions, options)) {
+    return state4.shutdownPromise;
   }
-  state5.shutdownOptions = options;
-  const attempt = clientShutdownOnce(state5, options);
-  state5.shutdownPromise = attempt;
+  state4.shutdownOptions = options;
+  const attempt = clientShutdownOnce(state4, options);
+  state4.shutdownPromise = attempt;
   attempt.catch(() => {
-    if (state5.shutdownPromise === attempt) {
-      state5.shutdownPromise = void 0;
-      state5.shutdownOptions = void 0;
+    if (state4.shutdownPromise === attempt) {
+      state4.shutdownPromise = void 0;
+      state4.shutdownOptions = void 0;
     }
   });
   return attempt;
 }
-async function clientShutdownOnce(state5, options) {
+async function clientShutdownOnce(state4, options) {
   const shutdownStart = Date.now();
-  state5.shutdownRequested = true;
-  state5.isConnected = false;
-  state5.isDestroyed = true;
-  for (const timer of state5.pendingDiagnostics.values()) {
+  state4.shutdownRequested = true;
+  state4.isConnected = false;
+  state4.isDestroyed = true;
+  for (const timer of state4.pendingDiagnostics.values()) {
     clearTimeout(timer);
   }
-  state5.pendingDiagnostics.clear();
-  state5.pendingOpens.clear();
-  state5.openDocuments.clear();
-  state5.openDocumentUris?.clear();
-  cancelDocumentNotifyQueues(state5);
-  state5.projectIdentityProbedFiles?.clear();
-  state5.watchQueue?.cancel();
-  state5.diagnosticEmitter.removeAllListeners();
+  state4.pendingDiagnostics.clear();
+  state4.pendingOpens.clear();
+  state4.openDocuments.clear();
+  state4.openDocumentUris?.clear();
+  cancelDocumentNotifyQueues(state4);
+  state4.projectIdentityProbedFiles?.clear();
+  state4.watchQueue?.cancel();
+  state4.diagnosticEmitter.removeAllListeners();
   let shutdownRequestTimedOut = false;
   let exitNotifyTimedOut = false;
   let shutdownRequestUndelivered = false;
@@ -14395,7 +14335,7 @@ async function clientShutdownOnce(state5, options) {
   try {
     if (!options.fast) {
       try {
-        const shutdownAck = await withTimeout(safeSendRequest(state5.connection, "shutdown", {}), SHUTDOWN_REQUEST_TIMEOUT_MS);
+        const shutdownAck = await withTimeout(safeSendRequest(state4.connection, "shutdown", {}), SHUTDOWN_REQUEST_TIMEOUT_MS);
         if (shutdownAck === void 0)
           shutdownRequestUndelivered = true;
       } catch (err) {
@@ -14406,7 +14346,7 @@ async function clientShutdownOnce(state5, options) {
         }
       }
       try {
-        const exitSent = await withTimeout(safeSendNotification(state5.connection, "exit", {}), EXIT_NOTIFY_TIMEOUT_MS);
+        const exitSent = await withTimeout(safeSendNotification(state4.connection, "exit", {}), EXIT_NOTIFY_TIMEOUT_MS);
         if (exitSent === false)
           exitNotifyUndelivered = true;
       } catch (err) {
@@ -14418,15 +14358,15 @@ async function clientShutdownOnce(state5, options) {
       }
     }
   } finally {
-    disposeClientConnection(state5);
-    const pid = state5.lspProcess.pid;
+    disposeClientConnection(state4);
+    const pid = state4.lspProcess.pid;
     logLatency({
       type: "phase",
       phase: "lsp_client_shutdown",
-      filePath: state5.root,
+      filePath: state4.root,
       durationMs: Date.now() - shutdownStart,
       metadata: {
-        serverId: state5.serverId,
+        serverId: state4.serverId,
         pid,
         fast: !!options.fast,
         processExiting: !!options.processExiting,
@@ -14448,7 +14388,7 @@ async function clientShutdownOnce(state5, options) {
         shutdownOutcome: options.fast ? "fast" : shutdownRequestTimedOut || exitNotifyTimedOut || shutdownRequestUndelivered || exitNotifyUndelivered ? "forced" : "graceful"
       }
     });
-    void removeLspChild(pid, extractSpawnMarker(state5.lspProcess.args)).catch((err) => {
+    void removeLspChild(pid, extractSpawnMarker(state4.lspProcess.args)).catch((err) => {
       logLatency({
         type: "phase",
         phase: "lsp_registry_write_failed",
@@ -14457,17 +14397,17 @@ async function clientShutdownOnce(state5, options) {
         metadata: { op: "remove", pid, error: String(err) }
       });
     });
-    await killProcessTree(state5.lspProcess.process, pid, options);
+    await killProcessTree(state4.lspProcess.process, pid, options);
   }
 }
-async function toWirePosition(state5, filePath, line, character) {
-  if (state5.positionEncoding === "utf-16")
+async function toWirePosition(state4, filePath, line, character) {
+  if (state4.positionEncoding === "utf-16")
     return { line, character };
   try {
     const content = await readFile(filePath, "utf8");
     return {
       line,
-      character: convertCharacterOffset(state5.positionEncoding, lineTextAt(content, line), character)
+      character: convertCharacterOffset(state4.positionEncoding, lineTextAt(content, line), character)
     };
   } catch {
     return { line, character };
@@ -14476,13 +14416,13 @@ async function toWirePosition(state5, filePath, line, character) {
 function navStaleDropEnabled() {
   return process.env.PI_LENS_LSP_NAV_STALE_DROP !== "0";
 }
-async function navRequest(state5, method, params, staleCheckPath, timeoutMs = NAV_REQUEST_TIMEOUT_MS, signal = getAmbientAbortSignal()) {
-  if (!isClientAlive(state5))
+async function navRequest(state4, method, params, staleCheckPath, timeoutMs = NAV_REQUEST_TIMEOUT_MS, signal = getAmbientAbortSignal()) {
+  if (!isClientAlive(state4))
     return null;
   const normalizedPath = staleCheckPath !== void 0 ? normalizeMapKey(staleCheckPath) : void 0;
-  const requestVersion = normalizedPath !== void 0 ? state5.documentVersions.get(normalizedPath) : void 0;
+  const requestVersion = normalizedPath !== void 0 ? state4.documentVersions.get(normalizedPath) : void 0;
   const requestStartedAt = Date.now();
-  const requestPromise = safeSendRequest(state5.connection, method, params, signal);
+  const requestPromise = safeSendRequest(state4.connection, method, params, signal);
   const result = await withTimeout(requestPromise, timeoutMs).catch((err) => {
     if (isNavTimeoutError(err, timeoutMs)) {
       recordNavTimeoutTelemetry({
@@ -14505,7 +14445,7 @@ async function navRequest(state5, method, params, staleCheckPath, timeoutMs = NA
     throw err;
   });
   if (normalizedPath !== void 0 && requestVersion !== void 0 && navStaleDropEnabled()) {
-    const currentVersion = state5.documentVersions.get(normalizedPath);
+    const currentVersion = state4.documentVersions.get(normalizedPath);
     if (currentVersion !== void 0 && currentVersion > requestVersion) {
       return void 0;
     }
@@ -14550,23 +14490,23 @@ function armNavLateAnswerTelemetry(args) {
   }, () => {
   });
 }
-function chooseLivenessProbe(state5) {
-  if (state5.operationSupport?.workspaceSymbol === true) {
+function chooseLivenessProbe(state4) {
+  if (state4.operationSupport?.workspaceSymbol === true) {
     return {
       method: "workspace/symbol",
       params: { query: LIVENESS_PING_QUERY }
     };
   }
-  const openUri = firstOpenDocumentUri(state5);
+  const openUri = firstOpenDocumentUri(state4);
   if (openUri === void 0)
     return void 0;
-  if (state5.operationSupport?.documentSymbol === true) {
+  if (state4.operationSupport?.documentSymbol === true) {
     return {
       method: "textDocument/documentSymbol",
       params: { textDocument: { uri: openUri } }
     };
   }
-  if (state5.operationSupport?.hover === true) {
+  if (state4.operationSupport?.hover === true) {
     return {
       method: "textDocument/hover",
       params: {
@@ -14577,62 +14517,62 @@ function chooseLivenessProbe(state5) {
   }
   return void 0;
 }
-function firstOpenDocumentUri(state5) {
-  for (const normalizedPath of state5.openDocuments) {
-    const uri = state5.openDocumentUris?.get(normalizedPath);
+function firstOpenDocumentUri(state4) {
+  for (const normalizedPath of state4.openDocuments) {
+    const uri = state4.openDocumentUris?.get(normalizedPath);
     if (uri !== void 0)
       return uri;
   }
   return void 0;
 }
-async function clientPingLiveness(state5, timeoutMs = LIVENESS_PING_TIMEOUT_MS) {
-  if (!isClientAlive(state5))
+async function clientPingLiveness(state4, timeoutMs = LIVENESS_PING_TIMEOUT_MS) {
+  if (!isClientAlive(state4))
     return false;
-  const probe = chooseLivenessProbe(state5);
+  const probe = chooseLivenessProbe(state4);
   if (probe === void 0) {
     try {
       incrementDegradationCount({
         kind: "lsp-liveness-probe-unsupported",
-        subject: state5.serverId,
+        subject: state4.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(state5);
+    return isClientAlive(state4);
   }
   try {
-    await withTimeout(safeSendRequest(state5.connection, probe.method, probe.params), timeoutMs);
+    await withTimeout(safeSendRequest(state4.connection, probe.method, probe.params), timeoutMs);
   } catch (err) {
     if (err instanceof Error && err.message.startsWith("Timeout after")) {
       return false;
     }
   }
-  return isClientAlive(state5);
+  return isClientAlive(state4);
 }
-function syncMutationContextSlot(state5) {
-  state5.activeMutationContext = state5.activeMutationDepth === 1 ? state5.mutationContextOwner : void 0;
+function syncMutationContextSlot(state4) {
+  state4.activeMutationContext = state4.activeMutationDepth === 1 ? state4.mutationContextOwner : void 0;
 }
-async function runServerCommand(state5, command, args, timeoutMs = EXECUTE_COMMAND_TIMEOUT_MS, mutationContext) {
-  if (!isClientAlive(state5)) {
+async function runServerCommand(state4, command, args, timeoutMs = EXECUTE_COMMAND_TIMEOUT_MS, mutationContext) {
+  if (!isClientAlive(state4)) {
     return { executed: false, reason: "lsp client not alive" };
   }
-  if (!state5.advertisedCommands.has(command)) {
+  if (!state4.advertisedCommands.has(command)) {
     return {
       executed: false,
-      reason: `command "${command}" is not advertised by the ${state5.serverId} server`
+      reason: `command "${command}" is not advertised by the ${state4.serverId} server`
     };
   }
-  state5.serverEditsAllowed += 1;
-  state5.activeMutationDepth = (state5.activeMutationDepth ?? 0) + 1;
-  const isMutationContextOwner = state5.activeMutationDepth === 1;
+  state4.serverEditsAllowed += 1;
+  state4.activeMutationDepth = (state4.activeMutationDepth ?? 0) + 1;
+  const isMutationContextOwner = state4.activeMutationDepth === 1;
   if (isMutationContextOwner) {
-    state5.mutationContextOwner = mutationContext;
+    state4.mutationContextOwner = mutationContext;
   }
-  syncMutationContextSlot(state5);
+  syncMutationContextSlot(state4);
   try {
     let result;
     try {
-      result = await withTimeout(safeSendRequest(state5.connection, "workspace/executeCommand", {
+      result = await withTimeout(safeSendRequest(state4.connection, "workspace/executeCommand", {
         command,
         arguments: args ?? []
       }), timeoutMs);
@@ -14647,26 +14587,26 @@ async function runServerCommand(state5, command, args, timeoutMs = EXECUTE_COMMA
     }
     return { executed: true, result };
   } finally {
-    state5.serverEditsAllowed -= 1;
-    state5.activeMutationDepth = Math.max(0, (state5.activeMutationDepth ?? 0) - 1);
+    state4.serverEditsAllowed -= 1;
+    state4.activeMutationDepth = Math.max(0, (state4.activeMutationDepth ?? 0) - 1);
     if (isMutationContextOwner) {
-      state5.mutationContextOwner = void 0;
+      state4.mutationContextOwner = void 0;
     }
-    syncMutationContextSlot(state5);
+    syncMutationContextSlot(state4);
   }
 }
-async function runReadOnlyServerCommand(state5, command, args, timeoutMs = PROBE_COMMAND_TIMEOUT_MS) {
-  if (!isClientAlive(state5)) {
+async function runReadOnlyServerCommand(state4, command, args, timeoutMs = PROBE_COMMAND_TIMEOUT_MS) {
+  if (!isClientAlive(state4)) {
     return { executed: false, reason: "lsp client not alive" };
   }
-  if (!state5.advertisedCommands.has(command)) {
+  if (!state4.advertisedCommands.has(command)) {
     return {
       executed: false,
-      reason: `command "${command}" is not advertised by the ${state5.serverId} server`
+      reason: `command "${command}" is not advertised by the ${state4.serverId} server`
     };
   }
   try {
-    const result = await withTimeout(safeSendRequest(state5.connection, "workspace/executeCommand", {
+    const result = await withTimeout(safeSendRequest(state4.connection, "workspace/executeCommand", {
       command,
       arguments: args ?? []
     }), timeoutMs);
@@ -14681,14 +14621,14 @@ async function runReadOnlyServerCommand(state5, command, args, timeoutMs = PROBE
     throw err;
   }
 }
-function validateWorkspaceEditVersions(state5, edit) {
+function validateWorkspaceEditVersions(state4, 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 = state5.documentVersions.get(normalizeMapKey(uriToPath(textDocument.uri)));
+    const current = state4.documentVersions.get(normalizeMapKey(uriToPath(textDocument.uri)));
     if (current === void 0 || current !== textDocument.version) {
       throw new Error(`stale workspace edit document version for ${textDocument.uri}`);
     }
@@ -14711,31 +14651,31 @@ function stripDocumentVersions(edit) {
   });
   return { ...edit, documentChanges };
 }
-async function normalizeClientWorkspaceEdit(state5, edit) {
-  validateWorkspaceEditVersions(state5, edit);
-  const normalized = await normalizeWorkspaceEditToUtf16(edit, state5.positionEncoding, state5.root);
+async function normalizeClientWorkspaceEdit(state4, edit) {
+  validateWorkspaceEditVersions(state4, edit);
+  const normalized = await normalizeWorkspaceEditToUtf16(edit, state4.positionEncoding, state4.root);
   return stripDocumentVersions(normalized);
 }
-async function resolveCodeActionBestEffort(state5, action) {
-  if (!isClientAlive(state5))
+async function resolveCodeActionBestEffort(state4, action) {
+  if (!isClientAlive(state4))
     return action;
   if (action.edit) {
     return {
       ...action,
-      edit: await normalizeClientWorkspaceEdit(state5, action.edit)
+      edit: await normalizeClientWorkspaceEdit(state4, action.edit)
     };
   }
-  if (!state5.operationSupport.codeActionResolve) {
+  if (!state4.operationSupport.codeActionResolve) {
     recordDegradationOnce({
       kind: "lsp-capability-skip",
-      subject: `${state5.serverId}:codeAction/resolve`,
+      subject: `${state4.serverId}:codeAction/resolve`,
       reason: "server did not advertise codeActionProvider.resolveProvider"
     });
     return action;
   }
   let resolved2;
   try {
-    resolved2 = await withTimeout(safeSendRequest(state5.connection, "codeAction/resolve", action), NAV_REQUEST_TIMEOUT_MS);
+    resolved2 = await withTimeout(safeSendRequest(state4.connection, "codeAction/resolve", action), NAV_REQUEST_TIMEOUT_MS);
   } catch {
     return action;
   }
@@ -14744,7 +14684,7 @@ async function resolveCodeActionBestEffort(state5, action) {
   const merged = { ...action, ...resolved2 };
   return merged.edit ? {
     ...merged,
-    edit: await normalizeClientWorkspaceEdit(state5, merged.edit)
+    edit: await normalizeClientWorkspaceEdit(state4, merged.edit)
   } : merged;
 }
 async function createLSPClient(options) {
@@ -14819,7 +14759,7 @@ async function createLSPClient(options) {
   const connection = (0, import_node.createMessageConnection)(new import_node.StreamMessageReader(lspProcess.stdout), new import_node.StreamMessageWriter(lspProcess.stdin));
   const diagnosticEmitter = new EventEmitter();
   diagnosticEmitter.setMaxListeners(50);
-  const state5 = {
+  const state4 = {
     isConnected: true,
     isDestroyed: false,
     startedAtMs: Date.now(),
@@ -14887,15 +14827,15 @@ async function createLSPClient(options) {
     // SAFETY: state construction completes before the flush closure can run.
     watchQueue: void 0
   };
-  activeLspClientSet().add(state5);
-  state5.watchQueue = new WatchedFilesQueue((changes) => {
-    if (!isClientAlive(state5))
+  activeLspClientSet().add(state4);
+  state4.watchQueue = new WatchedFilesQueue((changes) => {
+    if (!isClientAlive(state4))
       return;
-    void safeSendNotification(state5.connection, "workspace/didChangeWatchedFiles", { changes });
+    void safeSendNotification(state4.connection, "workspace/didChangeWatchedFiles", { changes });
   });
-  setupIncomingHandlers(state5, initialization, onDiagnosticsPublished);
+  setupIncomingHandlers(state4, initialization, onDiagnosticsPublished);
   connection.listen();
-  setupConnectionLifecycle(state5, recentStderr);
+  setupConnectionLifecycle(state4, recentStderr);
   let initResult;
   try {
     initResult = await withTimeout(safeSendRequest(connection, "initialize", {
@@ -14908,7 +14848,7 @@ async function createLSPClient(options) {
       initializationOptions: initialization
     }), initializeTimeoutMs);
   } catch (err) {
-    state5.shutdownRequested = true;
+    state4.shutdownRequested = true;
     const pid = lspProcess.pid;
     void killProcessTree(lspProcess.process, pid);
     void removeLspChild(pid, extractSpawnMarker(lspProcess.args)).catch((err2) => {
@@ -14943,8 +14883,8 @@ async function createLSPClient(options) {
     ].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}`);
   }
-  state5.workspaceDiagnosticsSupport = detectWorkspaceDiagnosticsSupport(initResult);
-  state5.operationSupport = detectOperationSupport(initResult);
+  state4.workspaceDiagnosticsSupport = detectWorkspaceDiagnosticsSupport(initResult);
+  state4.operationSupport = detectOperationSupport(initResult);
   const capabilities = initResult?.capabilities ?? {};
   const workspace = isCapabilityRecord(capabilities.workspace) ? capabilities.workspace : void 0;
   const fileOperations = isCapabilityRecord(workspace) ? workspace.fileOperations : void 0;
@@ -14956,21 +14896,21 @@ async function createLSPClient(options) {
       }
     }
   }
-  state5.fileOperationMalformedRegistrations = malformedFileOperationRegistrations;
+  state4.fileOperationMalformedRegistrations = malformedFileOperationRegistrations;
   if (isCapabilityRecord(fileOperations)) {
-    state5.fileOperationFilters = {
+    state4.fileOperationFilters = {
       willRename: parseFileOperationFilters(fileOperations.willRename),
       didRename: parseFileOperationFilters(fileOperations.didRename)
     };
   }
-  state5.positionEncoding = negotiatePositionEncoding(initResult?.capabilities);
-  state5.syncKind = negotiateSyncKind(initResult?.capabilities);
-  state5.saveOptions = negotiateSaveOptions(initResult?.capabilities);
-  state5.rawCapabilityKeys = Object.keys(initResult?.capabilities ?? {}).sort((a, b) => a.localeCompare(b));
+  state4.positionEncoding = negotiatePositionEncoding(initResult?.capabilities);
+  state4.syncKind = negotiateSyncKind(initResult?.capabilities);
+  state4.saveOptions = negotiateSaveOptions(initResult?.capabilities);
+  state4.rawCapabilityKeys = Object.keys(initResult?.capabilities ?? {}).sort((a, b) => a.localeCompare(b));
   for (const cmd of detectExecuteCommands(initResult)) {
-    state5.advertisedCommands.add(cmd);
+    state4.advertisedCommands.add(cmd);
   }
-  state5.staticDiagnosticsMode = state5.workspaceDiagnosticsSupport.mode;
+  state4.staticDiagnosticsMode = state4.workspaceDiagnosticsSupport.mode;
   await safeSendNotification(connection, "initialized", {});
   if (initialization) {
     await safeSendNotification(connection, "workspace/didChangeConfiguration", {
@@ -14981,59 +14921,59 @@ async function createLSPClient(options) {
     serverId,
     root,
     connection,
-    isAlive: () => isClientAlive(state5),
+    isAlive: () => isClientAlive(state4),
     /** True if the server process has exited or been killed. */
     processExited: () => lspProcess.process.exitCode !== null || lspProcess.process.killed === true,
     /** #1127: mirrors `state.shutdownRequested` — see interface doc. */
-    wasShutdownIntentional: () => state5.shutdownRequested,
+    wasShutdownIntentional: () => state4.shutdownRequested,
     /** #1127: mirrors `state.exitedAt` — see interface doc. */
-    getExitedAt: () => state5.exitedAt,
+    getExitedAt: () => state4.exitedAt,
     /** Last N lines of server stderr for diagnostics. */
     recentStderr: (lines) => recentStderr(lines),
-    getPullFailureHistory: () => state5.pullFailureHistory.map((entry) => ({
+    getPullFailureHistory: () => state4.pullFailureHistory.map((entry) => ({
       ...entry,
       message: entry.message.slice(0, 200)
     })),
     /** Pre-request health check — returns error string if dead. */
     checkAlive: () => checkProcessAlive(),
     /** #1277: cheap request round-trip proving the server still responds. */
-    pingLiveness: (timeoutMs) => clientPingLiveness(state5, timeoutMs),
+    pingLiveness: (timeoutMs) => clientPingLiveness(state4, timeoutMs),
     /** #2358: the OS pid of the live server process (see interface doc). */
     getProcessPid: () => lspProcess.pid,
     notify: {
       async open(filePath, content, languageId, preserveDiagnostics, silent, saved, readStamp) {
-        return handleNotifyOpen(state5, filePath, content, languageId, preserveDiagnostics, silent, saved, readStamp);
+        return handleNotifyOpen(state4, filePath, content, languageId, preserveDiagnostics, silent, saved, readStamp);
       },
       async change(filePath, content) {
-        return handleNotifyChange(state5, filePath, content);
+        return handleNotifyChange(state4, filePath, content);
       },
       watchedFileChange(filePath, type) {
-        handleNotifyExternalChange(state5, filePath, type);
+        handleNotifyExternalChange(state4, filePath, type);
       }
     },
     getDiagnostics(filePath) {
-      return getMergedDiagnosticsForPath(state5, normalizeMapKey(filePath));
+      return getMergedDiagnosticsForPath(state4, normalizeMapKey(filePath));
     },
     getDiagnosticBinding(filePath) {
-      return state5.diagnosticBindings.get(normalizeMapKey(filePath));
+      return state4.diagnosticBindings.get(normalizeMapKey(filePath));
     },
     getDiagnosticsVersionForPath(filePath) {
-      return diagnosticsVersionForPath(state5, normalizeMapKey(filePath));
+      return diagnosticsVersionForPath(state4, normalizeMapKey(filePath));
     },
     getPublicationCountsForPath(filePath) {
-      return publicationCountsForPath(state5, normalizeMapKey(filePath));
+      return publicationCountsForPath(state4, normalizeMapKey(filePath));
     },
     getAllDiagnostics() {
       const result = /* @__PURE__ */ new Map();
       const keys = /* @__PURE__ */ new Set([
-        ...state5.pushDiagnostics.keys(),
-        ...state5.documentPullDiagnostics.keys()
+        ...state4.pushDiagnostics.keys(),
+        ...state4.documentPullDiagnostics.keys()
       ]);
       for (const key of keys) {
         result.set(key, {
-          diags: getMergedDiagnosticsForPath(state5, key),
-          ts: Math.max(state5.pushDiagnosticTimestamps.get(key) ?? 0, state5.documentPullDiagnosticTimestamps.get(key) ?? 0),
-          binding: state5.diagnosticBindings.get(key)
+          diags: getMergedDiagnosticsForPath(state4, key),
+          ts: Math.max(state4.pushDiagnosticTimestamps.get(key) ?? 0, state4.documentPullDiagnosticTimestamps.get(key) ?? 0),
+          binding: state4.diagnosticBindings.get(key)
         });
       }
       return result;
@@ -15041,188 +14981,188 @@ async function createLSPClient(options) {
     getTrackedDiagnosticPaths() {
       return [
         .../* @__PURE__ */ new Set([
-          ...state5.pushDiagnostics.keys(),
-          ...state5.documentPullDiagnostics.keys()
+          ...state4.pushDiagnostics.keys(),
+          ...state4.documentPullDiagnostics.keys()
         ])
       ].map((filePath) => process.platform === "win32" ? filePath.replace(/\//g, "\\") : filePath);
     },
     pruneDiagnostics(predicate) {
       let removed = 0;
       const keys = /* @__PURE__ */ new Set([
-        ...state5.pushDiagnostics.keys(),
-        ...state5.documentPullDiagnostics.keys()
+        ...state4.pushDiagnostics.keys(),
+        ...state4.documentPullDiagnostics.keys()
       ]);
       for (const key of keys) {
-        const diags = getMergedDiagnosticsForPath(state5, key);
-        const ts = Math.max(state5.pushDiagnosticTimestamps.get(key) ?? 0, state5.documentPullDiagnosticTimestamps.get(key) ?? 0);
+        const diags = getMergedDiagnosticsForPath(state4, key);
+        const ts = Math.max(state4.pushDiagnosticTimestamps.get(key) ?? 0, state4.documentPullDiagnosticTimestamps.get(key) ?? 0);
         if (!predicate(key, ts, diags))
           continue;
-        clearDiagnosticsForPath(state5, key);
+        clearDiagnosticsForPath(state4, key);
         removed++;
       }
       return removed;
     },
     getWorkspaceDiagnosticsSupport() {
-      return state5.workspaceDiagnosticsSupport;
+      return state4.workspaceDiagnosticsSupport;
     },
     requestWorkspaceDiagnostics(budgetMs) {
-      return clientRequestWorkspaceDiagnostics(state5, budgetMs);
+      return clientRequestWorkspaceDiagnostics(state4, budgetMs);
     },
     getOperationSupport() {
-      return state5.operationSupport;
+      return state4.operationSupport;
     },
     getMalformedFileOperationRegistrations() {
-      return state5.fileOperationMalformedRegistrations ?? /* @__PURE__ */ new Set();
+      return state4.fileOperationMalformedRegistrations ?? /* @__PURE__ */ new Set();
     },
     getAdvertisedCommands() {
-      return [...state5.advertisedCommands];
+      return [...state4.advertisedCommands];
     },
     getRawCapabilityKeys() {
-      return state5.rawCapabilityKeys ?? [];
+      return state4.rawCapabilityKeys ?? [];
     },
     getSaveOptions() {
-      return state5.saveOptions ? { ...state5.saveOptions } : void 0;
+      return state4.saveOptions ? { ...state4.saveOptions } : void 0;
     },
     getLaunchVariant() {
-      return state5.launchVariant;
+      return state4.launchVariant;
     },
     async executeCommand(command, args, mutationContext) {
-      return runServerCommand(state5, command, args, EXECUTE_COMMAND_TIMEOUT_MS, mutationContext);
+      return runServerCommand(state4, command, args, EXECUTE_COMMAND_TIMEOUT_MS, mutationContext);
     },
     async executeReadOnlyCommand(command, args) {
-      return runReadOnlyServerCommand(state5, command, args);
+      return runReadOnlyServerCommand(state4, command, args);
     },
     get diagnosticsVersion() {
-      return state5.diagnosticsVersion;
+      return state4.diagnosticsVersion;
     },
     async waitForDiagnostics(filePath, timeoutMs = DIAGNOSTICS_WAIT_TIMEOUT_MS, options2) {
-      return clientWaitForDiagnostics(state5, filePath, timeoutMs, options2);
+      return clientWaitForDiagnostics(state4, filePath, timeoutMs, options2);
     },
     async definition(filePath, line, character) {
-      const result = await navRequest(state5, "textDocument/definition", {
+      const result = await navRequest(state4, "textDocument/definition", {
         textDocument: { uri: pathToFileURL2(filePath).href },
-        position: await toWirePosition(state5, filePath, line, character)
+        position: await toWirePosition(state4, filePath, line, character)
       }, filePath);
       if (!result)
         return [];
       return Array.isArray(result) ? result : [result];
     },
     async typeDefinition(filePath, line, character) {
-      const result = await navRequest(state5, "textDocument/typeDefinition", {
+      const result = await navRequest(state4, "textDocument/typeDefinition", {
         textDocument: { uri: pathToFileURL2(filePath).href },
-        position: await toWirePosition(state5, filePath, line, character)
+        position: await toWirePosition(state4, filePath, line, character)
       }, filePath);
       if (!result)
         return [];
       return Array.isArray(result) ? result : [result];
     },
     async declaration(filePath, line, character) {
-      const result = await navRequest(state5, "textDocument/declaration", {
+      const result = await navRequest(state4, "textDocument/declaration", {
         textDocument: { uri: pathToFileURL2(filePath).href },
-        position: await toWirePosition(state5, filePath, line, character)
+        position: await toWirePosition(state4, filePath, line, character)
       }, filePath);
       if (!result)
         return [];
       return Array.isArray(result) ? result : [result];
     },
     async references(filePath, line, character, includeDeclaration = true) {
-      const result = await navRequest(state5, "textDocument/references", {
+      const result = await navRequest(state4, "textDocument/references", {
         textDocument: { uri: pathToFileURL2(filePath).href },
-        position: await toWirePosition(state5, filePath, line, character),
+        position: await toWirePosition(state4, filePath, line, character),
         context: { includeDeclaration }
       }, filePath);
       return result ?? [];
     },
     async hover(filePath, line, character) {
-      const result = await navRequest(state5, "textDocument/hover", {
+      const result = await navRequest(state4, "textDocument/hover", {
         textDocument: { uri: pathToFileURL2(filePath).href },
-        position: await toWirePosition(state5, filePath, line, character)
+        position: await toWirePosition(state4, filePath, line, character)
       }, filePath);
       return result ?? null;
     },
     async signatureHelp(filePath, line, character) {
-      const result = await navRequest(state5, "textDocument/signatureHelp", {
+      const result = await navRequest(state4, "textDocument/signatureHelp", {
         textDocument: { uri: pathToFileURL2(filePath).href },
-        position: await toWirePosition(state5, filePath, line, character)
+        position: await toWirePosition(state4, filePath, line, character)
       }, filePath);
       return result ?? null;
     },
     async documentSymbol(filePath) {
-      const result = await navRequest(state5, "textDocument/documentSymbol", { textDocument: { uri: pathToFileURL2(filePath).href } }, filePath);
+      const result = await navRequest(state4, "textDocument/documentSymbol", { textDocument: { uri: pathToFileURL2(filePath).href } }, filePath);
       return result ?? [];
     },
     isDocumentOpen(filePath) {
-      return state5.openDocuments.has(normalizeMapKey(filePath));
+      return state4.openDocuments.has(normalizeMapKey(filePath));
     },
     openDocumentPaths() {
-      return [...state5.openDocuments];
+      return [...state4.openDocuments];
     },
     getSentContent(filePath) {
-      const sent = state5.documentContentHashes.get(normalizeMapKey(filePath));
+      const sent = state4.documentContentHashes.get(normalizeMapKey(filePath));
       return sent && {
         hash: sent.hash,
         changedAtMs: sent.changedAtMs,
         openedAtMs: sent.openedAtMs,
         openedHash: sent.openedHash,
-        clientStartedAtMs: state5.startedAtMs
+        clientStartedAtMs: state4.startedAtMs
       };
     },
     isBusy() {
       return isConnectionBusy(connection);
     },
     getDocumentUri(filePath) {
-      return state5.openDocumentUris?.get(normalizeMapKey(filePath));
+      return state4.openDocumentUris?.get(normalizeMapKey(filePath));
     },
     async workspaceSymbol(query) {
-      if (!isClientAlive(state5))
+      if (!isClientAlive(state4))
         return [];
-      const result = await navRequest(state5, "workspace/symbol", {
+      const result = await navRequest(state4, "workspace/symbol", {
         query
       });
       return result ?? [];
     },
     async codeAction(filePath, line, character, endLine, endCharacter) {
-      if (!isClientAlive(state5))
+      if (!isClientAlive(state4))
         return [];
       const uri = pathToFileURL2(filePath).href;
-      const result = await navRequest(state5, "textDocument/codeAction", {
+      const result = await navRequest(state4, "textDocument/codeAction", {
         textDocument: { uri },
         range: {
-          start: await toWirePosition(state5, filePath, line, character),
-          end: await toWirePosition(state5, filePath, endLine, endCharacter)
+          start: await toWirePosition(state4, filePath, line, character),
+          end: await toWirePosition(state4, filePath, endLine, endCharacter)
         },
         context: {
-          diagnostics: getMergedDiagnosticsForPath(state5, normalizeMapKey(filePath))
+          diagnostics: getMergedDiagnosticsForPath(state4, 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(state5, action)));
+      return Promise.all(actions.map((action) => resolveCodeActionBestEffort(state4, action)));
     },
     async rename(filePath, line, character, newName) {
-      const result = await navRequest(state5, "textDocument/rename", {
+      const result = await navRequest(state4, "textDocument/rename", {
         textDocument: { uri: pathToFileURL2(filePath).href },
-        position: await toWirePosition(state5, filePath, line, character),
+        position: await toWirePosition(state4, filePath, line, character),
         newName
       }, filePath);
-      return result ? await normalizeClientWorkspaceEdit(state5, result) : null;
+      return result ? await normalizeClientWorkspaceEdit(state4, result) : null;
     },
-    closeDocument: (filePath) => closeDocument(state5, filePath),
+    closeDocument: (filePath) => closeDocument(state4, filePath),
     async willRenameFiles(oldFilePath, newFilePath) {
-      if (!isClientAlive(state5))
+      if (!isClientAlive(state4))
         return null;
       const oldUri = pathToFileURL2(oldFilePath).href;
       const newUri = pathToFileURL2(newFilePath).href;
-      if (!await fileOperationFiltersMatch(state5.fileOperationFilters?.willRename, oldUri, newUri, oldFilePath, newFilePath)) {
+      if (!await fileOperationFiltersMatch(state4.fileOperationFilters?.willRename, oldUri, newUri, oldFilePath, newFilePath)) {
         recordDegradationOnce({
           kind: "lsp-capability-skip",
-          subject: `${state5.serverId}:workspace/willRenameFiles:filter`,
+          subject: `${state4.serverId}:workspace/willRenameFiles:filter`,
           reason: "filter-mismatch"
         });
         return null;
       }
-      const result = await navRequest(state5, "workspace/willRenameFiles", {
+      const result = await navRequest(state4, "workspace/willRenameFiles", {
         files: [
           {
             oldUri,
@@ -15230,22 +15170,22 @@ async function createLSPClient(options) {
           }
         ]
       });
-      return result ? await normalizeClientWorkspaceEdit(state5, result) : null;
+      return result ? await normalizeClientWorkspaceEdit(state4, result) : null;
     },
     async didRenameFiles(oldFilePath, newFilePath, oldUri, newUri) {
-      if (!isClientAlive(state5))
+      if (!isClientAlive(state4))
         return;
       const wireOldUri = oldUri ?? pathToFileURL2(oldFilePath).href;
       const wireNewUri = newUri ?? pathToFileURL2(newFilePath).href;
-      if (!await fileOperationFiltersMatch(state5.fileOperationFilters?.didRename, wireOldUri, wireNewUri, oldFilePath, newFilePath)) {
+      if (!await fileOperationFiltersMatch(state4.fileOperationFilters?.didRename, wireOldUri, wireNewUri, oldFilePath, newFilePath)) {
         recordDegradationOnce({
           kind: "lsp-capability-skip",
-          subject: `${state5.serverId}:workspace/didRenameFiles:filter`,
+          subject: `${state4.serverId}:workspace/didRenameFiles:filter`,
           reason: "filter-mismatch"
         });
         return;
       }
-      await safeSendNotification(state5.connection, "workspace/didRenameFiles", {
+      await safeSendNotification(state4.connection, "workspace/didRenameFiles", {
         files: [
           {
             oldUri: wireOldUri,
@@ -15255,54 +15195,54 @@ async function createLSPClient(options) {
       });
     },
     async implementation(filePath, line, character) {
-      const result = await navRequest(state5, "textDocument/implementation", {
+      const result = await navRequest(state4, "textDocument/implementation", {
         textDocument: { uri: pathToFileURL2(filePath).href },
-        position: await toWirePosition(state5, filePath, line, character)
+        position: await toWirePosition(state4, filePath, line, character)
       }, filePath);
       if (!result)
         return [];
       return Array.isArray(result) ? result : [result];
     },
     async prepareCallHierarchy(filePath, line, character) {
-      const result = await navRequest(state5, "textDocument/prepareCallHierarchy", {
+      const result = await navRequest(state4, "textDocument/prepareCallHierarchy", {
         textDocument: { uri: pathToFileURL2(filePath).href },
-        position: await toWirePosition(state5, filePath, line, character)
+        position: await toWirePosition(state4, filePath, line, character)
       }, filePath);
       if (!result)
         return [];
       return Array.isArray(result) ? result : [result];
     },
     async incomingCalls(item) {
-      const result = await navRequest(state5, "callHierarchy/incomingCalls", { item });
+      const result = await navRequest(state4, "callHierarchy/incomingCalls", { item });
       return result ?? [];
     },
     async outgoingCalls(item) {
-      const result = await navRequest(state5, "callHierarchy/outgoingCalls", { item });
+      const result = await navRequest(state4, "callHierarchy/outgoingCalls", { item });
       return result ?? [];
     },
     async shutdown(options2) {
-      return clientShutdown(state5, options2);
+      return clientShutdown(state4, options2);
     }
   };
 }
-function sendFenced(state5, normalizedPath, uri, method, params) {
-  const sent = safeSendNotification(state5.connection, method, params);
-  armDiagnosticsFence(state5, normalizedPath, uri);
+function sendFenced(state4, normalizedPath, uri, method, params) {
+  const sent = safeSendNotification(state4.connection, method, params);
+  armDiagnosticsFence(state4, normalizedPath, uri);
   return sent;
 }
-function armDiagnosticsFence(state5, normalizedPath, uri) {
-  if (getStrategy(state5.serverId, state5.launchVariant).diagnosticsFence !== "reply-first") {
+function armDiagnosticsFence(state4, normalizedPath, uri) {
+  if (getStrategy(state4.serverId, state4.launchVariant).diagnosticsFence !== "reply-first") {
     return;
   }
-  if (state5.operationSupport?.documentSymbol !== true) {
-    if (!state5.fenceSkipRecorded) {
-      state5.fenceSkipRecorded = true;
+  if (state4.operationSupport?.documentSymbol !== true) {
+    if (!state4.fenceSkipRecorded) {
+      state4.fenceSkipRecorded = true;
       logLatency({
         type: "phase",
         phase: "lsp_diagnostics_fence",
         filePath: normalizedPath,
         durationMs: 0,
-        metadata: { serverId: state5.serverId, outcome: "no-request" }
+        metadata: { serverId: state4.serverId, outcome: "no-request" }
       });
     }
     return;
@@ -15314,7 +15254,7 @@ function armDiagnosticsFence(state5, normalizedPath, uri) {
       return;
     ended = true;
     clearTimeout(bound);
-    state5.diagnosticFences.delete(normalizedPath);
+    state4.diagnosticFences.delete(normalizedPath);
     cancellation.cancel();
     cancellation.dispose();
     if (outcome === "timeout" || fence.dropped > 0) {
@@ -15324,7 +15264,7 @@ function armDiagnosticsFence(state5, normalizedPath, uri) {
         filePath: normalizedPath,
         durationMs: Date.now() - armedAt,
         metadata: {
-          serverId: state5.serverId,
+          serverId: state4.serverId,
           outcome,
           droppedPublishes: fence.dropped
         }
@@ -15336,13 +15276,13 @@ function armDiagnosticsFence(state5, normalizedPath, uri) {
     dropped: 0,
     supersede: () => end("superseded")
   };
-  state5.diagnosticFences.get(normalizedPath)?.supersede();
-  state5.diagnosticFences.set(normalizedPath, fence);
+  state4.diagnosticFences.get(normalizedPath)?.supersede();
+  state4.diagnosticFences.set(normalizedPath, fence);
   const bound = setTimeout(() => end("timeout"), DIAGNOSTICS_WAIT_TIMEOUT_MS);
   bound.unref?.();
   let reply;
   try {
-    reply = Promise.resolve(state5.connection.sendRequest("textDocument/documentSymbol", { textDocument: { uri } }, cancellation.token));
+    reply = Promise.resolve(state4.connection.sendRequest("textDocument/documentSymbol", { textDocument: { uri } }, cancellation.token));
   } catch (thrown) {
     reply = Promise.reject(thrown);
   }
@@ -15599,6 +15539,45 @@ async function probeRenameEntityKind(oldFilePath, newFilePath) {
   return void 0;
 }
 
+// dist/clients/lsp/grouping.js
+function groupFilesByPrimaryServer(files2) {
+  const byServer = /* @__PURE__ */ new Map();
+  for (const filePath of files2) {
+    const servers = getServersForFileWithConfig(filePath);
+    const primary = servers[0]?.id ?? "none";
+    const group = byServer.get(primary);
+    const fallbackFamilyHeads = /* @__PURE__ */ new Map();
+    const familyHeads = servers.map((server) => {
+      const head = server.fallbackFor ? fallbackFamilyHeads.get(server.fallbackFor) ?? server.fallbackFor : server.id;
+      fallbackFamilyHeads.set(server.id, head);
+      return head;
+    });
+    const multiServer = new Set(familyHeads).size > 1;
+    if (group) {
+      group.files.push(filePath);
+      if (multiServer)
+        group.multiServer = true;
+    } else {
+      byServer.set(primary, { files: [filePath], multiServer });
+    }
+  }
+  return [...byServer.values()];
+}
+async function runPerServerGroups(groups, concurrency, processGroup, signal) {
+  let nextGroup = 0;
+  const workers = Math.min(Math.max(1, concurrency), groups.length);
+  await Promise.all(Array.from({ length: workers }, async () => {
+    while (!signal?.aborted) {
+      const gi = nextGroup;
+      nextGroup += 1;
+      if (gi >= groups.length)
+        break;
+      await processGroup(groups[gi]);
+    }
+    return true;
+  }));
+}
+
 // dist/clients/lsp/language.js
 import path15 from "node:path";
 var LANGUAGE_EXTENSIONS = EXTENSION_TO_LSP_ID;
@@ -15675,7 +15654,7 @@ function createLazyImport(load) {
 }
 
 // dist/clients/lsp-lazy.js
-var lazyLsp = createLazyImport(() => import("./chunk-RJFED73B.js"));
+var lazyLsp = createLazyImport(() => import("./chunk-KSX3TXSZ.js"));
 function warmLspService() {
   return lazyLsp.get();
 }
@@ -15684,7 +15663,7 @@ function loadLspService() {
 }
 
 // dist/clients/warm-attach.js
-var state4 = { local: true, servedDiagnosticHashes: /* @__PURE__ */ new Map() };
+var state3 = { local: true, servedDiagnosticHashes: /* @__PURE__ */ new Map() };
 function record(event, cwd, reason, pid, source) {
   logLatency({
     type: "phase",
@@ -15698,50 +15677,50 @@ function selectWarmAttachIncumbent(entries, cwd, now = Date.now(), isPidAlive =
   return selectLivePeerInstances(entries, cwd, now, isPidAlive)[0];
 }
 async function tryWarmAttachedDiagnostics(file, content, timeoutMs, source = "per-edit") {
-  if (state4.local || !state4.cwd || !state4.incumbentPid)
+  if (state3.local || !state3.cwd || !state3.incumbentPid)
     return void 0;
   const entries = await readInstanceRegistry();
-  const incumbent = selectWarmAttachIncumbent(entries, state4.cwd);
-  if (incumbent?.pid !== state4.incumbentPid) {
+  const incumbent = selectWarmAttachIncumbent(entries, state3.cwd);
+  if (incumbent?.pid !== state3.incumbentPid) {
     promoteToLocal("incumbent-stale-or-exited");
     return void 0;
   }
-  const result = await requestWarmDiagnostics(state4.cwd, state4.incumbentPid, file, content, timeoutMs);
+  const result = await requestWarmDiagnostics(state3.cwd, state3.incumbentPid, file, content, timeoutMs);
   if (!result.available) {
     if (result.reason === "no-listener") {
       recordDegradationOnce({
         kind: "warm-ipc-endpoint-missing",
-        subject: diagnosticsIpcPathForCwd(state4.cwd, state4.incumbentPid),
+        subject: diagnosticsIpcPathForCwd(state3.cwd, state3.incumbentPid),
         reason: "the registry confirms this incumbent is alive but nothing is listening on its derived endpoint \u2014 if pi-lens was upgraded while it was running, restart it"
       });
     }
     promoteToLocal(result.reason);
   } else {
-    record("diagnostics-served", file, void 0, state4.incumbentPid, source);
+    record("diagnostics-served", file, void 0, state3.incumbentPid, source);
   }
   return result;
 }
 async function tryWarmAttachedCodeActions(file, expectedContentHash, ranges, timeoutMs) {
-  if (state4.local || !state4.cwd || !state4.incumbentPid)
+  if (state3.local || !state3.cwd || !state3.incumbentPid)
     return void 0;
-  const result = await requestWarmCodeActions(state4.cwd, state4.incumbentPid, file, expectedContentHash, ranges, timeoutMs);
+  const result = await requestWarmCodeActions(state3.cwd, state3.incumbentPid, file, expectedContentHash, ranges, timeoutMs);
   if (result.available) {
-    record("code-actions-served", file, void 0, state4.incumbentPid);
+    record("code-actions-served", file, void 0, state3.incumbentPid);
   } else {
-    record("code-actions-skipped", file, result.reason, state4.incumbentPid);
+    record("code-actions-skipped", file, result.reason, state3.incumbentPid);
   }
   return result;
 }
 function isWarmAttached() {
-  return !state4.local && state4.incumbentPid !== void 0;
+  return !state3.local && state3.incumbentPid !== void 0;
 }
 function promoteToLocal(reason) {
-  if (state4.local)
+  if (state3.local)
     return;
-  const pid = state4.incumbentPid;
-  state4.local = true;
-  state4.incumbentPid = void 0;
-  record("takeover", state4.cwd ?? process.cwd(), reason, pid);
+  const pid = state3.incumbentPid;
+  state3.local = true;
+  state3.incumbentPid = void 0;
+  record("takeover", state3.cwd ?? process.cwd(), reason, pid);
 }
 
 // dist/clients/lsp/index.js
@@ -15758,6 +15737,8 @@ var AUX_WAIT_DEMOTION_THRESHOLD = 5;
 var AUX_WAIT_DEMOTION_RATIO = 0.9;
 var AUX_WAIT_REPROMOTION_THRESHOLD = 5;
 var AUX_WAIT_REPROMOTION_RATIO = 0.5;
+var ADOPTED_ROOT_CAP = 2;
+var ADOPTED_ROOT_IDLE_EVICT_MS = 6e4;
 function destinationUriPreservingSpelling(oldUri, oldFilePath, newFilePath) {
   const canonical = pathToFileURL3(newFilePath);
   try {
@@ -15927,32 +15908,6 @@ function mergeLspDiagnostics(diagnostics) {
 function attributeDiagnostics(serverId, diagnostics) {
   return diagnostics.map((diagnostic) => ({ ...diagnostic, serverId }));
 }
-function groupFilesByPrimaryServer(files2) {
-  const byServer = /* @__PURE__ */ new Map();
-  for (const filePath of files2) {
-    const servers = getServersForFileWithConfig(filePath);
-    const primary = servers[0]?.id ?? "none";
-    const group = byServer.get(primary);
-    const fallbackFamilyHeads = /* @__PURE__ */ new Map();
-    const familyHeads = servers.map((server) => {
-      const head = server.fallbackFor ? fallbackFamilyHeads.get(server.fallbackFor) ?? server.fallbackFor : server.id;
-      fallbackFamilyHeads.set(server.id, head);
-      return head;
-    });
-    const multiServer = new Set(familyHeads).size > 1;
-    if (group) {
-      group.files.push(filePath);
-      if (multiServer)
-        group.multiServer = true;
-    } else {
-      byServer.set(primary, {
-        files: [filePath],
-        multiServer
-      });
-    }
-  }
-  return [...byServer.values()];
-}
 function createSweepIndexGate() {
   const seen = /* @__PURE__ */ new Set();
   return {
@@ -15964,20 +15919,6 @@ function createSweepIndexGate() {
     }
   };
 }
-async function runPerServerGroups(groups, concurrency, processGroup, signal) {
-  let nextGroup = 0;
-  const workers = Math.min(Math.max(1, concurrency), groups.length);
-  await Promise.all(Array.from({ length: workers }, async () => {
-    while (!signal?.aborted) {
-      const gi = nextGroup;
-      nextGroup += 1;
-      if (gi >= groups.length)
-        break;
-      await processGroup(groups[gi]);
-    }
-    return true;
-  }));
-}
 var WORKSPACE_DIAGNOSTICS_CONCURRENCY = 8;
 var WORKSPACE_SWEEP_PREOPEN_CHUNK_SIZE = (() => {
   const raw = Number(process.env.PI_LENS_LSP_WORKSPACE_PREOPEN_CHUNK);
@@ -16265,6 +16206,9 @@ var LSPService = class _LSPService {
   notifyStallDemotions = new BoundedFifoMap(_LSPService.MAX_NOTIFY_STALL_DEMOTIONS);
   /** LRU clock for capacity eviction, keyed by the canonical server/root key. */
   clientLastUsedAt = /* @__PURE__ */ new Map();
+  /** LRU of foreign project roots; kept apart from the session-root registry. */
+  adoptedRootLastUsedAt = /* @__PURE__ */ new Map();
+  adoptedClientKeys = /* @__PURE__ */ new Set();
   /**
    * Manager-owned use leases close the acquisition/use gap that `isBusy()`
    * cannot see: a caller may hold a selected client before its first request has
@@ -16354,6 +16298,67 @@ var LSPService = class _LSPService {
       reason: "auxiliary produced five consecutive late answers below half its declared wait budget"
     });
   }
+  analysisRootModeForFile(filePath) {
+    const roots = getSessionRootsForTelemetry(128);
+    if (this.sessionCwd)
+      roots.push(this.sessionCwd);
+    let adopted = false;
+    for (const root of new Set(roots)) {
+      const mode = resolveAnalysisRoot(filePath, root);
+      if (mode === "session" || mode === "linked-worktree")
+        return mode;
+      adopted ||= mode === "adopted";
+    }
+    return adopted ? "adopted" : "none";
+  }
+  fileIsOutsideRegisteredRoots(filePath) {
+    const roots = getSessionRootsForTelemetry(128);
+    if (roots.length === 0)
+      return isOutsideAllSessionRoots(filePath);
+    return !roots.some((root) => isSameOrWithin(root, filePath));
+  }
+  admitAdoptedRoot(root, filePath) {
+    if (this.analysisRootModeForFile(filePath) !== "adopted")
+      return false;
+    const normalized = normalizeMapKey(root);
+    const liveRoots = /* @__PURE__ */ new Set();
+    for (const key of this.state.clients.keys()) {
+      if (this.adoptedClientKeys.has(key))
+        liveRoots.add(key.slice(key.indexOf(":") + 1));
+    }
+    for (const root2 of this.adoptedRootLastUsedAt.keys()) {
+      if (!liveRoots.has(root2))
+        this.adoptedRootLastUsedAt.delete(root2);
+    }
+    if (liveRoots.has(normalized)) {
+      this.adoptedRootLastUsedAt.set(normalized, Date.now());
+      return true;
+    }
+    if (this.adoptedRootLastUsedAt.size < ADOPTED_ROOT_CAP) {
+      this.adoptedRootLastUsedAt.set(normalized, Date.now());
+      return true;
+    }
+    this.adoptedRootLastUsedAt.set(normalized, Date.now());
+    const victim = [...this.adoptedRootLastUsedAt.keys()].sort((a, b) => (this.adoptedRootLastUsedAt.get(a) ?? 0) - (this.adoptedRootLastUsedAt.get(b) ?? 0)).find((candidate) => candidate !== normalized);
+    if (!victim)
+      return true;
+    this.adoptedRootLastUsedAt.delete(victim);
+    for (const [key, client] of this.state.clients) {
+      if (!this.adoptedClientKeys.has(key) || !key.endsWith(`:${victim}`))
+        continue;
+      if ((this.clientLeases.get(key) ?? 0) > 0)
+        continue;
+      this.retireClient(key);
+      void client.shutdown({ reason: "adopted-root-lru" }).catch(() => {
+      });
+    }
+    incrementDegradationCount({
+      kind: "lsp-adopted-root-evicted",
+      subject: victim,
+      reason: `adopted root cap ${ADOPTED_ROOT_CAP} evicted ${victim}`
+    });
+    return true;
+  }
   /**
    * Resolve one server's client identity root. Root selection is hard-bounded
    * by the session cwd, then config-only nested roots reuse an already-hosted
@@ -16363,7 +16368,13 @@ var LSPService = class _LSPService {
     const candidate = await resolveLspServerCwd(server, filePath, this.sessionCwd ?? process.cwd(), onRootFailure);
     if (!candidate)
       return void 0;
-    if (isOutsideAllSessionRoots(filePath))
+    const mode = this.analysisRootModeForFile(filePath);
+    if (mode === "adopted") {
+      const classifierRoot = resolveAnalysisRootPath(filePath, this.sessionCwd ?? process.cwd());
+      if (!classifierRoot || normalizeMapKey(classifierRoot) !== normalizeMapKey(candidate))
+        return void 0;
+    }
+    if (this.fileIsOutsideRegisteredRoots(filePath) && this.analysisRootModeForFile(filePath) !== "adopted")
       return void 0;
     const root = enforceLspRootCeiling(candidate, process.cwd(), filePath);
     if (normalizeMapKey(root) === normalizeMapKey(process.cwd()))
@@ -16551,6 +16562,11 @@ var LSPService = class _LSPService {
     this.state.clientSpawnedAt.delete(key);
     this.forgetReadiness(key);
     this.clientLastUsedAt.delete(key);
+    if (this.adoptedClientKeys.delete(key)) {
+      const root = key.slice(key.indexOf(":") + 1);
+      if (![...this.adoptedClientKeys].some((candidate) => candidate.endsWith(`:${root}`)))
+        this.adoptedRootLastUsedAt.delete(root);
+    }
     this.clearIdleEvictionTimer(key);
     this.auxNotifyInflight.delete(key);
     this.auxNotifyDrainLatencyEwma.delete(key);
@@ -16565,12 +16581,12 @@ var LSPService = class _LSPService {
     current.resolveSettled();
   }
   scheduleIdleEviction(key, server) {
-    if (server.idleEviction !== "transparent")
+    if (server.idleEviction !== "transparent" && !this.adoptedClientKeys.has(key))
       return;
     this.clearIdleEvictionTimer(key);
     const lastUsedAt = this.clientLastUsedAt.get(key) ?? Date.now();
     const root = key.slice(key.indexOf(":") + 1);
-    const idleMs = getLspIdleEvictMsForRoot(root);
+    const idleMs = this.adoptedClientKeys.has(key) ? ADOPTED_ROOT_IDLE_EVICT_MS : getLspIdleEvictMsForRoot(root);
     const timer = setTimeout(() => {
       this.idleEvictionTimers.delete(key);
       void this.withClientSpawnGate(async () => {
@@ -18025,6 +18041,22 @@ var LSPService = class _LSPService {
     const allowInstall = this.shouldAllowInstall(server.id);
     const normalizedRoot = normalizeMapKey(root);
     const key = `${server.id}:${normalizedRoot}`;
+    const adopted = this.analysisRootModeForFile(filePath) === "adopted";
+    if (adopted) {
+      const localCommand = server.command ?? server.projectLocalCommand ?? server.availabilityKey;
+      const localBinary = localCommand ? path16.isAbsolute(localCommand) ? isProjectLocalBinPath(localCommand, root) ? localCommand : void 0 : findLocalBinUpwards(localCommand, root) : void 0;
+      if (localBinary) {
+        recordDegradationOnce({
+          kind: "lsp-registry-decision",
+          subject: `${server.id}:${normalizeMapKey(root)}`,
+          reason: "project-local LSP binary refused for adopted root"
+        });
+        return void 0;
+      }
+      this.adoptedClientKeys.add(key);
+      if (!this.admitAdoptedRoot(root, filePath))
+        return void 0;
+    }
     const isOptionalServer = OPTIONAL_LSP_SERVER_IDS.has(server.id);
     if (server.availabilityKey && isDirectLspCommandTemporarilyUnavailable(server.availabilityKey)) {
       emitBounded("lsp_client_skipped_unavailable_command", `${server.availabilityKey}:${normalizeMapKey(filePath)}`, {
@@ -18198,7 +18230,20 @@ var LSPService = class _LSPService {
    * Internal: spawn a client for a server/root combination
    */
   async spawnClient(server, root, key, filePath, allowInstall) {
-    if (!isLspSpawnAllowedByTrust()) {
+    try {
+      if (server.executesProjectCode === true) {
+        refuseUntrustedLspExecution({
+          kind: "project-code-server",
+          serverId: server.id,
+          root
+        });
+      }
+    } catch (error) {
+      logSessionStart(`lsp spawn ${server.id}: refused \u2014 ${error instanceof Error ? error.message : String(error)}`);
+      this.noteSpawnVerdict(key, "failed");
+      return void 0;
+    }
+    if (server.trustAllowed !== true && !isLspSpawnAllowedByTrust()) {
       logSessionStart(`lsp spawn ${server.id}: refused \u2014 ${projectTrustDenialReason()}`);
       this.noteSpawnVerdict(key, "declined");
       return void 0;
@@ -18208,7 +18253,12 @@ var LSPService = class _LSPService {
     logSessionStart(`lsp spawn ${server.id}: start root=${root} install=${allowInstall ? "enabled" : "disabled"} file=${filePath}`);
     recordLsp(server.id, root, "spawn_start");
     try {
-      const spawned = await server.spawn(root, { allowInstall });
+      const projectCodeAllowed = this.analysisRootModeForFile(filePath) !== "adopted";
+      const spawned = await withLspProjectCodePermission(projectCodeAllowed, () => server.spawn(root, {
+        allowInstall,
+        projectCodeAllowed,
+        sessionRoot: this.sessionCwd ?? process.cwd()
+      }));
       if (this.isDestroyed) {
         try {
           spawned?.process?.process?.kill();
@@ -18240,7 +18290,7 @@ var LSPService = class _LSPService {
         return void 0;
       }
       const override = getServerInitOverride(server.id, filePath);
-      const mergedInit = mergeInitializationOptions(spawned.initialization, override?.initializationOptions);
+      const mergedInit = spawned.launchVariant === "classic" ? mergeInitializationOptions(override?.initializationOptions, spawned.initialization) : mergeInitializationOptions(spawned.initialization, override?.initializationOptions);
       this.state.diagnosticsPublished.delete(server.id);
       this.state.diagnosticsUnsupported.delete(server.id);
       this.firstContactWaits.delete(server.id);
@@ -19487,7 +19537,9 @@ var LSPService = class _LSPService {
    * pays one bounded map walk and never the `server.root()` filesystem walks.
    */
   async findOutsideProjectRoot(filePath) {
-    if (!isOutsideAllSessionRoots(filePath))
+    if (!this.fileIsOutsideRegisteredRoots(filePath))
+      return void 0;
+    if (this.analysisRootModeForFile(filePath) === "adopted")
       return void 0;
     const candidates = await Promise.all(getServersForFileWithConfig(filePath).map((server) => server.root(filePath)));
     return candidates.find((candidate) => Boolean(candidate));
@@ -21522,71 +21574,107 @@ var LSPService = class _LSPService {
     return [...primary, ...aux];
   }
 };
-var LSP_PROCESS_FAMILY = "lsp.service";
-var LSP_PROCESS_VERSION = 1;
-function lspProcessState() {
-  let incompatibleHandoff;
-  return getProcessSingleton(LSP_PROCESS_FAMILY, LSP_PROCESS_VERSION, () => ({ service: null, generationHandoff: incompatibleHandoff }), (value) => {
-    if (!value || typeof value !== "object")
-      return;
-    const candidate = value;
-    const previousHandoff = candidate.generationHandoff;
-    const teardown = candidate.service?.shutdown ? candidate.service.shutdown({ fast: true, reason: "process_singleton_reset" }).catch(() => void 0) : void 0;
-    if (previousHandoff && teardown) {
-      incompatibleHandoff = Promise.allSettled([
-        previousHandoff,
-        teardown
-      ]).then(() => void 0);
-    } else {
-      incompatibleHandoff = previousHandoff ?? teardown;
+configureLspServiceLifecycle({
+  create: (generationHandoff) => new LSPService(generationHandoff, process.cwd()),
+  beforeReset: (options) => {
+    abortDeferredLspWork(`lsp service reset: ${options.reason ?? "unspecified"}`);
+    resetLspLaunchAvailabilityGeneration();
+    if (options.reason === "session_start") {
+      resetClassicTsRepairGuard();
+    }
+  },
+  destroy: (service, options) => service.shutdown(options)
+});
+
+// dist/clients/lsp/capabilities.js
+var adaptedServices = /* @__PURE__ */ new WeakMap();
+function bindGroup(service, keys) {
+  return new Proxy({}, {
+    get(_target, key) {
+      if (!keys.includes(key))
+        return void 0;
+      const value = service[key];
+      return typeof value === "function" ? value.bind(service) : value;
     }
   });
 }
-function processService() {
-  const state5 = lspProcessState();
-  if (!state5.service)
-    state5.service = new LSPService(state5.generationHandoff, process.cwd());
-  return state5.service;
+function adaptLspService(service) {
+  const existing = adaptedServices.get(service);
+  if (existing)
+    return existing;
+  const groups = {
+    clients: bindGroup(service, [
+      "checkDestroyed",
+      "getAliveClientCount",
+      "getAliveServerIds",
+      "getBrokenStatus",
+      "getStatus",
+      "isSpawnInFlight",
+      "shutdown"
+    ]),
+    documents: bindGroup(service, [
+      "getOpenDocumentPaths",
+      "openFile",
+      "touchFile"
+    ]),
+    diagnostics: bindGroup(service, [
+      "getAllDiagnostics",
+      "getDiagnostics",
+      "getDiagnosticsHealth",
+      "getLastKnownDiagnostics",
+      "readCachedDiagnosticsForServers",
+      "runWorkspaceDiagnostics"
+    ]),
+    navigation: bindGroup(service, [
+      "codeAction",
+      "documentSymbol",
+      "definition",
+      "hover",
+      "implementation",
+      "incomingCalls",
+      "outgoingCalls",
+      "prepareCallHierarchy",
+      "references",
+      "rename",
+      "typeDefinition"
+    ]),
+    workspace: bindGroup(service, [
+      "getAdvertisedCommands",
+      "getCapabilitySnapshots",
+      "getClientForFile",
+      "getOperationSupport",
+      "getWarmClientForFile",
+      "hasServerPublishedForFileRoot",
+      "supportsLSP"
+    ])
+  };
+  const adapted = new Proxy(service, {
+    get(target, key, receiver) {
+      if (key in groups)
+        return groups[key];
+      const value = Reflect.get(target, key, receiver);
+      return typeof value === "function" ? value.bind(target) : value;
+    }
+  });
+  adaptedServices.set(service, adapted);
+  return adapted;
 }
 function getLSPService() {
-  return processService();
+  return adaptLspService(getOwnedLspService());
 }
 function peekLSPService() {
-  return lspProcessState().service ?? void 0;
-}
-async function hasAuxiliaryLspPublishedForRoot(serverId, filePath) {
-  return getLSPService().hasServerPublishedForFileRoot(serverId, filePath);
+  const service = peekOwnedLspService();
+  return service ? adaptLspService(service) : void 0;
 }
+var resetLSPService = (options = {}) => resetOwnedLspService(options);
 async function notifyExternalFileChange(filePath, type) {
   return getLSPService().notifyExternalFileChange(filePath, type);
 }
 async function resyncGitChangedFiles(changedPaths) {
   return getLSPService().resyncGitChangedFiles(changedPaths);
 }
-function resetLSPService(options = {}) {
-  abortDeferredLspWork(`lsp service reset: ${options.reason ?? "unspecified"}`);
-  resetLspLaunchAvailabilityGeneration();
-  if (options.reason === "session_start") {
-    resetClassicTsRepairGuard();
-    clearWorkspaceSweepHoldForSessionStart();
-  }
-  const state5 = lspProcessState();
-  const retiringService = state5.service;
-  state5.service = null;
-  if (!retiringService)
-    return;
-  const teardown = retiringService.shutdown(options);
-  const pending2 = state5.generationHandoff ? [state5.generationHandoff, teardown] : [teardown];
-  const handoff = Promise.allSettled(pending2).then(() => void 0);
-  state5.generationHandoff = handoff;
-  void handoff.then(() => {
-    if (state5.generationHandoff === handoff) {
-      state5.generationHandoff = void 0;
-    }
-  });
-}
-function __collectWorkspaceDiagnosticFilesForTest(root, maxFiles, signal, homeDir) {
-  return collectWorkspaceDiagnosticFiles(path16.resolve(root), maxFiles ?? getMaxWorkspaceDiagnosticFiles(), signal, homeDir);
+async function hasAuxiliaryLspPublishedForRoot(serverId, filePath) {
+  return getLSPService().hasServerPublishedForFileRoot(serverId, filePath);
 }
 
 export {
@@ -21661,10 +21749,6 @@ export {
   retagAuxiliaryDiagnostics,
   armDeferredLspWork,
   registerDeferredLspWork,
-  SWEEP_IDLE_SAFETY_MARGIN_MS,
-  isWorkspaceSweepActive,
-  runWhenWorkspaceSweepIdle,
-  getFullScanWallClockMs,
   MAX_LATE_AUX_REARMS,
   isAuxBacklogPublished,
   isPendingAuxiliaryPastRearmTtl,
@@ -21697,24 +21781,18 @@ export {
   buildReverseDependencyIndexFromGraph,
   buildScopeKey,
   createWorkspaceDiagnosticsCacheContext,
+  groupFilesByPrimaryServer,
+  runPerServerGroups,
   createLazyImport,
   loadLspService,
   tryWarmAttachedDiagnostics,
   tryWarmAttachedCodeActions,
   isWarmAttached,
-  mergeInitializationOptions,
-  getLspIdleEvictMs,
-  getLspIdleEvictMsForRoot,
-  getLspClientCeiling,
-  groupFilesByPrimaryServer,
-  createSweepIndexGate,
-  runPerServerGroups,
-  LSPService,
+  adaptLspService,
   getLSPService,
   peekLSPService,
-  hasAuxiliaryLspPublishedForRoot,
+  resetLSPService,
   notifyExternalFileChange,
   resyncGitChangedFiles,
-  resetLSPService,
-  __collectWorkspaceDiagnosticFilesForTest
+  hasAuxiliaryLspPublishedForRoot
 };