@herbertgao/pi-extensions 2026.9.0 → 2026.9.1

package/node_modules/pi-lens/dist/clients/lsp/client.js

@@ -730,7 +730,7 @@ function retirePullSource(state, identifier) {
     for (const source of [state.pullResultIds, state.pullRequestSequences]) {
         if (!source)
             continue;
-        for (const key of [...source.keys()]) {
+        for (const key of source.keys()) {
             if (key.endsWith(suffix))
                 source.delete(key);
         }
@@ -947,7 +947,7 @@ function scanSentContent(content) {
  * read on the notification path (I1). Bounded by the same file-size gates the
  * caller already applies to the content it hands us.
  */
-function recordSentContent(state, normalizedPath, version, content) {
+function recordSentContent(state, normalizedPath, version, content, coalescedCount = 0) {
     const scan = scanSentContent(content);
     const previous = state.documentContentHashes.get(normalizedPath);
     if (previous && previous.version > version) {
@@ -1049,6 +1049,7 @@ function recordSentContent(state, normalizedPath, version, content) {
             version,
             contentLength: content.length,
             contentLineCount: scan.lfNewlineCount + 1,
+            ...(coalescedCount > 0 && { coalescedCount }),
         },
     });
 }
@@ -1423,14 +1424,33 @@ export function setupIncomingHandlers(state, initialization) {
         if (state.serverEditsAllowed <= 0 || !params?.edit) {
             return { applied: false, failureReason: "edit not solicited" };
         }
-        const context = (state.activeMutationDepth ?? 0) === 1
-            ? state.activeMutationContext
-            : undefined;
+        // #2450 fix round 3 (F3) removed a `depth === 1` re-check here as
+        // dead code. It is not dead — it moved to the WRITE side, where it
+        // is the live invariant: `state.activeMutationContext` is assigned
+        // only by `syncMutationContextSlot` (below in this file), which
+        // populates it exactly when `activeMutationDepth === 1` and
+        // empties it on every other frame transition. The depth test
+        // therefore still runs, on each entry and each unwind; repeating
+        // it here would be a second copy of the same predicate, not an
+        // independent gate. What this handler reads is consequently either
+        // the context of the single frame currently in flight or
+        // `undefined` — never a settled frame's context, and never a
+        // context belonging to some other window that is still open
+        // (#2479 review rounds 2/3).
+        const context = state.activeMutationContext;
+        // `workspace/applyEdit` is only ever honored inside the
+        // `serverEditsAllowed` window this handler just checked, which is
+        // opened exclusively by an executeCommand call — so a fallback here is
+        // always executeCommand-solicited, never a bare edit (#2450). This
+        // fallback context carries no runtime/cacheManager (there is no live
+        // reference to those singletons at this call site); lsp-mutation.ts's
+        // bookkeepLspMutation falls back to the mutation bridge for exactly
+        // that reason rather than silently dropping the write's bookkeeping.
         const telemetryContext = context ?? {
             cwd: state.root,
             correlationId: newLspMutationCorrelationId(),
             tool: "lsp-workspace-applyEdit",
-            source: "lsp-edit",
+            source: "lsp-execute-command",
         };
         try {
             await applyWorkspaceEdit(params.edit, state.root, {
@@ -2430,7 +2450,7 @@ export function handleNotifyExternalChange(state, filePath, type) {
     const uri = state.openDocumentUris?.get(normalizedPath) ?? pathToFileURL(filePath).href;
     state.watchQueue.enqueue(uri, type);
 }
-export async function handleNotifyOpen(state, filePath, content, languageId, preserveDiagnostics = false, silent = false) {
+async function handleNotifyOpenOnce(state, filePath, content, languageId, preserveDiagnostics = false, silent = false, coalescedCount = 0) {
     if (!isClientAlive(state))
         return;
     const normalizedPath = normalizeMapKey(filePath);
@@ -2478,7 +2498,7 @@ export async function handleNotifyOpen(state, filePath, content, languageId, pre
             // #1669 review F7: only mirror the send locally once it actually left
             // the process — see safeSendNotification's doc comment.
             if (reopenSent)
-                recordSentContent(state, normalizedPath, version, content);
+                recordSentContent(state, normalizedPath, version, content, coalescedCount);
             state.openDocuments.add(normalizedPath);
             state.openDocumentUris?.set(normalizedPath, uri);
             return;
@@ -2488,7 +2508,7 @@ export async function handleNotifyOpen(state, filePath, content, languageId, pre
             contentChanges: buildContentChanges(state, normalizedPath, content),
         });
         if (changeSent)
-            recordSentContent(state, normalizedPath, version, content);
+            recordSentContent(state, normalizedPath, version, content, coalescedCount);
         return;
     }
     state.pendingOpens.add(normalizedPath);
@@ -2523,7 +2543,7 @@ export async function handleNotifyOpen(state, filePath, content, languageId, pre
         return;
     const openSent = await safeSendNotification(state.connection, "textDocument/didOpen", { textDocument: { uri, languageId, version: 0, text: content } });
     if (openSent)
-        recordSentContent(state, normalizedPath, 0, content);
+        recordSentContent(state, normalizedPath, 0, content, coalescedCount);
     state.pendingOpens.delete(normalizedPath);
     state.openDocuments.add(normalizedPath);
     state.closedDocuments?.delete(normalizedPath);
@@ -2547,7 +2567,81 @@ export async function handleNotifyOpen(state, filePath, content, languageId, pre
         },
     });
 }
-async function handleNotifyChangeOnce(state, filePath, content, normalizedPath) {
+/**
+ * Replace only notifications that have not started a transport write. A
+ * microtask starts the first entry so a synchronous burst of callers installs
+ * one latest entry before any bytes are handed to vscode-jsonrpc. Once an
+ * entry starts, it runs to completion; LSP has no cancellation/acknowledgement
+ * for notifications, so dropping a started write could violate didOpen before
+ * didChange ordering or leave a partial message in the pipe.
+ */
+function enqueueDocumentNotify(state, normalizedPath, run) {
+    let queue = state.notifyChangeQueues.get(normalizedPath);
+    if (!queue) {
+        queue = { running: false };
+        state.notifyChangeQueues.set(normalizedPath, queue);
+    }
+    return new Promise((resolve, reject) => {
+        const previous = queue?.pending;
+        // Keep superseded callers attached to the replacement's completion. The
+        // notification is dropped, but callers such as the auxiliary backlog
+        // ledger must not observe completion before the newest content is sent.
+        const waiters = previous?.waiters ?? [];
+        waiters.push({ resolve, reject });
+        queue.pending = {
+            run,
+            waiters,
+            coalescedCount: (previous?.coalescedCount ?? 0) + (previous ? 1 : 0),
+        };
+        if (queue.running)
+            return;
+        queue.running = true;
+        // Let same-turn callers replace the unwritten entry before the runner
+        // invokes the transport. Different path queues still start independently.
+        void Promise.resolve().then(async () => {
+            try {
+                for (;;) {
+                    const next = queue.pending;
+                    if (!next)
+                        break;
+                    queue.pending = undefined;
+                    try {
+                        await next.run(next.coalescedCount);
+                        for (const waiter of next.waiters)
+                            waiter.resolve();
+                    }
+                    catch (error) {
+                        for (const waiter of next.waiters)
+                            waiter.reject(error);
+                    }
+                }
+            }
+            finally {
+                queue.running = false;
+                if (!queue.pending &&
+                    state.notifyChangeQueues.get(normalizedPath) === queue) {
+                    state.notifyChangeQueues.delete(normalizedPath);
+                }
+            }
+        });
+    });
+}
+/** Drop unwritten document notifications when a client is torn down. */
+function cancelDocumentNotifyQueues(state) {
+    for (const queue of state.notifyChangeQueues.values()) {
+        for (const waiter of queue.pending?.waiters ?? [])
+            waiter.resolve();
+        queue.pending = undefined;
+    }
+    state.notifyChangeQueues.clear();
+}
+export function handleNotifyOpen(state, filePath, content, languageId, preserveDiagnostics = false, silent = false) {
+    if (!isClientAlive(state))
+        return Promise.resolve();
+    const normalizedPath = normalizeMapKey(filePath);
+    return enqueueDocumentNotify(state, normalizedPath, (coalescedCount) => handleNotifyOpenOnce(state, filePath, content, languageId, preserveDiagnostics, silent, coalescedCount));
+}
+async function handleNotifyChangeOnce(state, filePath, content, normalizedPath, coalescedCount = 0) {
     if (!isClientAlive(state))
         return;
     const uri = state.openDocumentUris?.get(normalizedPath) ?? pathToFileURL(filePath).href;
@@ -2566,7 +2660,7 @@ async function handleNotifyChangeOnce(state, filePath, content, normalizedPath)
         state.documentOpenedAt.set(normalizedPath, Date.now());
         state.diagnosticPublicationCounts.set(normalizedPath, 0);
         if (fallbackOpenSent)
-            recordSentContent(state, normalizedPath, 0, content);
+            recordSentContent(state, normalizedPath, 0, content, coalescedCount);
         state.openDocuments.add(normalizedPath);
         state.openDocumentUris?.set(normalizedPath, uri);
         return;
@@ -2581,7 +2675,7 @@ async function handleNotifyChangeOnce(state, filePath, content, normalizedPath)
         contentChanges: buildContentChanges(state, normalizedPath, content),
     });
     if (changeSent)
-        recordSentContent(state, normalizedPath, version, content);
+        recordSentContent(state, normalizedPath, version, content, coalescedCount);
 }
 /**
  * #2113: serialize the read/build/send/record transaction per document. The
@@ -2592,17 +2686,7 @@ export function handleNotifyChange(state, filePath, content) {
     if (!isClientAlive(state))
         return Promise.resolve();
     const normalizedPath = normalizeMapKey(filePath);
-    const previous = state.notifyChangeQueues.get(normalizedPath) ?? Promise.resolve();
-    const queued = previous
-        .catch(() => undefined)
-        .then(() => handleNotifyChangeOnce(state, filePath, content, normalizedPath));
-    const settled = queued.finally(() => {
-        if (state.notifyChangeQueues.get(normalizedPath) === settled) {
-            state.notifyChangeQueues.delete(normalizedPath);
-        }
-    });
-    state.notifyChangeQueues.set(normalizedPath, settled);
-    return settled;
+    return enqueueDocumentNotify(state, normalizedPath, (coalescedCount) => handleNotifyChangeOnce(state, filePath, content, normalizedPath, coalescedCount));
 }
 /** Close a document through the same lifecycle path exposed by the client. */
 export async function closeDocument(state, filePath) {
@@ -2739,6 +2823,9 @@ async function clientShutdownOnce(state, options) {
     state.pendingOpens.clear();
     state.openDocuments.clear();
     state.openDocumentUris?.clear();
+    // #2357: superseded notifications that have not started writing are moot
+    // once this client is dead; resolve their callers and release the queue.
+    cancelDocumentNotifyQueues(state);
     // #1412 L1: mirror openDocuments' clear — a shut-down/evicted client's
     // probe memo is moot along with everything else document-scoped.
     state.projectIdentityProbedFiles?.clear();
@@ -3183,6 +3270,35 @@ async function clientPingLiveness(state, timeoutMs = LIVENESS_PING_TIMEOUT_MS) {
     }
     return isClientAlive(state);
 }
+// #2479: `activeMutationContext` is DERIVED state, not a stack. The frame that
+// takes `activeMutationDepth` 0 -> 1 owns the context for its whole lifetime
+// (`mutationContextOwner`); the slot merely exposes that owner while it is the
+// ONLY frame in flight. Deeper or overlapping frames therefore empty the slot
+// for as long as they are open — concurrent and nested commands deliberately
+// do not cross-correlate — and it refills by itself when they unwind, with no
+// frame having to remember anything.
+//
+// Recomputing beats saving and restoring because these frames do not nest:
+// `LSPClient.executeCommand` and `LSPService.executeCommand` fan out with no
+// mutex, parallel `lsp_navigation` calls with `apply: true` overlap, and #449
+// light mode shares one client across agents. With A (the owner), B and C
+// overlapping and the MIDDLE one settling first, a per-frame restore hands A's
+// context back while C's window is the open one — and `LspMutationContext`
+// carries a cwd plus a directly-threaded runtime/cacheManager, with
+// `readTurnState` / `appendProjectChange` cwd-scoped, so that routes a live
+// edit's bookkeeping into another project's change log (strictly worse than
+// the honest fallback the pre-#2479 code gave). An owner-liveness flag does
+// not fix it either: it answers "is an owner live", not "does the slot belong
+// to the window this edit is in" — and C's own unwind then puts back the
+// `undefined` it saved while the owner is still running, resurrecting #2479
+// (review round 3). Deriving answers the second question by construction, and
+// "no command in flight == no context" — the invariant the
+// `serverEditsAllowed` gate on `workspace/applyEdit` is paired with — falls
+// out of it with no depth-0 special case.
+function syncMutationContextSlot(state) {
+    state.activeMutationContext =
+        state.activeMutationDepth === 1 ? state.mutationContextOwner : undefined;
+}
 // Run an advertised server command via workspace/executeCommand, with the
 // generous EXECUTE_COMMAND_TIMEOUT_MS anti-deadlock backstop. Preserves the
 // hardening invariants: allowlist-by-advertisement (only commands the server
@@ -3201,10 +3317,20 @@ export async function runServerCommand(state, command, args, timeoutMs = EXECUTE
     }
     state.serverEditsAllowed += 1;
     state.activeMutationDepth = (state.activeMutationDepth ?? 0) + 1;
-    if (state.activeMutationDepth === 1)
-        state.activeMutationContext = mutationContext;
-    else
-        state.activeMutationContext = undefined;
+    // #2479: the frame that takes the depth to 1 owns the context; the slot is
+    // derived from that owner (see `syncMutationContextSlot` above). The
+    // pre-#2479 shape only ever CLEARED the slot, and only once the depth
+    // returned to 0, so a nested `executeCommand` unwinding from depth 2 back
+    // to 1 left the OUTER call without its own context for the rest of its
+    // window: every server-initiated `applyEdit` it still solicited read
+    // `undefined`, fell to the mutation bridge, and carried the generic
+    // `agent-tool:lsp-workspace-applyEdit` receipt instead of the outer
+    // operation's own (`lsp-rename` / `lsp-execute-command`).
+    const isMutationContextOwner = state.activeMutationDepth === 1;
+    if (isMutationContextOwner) {
+        state.mutationContextOwner = mutationContext;
+    }
+    syncMutationContextSlot(state);
     try {
         let result;
         try {
@@ -3231,8 +3357,15 @@ export async function runServerCommand(state, command, args, timeoutMs = EXECUTE
     finally {
         state.serverEditsAllowed -= 1;
         state.activeMutationDepth = Math.max(0, (state.activeMutationDepth ?? 0) - 1);
-        if (state.activeMutationDepth === 0)
-            state.activeMutationContext = undefined;
+        // The owner drops its context; every frame then resyncs. Both the
+        // hand-back to a still-live owner once the deeper frames unwind and
+        // the empty slot while more than one frame is open are consequences of
+        // the derivation, not separate rules each frame has to get right
+        // (#2479 review rounds 2/3).
+        if (isMutationContextOwner) {
+            state.mutationContextOwner = undefined;
+        }
+        syncMutationContextSlot(state);
     }
 }
 // #1412 H1/H2: read-only sibling of runServerCommand for telemetry/identity
@@ -3694,6 +3827,8 @@ export async function createLSPClient(options) {
         checkAlive: () => checkProcessAlive(),
         /** #1277: cheap request round-trip proving the server still responds. */
         pingLiveness: (timeoutMs) => clientPingLiveness(state, timeoutMs),
+        /** #2358: the OS pid of the live server process (see interface doc). */
+        getProcessPid: () => lspProcess.pid,
         notify: {
             async open(filePath, content, languageId, preserveDiagnostics, silent) {
                 return handleNotifyOpen(state, filePath, content, languageId, preserveDiagnostics, silent);
@@ -3842,6 +3977,9 @@ export async function createLSPClient(options) {
         isDocumentOpen(filePath) {
             return state.openDocuments.has(normalizeMapKey(filePath));
         },
+        openDocumentPaths() {
+            return [...state.openDocuments];
+        },
         isBusy() {
             return (activeRequestsByConnection.get(connection) ?? 0) > 0;
         },