@herbertgao/pi-extensions 2026.10.2 → 2026.10.4

package/node_modules/pi-lens/dist/{chunk-LW6XKDZQ.js → chunk-UEAHAMEI.js}

@@ -3,8 +3,10 @@ import {
   resolveWebTreeSitterPackageDir
 } from "./chunk-Z54ZSOBZ.js";
 import {
-  EXTENSION_TO_GRAMMAR
-} from "./chunk-TGPXLY2J.js";
+  EXTENSION_TO_GRAMMAR,
+  getUserRuleRoot,
+  ruleCorpusFingerprintForCycle
+} from "./chunk-KJCWXUUS.js";
 import {
   getPackageRoot,
   js_yaml_default,
@@ -13,40 +15,41 @@ import {
 import {
   assertInstallAllowed,
   getProjectTrustGeneration
-} from "./chunk-NTUJEGDZ.js";
+} from "./chunk-D6YF5HKX.js";
 import {
   transientRetryDelayMs
-} from "./chunk-WONERJTP.js";
+} from "./chunk-O7HZX7CA.js";
 import {
   getProjectIgnoreMatcher,
   isExcludedDirName
-} from "./chunk-VN2AXLEX.js";
+} from "./chunk-T54VJRAD.js";
 import {
   notifyUserDegradation
-} from "./chunk-DQ2NZ7C4.js";
+} from "./chunk-N2IRDBZI.js";
 import {
   writeFileAtomic
 } from "./chunk-2EECBNC5.js";
 import {
+  compareOrdinal,
   escapeRegExp,
   getDegradationLedgerGeneration,
   incrementDegradationCount,
   recordDegradation,
   recordDegradationOnce
-} from "./chunk-N3YQJI6O.js";
+} from "./chunk-7ELY2CSM.js";
 import {
   createNdjsonLogger,
   getGlobalPiLensLogDir,
   getMaxLogSizeMB,
   isTestMode
-} from "./chunk-UK3CMEAL.js";
+} from "./chunk-VSMJK3ZJ.js";
 import {
   BoundedFifoMap
 } from "./chunk-ABBOA7UD.js";
 import {
   normalizeFilePath,
   normalizeLoggedPath
-} from "./chunk-Q5U6FMDI.js";
+} from "./chunk-G3RLJYA2.js";
 
 // dist/clients/tree-sitter-logger.js
 import * as path from "node:path";
@@ -118,7 +121,7 @@ function logTreeSitterDiagnostic(entry) {
 
 // dist/clients/tree-sitter-client.js
 import { AsyncLocalStorage } from "node:async_hooks";
-import * as crypto2 from "node:crypto";
+import * as crypto3 from "node:crypto";
 import * as fs5 from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
 import * as path4 from "node:path";
@@ -1429,6 +1432,7 @@ function isSqlAlchemyEntityQueryArgument(node, root) {
 
 // dist/clients/tree-sitter-query-loader.js
 import * as fs4 from "node:fs";
+import * as crypto2 from "node:crypto";
 import * as path3 from "node:path";
 
 // dist/clients/bundled-resource-health.js
@@ -1500,6 +1504,7 @@ function ruleFilesForLanguage(languageId, rootDir = process.cwd()) {
   for (const lang of ruleSourceLanguages(languageId)) {
     for (const dir of [
       path3.join(resolvedRoot, "rules", "tree-sitter-queries", lang),
+      path3.join(getUserRuleRoot(), "tree-sitter-queries", lang),
       path3.join(BUNDLED_QUERIES_ROOT, lang)
     ]) {
       if (!fs4.existsSync(dir))
@@ -1518,6 +1523,67 @@ function ruleFilesForLanguage(languageId, rootDir = process.cwd()) {
   }
   return [...files];
 }
+function computeRuleFilesFingerprint(ruleFiles) {
+  const hash = crypto2.createHash("sha256");
+  for (const file of [...ruleFiles].sort(compareOrdinal)) {
+    const resolved = path3.resolve(file);
+    if (!fs4.existsSync(resolved))
+      continue;
+    const stat = fs4.statSync(resolved);
+    hash.update(`${file}:${stat.mtimeMs}:${stat.size}`);
+    if (resolved !== BUNDLED_QUERIES_ROOT && !resolved.startsWith(BUNDLED_QUERIES_ROOT + path3.sep)) {
+      hash.update(fs4.readFileSync(resolved));
+    }
+  }
+  return hash.digest("hex").slice(0, 16);
+}
+function computeMutableRuleFingerprint(rootDir) {
+  const files = [];
+  for (const queriesDir of [
+    path3.join(path3.resolve(rootDir), "rules", "tree-sitter-queries"),
+    path3.join(getUserRuleRoot(), "tree-sitter-queries")
+  ]) {
+    if (!fs4.existsSync(queriesDir))
+      continue;
+    let languages;
+    try {
+      languages = fs4.readdirSync(queriesDir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const language of languages) {
+      if (!language.isDirectory())
+        continue;
+      let names;
+      try {
+        names = fs4.readdirSync(path3.join(queriesDir, language.name));
+      } catch {
+        continue;
+      }
+      for (const name of names) {
+        if (name.endsWith(".yml")) {
+          files.push(path3.join(queriesDir, language.name, name));
+        }
+      }
+    }
+  }
+  const hash = crypto2.createHash("sha256");
+  for (const filePath of files.sort(compareOrdinal)) {
+    hash.update(filePath);
+    hash.update("\0");
+    let content;
+    try {
+      content = fs4.readFileSync(filePath, "utf-8");
+    } catch {
+      hash.update("missing");
+      hash.update("\0");
+      continue;
+    }
+    hash.update(content);
+    hash.update("\0");
+  }
+  return hash.digest("hex").slice(0, 16);
+}
 function queriesForLanguage(queries, languageId) {
   const enabled = (langId) => (queries.get(langId) ?? []).filter((q) => !isDisabledQueryFilePath(q.filePath));
   return ruleSourceLanguages(languageId).flatMap((langId) => enabled(langId));
@@ -1535,6 +1601,7 @@ var TreeSitterQueryLoader = class {
   queries = /* @__PURE__ */ new Map();
   loaded = false;
   loadedRoot = null;
+  loadedRuleFingerprint = null;
   verbose;
   /**
    * This root's per-file parse failures, remembered across the memoized
@@ -1612,16 +1679,24 @@ var TreeSitterQueryLoader = class {
   /**
    * Load all queries from the rules/tree-sitter-queries directory.
    *
-   * Returns the in-memory memo when the same root was already loaded.
-   * `force: true` re-reads from disk even then — the memo has no notion of
-   * rule-file mtimes, so a caller that KNOWS the files changed (the dispatch
-   * runner's RuleCache-miss path: a miss means the rule-file fingerprint
-   * moved) must force, or it gets the pre-edit rules back and persists them
+   * Returns the in-memory memo when the same root is already loaded and the
+   * mutable corpus's content fingerprint is unchanged. That fingerprint is
+   * computed at most once per dispatch cycle and reused by every later call
+   * in the cycle (`ruleCorpusFingerprintForCycle`), so routine re-scans and
+   * structural searches do no filesystem work at all on the warm path
+   * (#4212 round 4; rounds 2 and 3 each paid for per-call detection). An edit
+   * made during a cycle is therefore seen by the NEXT cycle — or earlier, by
+   * any `force: true` call, which republishes the fresh value into the cycle.
+   *
+   * `force: true` re-reads from disk regardless — the dispatch runner's
+   * RuleCache-miss path: a miss means the content fingerprint moved, so
+   * without `force` the memo could hand back pre-edit rules to be persisted
    * under the fresh fingerprint (#878).
    */
   async loadQueries(rootDir = process.cwd(), options = {}) {
     const resolvedRoot = path3.resolve(rootDir);
-    if (!options.force && this.loaded && this.loadedRoot === resolvedRoot) {
+    const ruleFingerprint = ruleCorpusFingerprintForCycle("tree-sitter", resolvedRoot, computeMutableRuleFingerprint, options.force);
+    if (!options.force && this.loaded && this.loadedRoot === resolvedRoot && this.loadedRuleFingerprint === ruleFingerprint) {
       this.replayQueryParseFailures();
       return this.queries;
     }
@@ -1631,6 +1706,7 @@ var TreeSitterQueryLoader = class {
     const queryDirs = [
       .../* @__PURE__ */ new Set([
         path3.join(resolvedRoot, "rules", "tree-sitter-queries"),
+        path3.join(getUserRuleRoot(), "tree-sitter-queries"),
         resolvePackagePath(import.meta.url, "rules", "tree-sitter-queries")
       ])
     ];
@@ -1649,7 +1725,9 @@ var TreeSitterQueryLoader = class {
           const filePath = path3.join(langDir, file);
           const query = this.parseQueryFile(filePath, languageKey);
           if (query) {
-            langQueries.push(query);
+            if (!langQueries.some((existing) => existing.id === query.id)) {
+              langQueries.push(query);
+            }
           }
         }
         if (langQueries.length > 0) {
@@ -1660,6 +1738,7 @@ var TreeSitterQueryLoader = class {
     }
     this.loaded = true;
     this.loadedRoot = resolvedRoot;
+    this.loadedRuleFingerprint = ruleFingerprint;
     this.parseFailuresReplayedGeneration = getDegradationLedgerGeneration();
     return this.queries;
   }
@@ -1945,6 +2024,7 @@ function classifyTreeSitterWasmError(thrown) {
   return WASM_TRAP_MESSAGES.some((trap) => message.includes(trap)) ? "trap" : void 0;
 }
 var WASM_TRAP_BUDGET = 3;
+var GRAMMAR_TRAP_LATCH_THRESHOLD = WASM_TRAP_BUDGET - 1;
 var RESOLUTION_ERROR_CODES = /* @__PURE__ */ new Set([
   "ERR_MODULE_NOT_FOUND",
   "MODULE_NOT_FOUND",
@@ -2127,6 +2207,12 @@ var TreeSitterClient = class _TreeSitterClient {
   queryCache = new BoundedFifoMap(_TreeSitterClient.QUERY_CACHE_MAX_ENTRIES);
   /** Combined multi-rule queries by language + rule-set identity (null = don't retry). */
   queryBatchCache = new BoundedFifoMap(_TreeSitterClient.QUERY_BATCH_CACHE_MAX_ENTRIES);
+  /** Concurrent callers share one native batch build per cache key. */
+  queryBatchBuilds = /* @__PURE__ */ new Map();
+  /** Advances whenever a successful query input heal can invalidate a build. */
+  queryBatchHealEpoch = 0;
+  /** Raw and batch cache keys represented by each bounded entry (#3834). */
+  queryBatchInputs = /* @__PURE__ */ new Map();
   queryCacheCap() {
     const value = Number.parseInt(process.env.PI_LENS_TREE_SITTER_QUERY_CACHE_CAP ?? "", 10);
     return Number.isSafeInteger(value) && value > 0 ? value : _TreeSitterClient.QUERY_CACHE_MAX_ENTRIES;
@@ -2143,12 +2229,63 @@ var TreeSitterClient = class _TreeSitterClient {
     for (const [, dropped] of evicted)
       dropped?.query?.delete?.();
   }
-  cacheQueryBatch(key, value) {
+  cacheQueryBatch(key, value, inputKeys = []) {
+    const replaced = this.queryBatchCache.get(key);
     this.queryBatchCache.delete(key);
+    if (replaced)
+      this.retireQueryBatch(replaced);
     const evicted = this.queryBatchCache.setMaxEntries(this.queryBatchCacheCap());
     evicted.push(...this.queryBatchCache.set(key, value));
+    for (const [evictedKey] of evicted)
+      this.queryBatchInputs.delete(evictedKey);
+    this.queryBatchInputs.set(key, new Set(inputKeys));
     for (const [, dropped] of evicted)
-      dropped?.query?.delete?.();
+      this.retireQueryBatch(dropped);
+  }
+  disposeQueryBatch(batch) {
+    if (batch.disposed)
+      return;
+    batch.disposed = true;
+    batch.query?.delete?.();
+  }
+  retireQueryBatch(batch) {
+    if (!batch)
+      return;
+    batch.retired = true;
+    if (batch.users === 0) {
+      this.disposeQueryBatch(batch);
+    } else {
+      incrementDegradationCount({
+        kind: "wasm-query-batch-disposal-deferred",
+        subject: "web-tree-sitter",
+        reason: "deferred batch disposal while a scan is active"
+      });
+    }
+  }
+  retainQueryBatch(batch) {
+    batch.users++;
+  }
+  releaseQueryBatch(batch) {
+    batch.users--;
+    if (batch.retired && batch.users === 0)
+      this.disposeQueryBatch(batch);
+  }
+  /**
+   * Move the leases counted at join onto the batch they were built for, and
+   * mark the build decided (#4207 F9). Runs in the same synchronous section
+   * that publishes the batch, so a batch is never visible to a heal without
+   * its consumers' leases: the heal then defers disposal to the last release
+   * instead of deleting the native Query under scans that are about to run it
+   * and silently report zero findings. A later joiner reads `lease.batch` and
+   * retains directly, because the counter is drained.
+   */
+  takeQueryBatchLeases(lease, batch) {
+    lease.batch = batch;
+    if (!batch)
+      return null;
+    batch.users += lease.count;
+    lease.count = 0;
+    return batch;
   }
   /** Consecutive grammar-load failures per batch key — bounds load retries (#889). */
   queryBatchLoadFailures = /* @__PURE__ */ new Map();
@@ -2170,6 +2307,13 @@ var TreeSitterClient = class _TreeSitterClient {
    * a trap that spends budget (or escalates) adds an entry, so the map never
    * holds more than `WASM_TRAP_BUDGET + 1`. */
   trappedInputs = /* @__PURE__ */ new Map();
+  /** Distinct input keys that trapped (first trap) and have not healed, by
+   * language. Process-lifetime. A key enters only on a trap, a first trap
+   * spends budget, and the budget aborts the process after `WASM_TRAP_BUDGET + 1`
+   * of them, so at most that many keys exist across all languages. */
+  grammarTrapInputs = /* @__PURE__ */ new Map();
+  /** Grammars retired for the process after repeated scanner traps. */
+  retiredGrammars = /* @__PURE__ */ new Map();
   /** The input `parseFileAndUse` is consuming. That region is synchronous, so
    * a report nested in it (the extractor's `queryMatches`) is charged to it. */
   activeWasmInput;
@@ -2217,6 +2361,7 @@ var TreeSitterClient = class _TreeSitterClient {
       }
       if (input) {
         const key = this.wasmInputKey(input);
+        this.countGrammarTrapInput(input.languageId, key);
         const entry = this.trappedInputs.get(key);
         if (entry) {
           entry.traps++;
@@ -2227,7 +2372,11 @@ var TreeSitterClient = class _TreeSitterClient {
           });
           return false;
         }
-        this.trappedInputs.set(key, { traps: 1, by: input.caller });
+        this.trappedInputs.set(key, {
+          traps: 1,
+          by: input.caller,
+          source: input.languageId === "query" ? input.source : void 0
+        });
       }
       if (++this.wasmTraps <= WASM_TRAP_BUDGET) {
         incrementDegradationCount({
@@ -2251,8 +2400,29 @@ var TreeSitterClient = class _TreeSitterClient {
     }
     return true;
   }
+  /**
+   * Count `key` as a distinct trapping input of `languageId`'s grammar and
+   * retire the grammar at {@link GRAMMAR_TRAP_LATCH_THRESHOLD} of them (#4010).
+   * The first trap of an input is what counts: most surfaces parse fresh bytes
+   * per edit, so waiting for a retry would let distinct bad files spend the
+   * whole budget first. A repeat trap of one input adds nothing (set), and
+   * `clearWasmInput` removes the key when the trapper's own parse succeeds.
+   */
+  countGrammarTrapInput(languageId, key) {
+    const grammarFile = LANGUAGE_TO_GRAMMAR[languageId];
+    if (!grammarFile)
+      return;
+    let inputs = this.grammarTrapInputs.get(languageId);
+    if (!inputs)
+      this.grammarTrapInputs.set(languageId, inputs = /* @__PURE__ */ new Set());
+    inputs.add(key);
+    if (inputs.size >= GRAMMAR_TRAP_LATCH_THRESHOLD) {
+      this.retiredGrammars.set(languageId, grammarFile);
+      this.recordGrammarBlocked(grammarFile);
+    }
+  }
   wasmInputKey(input) {
-    input.key ??= crypto2.createHash("sha256").update(input.languageId).update("\0").update(input.source).digest("hex");
+    input.key ??= crypto3.createHash("sha256").update(input.languageId).update("\0").update(input.source).digest("hex");
     return input.key;
   }
   /** Traps charged to `input` so far; no hash while nothing has trapped. */
@@ -2270,12 +2440,25 @@ var TreeSitterClient = class _TreeSitterClient {
    * Only a success by the entry's first trapper decays it (#3678 F2, F4): a
    * healthy consumer says nothing about another consumer's trap.
    */
-  clearWasmInput(input) {
+  clearWasmInput(input, internalBatchHeal = false) {
     if (!input || this.trappedInputs.size === 0)
       return;
     const key = this.wasmInputKey(input);
-    if (this.trappedInputs.get(key)?.by === input.caller) {
+    const entry = this.trappedInputs.get(key);
+    const source = entry?.source;
+    if (entry?.by === input.caller) {
       this.trappedInputs.delete(key);
+      this.grammarTrapInputs.get(input.languageId)?.delete(key);
+      if (!internalBatchHeal)
+        this.queryBatchHealEpoch++;
+      for (const [batchKey, batch] of this.queryBatchCache) {
+        const inputs = this.queryBatchInputs.get(batchKey);
+        if (!source || !inputs?.has(source))
+          continue;
+        this.queryBatchCache.delete(batchKey);
+        this.queryBatchInputs.delete(batchKey);
+        this.retireQueryBatch(batch);
+      }
     }
   }
   /** The not-parsed outcome for `thrown` on `input` (#3605). */
@@ -2519,6 +2702,16 @@ var TreeSitterClient = class _TreeSitterClient {
     this.grammarLastNotifiedDelayMs.clear();
     this.poisonedGrammarPaths.clear();
     this.staleReportedGrammarPaths.clear();
+    for (const grammarFile of this.retiredGrammars.values()) {
+      this.recordGrammarBlocked(grammarFile);
+    }
+  }
+  recordGrammarBlocked(grammarFile) {
+    recordDegradationOnce({
+      kind: "grammar-blocked",
+      subject: grammarFile,
+      reason: `grammar retired after ${GRAMMAR_TRAP_LATCH_THRESHOLD} distinct WASM traps; structural analysis is unavailable for this language until restart`
+    });
   }
   /**
    * Log + record a grammar file on disk that isn't a wasm module, once per
@@ -2942,12 +3135,15 @@ var TreeSitterClient = class _TreeSitterClient {
    */
   resetLoadStateForSession() {
     this.webTreeSitterLoadFailed = false;
+    this.refreshGrammarSessionLatches();
   }
   /** Load language grammar */
   async loadLanguage(languageId) {
     if (this.wasmAborted)
       return null;
     this.dbg(`Loading language: ${languageId}`);
+    if (this.retiredGrammars.has(languageId))
+      return null;
     if (this.languages.has(languageId)) {
       this.dbg(`Language ${languageId} already loaded`);
       return this.languages.get(languageId);
@@ -3151,7 +3347,7 @@ var TreeSitterClient = class _TreeSitterClient {
   }
   /** Get loaded language for symbol extraction */
   getLanguage(languageId) {
-    if (this.wasmAborted)
+    if (this.wasmAborted || this.retiredGrammars.has(languageId))
       return null;
     return this.languages.get(languageId) || null;
   }
@@ -3234,7 +3430,7 @@ var TreeSitterClient = class _TreeSitterClient {
         return [];
     }
     const maxResults = options.maxResults ?? 50;
-    const batch = await this.compileQueryBatch(queryDefs, languageId);
+    const batch = await this.compileQueryBatch(queryDefs, languageId, true);
     if (!batch) {
       const results2 = [];
       for (const queryDef of queryDefs) {
@@ -3296,7 +3492,7 @@ var TreeSitterClient = class _TreeSitterClient {
       // #3678 F4: the scanner and the dispatch runner run different rule
       // sets under this one call site.
       `runQueriesOnFile\0${batch.key}`
-    );
+    ).finally(() => this.releaseQueryBatch(batch));
     const results = [];
     for (let i = 0; i < batch.entries.length; i++) {
       for (const match of perQuery.get(i) ?? []) {
@@ -3309,26 +3505,65 @@ var TreeSitterClient = class _TreeSitterClient {
    * Compile `queryDefs` into one multi-pattern Query for `languageId`, with a
    * pattern-index → rule map. Cached per language + rule-set identity.
    */
-  async compileQueryBatch(queryDefs, languageId) {
-    const identity = crypto2.createHash("sha256").update(JSON.stringify(queryDefs)).digest("hex");
+  async compileQueryBatch(queryDefs, languageId, retain = false) {
+    const identity = crypto3.createHash("sha256").update(JSON.stringify(queryDefs)).digest("hex");
     const cacheKey = this.getQueryCacheKey(`batch:${identity}`, languageId);
     const cached = this.queryBatchCache.get(cacheKey);
     if (cached !== void 0) {
       this.queryBatchCache.delete(cacheKey);
       this.queryBatchCache.set(cacheKey, cached);
+      if (retain && cached)
+        this.retainQueryBatch(cached);
       return cached;
     }
+    const inFlight = this.queryBatchBuilds.get(cacheKey);
+    if (inFlight) {
+      if (retain) {
+        const decided = inFlight.lease.batch;
+        if (decided === void 0)
+          inFlight.lease.count++;
+        else if (decided)
+          this.retainQueryBatch(decided);
+      }
+      return inFlight.promise;
+    }
+    const lease = { count: retain ? 1 : 0, batch: void 0 };
+    const promise = this.compileQueryBatchOnce(queryDefs, languageId, lease);
+    const build = { promise, lease };
+    this.queryBatchBuilds.set(cacheKey, build);
+    try {
+      return await promise;
+    } finally {
+      if (this.queryBatchBuilds.get(cacheKey) === build) {
+        this.queryBatchBuilds.delete(cacheKey);
+      }
+    }
+  }
+  async compileQueryBatchOnce(queryDefs, languageId, lease) {
+    const identity = crypto3.createHash("sha256").update(JSON.stringify(queryDefs)).digest("hex");
+    const cacheKey = this.getQueryCacheKey(`batch:${identity}`, languageId);
+    const inputKeys = [
+      cacheKey,
+      ...queryDefs.map((queryDef) => this.getQueryCacheKey(`raw:${queryDef.id}:${queryDef.query}`, languageId))
+    ];
+    const cached = this.queryBatchCache.get(cacheKey);
+    if (cached !== void 0) {
+      this.queryBatchCache.delete(cacheKey);
+      this.queryBatchCache.set(cacheKey, cached);
+      return this.takeQueryBatchLeases(lease, cached);
+    }
+    const healEpoch = this.queryBatchHealEpoch;
     const language = await this.loadLanguage(languageId);
     if (!language) {
       const failures = (this.queryBatchLoadFailures.get(cacheKey) ?? 0) + 1;
       if (failures >= QUERY_BATCH_MAX_LOAD_FAILURES) {
         this.dbg(`Batch: grammar for ${languageId} failed to load ${failures} times \u2014 caching miss`);
         this.queryBatchLoadFailures.delete(cacheKey);
-        this.cacheQueryBatch(cacheKey, null);
+        this.cacheQueryBatch(cacheKey, null, inputKeys);
       } else {
         this.queryBatchLoadFailures.set(cacheKey, failures);
       }
-      return null;
+      return this.takeQueryBatchLeases(lease, null);
     }
     this.queryBatchLoadFailures.delete(cacheKey);
     let trapped = false;
@@ -3351,7 +3586,7 @@ var TreeSitterClient = class _TreeSitterClient {
           const probe = new Query(language, queryDef.query);
           patternCount = probe.patternCount();
           probe.delete?.();
-          this.clearWasmInput(probeInput);
+          this.clearWasmInput(probeInput, true);
         } catch (err) {
           if (this.reportWasmAbort(err, probeInput))
             return null;
@@ -3380,8 +3615,16 @@ var TreeSitterClient = class _TreeSitterClient {
           this.dbg(`Batch pattern count mismatch for ${languageId} (${query.patternCount()} vs ${ownerOfPattern.length}) \u2014 falling back`);
           return null;
         }
-        this.clearWasmInput(batchInput);
-        return { query, entries, ownerOfPattern, key: cacheKey };
+        this.clearWasmInput(batchInput, true);
+        return {
+          query,
+          entries,
+          ownerOfPattern,
+          key: cacheKey,
+          users: 0,
+          retired: false,
+          disposed: false
+        };
       } catch (err) {
         if (this.reportWasmAbort(err, batchInput))
           return null;
@@ -3392,8 +3635,13 @@ var TreeSitterClient = class _TreeSitterClient {
       }
     };
     const batch = await build();
-    if (!trapped)
-      this.cacheQueryBatch(cacheKey, batch);
+    const published = !trapped && this.queryBatchHealEpoch === healEpoch;
+    this.takeQueryBatchLeases(lease, batch);
+    if (published) {
+      this.cacheQueryBatch(cacheKey, batch, inputKeys);
+    } else {
+      this.retireQueryBatch(batch);
+    }
     return batch;
   }
   /**
@@ -5544,6 +5792,7 @@ export {
   getBundledQueriesRootHealth,
   ruleSourceLanguages,
   ruleFilesForLanguage,
+  computeRuleFilesFingerprint,
   queriesForLanguage,
   isDisabledQueryFilePath,
   queryLoader,

package/node_modules/pi-lens/dist/{chunk-NMABWBZN.js → chunk-UGSMCQ4D.js}

@@ -4,7 +4,7 @@ import {
 } from "./chunk-ABBOA7UD.js";
 import {
   normalizeMapKey
-} from "./chunk-Q5U6FMDI.js";
+} from "./chunk-G3RLJYA2.js";
 
 // dist/clients/dispatch/fact-store.js
 var capacityEvictionReporter;

package/node_modules/pi-lens/dist/{chunk-6QIUX4EP.js → chunk-USHG4DLH.js}

@@ -3,31 +3,31 @@ import {
   shouldRecurseIntoDir,
   walkTreeRecursiveSync,
   walkTreeStackAsync
-} from "./chunk-VHQLPIRJ.js";
+} from "./chunk-H5EV3VMF.js";
 import {
   getProjectIgnoreMatcher
-} from "./chunk-VN2AXLEX.js";
+} from "./chunk-T54VJRAD.js";
 import {
   KIND_EXTENSIONS,
   isCodeKindFile
-} from "./chunk-5ZEJHV35.js";
+} from "./chunk-64LU2OVH.js";
 import {
   classifyGeneratedOrArtifactDetailed,
   isDeclarationFile
-} from "./chunk-DQ2NZ7C4.js";
+} from "./chunk-N2IRDBZI.js";
 import {
   logLatency
-} from "./chunk-5THXD6X5.js";
+} from "./chunk-3PNFWVHT.js";
 import {
   toPositiveFinite
-} from "./chunk-UK3CMEAL.js";
+} from "./chunk-VSMJK3ZJ.js";
 import {
   BoundedLruCache
 } from "./chunk-ABBOA7UD.js";
 import {
   normalizeEphemeralMapKey,
   normalizeFilePath
-} from "./chunk-Q5U6FMDI.js";
+} from "./chunk-G3RLJYA2.js";
 
 // dist/clients/source-filter.js
 import * as fs2 from "node:fs";