@herbertgao/pi-extensions 2026.9.0 → 2026.9.1

package/node_modules/pi-lens/dist/clients/word-index-store.js

@@ -1,4 +1,4 @@
-import { createDeadline, yieldIfOverBudget } from "./cooperative-budget.js";
+import { createDeadline, yieldIfOverBudget, } from "./cooperative-budget.js";
 /**
  * Packed backing store for the word index's inverted postings (#2069).
  *
@@ -248,8 +248,20 @@ export function compactPostingsIntoArena(postings) {
  *
  * Each `adoptArena` copies and re-homes one list within a single synchronous
  * step, so readers never observe a partially written list.
+ *
+ * `options.deadline` and `options.beforeYield` are a test seam only (#2293):
+ * production always takes the default 8 ms wall-clock deadline. The #2117
+ * regression test used to prove the "grew during a yield" invariant by racing
+ * a real timer against a 40,000-list copy, which made the yield itself a
+ * scheduling accident — the copy sometimes finished inside the 8 ms budget
+ * and never yielded at all, so the test's own precondition went unmet under
+ * load. Injecting a deadline lets a test force a yield deterministically
+ * instead of hoping wall-clock crosses the budget; `beforeYield` runs
+ * in-line, immediately before the real cooperative pause, so a test can
+ * mutate a not-yet-adopted list at that exact point with no reliance on
+ * event-loop scheduling order.
  */
-export async function compactPostingsIntoArenaCooperatively(postings) {
+export async function compactPostingsIntoArenaCooperatively(postings, options) {
     // Snapshot (token, list, width) in one synchronous pass; the arena is sized
     // from these widths and only unchanged lists are adopted, so the sum of the
     // widths actually written can never exceed the arena length.
@@ -264,15 +276,17 @@ export async function compactPostingsIntoArenaCooperatively(postings) {
         return;
     const arena = new Int32Array(lanes);
     let offset = 0;
-    const deadline = createDeadline(8);
+    const deadline = options?.deadline ?? createDeadline(8);
     for (const plan of planned) {
         if (postings.get(plan.token) === plan.list &&
             plan.list.length * 2 === plan.width &&
             offset + plan.width <= arena.length) {
             offset = plan.list.adoptArena(arena, offset);
         }
-        if (deadline.expired())
+        if (deadline.expired()) {
+            await options?.beforeYield?.();
             await yieldIfOverBudget(deadline);
+        }
     }
 }
 /**
@@ -375,7 +389,8 @@ export class WordForwardEntry {
     }
     /** Pack a tokenizer tally. Insertion order is preserved. */
     static fromTally(tally) {
-        const tokenNames = new Array(tally.size);
+        const tokenNames = [];
+        tokenNames.length = tally.size;
         const lineCounts = new Int32Array(tally.size);
         let i = 0;
         for (const [token, count] of tally) {

package/node_modules/pi-lens/dist/clients/word-index.js

@@ -888,7 +888,8 @@ export async function refreshWordIndexIncrementally(index, root, shouldContinue
     const statConcurrency = Number.isFinite(requestedConcurrency) && requestedConcurrency > 0
         ? Math.max(1, Math.floor(requestedConcurrency))
         : WORD_INDEX_STAT_CONCURRENCY;
-    const statResults = new Array(walked.length);
+    const statResults = [];
+    statResults.length = walked.length;
     let cursor = 0;
     let superseded = false;
     const worker = async () => {
@@ -1391,6 +1392,22 @@ export function centralityFromReverseDeps(index, reverseDeps, normalizeKey = (fi
 }
 /** Persisted word-index serialization format version. Bump on breaking format changes. */
 export const WORD_INDEX_FORMAT_VERSION = 2;
+const WORD_INDEX_INT32_MAX = 2_147_483_647;
+// A file id and line fit in one exact Number key through this boundary.
+const WORD_INDEX_PACKED_FILE_ID_MAX = 4_194_303;
+function isCanonicalWordIndexNumber(value) {
+    return (typeof value === "number" &&
+        Number.isFinite(value) &&
+        Number.isSafeInteger(value) &&
+        !Object.is(value, -0));
+}
+function isCanonicalWordIndexToken(token) {
+    return (typeof token === "string" &&
+        token.length >= 2 &&
+        token === token.toLowerCase() &&
+        /^[a-z0-9_$]+$/.test(token) &&
+        !STOPWORDS.has(token));
+}
 const serializedWordIndexCaches = new WeakMap();
 let _lastSerializeWork;
 /** Test-only: work stats for the most recent {@link serializeWordIndex} call. */
@@ -1585,10 +1602,25 @@ export function deserializeWordIndex(data) {
         !Array.isArray(data.files) ||
         !Array.isArray(data.postings) ||
         !Array.isArray(data.docLengths) ||
-        !Array.isArray(data.fileMtimes) ||
-        data.fileMtimes.length !== data.files.length) {
+        !Array.isArray(data.fileMtimes)) {
         return null;
     }
+    let canonical = data.docLengths.length === data.files.length &&
+        data.fileMtimes.length === data.files.length;
+    let needsDeepSanitize = !Array.isArray(data.forward);
+    if (needsDeepSanitize)
+        canonical = false;
+    const fileKeys = new Set();
+    for (const file of data.files) {
+        if (typeof file !== "string")
+            return null;
+        const key = wordIndexKey(file);
+        if (fileKeys.has(key)) {
+            canonical = false;
+            needsDeepSanitize = true;
+        }
+        fileKeys.add(key);
+    }
     const docLengths = new PathKeyedMap(wordIndexKey);
     // Slot i of the wire `files` array becomes file id `fileIdBySlot[i]`. Two
     // slots whose spellings fold to one key share one id, exactly as a build
@@ -1596,33 +1628,94 @@ export function deserializeWordIndex(data) {
     // posting identities for one document.
     const fileTable = new WordIndexFileTable();
     const fileIdBySlot = data.files.map((file) => fileTable.intern(wordIndexKey(file), file));
+    const slotByFileId = new Map();
+    fileIdBySlot.forEach((fileId, slot) => {
+        if (!slotByFileId.has(fileId))
+            slotByFileId.set(fileId, slot);
+    });
     const fileMtimes = new PathKeyedMap(wordIndexKey);
     const fileSizes = new PathKeyedMap(wordIndexKey);
-    data.files.forEach((file, i) => docLengths.set(file, data.docLengths[i] ?? 0));
-    data.files.forEach((file, i) => fileMtimes.set(file, data.fileMtimes[i] ?? 0));
+    data.files.forEach((file, i) => {
+        const value = data.docLengths[i];
+        if (!isCanonicalWordIndexNumber(value) || value < 0)
+            canonical = false;
+        docLengths.set(file, isCanonicalWordIndexNumber(value) && value >= 0 ? value : 0);
+    });
+    data.files.forEach((file, i) => {
+        const value = data.fileMtimes[i];
+        if (typeof value !== "number" || !Number.isFinite(value))
+            canonical = false;
+        fileMtimes.set(file, typeof value === "number" && Number.isFinite(value) ? value : 0);
+    });
     // #1105: `fileSizes` is optional on the wire (pre-#1105 snapshots omit it).
     // Only populate when the array is present AND parallel to `files`; otherwise
     // leave it empty so the refresh gate re-reads every file once to repopulate,
     // rather than trusting a bogus/misaligned size. Never treated as "current".
     if (Array.isArray(data.fileSizes) &&
         data.fileSizes.length === data.files.length) {
-        data.files.forEach((file, i) => fileSizes.set(file, data.fileSizes?.[i] ?? 0));
+        data.files.forEach((file, i) => {
+            const value = data.fileSizes?.[i];
+            if (!isCanonicalWordIndexNumber(value) || value < 0)
+                canonical = false;
+            fileSizes.set(file, isCanonicalWordIndexNumber(value) && value >= 0 ? value : 0);
+        });
+    }
+    else {
+        canonical = false;
     }
     const postings = new Map();
-    for (const [token, flat] of data.postings) {
-        if (typeof token !== "string" || !Array.isArray(flat))
+    const postingTokens = new Set();
+    const postingFileCounts = new Map();
+    for (const posting of data.postings) {
+        if (!Array.isArray(posting) || posting.length !== 2) {
+            canonical = false;
+            needsDeepSanitize = true;
+            continue;
+        }
+        const [token, flat] = posting;
+        if (!isCanonicalWordIndexToken(token) ||
+            postingTokens.has(token) ||
+            !Array.isArray(flat) ||
+            flat.length === 0 ||
+            flat.length % 2 !== 0) {
+            canonical = false;
+            needsDeepSanitize = true;
             continue;
+        }
+        postingTokens.add(token);
         const lanes = [];
-        for (let i = 0; i + 1 < flat.length; i += 2) {
-            const fileId = fileIdBySlot[flat[i]];
+        const seenPairs = new Set();
+        const observedCounts = new Map();
+        for (let i = 0; i < flat.length; i += 2) {
+            const slot = flat[i];
             const line = flat[i + 1];
-            if (typeof fileId === "number" && typeof line === "number") {
-                lanes.push(fileId, line);
+            if (!isCanonicalWordIndexNumber(slot) ||
+                slot < 0 ||
+                slot >= fileIdBySlot.length ||
+                !isCanonicalWordIndexNumber(line) ||
+                line < 1 ||
+                line > WORD_INDEX_INT32_MAX) {
+                canonical = false;
+                needsDeepSanitize = true;
+                continue;
             }
+            const fileId = fileIdBySlot[slot];
+            const pairKey = fileId <= WORD_INDEX_PACKED_FILE_ID_MAX
+                ? fileId * (WORD_INDEX_INT32_MAX + 1) + line
+                : `${fileId}:${line}`;
+            if (seenPairs.has(pairKey)) {
+                canonical = false;
+                needsDeepSanitize = true;
+            }
+            seenPairs.add(pairKey);
+            lanes.push(fileId, line);
+            observedCounts.set(fileId, (observedCounts.get(fileId) ?? 0) + 1);
         }
-        if (lanes.length > 0) {
-            postings.set(token, WordPostingList.fromLanes(token, lanes));
-        }
+        if (lanes.length === 0)
+            continue;
+        const list = WordPostingList.fromLanes(token, lanes);
+        postings.set(token, list);
+        postingFileCounts.set(token, observedCounts);
     }
     // Every list above was sized exactly from the wire payload, so there is no
     // growth slack to release — but the per-list `ArrayBuffer` headers are the
@@ -1631,34 +1724,128 @@ export function deserializeWordIndex(data) {
     compactPostingsIntoArena(postings);
     let forward;
     if (Array.isArray(data.forward)) {
-        forward = new PathKeyedMap(wordIndexKey);
-        for (const entry of data.forward) {
-            if (!Array.isArray(entry) || entry.length !== 2)
+        const candidate = data.files.map(() => new Map());
+        const forwardTotals = new Map();
+        if (data.forward.length !== data.files.length)
+            canonical = false;
+        if (data.forward.length !== data.files.length)
+            needsDeepSanitize = true;
+        for (const [entryIndex, entry] of data.forward.entries()) {
+            if (!Array.isArray(entry) || entry.length !== 2) {
+                canonical = false;
+                needsDeepSanitize = true;
                 continue;
+            }
             const [fileIdx, tokenCounts] = entry;
-            const file = data.files[fileIdx];
-            if (typeof file !== "string" || !Array.isArray(tokenCounts))
+            if (!isCanonicalWordIndexNumber(fileIdx) ||
+                fileIdx !== entryIndex ||
+                fileIdx < 0 ||
+                fileIdx >= data.files.length ||
+                !Array.isArray(tokenCounts)) {
+                canonical = false;
+                needsDeepSanitize = true;
                 continue;
-            const perToken = new Map();
+            }
             for (const pair of tokenCounts) {
-                if (!Array.isArray(pair) || pair.length !== 2)
+                if (!Array.isArray(pair) ||
+                    pair.length !== 2 ||
+                    !isCanonicalWordIndexToken(pair[0]) ||
+                    !isCanonicalWordIndexNumber(pair[1]) ||
+                    pair[1] < 1 ||
+                    pair[1] > WORD_INDEX_INT32_MAX ||
+                    candidate[fileIdx].has(pair[0])) {
+                    canonical = false;
+                    needsDeepSanitize = true;
+                    continue;
+                }
+                candidate[fileIdx].set(pair[0], pair[1]);
+                forwardTotals.set(pair[0], (forwardTotals.get(pair[0]) ?? 0) + pair[1]);
+            }
+        }
+        let forwardMatchesPostings = true;
+        for (const [token, list] of postings) {
+            if (forwardTotals.get(token) !== list.length) {
+                forwardMatchesPostings = false;
+            }
+            const observed = postingFileCounts.get(token);
+            if (!observed) {
+                forwardMatchesPostings = false;
+                continue;
+            }
+            for (const [fileId, count] of observed) {
+                const slot = slotByFileId.get(fileId);
+                if (slot === undefined || candidate[slot].get(token) !== count) {
+                    forwardMatchesPostings = false;
+                }
+            }
+        }
+        for (const token of forwardTotals.keys()) {
+            if (!postingTokens.has(token))
+                forwardMatchesPostings = false;
+        }
+        if (!forwardMatchesPostings)
+            canonical = false;
+        if (!forwardMatchesPostings)
+            needsDeepSanitize = true;
+        forward = new PathKeyedMap(wordIndexKey);
+        for (let i = 0; i < data.files.length; i += 1) {
+            forward.set(data.files[i], WordForwardEntry.fromTally(candidate[i]));
+        }
+    }
+    else if (Object.prototype.hasOwnProperty.call(data, "forward")) {
+        canonical = false;
+        needsDeepSanitize = true;
+    }
+    if (needsDeepSanitize) {
+        const actualForwardCounts = data.files.map(() => new Map());
+        for (const [token, list] of postings) {
+            const seenPairs = new Set();
+            const sanitized = new WordPostingList(token, list.length);
+            for (let i = 0; i < list.length; i += 1) {
+                const fileId = list.fileIdAt(i);
+                const line = list.lineAt(i);
+                const pairKey = `${fileId}:${line}`;
+                if (seenPairs.has(pairKey))
                     continue;
-                const [token, count] = pair;
-                if (typeof token === "string" && typeof count === "number") {
-                    // Point at the canonical instance the postings map holds, not
-                    // this document’s own JSON.parse allocation (#2069).
-                    perToken.set(postings.get(token)?.token ?? token, count);
+                seenPairs.add(pairKey);
+                sanitized.push(fileId, line);
+                const slot = slotByFileId.get(fileId);
+                if (slot !== undefined) {
+                    const counts = actualForwardCounts[slot];
+                    counts.set(token, (counts.get(token) ?? 0) + 1);
                 }
             }
-            forward.set(file, WordForwardEntry.fromTally(perToken));
+            postings.set(token, sanitized);
+        }
+        compactPostingsIntoArena(postings);
+        if (Array.isArray(data.forward)) {
+            forward = new PathKeyedMap(wordIndexKey);
+            for (let i = 0; i < data.files.length; i += 1) {
+                const canonicalSlot = slotByFileId.get(fileIdBySlot[i]) ?? i;
+                forward.set(data.files[i], WordForwardEntry.fromTally(actualForwardCounts[canonicalSlot]));
+            }
         }
     }
-    return {
+    const expectedTotalTokens = [...docLengths.values()].reduce((total, length) => total + length, 0);
+    const totalTokens = isCanonicalWordIndexNumber(expectedTotalTokens)
+        ? expectedTotalTokens
+        : 0;
+    if (!isCanonicalWordIndexNumber(data.totalTokens) ||
+        data.totalTokens !== totalTokens) {
+        canonical = false;
+    }
+    if (typeof data.indexedFileCount !== "number" ||
+        data.indexedFileCount !== docLengths.size) {
+        canonical = false;
+    }
+    if (typeof data.truncated !== "boolean")
+        canonical = false;
+    const index = {
         postings,
         fileTable,
         docLengths,
-        totalTokens: typeof data.totalTokens === "number" ? data.totalTokens : 0,
-        docCount: data.files.length,
+        totalTokens,
+        docCount: docLengths.size,
         truncated: data.truncated === true,
         forward,
         fileMtimes,
@@ -1667,7 +1854,32 @@ export function deserializeWordIndex(data) {
         // starts from the exact post-compaction store count (#2117).
         postingStoreCount: countPostingBackingStores(postings),
         recompactFlight: createSingleFlight(),
+        // A deserialized index is a fresh object distinct from whichever index
+        // produced `data`. Without this, every per-edit dirty mark on a
+        // session-start reload (#2068) is a no-op against `undefined`, and
+        // serializeWordIndexIncrementally's `!dirty` branch then returns the
+        // stale cached wire view forever, silently dropping every later edit
+        // from the persisted snapshot.
+        dirtyFiles: new Set(),
     };
+    // Seed the wire cache from the snapshot just loaded so the FIRST persist
+    // of a reloaded session (session-start's `snapshotSaveSyncMs`, #2068) also
+    // takes the bounded incremental path instead of paying a full rebuild —
+    // mirrors exactly what one priming `serializeWordIndex` call would cache.
+    const tokensByFile = new Map();
+    if (forward) {
+        for (const file of data.files) {
+            tokensByFile.set(wordIndexKey(file), new Set(forward.get(file)?.keys() ?? []));
+        }
+    }
+    if (canonical) {
+        serializedWordIndexCaches.set(index, {
+            serialized: data,
+            slotByFileId,
+            tokensByFile,
+        });
+    }
+    return index;
 }
 const buildStatuses = new Map();
 export function getWordIndexBuildStatus(cwd) {

package/node_modules/pi-lens/dist/clients/workspace-topology.js

@@ -39,11 +39,18 @@
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
+import { PROJECT_CONFIG_BASENAMES } from "./config-locations.js";
 import { logLatency } from "./latency-logger.js";
 import { isAtOrAboveHomeDir, nameMatchesMarkerGlob, walkUpDirs, } from "./path-utils.js";
 /** Depth cap on any upward marker walk — mirrors `findNearestMarkerRoot`'s bound. */
 const MAX_WALK_DEPTH = 64;
-const PI_LENS_CONFIG_BASENAMES = [".pi-lens.json", "pi-lens.json"];
+/**
+ * The project config basenames, canonical first — the SHARED table, not a
+ * fourth copy of the pair (#2426 review round 2). `config-locations.ts` derives
+ * it from the one location table the resolver walks, so a change there cannot
+ * leave this marker index preferring a different file than the loaders do.
+ */
+const PI_LENS_CONFIG_BASENAMES = PROJECT_CONFIG_BASENAMES;
 /** Per-directory marker cache — the shared seam every consumer reads through. */
 const dirMarkerCache = new Map();
 /** Downstream memo clears that must follow the topology index reset. */

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

@@ -21,6 +21,9 @@ export const LOCAL_ZIZMOR_CONFIG_NAMES = [
     "zizmor.yml",
     "zizmor.yaml",
 ];
+// Deliberately UNCEILINGED at $HOME (refs #2472 review round 3, F1): a
+// user-level `~/zizmor.yml` (or `~/.github/zizmor.yml`) is a legitimate
+// global config, not an escaped-workspace accident.
 export function findLocalZizmorConfig(startDir) {
     return findLocalToolConfig(startDir, LOCAL_ZIZMOR_CONFIG_NAMES);
 }