@herbertgao/pi-extensions 2026.9.0 → 2026.9.1

package/node_modules/pi-lens/dist/clients/partial-edit-apply.js

@@ -1,68 +1,345 @@
+import { createHash } from "node:crypto";
 import * as fs from "node:fs";
+import { writeFileAtomic } from "./atomic-write.js";
+import { createFileTime } from "./file-time.js";
 import { detectLineEnding, normalizeToLF, restoreLineEndings, } from "./host-edit-normalize.js";
+import { PathKeyedMap } from "./path-keyed-map.js";
+import { normalizeMapKey } from "./path-utils.js";
 import { boundedEditIndexes, createReadGuardEditBatchSummary, formatBoundedEditIndexes, logReadGuardEvent, } from "./read-guard-logger.js";
-function replaceOnce(content, oldText, newText) {
-    const idx = content.indexOf(oldText);
-    if (idx === -1)
-        return { content, changed: false };
-    return {
-        content: content.slice(0, idx) + newText + content.slice(idx + oldText.length),
-        changed: true,
-    };
+const MAX_APPLIED_RECORDS_PER_FILE = 8;
+/** Exported for #2442's bounded-eviction test; not a public API. */
+export const MAX_APPLIED_RECORD_FILES = 64;
+/**
+ * Canonical key for an applied edit: LF-normalized, per-line trailing
+ * whitespace stripped, trailing empty lines dropped. Retry payloads go through
+ * the same normalization, so an identical resubmission matches its record even
+ * when the two passes' autopatch results diverged on trailing whitespace
+ * (deterministic given identical payloads; the strip removes the only
+ * payload-dependent axis that survives to the retry).
+ */
+export function stripOldTextTrailingWhitespace(value) {
+    const lines = value
+        .replace(/\r\n/g, "\n")
+        .split("\n")
+        .map((l) => l.trimEnd());
+    while (lines.length > 1 && lines[lines.length - 1] === "")
+        lines.pop();
+    return lines.join("\n");
+}
+function editPairDigest(oldText, newText) {
+    return createHash("sha256")
+        .update(JSON.stringify([oldText, newText ?? ""]), "utf8")
+        .digest("hex");
+}
+function countLfOccurrences(content, needle) {
+    if (!needle)
+        return 0;
+    let count = 0;
+    let pos = 0;
+    while (pos < content.length) {
+        const idx = content.indexOf(needle, pos);
+        if (idx === -1)
+            break;
+        count += 1;
+        pos = idx + needle.length;
+    }
+    return count;
+}
+/**
+ * Evidence check for an exact-retry recognition (#2402): the recorded pair was
+ * applied by this process; the content evidence answers whether that state is
+ * still the file's state. Deliberately NOT a global heuristic — it only runs
+ * for an edit whose exact (oldText, newText) pair is on record.
+ *
+ * - oldText not contained in newText: the applied state holds when oldText is
+ *   gone and newText is present.
+ * - oldText contained in newText (e.g. an extended import line): the applied
+ *   state holds when every remaining oldText occurrence lies inside a newText
+ *   occurrence. Re-applying would duplicate newText — the exact #2402 loop.
+ */
+export function isExactAppliedRetry(args) {
+    const { contentLf, oldKey, newKey, contentHash, expectedContentHash, expectedAfterWriteHash, } = args;
+    // Hash gate (fail-safe): when the caller recorded any file-state hash, the
+    // current file must match one of the states THIS process produced — the
+    // post-commit bytes or the post-afterWrite (formatter) bytes. A file in any
+    // other state is an unrecognized third-party change; we refuse rather than
+    // re-resolve against it. The gate is skipped only when no hash was recorded.
+    const haveExpectedHash = expectedContentHash !== undefined || expectedAfterWriteHash !== undefined;
+    if (haveExpectedHash) {
+        const matchesKnownState = contentHash !== undefined &&
+            (contentHash === expectedContentHash ||
+                contentHash === expectedAfterWriteHash);
+        if (!matchesKnownState)
+            return false;
+    }
+    if (!oldKey)
+        return false;
+    if (newKey === "")
+        return countLfOccurrences(contentLf, oldKey) === 0;
+    if (!newKey.includes(oldKey)) {
+        return (countLfOccurrences(contentLf, oldKey) === 0 &&
+            countLfOccurrences(contentLf, newKey) >= 1);
+    }
+    const newOccurrences = [];
+    let pos = 0;
+    while (pos < contentLf.length) {
+        const idx = contentLf.indexOf(newKey, pos);
+        if (idx === -1)
+            break;
+        newOccurrences.push([idx, idx + newKey.length]);
+        pos = idx + newKey.length;
+    }
+    if (newOccurrences.length === 0)
+        return false;
+    pos = 0;
+    while (pos < contentLf.length) {
+        const idx = contentLf.indexOf(oldKey, pos);
+        if (idx === -1)
+            break;
+        const end = idx + oldKey.length;
+        if (!newOccurrences.some(([s, e]) => s <= idx && e >= end))
+            return false;
+        pos = end;
+    }
+    return true;
+}
+/**
+ * Session-scoped store of applied partial/full edits, keyed by normalized file
+ * path. `RuntimeCoordinator.resetForSession` clears it, so an applied record
+ * never outlives the session whose edit produced it. Records are bounded on
+ * both axes (per-file entries, and files) with oldest-entry eviction.
+ */
+export class PartialApplyRecordStore {
+    // Bounded on the PathKeyedMap itself (#2442): the file axis used to
+    // hand-roll `keys().next().value` here, which also evicted an unrelated
+    // file when a path ALREADY in the map was re-recorded at capacity.
+    files = new PathKeyedMap(normalizeMapKey, MAX_APPLIED_RECORD_FILES);
+    find(filePath, oldText, newText) {
+        if (!oldText)
+            return undefined;
+        const pairDigest = editPairDigest(oldText, newText);
+        const records = this.files.get(filePath) ?? [];
+        return records.find((r) => r.pairDigest === pairDigest);
+    }
+    record(filePath, oldText, newText, contentHash) {
+        if (!oldText)
+            return;
+        const pairDigest = editPairDigest(oldText, newText);
+        const records = this.files.get(filePath) ?? [];
+        const existing = records.findIndex((r) => r.pairDigest === pairDigest);
+        if (existing >= 0)
+            records.splice(existing, 1);
+        const entry = {
+            pairDigest,
+            contentHash: contentHash ?? hashFile(filePath),
+            appliedAtMs: Date.now(),
+        };
+        if (records.length >= MAX_APPLIED_RECORDS_PER_FILE)
+            records.shift();
+        records.push(entry);
+        this.files.set(filePath, records); // the map bounds its own file axis
+    }
+    /**
+     * Stamps the post-afterWrite file hash onto an existing record so a later
+     * identical retry against the formatter-rewritten file is still recognized as
+     * already-applied (#2402). No-op when the pair was never recorded.
+     */
+    noteAfterWriteHash(filePath, oldText, newText, afterWriteContentHash) {
+        if (!oldText)
+            return;
+        const pairDigest = editPairDigest(oldText, newText);
+        const record = this.files
+            .get(filePath)
+            ?.find((r) => r.pairDigest === pairDigest);
+        if (record)
+            record.afterWriteContentHash = afterWriteContentHash;
+    }
+    clear() {
+        this.files.clear();
+    }
+    get fileCount() {
+        return this.files.size;
+    }
+}
+// Locks are process-global in FileTime (module-global map keyed by resolved
+// path), so one instance here serializes against every other FileTime user.
+const fileLock = createFileTime("partial-edit-apply");
+function hashBytes(content) {
+    return createHash("sha256").update(content).digest("hex");
+}
+function hashFile(filePath) {
+    try {
+        return createHash("sha256").update(fs.readFileSync(filePath)).digest("hex");
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Internal rejection signal: raised only BEFORE any bytes are written, so a
+ * rejection can never be confused with a commit failure.
+ */
+class PartialApplyRejectionError extends Error {
+    reason;
+    detail;
+    constructor(reason, detail) {
+        super(detail);
+        this.reason = reason;
+        this.detail = detail;
+        this.name = "PartialApplyRejectionError";
+    }
 }
 /**
- * Applies already-resolved oldText edits from the preflight path, then invokes
- * the caller's normal post-edit bookkeeping/pipeline hook. The edits are exact
- * LF-normalized replacements; entries that no longer match are skipped rather
- * than logged as applied.
+ * Applies preflight-approved spans from the original snapshot, then invokes the
+ * caller's normal post-edit bookkeeping/pipeline hook (#1053, #2402).
+ *
+ * Contract:
+ * - Spans are consumed as resolved; oldText is never re-searched against a
+ *   changed buffer.
+ * - The whole batch is validated (snapshot identity, span bounds, span text,
+ *   pairwise non-overlap) BEFORE any write; a rejection writes nothing and
+ *   dispatches no post-edit pipeline.
+ * - The commit goes through the shared atomic writer under the file lock.
+ * - A committed write and a post-edit analysis failure are separate outcomes;
+ *   the caller decides the message, and committed bytes are never reported as
+ *   a retryable oldText miss.
  */
 export async function applyPartiallyApplicableEdits(args) {
     const startedAt = Date.now();
-    const raw = fs.readFileSync(args.filePath, "utf-8");
-    // Detect + restore line endings the way the host edit tool does:
-    // first-occurrence-wins detection (not "any CRLF present") and lone-CR -> LF
-    // normalization, so this self-apply path can't diverge from how the host
-    // would have written the same edits (#257).
-    const ending = detectLineEnding(raw);
-    let content = normalizeToLF(raw);
-    const applied = [];
-    const skipped = [];
+    const summaryRef = args.summary;
+    const correlationId = args.correlationId;
+    const logBatchEvent = (entry) => logReadGuardEvent({ ...entry, correlationId });
+    const reject = (reason, detail) => {
+        logBatchEvent({
+            event: "edit_partial_apply_rejected",
+            filePath: args.filePath,
+            metadata: {
+                tool: "edit",
+                rejectionReason: reason,
+                detail,
+                editCount: args.edits.length,
+            },
+        });
+        return {
+            appliedCount: 0,
+            appliedTotal: 0,
+            appliedIndices: "",
+            postEditStatus: "not_run",
+            rejected: { reason, detail },
+        };
+    };
+    if (args.edits.length === 0) {
+        return reject("invalid_batch", "no preflight-approved edits were carried into the apply step");
+    }
+    const snapshot = args.edits[0].snapshot;
     for (const edit of args.edits) {
-        const oldText = normalizeToLF(edit.oldText);
-        const newText = normalizeToLF(edit.newText ?? "");
-        const replaced = replaceOnce(content, oldText, newText);
-        if (!replaced.changed) {
-            skipped.push(edit.originalIndex);
-            continue;
+        if (edit.snapshot.hash !== snapshot.hash) {
+            return reject("invalid_batch", "carried edits reference different snapshot identities; the batch must be rebuilt from one preflight");
         }
-        content = replaced.content;
-        applied.push(edit.originalIndex);
     }
-    let commitStatus = applied.length > 0 ? "committed" : "no_changes";
-    try {
-        if (applied.length > 0) {
-            fs.writeFileSync(args.filePath, restoreLineEndings(content, ending), "utf-8");
+    // Validate + commit inside the file lock so a concurrent same-file writer
+    // (formatter, LSP edit, another session's partial apply) cannot interleave
+    // between the identity re-check and the rename.
+    const commit = () => {
+        const rawBytes = fs.readFileSync(args.filePath);
+        if (hashBytes(rawBytes) !== snapshot.hash) {
+            throw new PartialApplyRejectionError("stale_snapshot", "the file changed since the preflight resolved these edits; rebuild the edit from the current content");
+        }
+        const raw = rawBytes.toString("utf8");
+        const ending = detectLineEnding(raw);
+        const lf = normalizeToLF(raw);
+        // The span-text equality is the single span guard: `slice` clamps to the
+        // buffer, so an out-of-bounds, inverted, or drifted span cannot produce
+        // the approved text and is rejected here as one rejection class. A
+        // separate bounds check would only re-label the same failure.
+        const ordered = [...args.edits].sort((a, b) => a.spanStart - b.spanStart);
+        for (let i = 0; i < ordered.length; i += 1) {
+            const edit = ordered[i];
+            if (lf.slice(edit.spanStart, edit.spanEnd) !== edit.appliedSpanText) {
+                throw new PartialApplyRejectionError("span_changed", `edits[${edit.originalIndex}] span no longer holds the text the preflight approved; the batch must be rebuilt from a fresh preflight`);
+            }
+            if (i > 0) {
+                const prev = ordered[i - 1];
+                if (edit.spanStart < prev.spanEnd) {
+                    throw new PartialApplyRejectionError("span_overlap", `edits[${prev.originalIndex}] and edits[${edit.originalIndex}] resolved to overlapping spans; extend one oldText to disambiguate the location`);
+                }
+            }
+        }
+        let committed = lf;
+        for (let i = ordered.length - 1; i >= 0; i -= 1) {
+            const edit = ordered[i];
+            const newText = normalizeToLF(edit.newText ?? "");
+            committed =
+                committed.slice(0, edit.spanStart) +
+                    newText +
+                    committed.slice(edit.spanEnd);
         }
+        const output = restoreLineEndings(committed, ending);
+        const targetPath = fs.lstatSync(args.filePath).isSymbolicLink()
+            ? fs.realpathSync(args.filePath)
+            : args.filePath;
+        const mode = fs.statSync(args.filePath).mode & 0o7777;
+        writeFileAtomic(targetPath, output, {
+            bestEffort: false,
+            mode,
+        });
+        return hashBytes(Buffer.from(output, "utf8"));
+    };
+    let commitStatus = "committed";
+    let committedContentHash;
+    try {
+        await fileLock.withLock(args.filePath, async () => {
+            committedContentHash = commit();
+            for (const edit of args.edits) {
+                args.recordStore?.record(args.filePath, edit.oldText, edit.newText, committedContentHash);
+            }
+        });
     }
     catch (error) {
+        if (error instanceof PartialApplyRejectionError) {
+            commitStatus = "not_attempted";
+            const baseSummary = summaryRef ??
+                createReadGuardEditBatchSummary({
+                    requestedIndexes: boundedEditIndexes(args.edits.map((edit) => edit.originalIndex)),
+                    requestedTotal: args.edits.length,
+                });
+            const summary = createReadGuardEditBatchSummary({
+                ...baseSummary,
+                participantIds: correlationId
+                    ? [...baseSummary.participantIds, correlationId]
+                    : baseSummary.participantIds,
+                participantTotal: correlationId
+                    ? baseSummary.participantTotal + 1
+                    : baseSummary.participantTotal,
+                commitStatus,
+                postEditStatus: "not_run",
+                terminalStatus: "blocked",
+                durationMs: Date.now() - startedAt,
+            });
+            logBatchEvent({
+                event: "edit_batch_summary",
+                filePath: args.filePath,
+                metadata: { tool: "edit", editBatchSummary: summary },
+            });
+            return reject(error.reason, error.detail);
+        }
         commitStatus = "failed";
-        if (args.summary || args.correlationId) {
+        if (summaryRef || correlationId) {
             const summary = createReadGuardEditBatchSummary({
-                ...(args.summary ?? {
-                    requestedIndexes: boundedEditIndexes(args.edits.slice(0, 100).map((edit) => edit.originalIndex)),
+                ...(summaryRef ?? {
+                    requestedIndexes: boundedEditIndexes(args.edits.map((edit) => edit.originalIndex)),
                     requestedTotal: args.edits.length,
                 }),
                 appliedIndexes: [],
                 appliedTotal: 0,
-                participantIds: args.correlationId ? [args.correlationId] : undefined,
-                participantTotal: args.correlationId ? 1 : undefined,
+                participantIds: correlationId ? [correlationId] : undefined,
+                participantTotal: correlationId ? 1 : undefined,
                 commitStatus,
                 terminalStatus: "failed",
                 durationMs: Date.now() - startedAt,
             });
-            logReadGuardEvent({
+            logBatchEvent({
                 event: "edit_batch_summary",
-                correlationId: args.correlationId,
                 filePath: args.filePath,
                 metadata: { tool: "edit", editBatchSummary: summary },
             });
@@ -71,89 +348,91 @@ export async function applyPartiallyApplicableEdits(args) {
     }
     let postEditOutput;
     let postEditStatus = "not_run";
-    if (applied.length > 0 && args.afterWrite) {
+    if (args.afterWrite) {
         try {
             postEditOutput = await args.afterWrite();
             postEditStatus = "succeeded";
+            // #2402: the afterWrite pipeline (a formatter) may have rewritten the
+            // file. Record the new state so an identical retry against the
+            // formatted bytes is still recognized as already-applied instead of
+            // falling back to oldText resolution and re-applying. Only stamped when
+            // the pipeline actually changed the bytes; the post-commit hash already
+            // covers a no-op pass.
+            if (args.recordStore) {
+                const afterWriteHash = hashFile(args.filePath);
+                if (afterWriteHash !== undefined &&
+                    afterWriteHash !== committedContentHash) {
+                    for (const edit of args.edits) {
+                        args.recordStore.noteAfterWriteHash(args.filePath, edit.oldText, edit.newText, afterWriteHash);
+                    }
+                }
+            }
         }
         catch (error) {
             // The write is committed. Preserve the existing caller behavior for
             // uninstrumented callers; the read-guard path records and handles it.
             postEditStatus = "failed";
-            if (!args.summary && !args.correlationId)
+            if (!summaryRef && !correlationId)
                 throw error;
         }
     }
-    if (!args.summary && !args.correlationId) {
+    const appliedIndexes = boundedEditIndexes(args.edits.map((edit) => edit.originalIndex));
+    if (!summaryRef && !correlationId) {
         return {
-            appliedCount: applied.length,
-            appliedIndices: formatBoundedEditIndexes(applied),
+            appliedCount: args.edits.length,
+            appliedTotal: args.edits.length,
+            appliedIndices: formatBoundedEditIndexes(appliedIndexes),
             postEditOutput,
+            postEditStatus,
         };
     }
-    const baseSummary = args.summary ??
+    const baseSummary = summaryRef ??
         createReadGuardEditBatchSummary({
-            requestedIndexes: boundedEditIndexes(args.edits.slice(0, 100).map((edit) => edit.originalIndex)),
+            requestedIndexes: appliedIndexes,
             requestedTotal: args.edits.length,
-            resolvedIndexes: boundedEditIndexes(args.edits.slice(0, 100).map((edit) => edit.originalIndex)),
+            resolvedIndexes: appliedIndexes,
             resolvedTotal: args.edits.length,
         });
     const summary = createReadGuardEditBatchSummary({
         ...baseSummary,
-        rejectedReasons: [
-            ...baseSummary.rejectedReasons,
-            ...skipped.slice(0, 100).map((index) => ({
-                index,
-                code: "replace_once_skipped",
-            })),
-        ],
-        rejectedTotal: baseSummary.rejectedTotal + skipped.length,
-        appliedIndexes: applied,
-        appliedTotal: applied.length,
-        participantIds: args.correlationId
-            ? [...baseSummary.participantIds, args.correlationId]
+        appliedIndexes,
+        appliedTotal: args.edits.length,
+        participantIds: correlationId
+            ? [...baseSummary.participantIds, correlationId]
             : baseSummary.participantIds,
-        participantTotal: args.correlationId
+        participantTotal: correlationId
             ? baseSummary.participantTotal + 1
             : baseSummary.participantTotal,
         commitStatus,
         postEditStatus,
-        terminalStatus: postEditStatus === "failed"
-            ? "failed"
-            : applied.length === 0
-                ? "skipped"
-                : "success",
+        // Commit failures rethrow above, so reaching here means the commit
+        // landed; only the post-edit analysis can fail from this point on.
+        terminalStatus: postEditStatus === "failed" ? "failed" : "success",
         durationMs: Date.now() - startedAt,
     });
     if (postEditStatus === "failed") {
-        logReadGuardEvent({
+        logBatchEvent({
             event: "edit_post_edit_pipeline_failed",
-            correlationId: args.correlationId,
             filePath: args.filePath,
             metadata: {
                 tool: "edit",
                 commitStatus,
-                appliedCount: applied.length,
-                appliedIndexes: applied.slice(0, 100),
-                appliedTotal: applied.length,
+                appliedCount: args.edits.length,
+                appliedIndexes,
+                appliedTotal: args.edits.length,
             },
         });
     }
-    logReadGuardEvent({
+    logBatchEvent({
         event: "edit_batch_summary",
-        correlationId: args.correlationId,
         filePath: args.filePath,
         metadata: { tool: "edit", editBatchSummary: summary },
     });
     return {
-        appliedCount: applied.length,
-        appliedTotal: applied.length,
-        appliedIndices: formatBoundedEditIndexes(applied),
+        appliedCount: args.edits.length,
+        appliedTotal: args.edits.length,
+        appliedIndices: formatBoundedEditIndexes(appliedIndexes),
         postEditOutput,
-        skippedCount: skipped.length,
-        skippedTotal: skipped.length,
-        skippedIndices: formatBoundedEditIndexes(skipped),
-        indexesTruncated: applied.length > 100 || skipped.length > 100 || summary.indexesTruncated,
         postEditStatus,
         summary,
     };

package/node_modules/pi-lens/dist/clients/path-attribution-telemetry.js

@@ -1,27 +1,43 @@
 import { logLatency } from "./latency-logger.js";
+import { getProcessSingleton } from "./process-singletons.js";
 // Verified guesses are expected host behavior, not degradations. Keep their
 // exact session count in memory and publish one bounded row at session end.
 // This tally is intentionally memory-only: a process crash loses its count.
 // The rollup is best-effort session telemetry, not durable accounting.
-let verifiedGuessCount = 0;
+//
+// Process-singleton backed (AGENTS.md catalog shape 25), NOT a module-scope
+// `let` like `bus-events-logger.ts`'s rollup: a `let` here exists once per
+// module EVALUATION, not once per process, and #2146 measured one pid
+// evaluating this graph nine times — a bare `let` would only ever count the
+// guesses routed through its own copy, undercounting every rollup that is not
+// reached through the first evaluation. This is the same decision its sibling
+// `session-start-observability.ts`'s bind rollup made in #2249.
+const VERIFIED_GUESS_FAMILY = "path-attribution-verified-guess-count";
+const VERIFIED_GUESS_VERSION = 1;
+function verifiedGuessCount() {
+    return getProcessSingleton(VERIFIED_GUESS_FAMILY, VERIFIED_GUESS_VERSION, () => ({
+        count: 0,
+    }));
+}
 export function recordVerifiedPathAttributionGuess() {
-    verifiedGuessCount += 1;
+    verifiedGuessCount().count += 1;
 }
 export function getVerifiedPathAttributionGuessCount() {
-    return verifiedGuessCount;
+    return verifiedGuessCount().count;
 }
 export function emitVerifiedPathAttributionRollup(filePath) {
-    if (verifiedGuessCount === 0)
+    const cell = verifiedGuessCount();
+    if (cell.count === 0)
         return;
     logLatency({
         type: "phase",
         phase: "path_attribution_verified_rollup",
         filePath,
         durationMs: 0,
-        metadata: { count: verifiedGuessCount },
+        metadata: { count: cell.count },
     });
-    verifiedGuessCount = 0;
+    cell.count = 0;
 }
 export function resetVerifiedPathAttributionGuessCount() {
-    verifiedGuessCount = 0;
+    verifiedGuessCount().count = 0;
 }

package/node_modules/pi-lens/dist/clients/path-keyed-map.js

@@ -21,6 +21,9 @@
  * write (last-writer-wins), matching a plain `Map`'s "the key you set is the
  * key you see" intuition while still de-duplicating by normalized identity.
  *
+ * Optionally BOUNDED: pass `maxEntries` and the backing store becomes a
+ * `BoundedFifoMap` (see the constructor). Unbounded by default.
+ *
  * Choose the normalizer to match how the keyed state is used:
  *  - `normalizeEphemeralMapKey` (path-utils.ts) — cheap slash-fold +
  *    win32-lowercase, NO filesystem I/O — for hot, single-process, in-memory
@@ -28,11 +31,27 @@
  *  - `normalizeMapKey` — realpath-canonicalizing — for long-lived state shared
  *    across call sites where symlink/real-casing resolution matters.
  */
+import { BoundedFifoMap } from "./bounded-cache.js";
 export class PathKeyedMap {
     normalize;
-    store = new Map();
-    constructor(normalize) {
+    store;
+    /**
+     * `maxEntries` bounds the map with insertion-order (FIFO) eviction, on
+     * `BoundedFifoMap` — the repo's one eviction implementation (#2442). Omit
+     * it for an unbounded map. A path-keyed map that needs a bound gets it
+     * here rather than hand-rolling `keys().next().value` at the call site,
+     * which is what `PartialApplyRecordStore` did before #2442's review round.
+     *
+     * FIFO, not LRU, and evicting AFTER the write, not before: a `set` of an
+     * already-resident path is an update, and must not drop an unrelated file
+     * to make room for a key that needs none.
+     */
+    constructor(normalize, maxEntries) {
         this.normalize = normalize;
+        this.store =
+            maxEntries === undefined
+                ? new Map()
+                : new BoundedFifoMap(maxEntries);
     }
     get size() {
         return this.store.size;