pi-lens 4.1.2 → 4.1.4

package/dist/clients/lsp/diagnostic-binding.js

@@ -135,7 +135,7 @@ export function hashDiagnosticContent(content) {
 export function composeBoundToCurrentDisk(values) {
     if (values.some((v) => v === false))
         return false;
-    if (values.length === 0 || values.every((v) => v === "unknown")) {
+    if (values.every((v) => v === "unknown")) {
         return "unknown";
     }
     return true;
@@ -161,15 +161,18 @@ export function createDiskBindingCache() {
     // the same path (`SUB\a.ts` vs `sub/a.ts`) can't produce a duplicate memo or a
     // false miss. Ephemeral (slash-fold + win32-lowercase, no realpath I/O) — the
     // keys are file paths this process is already stat'ing on the hot read path.
+    // #2300: the memo guards a CONTENT HASH recompute, so a stale memo serves a
+    // stale hash — `size` is the cheap second axis alongside `mtimeMs`, from the
+    // SAME stat call, so a same-mtime-bucket external rewrite is not masked.
     const diskHashByPath = new PathKeyedMap(normalizeEphemeralMapKey);
     return {
         boundToCurrentDisk(filePath, stored) {
             // No fingerprint captured (version-less server) → unknown, never false.
             if (stored.contentHash === undefined)
                 return "unknown";
-            let mtimeMs;
+            let stat;
             try {
-                mtimeMs = fs.statSync(filePath).mtimeMs;
+                stat = fs.statSync(filePath);
             }
             catch {
                 // Can't stat (deleted/unreadable): can't disprove the binding either,
@@ -177,7 +180,9 @@ export function createDiskBindingCache() {
                 return "unknown";
             }
             let cached = diskHashByPath.get(filePath);
-            if (!cached || cached.mtimeMs !== mtimeMs) {
+            if (!cached ||
+                cached.mtimeMs !== stat.mtimeMs ||
+                cached.size !== stat.size) {
                 let diskHash;
                 try {
                     diskHash = hashDiagnosticContent(fs.readFileSync(filePath, "utf-8"));
@@ -185,7 +190,7 @@ export function createDiskBindingCache() {
                 catch {
                     return "unknown";
                 }
-                cached = { mtimeMs, hash: diskHash };
+                cached = { mtimeMs: stat.mtimeMs, size: stat.size, hash: diskHash };
                 if (diskHashByPath.size >= DISK_BINDING_MEMO_MAX) {
                     diskHashByPath.clear();
                 }

package/dist/clients/lsp/edits.js

@@ -568,7 +568,17 @@ function planWorkspaceEdit(edit, trackOrigins = false) {
     };
     const flushSubtree = (uri) => {
         const key = indexKey(uri);
-        for (const candidate of [...(descendants.get(key) ?? [])]) {
+        // flushUri -> removeIndex deletes `candidate` from this very Set (`key`
+        // is one of `candidate`'s ancestors by construction). No defensive copy
+        // needed: Set iterators reflect deletions safely — deleting the current
+        // or a not-yet-visited entry during iteration removes it from the
+        // remaining traversal without skipping or duplicating any other member
+        // (verified: https://tc39.es/ecma262/#sec-set.prototype.values, same
+        // guarantee already relied on for the Map iteration below and at
+        // clients/lsp/client.ts / clients/persist-debounce.ts /
+        // clients/review-graph/builder.ts). Nothing adds to `descendants`
+        // during this loop (only `addIndex` does, and it isn't called here).
+        for (const candidate of descendants.get(key) ?? []) {
             const item = pending.get(candidate);
             if (item)
                 flushUri(item.uri);
@@ -607,7 +617,10 @@ function planWorkspaceEdit(edit, trackOrigins = false) {
             flushSubtree(resource.uri);
         ops.push(resource);
     }
-    for (const item of [...pending.values()])
+    // flushUri deletes from `pending` — the same Map being iterated here — but
+    // Map iterators reflect deletions safely (see flushSubtree above), so no
+    // defensive copy is needed.
+    for (const item of pending.values())
         flushUri(item.uri);
     return ops;
 }