@duckmind/dm-darwin-x64 0.66.5 → 0.66.6

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

@@ -463,6 +463,41 @@ export function pullDiagnosticSources(state) {
 export function bumpDiagnosticsVersion(state, normalizedPath) {
   state.diagnosticsVersion += 1;
   state.diagnosticsVersionsByPath?.set(normalizedPath, state.diagnosticsVersion);
+  countPublication(state, normalizedPath);
+}
+function countPublication(state, normalizedPath) {
+  const counts = state.publicationStoreCountsByPath;
+  if (!counts)
+    return;
+  const { sent } = publicationCountsForPath(state, normalizedPath);
+  if (sent === 0)
+    return;
+  counts.set(normalizedPath, Math.min((counts.get(normalizedPath) ?? 0) + 1, sent));
+}
+export function rebaselineForRulesRefresh(state) {
+  const counts = state.publicationStoreCountsByPath;
+  for (const [normalizedPath, published] of counts) {
+    counts.set(normalizedPath, published - 1);
+  }
+  for (const normalizedPath of state.pendingDiagnostics.keys()) {
+    if (counts.has(normalizedPath) || publicationCountsForPath(state, normalizedPath).sent === 0)
+      continue;
+    counts.set(normalizedPath, -1);
+  }
+  logLatency({
+    type: "phase",
+    phase: "lsp_rules_refreshed",
+    filePath: state.root,
+    durationMs: 0,
+    metadata: { serverId: state.serverId, rebaselinedPaths: counts.size }
+  });
+}
+export function publicationCountsForPath(state, normalizedPath) {
+  const lastSent = state.documentVersions.get(normalizedPath);
+  return {
+    sent: (lastSent === undefined ? 0 : lastSent + 1) + (state.expectedPublicationsBeyondSends?.get(normalizedPath) ?? 0),
+    published: state.publicationStoreCountsByPath?.get(normalizedPath) ?? 0
+  };
 }
 export function diagnosticsVersionForPath(state, normalizedPath) {
   return state.diagnosticsVersionsByPath?.get(normalizedPath) ?? 0;
@@ -471,8 +506,10 @@ export function clearDiagnosticsForPath(state, normalizedPath) {
   const legacy = state;
   state.pushDiagnostics?.delete(normalizedPath);
   const pending = state.pendingDiagnostics?.get(normalizedPath);
-  if (pending)
+  if (pending) {
     clearTimeout(pending);
+    countPublication(state, normalizedPath);
+  }
   state.pendingDiagnostics?.delete(normalizedPath);
   state.pushDiagnosticTimestamps?.delete(normalizedPath);
   state.documentPullDiagnostics?.delete(normalizedPath);
@@ -553,9 +590,13 @@ function recordSentContent(state, normalizedPath, version, content, coalescedCou
     state.incrementalTextBearingPaths?.delete(normalizedPath);
   }
   state.documentContentHashes.delete(normalizedPath);
+  const hash = hashDiagnosticContent(content);
   state.documentContentHashes.set(normalizedPath, {
     version,
-    hash: hashDiagnosticContent(content),
+    hash,
+    changedAtMs: previous?.hash === hash ? previous.changedAtMs : Date.now(),
+    openedAtMs: previous?.openedAtMs ?? Date.now(),
+    openedHash: previous === undefined ? hash : previous.openedHash,
     ...state.syncKind === TEXT_DOCUMENT_SYNC_KIND_INCREMENTAL && {
       text: content,
       lastLine: scan.lastLine
@@ -578,7 +619,10 @@ function recordSentContent(state, normalizedPath, version, content, coalescedCou
         continue;
       state.documentContentHashes.set(oldestPath, {
         version: binding.version,
-        hash: binding.hash
+        hash: binding.hash,
+        changedAtMs: binding.changedAtMs,
+        openedAtMs: binding.openedAtMs,
+        openedHash: binding.openedHash
       });
       state.incrementalTextRetainedEntries = Math.max(0, (state.incrementalTextRetainedEntries ?? 1) - 1);
       state.incrementalTextRetainedBytes = Math.max(0, (state.incrementalTextRetainedBytes ?? 0) - binding.text.length * 2);
@@ -679,11 +723,37 @@ export function setupIncomingHandlers(state, initialization, onDiagnosticsPublis
     const publishReceivedAt = Date.now();
     const filePath = uriToPath(params.uri);
     const normalizedPath = normalizeMapKey(filePath);
-    if (state.closedDocuments?.has(normalizedPath))
+    const docVersion = params.version;
+    if (docVersion === undefined && getStrategy(state.serverId, state.launchVariant).publishesOnClose) {
       return;
+    }
+    if (state.closedDocuments?.has(normalizedPath)) {
+      countPublication(state, normalizedPath);
+      return;
+    }
     onDiagnosticsPublished?.(state.serverId);
     const newDiags = normalizeLspDiagnostics(params.diagnostics || []);
-    const docVersion = params.version;
+    const fence = state.diagnosticFences.get(normalizedPath);
+    if (docVersion === undefined && fence) {
+      fence.dropped += 1;
+      countPublication(state, normalizedPath);
+      if (getStrategy(state.serverId, state.launchVariant).emptyFirstPublish === "indexing" && !state.emptyFirstPublishHoldSpent && newDiags.length === 0 && !state.pushDiagnostics.has(normalizedPath) && !state.pendingDiagnostics.has(normalizedPath)) {
+        state.emptyFirstPublishHoldSpent = true;
+        logLatency({
+          type: "phase",
+          phase: "lsp_empty_first_publish_held",
+          filePath: normalizedPath,
+          durationMs: Math.max(0, publishReceivedAt - (state.documentOpenedAt.get(normalizedPath) ?? publishReceivedAt)),
+          metadata: {
+            serverId: state.serverId,
+            emptyFirstPublish: "indexing",
+            via: "fence-drop",
+            pubVersion: "push-unversioned"
+          }
+        });
+      }
+      return;
+    }
     if (PUB_DEBUG) {
       logExtension({
         subsystem: "lsp-pub",
@@ -762,8 +832,10 @@ export function setupIncomingHandlers(state, initialization, onDiagnosticsPublis
       return;
     }
     if (strategy.seedFirstPush && !state.pushDiagnostics.has(normalizedPath)) {
-      if (isSupersededPush())
+      if (isSupersededPush()) {
+        countPublication(state, normalizedPath);
         return;
+      }
       state.pushDiagnostics.set(normalizedPath, newDiags);
       state.pushDiagnosticTimestamps.set(normalizedPath, Date.now());
       recordDocVersion();
@@ -774,12 +846,16 @@ export function setupIncomingHandlers(state, initialization, onDiagnosticsPublis
     }
     logSequence(false, "publication", 0);
     const existingTimer = state.pendingDiagnostics.get(normalizedPath);
-    if (existingTimer)
+    if (existingTimer) {
       clearTimeout(existingTimer);
+      countPublication(state, normalizedPath);
+    }
     const timer = setTimeout(() => {
       state.pendingDiagnostics.delete(normalizedPath);
-      if (isSupersededPush())
+      if (isSupersededPush()) {
+        countPublication(state, normalizedPath);
         return;
+      }
       state.pushDiagnostics.set(normalizedPath, newDiags);
       state.pushDiagnosticTimestamps.set(normalizedPath, Date.now());
       recordDocVersion();
@@ -860,6 +936,7 @@ export function setupIncomingHandlers(state, initialization, onDiagnosticsPublis
     return items.map((item) => resolveConfigurationSection(initialization, item?.section));
   });
   state.connection.onRequest("window/workDoneProgress/create", async () => {});
+  state.connection.onNotification("semgrep/rulesRefreshed", () => rebaselineForRulesRefresh(state));
   let refreshRepullRunning = false;
   let refreshRepullRerunRequested = false;
   const runRefreshRepullPool = async () => {
@@ -1268,12 +1345,8 @@ export async function clientRequestWorkspaceDiagnostics(state, budgetMs) {
         continue;
       }
       const diagnostics = normalizeLspDiagnostics(item.items ?? []);
-      let contentHash;
-      try {
-        contentHash = hashDiagnosticContent(await readFile(filePath, "utf-8"));
-      } catch {
-        contentHash = undefined;
-      }
+      const sent = state.openDocuments.has(normalizedPath) ? state.documentContentHashes.get(normalizedPath) : undefined;
+      const contentHash = sent !== undefined && sent.version === item.version ? sent.hash : undefined;
       if (item.resultId !== undefined) {
         if (state.workspacePullResultCache.size >= WORKSPACE_PULL_RESULT_CACHE_MAX) {
           state.workspacePullResultCache.clear();
@@ -1394,12 +1467,19 @@ export function handleNotifyExternalChange(state, filePath, type) {
   const uri = state.openDocumentUris?.get(normalizedPath) ?? pathToFileURL(filePath).href;
   state.watchQueue.enqueue(uri, type);
 }
-async function sendDidSave(state, uri, content) {
+function expectSaveRescan(state, normalizedPath) {
+  if (!getStrategy(state.serverId, state.launchVariant).rescansOnSave)
+    return;
+  const beyond = state.expectedPublicationsBeyondSends;
+  beyond?.set(normalizedPath, (beyond.get(normalizedPath) ?? 0) + 1);
+}
+async function sendDidSave(state, normalizedPath, uri, content) {
   const save = state.saveOptions;
   if (!save)
     return;
   if (!isClientAlive(state))
     return;
+  expectSaveRescan(state, normalizedPath);
   const limit = save.includeText ? exceedsLspSyncLimits(content) : { tooLarge: false, reason: "" };
   if (limit.tooLarge) {
     recordDegradationOnce({
@@ -1413,9 +1493,24 @@ async function sendDidSave(state, uri, content) {
     ...save.includeText && !limit.tooLarge ? { text: content } : {}
   });
 }
+async function sendDidSaveForHeldDocument(state, normalizedPath) {
+  if (!state.saveOptions || !isClientAlive(state))
+    return;
+  if (!state.openDocuments.has(normalizedPath))
+    return;
+  const uri = state.openDocumentUris?.get(normalizedPath);
+  if (uri === undefined)
+    return;
+  expectSaveRescan(state, normalizedPath);
+  try {
+    await safeSendNotification(state.connection, "textDocument/didSave", {
+      textDocument: { uri }
+    });
+  } catch {}
+}
 async function handleNotifyOpenOnce(state, filePath, content, languageId, preserveDiagnostics = false, silent = false, coalescedCount = 0, saved = false) {
   if (!isClientAlive(state))
-    return;
+    return false;
   const normalizedPath = normalizeMapKey(filePath);
   const uri = state.openDocumentUris?.get(normalizedPath) ?? pathToFileURL(filePath).href;
   if (state.openDocuments.has(normalizedPath) || state.pendingOpens.has(normalizedPath)) {
@@ -1434,31 +1529,35 @@ async function handleNotifyOpenOnce(state, filePath, content, languageId, preser
       state.documentOpenedAt.set(normalizedPath, Date.now());
       state.diagnosticPublicationCounts.set(normalizedPath, 0);
       if (!isClientAlive(state))
-        return;
+        return false;
       const reopenSent = await safeSendNotification(state.connection, "textDocument/didOpen", { textDocument: { uri, languageId, version, text: content } });
       if (reopenSent)
         recordSentContent(state, normalizedPath, version, content, coalescedCount);
       state.openDocuments.add(normalizedPath);
       state.openDocumentUris?.set(normalizedPath, uri);
       if (saved && reopenSent)
-        await sendDidSave(state, uri, content);
-      return;
+        await sendDidSave(state, normalizedPath, uri, content);
+      return reopenSent;
     }
-    const changeSent = await safeSendNotification(state.connection, "textDocument/didChange", {
+    const changeSent = await sendFenced(state, normalizedPath, uri, "textDocument/didChange", {
       textDocument: { uri, version },
       contentChanges: buildContentChanges(state, normalizedPath, content)
     });
     if (changeSent)
       recordSentContent(state, normalizedPath, version, content, coalescedCount);
     if (saved && changeSent)
-      await sendDidSave(state, uri, content);
-    return;
+      await sendDidSave(state, normalizedPath, uri, content);
+    return changeSent;
   }
+  if (await closedAndGone(state, filePath, normalizedPath))
+    return false;
   state.pendingOpens.add(normalizedPath);
   state.documentVersions.set(normalizedPath, 0);
   state.documentOpenedAt.set(normalizedPath, Date.now());
   state.diagnosticPublicationCounts.set(normalizedPath, 0);
   clearDiagnosticsForPath(state, normalizedPath);
+  if (!state.expectedPublicationsBeyondSends?.has(normalizedPath))
+    state.publicationStoreCountsByPath?.delete(normalizedPath);
   if (!silent) {
     let fileExists = true;
     try {
@@ -1469,8 +1568,8 @@ async function handleNotifyOpenOnce(state, filePath, content, languageId, preser
     state.watchQueue.enqueue(uri, fileExists ? 2 : 1);
   }
   if (!isClientAlive(state))
-    return;
-  const openSent = await safeSendNotification(state.connection, "textDocument/didOpen", { textDocument: { uri, languageId, version: 0, text: content } });
+    return false;
+  const openSent = await sendFenced(state, normalizedPath, uri, "textDocument/didOpen", { textDocument: { uri, languageId, version: 0, text: content } });
   if (openSent)
     recordSentContent(state, normalizedPath, 0, content, coalescedCount);
   state.pendingOpens.delete(normalizedPath);
@@ -1478,7 +1577,7 @@ async function handleNotifyOpenOnce(state, filePath, content, languageId, preser
   state.closedDocuments?.delete(normalizedPath);
   state.openDocumentUris?.set(normalizedPath, uri);
   if (saved && openSent)
-    await sendDidSave(state, uri, content);
+    await sendDidSave(state, normalizedPath, uri, content);
   probeTsserverProjectIdentity({
     serverId: state.serverId,
     launchVariant: state.launchVariant,
@@ -1490,22 +1589,37 @@ async function handleNotifyOpenOnce(state, filePath, content, languageId, preser
       executeCommand: (command, args) => runReadOnlyServerCommand(state, command, args)
     }
   });
+  return openSent;
 }
-function enqueueDocumentNotify(state, normalizedPath, run, saved = false) {
+function enqueueDocumentNotify(state, normalizedPath, run, saved = false, readStamp, close = false) {
   let queue = state.notifyChangeQueues.get(normalizedPath);
   if (!queue) {
     queue = { running: false };
     state.notifyChangeQueues.set(normalizedPath, queue);
   }
   return new Promise((resolve, reject) => {
+    if (queue.closing && !close) {
+      resolve(false);
+      return;
+    }
     const previous = queue?.pending;
     const waiters = previous?.waiters ?? [];
-    waiters.push({ resolve, reject });
+    if (close) {
+      for (const waiter of waiters)
+        waiter.stale = true;
+      queue.closing = true;
+    }
+    const lastSent = state.sentReadStamps.get(normalizedPath);
+    const before = (a, b) => a !== undefined && b !== undefined && a < b;
+    const stale = previous !== undefined && (before(readStamp, previous.readStamp) || before(readStamp, lastSent));
+    const heldStamp = before(previous?.readStamp, lastSent) ? undefined : previous?.readStamp;
+    waiters.push({ resolve, reject, stale });
     queue.pending = {
-      run,
+      run: stale ? previous.run : run,
       waiters,
       coalescedCount: (previous?.coalescedCount ?? 0) + (previous ? 1 : 0),
-      saved: saved || previous?.saved === true
+      saved: saved || previous?.saved === true,
+      readStamp: close ? undefined : stale ? previous.readStamp : readStamp ?? heldStamp
     };
     if (queue.running)
       return;
@@ -1517,10 +1631,20 @@ function enqueueDocumentNotify(state, normalizedPath, run, saved = false) {
           if (!next)
             break;
           queue.pending = undefined;
+          const lastSent = state.sentReadStamps.get(normalizedPath);
+          if (next.readStamp !== undefined && lastSent !== undefined && next.readStamp < lastSent) {
+            if (next.saved)
+              await sendDidSaveForHeldDocument(state, normalizedPath);
+            for (const waiter of next.waiters)
+              waiter.resolve(false);
+            continue;
+          }
+          if (next.readStamp !== undefined)
+            state.sentReadStamps.set(normalizedPath, next.readStamp);
           try {
-            await next.run(next.coalescedCount, next.saved);
+            const sent = await next.run(next.coalescedCount, next.saved);
             for (const waiter of next.waiters)
-              waiter.resolve();
+              waiter.resolve(sent !== false && !waiter.stale);
           } catch (error) {
             for (const waiter of next.waiters)
               waiter.reject(error);
@@ -1538,23 +1662,23 @@ function enqueueDocumentNotify(state, normalizedPath, run, saved = false) {
 function cancelDocumentNotifyQueues(state) {
   for (const queue of state.notifyChangeQueues.values()) {
     for (const waiter of queue.pending?.waiters ?? [])
-      waiter.resolve();
+      waiter.resolve(false);
     queue.pending = undefined;
   }
   state.notifyChangeQueues.clear();
 }
-export function handleNotifyOpen(state, filePath, content, languageId, preserveDiagnostics = false, silent = false, saved = false) {
-  if (!isClientAlive(state))
-    return Promise.resolve();
+export function handleNotifyOpen(state, filePath, content, languageId, preserveDiagnostics = false, silent = false, saved = false, readStamp) {
   const normalizedPath = normalizeMapKey(filePath);
-  return enqueueDocumentNotify(state, normalizedPath, (coalescedCount, queuedSaved) => handleNotifyOpenOnce(state, filePath, content, languageId, preserveDiagnostics, silent, coalescedCount, queuedSaved), saved);
+  return enqueueDocumentNotify(state, normalizedPath, (coalescedCount, queuedSaved) => handleNotifyOpenOnce(state, filePath, content, languageId, preserveDiagnostics, silent, coalescedCount, queuedSaved), saved, readStamp);
 }
-async function handleNotifyChangeOnce(state, filePath, content, normalizedPath, coalescedCount = 0) {
+async function handleNotifyChangeOnce(state, filePath, content, normalizedPath, coalescedCount = 0, saved = false) {
   if (!isClientAlive(state))
-    return;
+    return false;
   const uri = state.openDocumentUris?.get(normalizedPath) ?? pathToFileURL(filePath).href;
   if (!state.openDocuments.has(normalizedPath)) {
-    const fallbackOpenSent = await safeSendNotification(state.connection, "textDocument/didOpen", {
+    if (await closedAndGone(state, filePath, normalizedPath))
+      return false;
+    const fallbackOpenSent = await sendFenced(state, normalizedPath, uri, "textDocument/didOpen", {
       textDocument: {
         uri,
         languageId: "plaintext",
@@ -1568,31 +1692,52 @@ async function handleNotifyChangeOnce(state, filePath, content, normalizedPath,
     if (fallbackOpenSent)
       recordSentContent(state, normalizedPath, 0, content, coalescedCount);
     state.openDocuments.add(normalizedPath);
+    state.closedDocuments?.delete(normalizedPath);
     state.openDocumentUris?.set(normalizedPath, uri);
-    return;
+    if (saved && fallbackOpenSent)
+      await sendDidSave(state, normalizedPath, uri, content);
+    return fallbackOpenSent;
   }
   const version = (state.documentVersions.get(normalizedPath) ?? 0) + 1;
   state.documentVersions.set(normalizedPath, version);
   clearDiagnosticsForPath(state, normalizedPath);
-  const changeSent = await safeSendNotification(state.connection, "textDocument/didChange", {
+  const changeSent = await sendFenced(state, normalizedPath, uri, "textDocument/didChange", {
     textDocument: { uri, version },
     contentChanges: buildContentChanges(state, normalizedPath, content)
   });
   if (changeSent)
     recordSentContent(state, normalizedPath, version, content, coalescedCount);
+  if (saved && changeSent)
+    await sendDidSave(state, normalizedPath, uri, content);
+  return changeSent;
 }
 export function handleNotifyChange(state, filePath, content) {
-  if (!isClientAlive(state))
-    return Promise.resolve();
   const normalizedPath = normalizeMapKey(filePath);
-  return enqueueDocumentNotify(state, normalizedPath, (coalescedCount) => handleNotifyChangeOnce(state, filePath, content, normalizedPath, coalescedCount));
+  return enqueueDocumentNotify(state, normalizedPath, (coalescedCount, queuedSaved) => handleNotifyChangeOnce(state, filePath, content, normalizedPath, coalescedCount, queuedSaved));
+}
+async function closedAndGone(state, filePath, normalizedPath) {
+  if (!state.closedDocuments?.has(normalizedPath))
+    return false;
+  try {
+    await access(filePath);
+    return false;
+  } catch {
+    return true;
+  }
 }
 export async function closeDocument(state, filePath) {
   if (!isClientAlive(state))
     return;
   const normalizedPath = normalizeMapKey(filePath);
-  if (!state.openDocuments.has(normalizedPath))
+  await enqueueDocumentNotify(state, normalizedPath, () => closeDocumentOnce(state, filePath, normalizedPath), false, undefined, true);
+}
+async function closeDocumentOnce(state, filePath, normalizedPath) {
+  if (!isClientAlive(state))
+    return;
+  if (!state.openDocuments.has(normalizedPath)) {
+    state.closedDocuments?.add(normalizedPath);
     return;
+  }
   await safeSendNotification(state.connection, "textDocument/didClose", {
     textDocument: {
       uri: state.openDocumentUris?.get(normalizedPath) ?? pathToFileURL(filePath).href
@@ -1601,7 +1746,9 @@ export async function closeDocument(state, filePath) {
   state.openDocuments.delete(normalizedPath);
   state.closedDocuments?.add(normalizedPath);
   state.openDocumentUris?.delete(normalizedPath);
+  state.expectedPublicationsBeyondSends?.set(normalizedPath, publicationCountsForPath(state, normalizedPath).sent);
   state.documentVersions.delete(normalizedPath);
+  state.sentReadStamps.delete(normalizedPath);
   state.documentOpenedAt.delete(normalizedPath);
   state.diagnosticPublicationCounts.delete(normalizedPath);
   state.projectIdentityProbedFiles?.delete(normalizedPath);
@@ -2077,6 +2224,7 @@ export async function createLSPClient(options) {
   const state = {
     isConnected: true,
     isDestroyed: false,
+    startedAtMs: Date.now(),
     shutdownRequested: false,
     shutdownPromise: undefined,
     shutdownOptions: undefined,
@@ -2095,8 +2243,11 @@ export async function createLSPClient(options) {
     diagnosticEmitter,
     diagnosticsVersion: 0,
     diagnosticsVersionsByPath: new Map,
+    publicationStoreCountsByPath: new Map,
+    expectedPublicationsBeyondSends: new Map,
     documentVersions: new Map,
     notifyChangeQueues: new Map,
+    sentReadStamps: new Map,
     diagnosticDocVersions: new Map,
     documentContentHashes: new Map,
     incrementalTextRetainedEntries: 0,
@@ -2110,6 +2261,7 @@ export async function createLSPClient(options) {
     workspacePullResultCache: new Map,
     openDocuments: new Set,
     emptyFirstPublishHoldSpent: false,
+    diagnosticFences: new Map,
     closedDocuments: new Set,
     openDocumentUris: new Map,
     pendingOpens: new Set,
@@ -2236,8 +2388,8 @@ export async function createLSPClient(options) {
     pingLiveness: (timeoutMs) => clientPingLiveness(state, timeoutMs),
     getProcessPid: () => lspProcess.pid,
     notify: {
-      async open(filePath, content, languageId, preserveDiagnostics, silent, saved) {
-        return handleNotifyOpen(state, filePath, content, languageId, preserveDiagnostics, silent, saved);
+      async open(filePath, content, languageId, preserveDiagnostics, silent, saved, readStamp) {
+        return handleNotifyOpen(state, filePath, content, languageId, preserveDiagnostics, silent, saved, readStamp);
       },
       async change(filePath, content) {
         return handleNotifyChange(state, filePath, content);
@@ -2255,6 +2407,9 @@ export async function createLSPClient(options) {
     getDiagnosticsVersionForPath(filePath) {
       return diagnosticsVersionForPath(state, normalizeMapKey(filePath));
     },
+    getPublicationCountsForPath(filePath) {
+      return publicationCountsForPath(state, normalizeMapKey(filePath));
+    },
     getAllDiagnostics() {
       const result = new Map;
       const keys = new Set([
@@ -2312,6 +2467,9 @@ export async function createLSPClient(options) {
     getRawCapabilityKeys() {
       return state.rawCapabilityKeys ?? [];
     },
+    getSaveOptions() {
+      return state.saveOptions ? { ...state.saveOptions } : undefined;
+    },
     getLaunchVariant() {
       return state.launchVariant;
     },
@@ -2386,8 +2544,18 @@ export async function createLSPClient(options) {
     openDocumentPaths() {
       return [...state.openDocuments];
     },
+    getSentContent(filePath) {
+      const sent = state.documentContentHashes.get(normalizeMapKey(filePath));
+      return sent && {
+        hash: sent.hash,
+        changedAtMs: sent.changedAtMs,
+        openedAtMs: sent.openedAtMs,
+        openedHash: sent.openedHash,
+        clientStartedAtMs: state.startedAtMs
+      };
+    },
     isBusy() {
-      return (activeRequestsByConnection.get(connection) ?? 0) > 0;
+      return isConnectionBusy(connection);
     },
     getDocumentUri(filePath) {
       return state.openDocumentUris?.get(normalizeMapKey(filePath));
@@ -2504,6 +2672,69 @@ export async function createLSPClient(options) {
     }
   };
 }
+function sendFenced(state, normalizedPath, uri, method, params) {
+  const sent = safeSendNotification(state.connection, method, params);
+  armDiagnosticsFence(state, normalizedPath, uri);
+  return sent;
+}
+function armDiagnosticsFence(state, normalizedPath, uri) {
+  if (getStrategy(state.serverId, state.launchVariant).diagnosticsFence !== "reply-first") {
+    return;
+  }
+  if (state.operationSupport?.documentSymbol !== true) {
+    if (!state.fenceSkipRecorded) {
+      state.fenceSkipRecorded = true;
+      logLatency({
+        type: "phase",
+        phase: "lsp_diagnostics_fence",
+        filePath: normalizedPath,
+        durationMs: 0,
+        metadata: { serverId: state.serverId, outcome: "no-request" }
+      });
+    }
+    return;
+  }
+  const armedAt = Date.now();
+  const cancellation = new CancellationTokenSource;
+  const end = (outcome) => {
+    if (ended)
+      return;
+    ended = true;
+    clearTimeout(bound);
+    state.diagnosticFences.delete(normalizedPath);
+    cancellation.cancel();
+    cancellation.dispose();
+    if (outcome === "timeout" || fence.dropped > 0) {
+      logLatency({
+        type: "phase",
+        phase: "lsp_diagnostics_fence",
+        filePath: normalizedPath,
+        durationMs: Date.now() - armedAt,
+        metadata: {
+          serverId: state.serverId,
+          outcome,
+          droppedPublishes: fence.dropped
+        }
+      });
+    }
+  };
+  let ended = false;
+  const fence = {
+    dropped: 0,
+    supersede: () => end("superseded")
+  };
+  state.diagnosticFences.get(normalizedPath)?.supersede();
+  state.diagnosticFences.set(normalizedPath, fence);
+  const bound = setTimeout(() => end("timeout"), DIAGNOSTICS_WAIT_TIMEOUT_MS);
+  bound.unref?.();
+  let reply;
+  try {
+    reply = Promise.resolve(state.connection.sendRequest("textDocument/documentSymbol", { textDocument: { uri } }, cancellation.token));
+  } catch (thrown) {
+    reply = Promise.reject(thrown);
+  }
+  reply.then(() => end("reply"), () => end("reply"));
+}
 async function safeSendNotification(connection, method, params) {
   try {
     await connection.sendNotification(method, params);
@@ -2516,6 +2747,9 @@ async function safeSendNotification(connection, method, params) {
   }
 }
 const activeRequestsByConnection = new WeakMap;
+export function isConnectionBusy(connection) {
+  return (activeRequestsByConnection.get(connection) ?? 0) > 0;
+}
 async function safeSendRequest(connection, method, params, signal, settlement) {
   if (signal?.aborted)
     return;