@elaraai/east 1.0.83 → 1.0.85

package/dist/src/serialization/beast2/v5/stream.d.ts

@@ -405,6 +405,35 @@ export declare function encodeBeast2PagedFor<T extends EastType>(type: T | EastT
  * @throws {TypeError} When `type` is not an Array, Set or Dict type.
  */
 export declare function iterBeast2SegmentsFor<T extends EastType>(type: T | EastTypeValue, options?: Beast2DecodeOptions): (data: Uint8Array) => Generator<ValueTypeOf<T>>;
+/** Options accepted by {@link openBeast2PagesFor}: the decode options, and
+ *  what the reader's cache keeps. */
+export type Beast2PagesOptions = Beast2DecodeOptions & {
+    /**
+     * The decoded weight, in bytes, that the cache of the reader's element and
+     * keyed reads keeps of the segments they decode (v5/SPEC.md, "The pager's
+     * cache"). Defaults to 256 MiB. The segment read last always stays, so `1`
+     * keeps exactly one.
+     */
+    cacheBytes?: number;
+};
+/** What a {@link Beast2Pages}' cache has done, and what it holds: the figures
+ *  east-c's pager keeps (`east_beast2_pages_cache_stats`). */
+export type Beast2PagesCacheStats = {
+    /** Element and keyed reads a segment the cache held served. */
+    hits: number;
+    /** Segments let go, least recently used first, to keep within the budget. */
+    evictions: number;
+    /** Segments dropped behind a run of reads in key order. */
+    droppedBehind: number;
+    /** The segments it holds. */
+    segments: number;
+    /** Their decoded weight. */
+    weight: number;
+    /** The most decoded weight it has held. */
+    peakWeight: number;
+    /** Its budget, in decoded weight. */
+    budget: number;
+};
 /**
  * Random access over an indexed, self-contained v5 collection blob.
  *
@@ -412,9 +441,12 @@ export declare function iterBeast2SegmentsFor<T extends EastType>(type: T | East
  * {@link segment} seeks to and decodes exactly one segment. Requires the blob
  * to carry an index (written by default by {@link Beast2Writer}); random
  * access additionally requires self-contained segments. The element and keyed
- * read paths ({@link element} / {@link get}) reuse decoded segments through a
- * small LRU, so a read loop over neighbouring rows decodes each segment once
- * rather than once per element; {@link segment} itself always decodes fresh.
+ * read paths ({@link element} / {@link get}) keep the segments they decode in
+ * a cache of the reader's own — up to `cacheBytes` of decoded weight, least
+ * recently used first, and dropping behind reads in key order (v5/SPEC.md,
+ * "The pager's cache") — so a read loop over neighbouring rows decodes each
+ * segment once rather than once per element; {@link segment} itself always
+ * decodes fresh.
  *
  * The blob is either a whole `Uint8Array` or a {@link Beast2SyncRangeReader}:
  * through a reader the open reads only the tail (footer + index) and the
@@ -464,18 +496,72 @@ export declare class Beast2Pages<T extends EastType = EastType> {
     private fenceDec;
     /** The decoder of a manifest's stored fence bytes, built on first use. */
     private manifestFenceDec;
-    /** Decoded segments kept hot for the element and keyed read paths, keyed
-     *  by segment index in LRU order (mirrors east-c's `B2V5_PAGES_LRU`).
-     *  Only {@link element} and {@link get} route through it — the public
-     *  {@link segment} stays a fresh decode, so a caller mutating its result
-     *  cannot poison the cache. `first`/`last` carry a Set/Dict segment's key
-     *  range so a hit can maintain the caller's order threading without a
-     *  container walk. */
+    /** The decoded segments the element and keyed reads keep, by segment
+     *  index, least recently used first: the Map's order is the recency list,
+     *  and a hit moves its segment last. Only {@link element} and {@link get}
+     *  route through it: every scan — {@link segment}, {@link segmentDisjoint},
+     *  {@link slice} — decodes fresh. Its segments decode frozen, so a caller
+     *  cannot change what a later read is served through what one read
+     *  returned (#1129). `first`/`last` carry a Set/Dict segment's key range so
+     *  a hit can maintain the caller's order threading without a container
+     *  walk. */
     private readonly segmentCache;
+    /** The cache's budget, in decoded weight. */
+    private readonly cacheBudget;
+    /** The decoded weight of the segments the cache holds. */
+    private cacheWeight;
+    /** What the cache has done — see {@link cacheStats}. */
+    private cacheHits;
+    private cacheEvictions;
+    private cacheDropped;
+    private cachePeak;
+    /** Weighs a decoded segment; built on the first decode the cache keeps. */
+    private weighSegment;
+    /** Drop-behind: the segment the last miss read (-1 before any), the run's
+     *  misses so far, its first included, the first segment of the run not yet
+     *  dropped behind, and what the run marks the segments its misses decode. */
+    private runLast;
+    private runMisses;
+    private runNextDrop;
+    private runId;
+    /** Segments decoded so far — see {@link segmentsDecoded}. */
+    private decodes;
+    /** Fences probed so far — see {@link fencesProbed}. */
+    private probes;
+    /** The first key of each Set or Dict segment probed so far, by segment
+     *  index — see {@link firstKey}. */
+    private readonly keptFences;
     /** @internal Use {@link openBeast2PagesFor}. */
-    constructor(source: Uint8Array | Beast2SyncRangeReader | Beast2ManifestSource, typeValue: EastTypeValue, options?: Beast2DecodeOptions);
+    constructor(source: Uint8Array | Beast2SyncRangeReader | Beast2ManifestSource, typeValue: EastTypeValue, options?: Beast2PagesOptions);
     /** Number of segments in the blob. */
     get segmentCount(): number;
+    /**
+     * The segment decodes this reader has made: one per segment it decoded, and
+     * none for a read its kept segments served. A count above
+     * {@link segmentCount} says its reads decoded a segment again. With
+     * {@link fencesProbed}, what a reader's reads came to — the account east-c's
+     * pager keeps too.
+     */
+    get segmentsDecoded(): number;
+    /** The segment fences this reader has probed: each segment's first key it
+     *  decoded without the segment. A Set or Dict fence is probed once, whether
+     *  its keyed reads verify the fences or {@link fence} asks for one, and kept,
+     *  so asking for it again probes nothing; an Array's is probed each time. */
+    get fencesProbed(): number;
+    /**
+     * What the cache of the element and keyed reads has done, and what it holds
+     * now: the figures east-c's pager keeps, by the same rules (v5/SPEC.md, "The
+     * pager's cache").
+     */
+    get cacheStats(): Beast2PagesCacheStats;
+    /**
+     * Lets every segment the cache holds go, and forgets the run of reads in key
+     * order they were in: what a lazy value does once it has read its
+     * collection whole, after which its reads never come here again.
+     *
+     * @internal
+     */
+    clearCache(): void;
     /** Reads segment `i`'s frame — exactly its wire bytes, from its index
      *  offset to the next segment's (or the terminator) — and opens its
      *  logical chunk. The only place segment bytes are fetched, so a ranged
@@ -500,24 +586,48 @@ export declare class Beast2Pages<T extends EastType = EastType> {
      *   violates strict ascending order.
      */
     segment(i: number): ValueTypeOf<T>;
-    /** Seeks to and decodes segment `i`, threading the caller's order state. */
+    /** Seeks to and decodes segment `i`, threading the caller's order state.
+     *  `freeze` decodes it frozen whatever the pager was opened with: the
+     *  cache's segments are shared by every read they serve (#1129). */
     private decodeSegmentCore;
-    /** Decodes segment `i` through the LRU cache, threading the caller's
-     *  order state exactly as a fresh decode would: a hit replays the
-     *  boundary-ascent check against the cached segment's first key and
-     *  advances `order` to its last. Serves {@link element} and {@link get}
-     *  only — see {@link segmentCache}. */
+    /** Decodes segment `i` through the cache, threading the caller's order
+     *  state exactly as a fresh decode would: a hit replays the boundary-ascent
+     *  check against the cached segment's first key and advances `order` to its
+     *  last. A miss steps the run of misses ({@link runStep}), decodes the
+     *  segment frozen — every read it serves shares it — and weighs it, and the
+     *  least recently used go until the cache is within its budget; the newest
+     *  never does, so one segment over budget still caches. Serves
+     *  {@link element} and {@link get} only — see {@link segmentCache}. */
     private segmentCached;
+    /** A miss reading segment `s`: it continues the run of misses when it reads
+     *  one or two segments past the last — a join's lookups can skip a segment
+     *  holding no key they want — and starts a run otherwise. From the run's
+     *  fourth miss on ({@link RUN_DROPS_FROM}), what the run itself decoded, from
+     *  its first segment to two before `s`, is let go: a reader in key order
+     *  keeps the segment it is in and the one before. A reader at random lands
+     *  one or two past its last miss with odds of about 2 in the segment count
+     *  S, so three such misses in a row are (2/S)³ — 1 in 80,000 over 87
+     *  segments. Hits never touch the run. */
+    private runStep;
+    /** Lets cached segment `k` go. */
+    private letGo;
+    /** Segment `i`'s first key or element, probed ({@link probeFirstKey}) and
+     *  counted. A Set element or Dict key is immutable, so a Set or Dict fence
+     *  is kept and handed out again without a probe; an Array's first element
+     *  may be a container its caller changes, so it is probed afresh each time.
+     *  East values are never `undefined`, which marks a fence not yet kept. */
+    private firstKey;
     /** Decodes just the first key/element of segment `i` — a bounded probe
      *  (a prefix of the frame read and inflated, one element decode), not a
      *  whole-segment decode. A first key wider than the probe grows it; the
      *  final attempt reads the frame whole, so corruption is still reported
      *  with the frame's own error. */
-    private firstKey;
+    private probeFirstKey;
     /**
      * Probes segment `i`'s fence: its first Dict key, Set element, or Array
      * element, decoded without decoding the rest of the segment (one frame
-     * inflate, one element decode).
+     * inflate, one element decode). A Set or Dict fence is probed once per
+     * reader and kept, so asking for it again reads nothing.
      *
      * For Set/Dict roots the fences bound each segment's canonical key range —
      * segment `i` holds exactly the keys in `[fence(i), fence(i+1))` — which is
@@ -607,7 +717,11 @@ export declare class Beast2Pages<T extends EastType = EastType> {
     /**
      * Looks up one Set element or Dict value by key (Set/Dict roots only):
      * binary-searches the verified segment fences for the only segment whose
-     * range can hold the key, decodes it, and scans for an East-equal match.
+     * range can hold the key, decodes it (or takes it from the cache), and looks
+     * the key up in it. A segment is a SortedSet or SortedMap under the same
+     * East comparator, so the lookup is its B-tree's, O(log m) in a segment of m
+     * keys — as east-c looks a key up in its segment — and never a walk of the
+     * segment's entries.
      *
      * @param key - the Set element or Dict key to look up
      * @returns the Dict value (or the stored Set element) for `key`, or
@@ -627,9 +741,11 @@ export declare class Beast2Pages<T extends EastType = EastType> {
  * whose fences are already decoded, so a keyed read touches exactly one.
  *
  * @param type - the collection type (Array/Set/Dict)
- * @param options - decode options (platform functions for decoded functions)
- * @returns a function opening a blob for paged reads
+ * @param options - decode options (platform functions for decoded functions),
+ *   and the decoded weight the reader's cache keeps (`cacheBytes`)
+ * @returns a function opening a blob for paged reads, which throws a
+ *   `TypeError` when `cacheBytes` is negative or not a number
  * @throws {TypeError} When `type` is not an Array, Set or Dict type.
  */
-export declare function openBeast2PagesFor<T extends EastType>(type: T | EastTypeValue, options?: Beast2DecodeOptions): (source: Uint8Array | Beast2SyncRangeReader | Beast2ManifestSource) => Beast2Pages<T>;
+export declare function openBeast2PagesFor<T extends EastType>(type: T | EastTypeValue, options?: Beast2PagesOptions): (source: Uint8Array | Beast2SyncRangeReader | Beast2ManifestSource) => Beast2Pages<T>;
 //# sourceMappingURL=stream.d.ts.map

package/dist/src/serialization/beast2/v5/stream.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stream.d.ts","sourceRoot":"","sources":["../../../../../src/serialization/beast2/v5/stream.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"stream.d.ts","sourceRoot":"","sources":["../../../../../src/serialization/beast2/v5/stream.ts"],"names":[],"mappings":"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"}

package/dist/src/serialization/beast2/v5/stream.js

@@ -41,6 +41,7 @@ import { MAGIC_BYTES_V5, TAG_NEW, createV5EncodeContext, buildV5Encoder, buildV5
 import { TAG_OR_TERMINATOR_FRAME, bytesReader, isBeast2SyncRangeReader, readExact, readU64LE, readBeast2ExtentsSync } from "./range.js";
 import { SegmentCutter, decodeBeast2FenceFor } from "./boundary.js";
 import { isBeast2ManifestSource } from "./manifest.js";
+import { decodedWeightFor } from "./weight.js";
 /** Validates that a root type is streamable and returns its kind. */
 function checkSegmented(typeValue) {
     if (!isSegmentedRoot(typeValue)) {
@@ -914,12 +915,15 @@ export function iterBeast2SegmentsFor(type, options) {
 // =============================================================================
 // Paging reader
 // =============================================================================
-/** Decoded segments retained by a {@link Beast2Pages} for its element and
- *  keyed read paths (mirrors east-c's `B2V5_PAGES_LRU`): a keyed/indexed
- *  read loop over neighbouring rows then decodes each segment once instead
- *  of once per element. Bounded — at most this many decoded segments live
- *  per reader. */
-const SEGMENT_CACHE_CAPACITY = 4;
+/** The decoded weight a {@link Beast2Pages}' cache keeps by default: enough
+ *  for any input the query planner reads whole in each piece, which decodes to
+ *  at most about 16 times its stored 16 MiB (v5/SPEC.md, "The pager's
+ *  cache"). */
+const PAGES_CACHE_BYTES_DEFAULT = 256 * 1024 * 1024;
+/** The misses of a run — its first, then each one or two segments past the
+ *  last — from which it drops what it passed: one keyed read can straddle a
+ *  segment boundary, and four misses in order are not chance. */
+const RUN_DROPS_FROM = 4;
 /** The bytes a fence probe reads first: the frame header plus enough of the
  *  payload for the first key of any ordinary row. A key that does not fit
  *  grows the probe fourfold until it does, the final attempt reading the
@@ -932,9 +936,12 @@ const FENCE_PROBE_BYTES = 4096;
  * {@link segment} seeks to and decodes exactly one segment. Requires the blob
  * to carry an index (written by default by {@link Beast2Writer}); random
  * access additionally requires self-contained segments. The element and keyed
- * read paths ({@link element} / {@link get}) reuse decoded segments through a
- * small LRU, so a read loop over neighbouring rows decodes each segment once
- * rather than once per element; {@link segment} itself always decodes fresh.
+ * read paths ({@link element} / {@link get}) keep the segments they decode in
+ * a cache of the reader's own — up to `cacheBytes` of decoded weight, least
+ * recently used first, and dropping behind reads in key order (v5/SPEC.md,
+ * "The pager's cache") — so a read loop over neighbouring rows decodes each
+ * segment once rather than once per element; {@link segment} itself always
+ * decodes fresh.
  *
  * The blob is either a whole `Uint8Array` or a {@link Beast2SyncRangeReader}:
  * through a reader the open reads only the tail (footer + index) and the
@@ -984,16 +991,48 @@ export class Beast2Pages {
     fenceDec = null;
     /** The decoder of a manifest's stored fence bytes, built on first use. */
     manifestFenceDec = null;
-    /** Decoded segments kept hot for the element and keyed read paths, keyed
-     *  by segment index in LRU order (mirrors east-c's `B2V5_PAGES_LRU`).
-     *  Only {@link element} and {@link get} route through it — the public
-     *  {@link segment} stays a fresh decode, so a caller mutating its result
-     *  cannot poison the cache. `first`/`last` carry a Set/Dict segment's key
-     *  range so a hit can maintain the caller's order threading without a
-     *  container walk. */
+    /** The decoded segments the element and keyed reads keep, by segment
+     *  index, least recently used first: the Map's order is the recency list,
+     *  and a hit moves its segment last. Only {@link element} and {@link get}
+     *  route through it: every scan — {@link segment}, {@link segmentDisjoint},
+     *  {@link slice} — decodes fresh. Its segments decode frozen, so a caller
+     *  cannot change what a later read is served through what one read
+     *  returned (#1129). `first`/`last` carry a Set/Dict segment's key range so
+     *  a hit can maintain the caller's order threading without a container
+     *  walk. */
     segmentCache = new Map();
+    /** The cache's budget, in decoded weight. */
+    cacheBudget;
+    /** The decoded weight of the segments the cache holds. */
+    cacheWeight = 0;
+    /** What the cache has done — see {@link cacheStats}. */
+    cacheHits = 0;
+    cacheEvictions = 0;
+    cacheDropped = 0;
+    cachePeak = 0;
+    /** Weighs a decoded segment; built on the first decode the cache keeps. */
+    weighSegment = null;
+    /** Drop-behind: the segment the last miss read (-1 before any), the run's
+     *  misses so far, its first included, the first segment of the run not yet
+     *  dropped behind, and what the run marks the segments its misses decode. */
+    runLast = -1;
+    runMisses = 0;
+    runNextDrop = 0;
+    runId = 0;
+    /** Segments decoded so far — see {@link segmentsDecoded}. */
+    decodes = 0;
+    /** Fences probed so far — see {@link fencesProbed}. */
+    probes = 0;
+    /** The first key of each Set or Dict segment probed so far, by segment
+     *  index — see {@link firstKey}. */
+    keptFences = [];
     /** @internal Use {@link openBeast2PagesFor}. */
     constructor(source, typeValue, options) {
+        const cacheBytes = options?.cacheBytes ?? PAGES_CACHE_BYTES_DEFAULT;
+        if (!(cacheBytes >= 0)) {
+            throw new TypeError(`beast2 v5: cacheBytes is a decoded weight in bytes, 0 or more, not ${cacheBytes}`);
+        }
+        this.cacheBudget = cacheBytes;
         let kind;
         let sourceMap;
         let index;
@@ -1057,6 +1096,51 @@ export class Beast2Pages {
     get segmentCount() {
         return this.indexData.offsets.length;
     }
+    /**
+     * The segment decodes this reader has made: one per segment it decoded, and
+     * none for a read its kept segments served. A count above
+     * {@link segmentCount} says its reads decoded a segment again. With
+     * {@link fencesProbed}, what a reader's reads came to — the account east-c's
+     * pager keeps too.
+     */
+    get segmentsDecoded() {
+        return this.decodes;
+    }
+    /** The segment fences this reader has probed: each segment's first key it
+     *  decoded without the segment. A Set or Dict fence is probed once, whether
+     *  its keyed reads verify the fences or {@link fence} asks for one, and kept,
+     *  so asking for it again probes nothing; an Array's is probed each time. */
+    get fencesProbed() {
+        return this.probes;
+    }
+    /**
+     * What the cache of the element and keyed reads has done, and what it holds
+     * now: the figures east-c's pager keeps, by the same rules (v5/SPEC.md, "The
+     * pager's cache").
+     */
+    get cacheStats() {
+        return {
+            hits: this.cacheHits,
+            evictions: this.cacheEvictions,
+            droppedBehind: this.cacheDropped,
+            segments: this.segmentCache.size,
+            weight: this.cacheWeight,
+            peakWeight: this.cachePeak,
+            budget: this.cacheBudget,
+        };
+    }
+    /**
+     * Lets every segment the cache holds go, and forgets the run of reads in key
+     * order they were in: what a lazy value does once it has read its
+     * collection whole, after which its reads never come here again.
+     *
+     * @internal
+     */
+    clearCache() {
+        this.segmentCache.clear();
+        this.cacheWeight = 0;
+        this.runLast = -1;
+    }
     /** Reads segment `i`'s frame — exactly its wire bytes, from its index
      *  offset to the next segment's (or the terminator) — and opens its
      *  logical chunk. The only place segment bytes are fetched, so a ranged
@@ -1102,8 +1186,10 @@ export class Beast2Pages {
         const order = this.kind === "Array" ? undefined : { prev: undefined, has: false };
         return this.decodeSegmentCore(i, order);
     }
-    /** Seeks to and decodes segment `i`, threading the caller's order state. */
-    decodeSegmentCore(i, order) {
+    /** Seeks to and decodes segment `i`, threading the caller's order state.
+     *  `freeze` decodes it frozen whatever the pager was opened with: the
+     *  cache's segments are shared by every read they serve (#1129). */
+    decodeSegmentCore(i, order, freeze = false) {
         if (!this.selfContained) {
             throw new Error(`beast2 v5: blob has cross-segment aliasing — random access needs self-contained segments`);
         }
@@ -1115,23 +1201,28 @@ export class Beast2Pages {
         if (n !== this.indexData.counts[i]) {
             throw new Error(`beast2 v5: segment ${i} declares ${n} elements, index says ${this.indexData.counts[i]}`);
         }
-        const ctx = { containers: [], sourceMap: this.sourceMap, frozen: this.platform?.frozen ?? false, ...buildPlatformContext(this.platform) };
+        const ctx = { containers: [], sourceMap: this.sourceMap, frozen: freeze || (this.platform?.frozen ?? false), ...buildPlatformContext(this.platform) };
         const value = this.decodeSegment(reader, ctx, n, order);
         if (reader.offset !== reader.buffer.length) {
             throw new Error(`beast2 v5: ${reader.buffer.length - reader.offset} logical bytes after segment ${i}`);
         }
+        this.decodes++;
         return value;
     }
-    /** Decodes segment `i` through the LRU cache, threading the caller's
-     *  order state exactly as a fresh decode would: a hit replays the
-     *  boundary-ascent check against the cached segment's first key and
-     *  advances `order` to its last. Serves {@link element} and {@link get}
-     *  only — see {@link segmentCache}. */
+    /** Decodes segment `i` through the cache, threading the caller's order
+     *  state exactly as a fresh decode would: a hit replays the boundary-ascent
+     *  check against the cached segment's first key and advances `order` to its
+     *  last. A miss steps the run of misses ({@link runStep}), decodes the
+     *  segment frozen — every read it serves shares it — and weighs it, and the
+     *  least recently used go until the cache is within its budget; the newest
+     *  never does, so one segment over budget still caches. Serves
+     *  {@link element} and {@link get} only — see {@link segmentCache}. */
     segmentCached(i, order) {
         const hit = this.segmentCache.get(i);
         if (hit !== undefined) {
             this.segmentCache.delete(i);
-            this.segmentCache.set(i, hit); // refresh recency
+            this.segmentCache.set(i, hit); // the most recently used goes last
+            this.cacheHits++;
             if (order !== undefined && this.orderCmp !== null) {
                 if (order.has && this.orderCmp(order.prev, hit.first) >= 0) {
                     throw new Error(`beast2 v5: ${this.kind === "Dict" ? "Dict keys" : "Set elements"} are not strictly ascending in East order — the wire must hold the canonical value (corrupt or pre-contract blob)`);
@@ -1141,7 +1232,8 @@ export class Beast2Pages {
             }
             return hit.seg;
         }
-        const seg = this.decodeSegmentCore(i, order);
+        this.runStep(i);
+        const seg = this.decodeSegmentCore(i, order, true);
         let first;
         let last;
         if (this.kind !== "Array") {
@@ -1150,18 +1242,76 @@ export class Beast2Pages {
             // order state on the segment's last key.
             last = order?.prev;
         }
-        this.segmentCache.set(i, { seg, first, last });
-        if (this.segmentCache.size > SEGMENT_CACHE_CAPACITY) {
-            this.segmentCache.delete(this.segmentCache.keys().next().value);
+        this.weighSegment ??= decodedWeightFor(this.typeValue);
+        const weight = this.weighSegment(seg);
+        this.segmentCache.set(i, { seg, first, last, weight, run: this.runId });
+        this.cacheWeight += weight;
+        for (const [k, entry] of this.segmentCache) {
+            if (this.cacheWeight <= this.cacheBudget || k === i)
+                break;
+            this.letGo(k, entry);
+            this.cacheEvictions++;
         }
+        if (this.cacheWeight > this.cachePeak)
+            this.cachePeak = this.cacheWeight;
         return seg;
     }
+    /** A miss reading segment `s`: it continues the run of misses when it reads
+     *  one or two segments past the last — a join's lookups can skip a segment
+     *  holding no key they want — and starts a run otherwise. From the run's
+     *  fourth miss on ({@link RUN_DROPS_FROM}), what the run itself decoded, from
+     *  its first segment to two before `s`, is let go: a reader in key order
+     *  keeps the segment it is in and the one before. A reader at random lands
+     *  one or two past its last miss with odds of about 2 in the segment count
+     *  S, so three such misses in a row are (2/S)³ — 1 in 80,000 over 87
+     *  segments. Hits never touch the run. */
+    runStep(s) {
+        const last = this.runLast;
+        this.runLast = s;
+        if (last < 0 || s <= last || s - last > 2) {
+            this.runId++;
+            this.runMisses = 1;
+            this.runNextDrop = s;
+            return;
+        }
+        if (++this.runMisses < RUN_DROPS_FROM)
+            return;
+        for (let k = this.runNextDrop; k + 2 <= s; k++) {
+            const entry = this.segmentCache.get(k);
+            if (entry !== undefined && entry.run === this.runId) {
+                this.letGo(k, entry);
+                this.cacheDropped++;
+            }
+        }
+        if (s - 1 > this.runNextDrop)
+            this.runNextDrop = s - 1;
+    }
+    /** Lets cached segment `k` go. */
+    letGo(k, entry) {
+        this.segmentCache.delete(k);
+        this.cacheWeight -= entry.weight;
+    }
+    /** Segment `i`'s first key or element, probed ({@link probeFirstKey}) and
+     *  counted. A Set element or Dict key is immutable, so a Set or Dict fence
+     *  is kept and handed out again without a probe; an Array's first element
+     *  may be a container its caller changes, so it is probed afresh each time.
+     *  East values are never `undefined`, which marks a fence not yet kept. */
+    firstKey(i) {
+        const kept = this.keptFences[i];
+        if (kept !== undefined)
+            return kept;
+        const fence = this.probeFirstKey(i);
+        this.probes++;
+        if (this.kind !== "Array")
+            this.keptFences[i] = fence;
+        return fence;
+    }
     /** Decodes just the first key/element of segment `i` — a bounded probe
      *  (a prefix of the frame read and inflated, one element decode), not a
      *  whole-segment decode. A first key wider than the probe grows it; the
      *  final attempt reads the frame whole, so corruption is still reported
      *  with the frame's own error. */
-    firstKey(i) {
+    probeFirstKey(i) {
         // A manifest stores every fence already, so a bisect over one reads no
         // segment bytes at all — the whole point of carrying them.
         if (this.manifestSource !== null) {
@@ -1202,7 +1352,8 @@ export class Beast2Pages {
     /**
      * Probes segment `i`'s fence: its first Dict key, Set element, or Array
      * element, decoded without decoding the rest of the segment (one frame
-     * inflate, one element decode).
+     * inflate, one element decode). A Set or Dict fence is probed once per
+     * reader and kept, so asking for it again reads nothing.
      *
      * For Set/Dict roots the fences bound each segment's canonical key range —
      * segment `i` holds exactly the keys in `[fence(i), fence(i+1))` — which is
@@ -1426,7 +1577,11 @@ export class Beast2Pages {
     /**
      * Looks up one Set element or Dict value by key (Set/Dict roots only):
      * binary-searches the verified segment fences for the only segment whose
-     * range can hold the key, decodes it, and scans for an East-equal match.
+     * range can hold the key, decodes it (or takes it from the cache), and looks
+     * the key up in it. A segment is a SortedSet or SortedMap under the same
+     * East comparator, so the lookup is its B-tree's, O(log m) in a segment of m
+     * keys — as east-c looks a key up in its segment — and never a walk of the
+     * segment's entries.
      *
      * @param key - the Set element or Dict key to look up
      * @returns the Dict value (or the stored Set element) for `key`, or
@@ -1447,17 +1602,12 @@ export class Beast2Pages {
         const order = { prev: undefined, has: false };
         const segment = this.decodeDisjoint(this.segmentFor(key), order, fences, true);
         if (this.kind === "Set") {
-            for (const item of segment) {
-                if (this.orderCmp(item, key) === 0)
-                    return item;
-            }
-            return undefined;
-        }
-        for (const [k, v] of segment.entries()) {
-            if (this.orderCmp(k, key) === 0)
-                return v;
+            // The stored element, not the key asked with: the least at or above it,
+            // when that one is East-equal to it.
+            const at = segment.keys(key).next();
+            return !at.done && this.orderCmp(at.value, key) === 0 ? at.value : undefined;
         }
-        return undefined;
+        return segment.get(key);
     }
 }
 /**
@@ -1470,8 +1620,10 @@ export class Beast2Pages {
  * whose fences are already decoded, so a keyed read touches exactly one.
  *
  * @param type - the collection type (Array/Set/Dict)
- * @param options - decode options (platform functions for decoded functions)
- * @returns a function opening a blob for paged reads
+ * @param options - decode options (platform functions for decoded functions),
+ *   and the decoded weight the reader's cache keeps (`cacheBytes`)
+ * @returns a function opening a blob for paged reads, which throws a
+ *   `TypeError` when `cacheBytes` is negative or not a number
  * @throws {TypeError} When `type` is not an Array, Set or Dict type.
  */
 export function openBeast2PagesFor(type, options) {