@herbertgao/pi-extensions 2026.8.14 → 2026.8.15

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

@@ -53,7 +53,8 @@ import path from "node:path";
 import { BoundedLruCache } from "../bounded-cache.js";
 import { getGlobalPiLensDir } from "../file-utils.js";
 import { launchLSP } from "./launch.js";
-import { createRootDetector, LSP_SERVERS, } from "./server.js";
+import { registerSessionRoot, resetSessionRootsForTests, } from "./session-roots.js";
+import { createRootDetector, LSP_SERVERS, resetLSPCaseSensitivityState, } from "./server.js";
 // --- Config Loading ---
 const CONFIG_PATHS = [".pi-lens/lsp.json", ".pi-lens.json", "pi-lsp.json"];
 function warnInvalidLSPConfig(configPath, error) {
@@ -194,6 +195,10 @@ function getConfigForFile(filePath) {
  */
 export async function initLSPConfig(cwd) {
     const normalizedCwd = normalizeWorkspacePath(cwd);
+    // #2052: this cwd is now a served session root. Registered BEFORE the
+    // in-flight dedup return below, so a concurrent duplicate init still
+    // registers it rather than returning early with the root unrecorded.
+    registerSessionRoot(normalizedCwd);
     const existing = configInFlight.get(normalizedCwd);
     if (existing)
         return existing;
@@ -240,7 +245,13 @@ export async function initLSPConfig(cwd) {
         await promise;
     }
     finally {
-        configInFlight.delete(normalizedCwd);
+        // Identity-guarded release (#1968's pattern): delete only if THIS run is
+        // still the registered one. A bare delete-by-key lets a late-settling run
+        // evict a live successor a second writer registered under the same cwd
+        // mid-flight, after which the next caller starts a duplicate config load.
+        if (configInFlight.get(normalizedCwd) === promise) {
+            configInFlight.delete(normalizedCwd);
+        }
     }
 }
 /**
@@ -306,6 +317,18 @@ export function getServerInitOverride(serverId, filePath) {
 }
 export function resetLSPConfigStateForTests() {
     workspaceConfigs.clear();
+    resetLSPCaseSensitivityState();
+    // Reset both together: a cleared config store beside a live session-root
+    // registry would decline files for roots nothing can serve any more.
+    resetSessionRootsForTests();
+}
+/**
+ * Test hook — read the `initLSPConfig` in-flight map directly (#1968's ABA
+ * regression: a second writer replacing an entry mid-flight, then a
+ * late-settling first run evicting it with a bare delete-by-key).
+ */
+export function _peekConfigInFlightForTests() {
+    return configInFlight;
 }
 // Re-export with config support
 export { getAllServers as getServersForFile };

package/node_modules/pi-lens/dist/clients/lsp/diagnostic-binding.js

@@ -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();
                 }