Update client.ts

Author: Hona

packages/opencode/src/lsp/client.ts

@@ -115,9 +115,7 @@ export async function create(input: { serverID: string; server: LSPServer.Handle
   const diagnostics = new Map<string, Diagnostic[]>()
   const diagnosticRegistrations = new Map<string, CapabilityRegistration>()
   function updateDiagnostics(filePath: string, next: Diagnostic[]) {
-    const exists = diagnostics.has(filePath)
     diagnostics.set(filePath, next)
-    if (!exists && input.serverID === "typescript") return
     Bus.publish(Event.Diagnostics, { path: filePath, serverID: input.serverID })
   }
   connection.onNotification("textDocument/publishDiagnostics", (params) => {
@@ -127,6 +125,12 @@ export async function create(input: { serverID: string; server: LSPServer.Handle
       path: filePath,
       count: params.diagnostics.length,
     })
+    // tsserver emits an initial empty publish before analysis completes; store
+    // it so the next publish is treated as an update, but don't broadcast it.
+    if (input.serverID === "typescript" && !diagnostics.has(filePath)) {
+      diagnostics.set(filePath, params.diagnostics)
+      return
+    }
     updateDiagnostics(filePath, params.diagnostics)
   })
   connection.onRequest("window/workDoneProgress/create", (params) => {
@@ -384,47 +388,50 @@ export async function create(input: { serverID: string; server: LSPServer.Handle
         path.isAbsolute(request.path) ? request.path : path.resolve(input.directory, request.path),
       )
       log.info("waiting for diagnostics", { path: normalizedPath })
-      let unsub: (() => void) | undefined
+
+      const canPull = hasStaticPullDiagnostics || diagnosticRegistrations.size > 0
+      const timeout = canPull ? DIAGNOSTICS_PULL_WAIT_TIMEOUT_MS : DIAGNOSTICS_WAIT_TIMEOUT_MS
+
+      // Shared stop flag: whichever branch wins the race (or the outer
+      // timeout) sets this so the other branch bails before issuing more work.
+      let stopped = false
       let debounceTimer: ReturnType<typeof setTimeout> | undefined
-      let done = false
-      let resolvePushed: (() => void) | undefined
-      const timeout = hasStaticPullDiagnostics || diagnosticRegistrations.size > 0
-        ? DIAGNOSTICS_PULL_WAIT_TIMEOUT_MS
-        : DIAGNOSTICS_WAIT_TIMEOUT_MS
-      return await withTimeout(
-        Promise.race([
-          new Promise<void>((resolve) => {
-            resolvePushed = resolve
-            unsub = Bus.subscribe(Event.Diagnostics, (event) => {
-              if (event.properties.path !== normalizedPath || event.properties.serverID !== result.serverID) return
-              if (debounceTimer) clearTimeout(debounceTimer)
-              debounceTimer = setTimeout(() => {
-                log.info("got diagnostics", { path: normalizedPath })
-                resolve()
-              }, DIAGNOSTICS_DEBOUNCE_MS)
-            })
-          }),
-          (async () => {
-            let firstHandledAt: number | undefined
-            while (!done) {
-              const handled = await requestDiagnostics(normalizedPath)
-              if (handled) {
-                firstHandledAt = firstHandledAt ?? Date.now()
-                if (Date.now() - firstHandledAt >= DIAGNOSTICS_SETTLE_MS) {
-                  log.info("got diagnostics", { path: normalizedPath })
-                  return
-                }
-              }
-              await new Promise((resolve) => setTimeout(resolve, DIAGNOSTICS_POLL_MS))
+      let unsub: (() => void) | undefined
+
+      const waitForPush = new Promise<void>((resolve) => {
+        unsub = Bus.subscribe(Event.Diagnostics, (event) => {
+          if (event.properties.path !== normalizedPath || event.properties.serverID !== result.serverID) return
+          if (debounceTimer) clearTimeout(debounceTimer)
+          debounceTimer = setTimeout(() => {
+            log.info("got diagnostics", { path: normalizedPath })
+            stopped = true
+            resolve()
+          }, DIAGNOSTICS_DEBOUNCE_MS)
+        })
+      })
+
+      const waitForPull = async () => {
+        let firstHandledAt: number | undefined
+        while (!stopped) {
+          const handled = await requestDiagnostics(normalizedPath)
+          if (stopped) return
+          if (handled) {
+            firstHandledAt = firstHandledAt ?? Date.now()
+            if (Date.now() - firstHandledAt >= DIAGNOSTICS_SETTLE_MS) {
+              log.info("got diagnostics", { path: normalizedPath })
+              stopped = true
+              return
             }
-          })(),
-        ]),
-        timeout,
-      )
+          }
+          await new Promise((resolve) => setTimeout(resolve, DIAGNOSTICS_POLL_MS))
+        }
+      }
+
+      const race = canPull ? Promise.race([waitForPush, waitForPull()]) : waitForPush
+      return await withTimeout(race, timeout)
         .catch(() => {})
         .finally(() => {
-          done = true
-          resolvePushed?.()
+          stopped = true
           if (debounceTimer) clearTimeout(debounceTimer)
           unsub?.()
         })