@elaraai/east 1.0.55 → 1.0.57

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

@@ -22,6 +22,9 @@
 import {} from "../../../type_of_type.js";
 import { BufferWriter, BufferReader } from "../../binary-utils.js";
 import { SourceMap } from "../../../location.js";
+import { compareFor } from "../../../comparison.js";
+import { SortedSet } from "../../../containers/sortedset.js";
+import { SortedMap } from "../../../containers/sortedmap.js";
 import { buildPlatformContext } from "../shared.js";
 import { writeTypeSection, readTypeSection, asTypeValue } from "./type-section.js";
 import { FrameReader, writeFrame } from "./frames.js";
@@ -33,6 +36,13 @@ function checkSegmented(typeValue) {
     }
     return typeValue.type;
 }
+/** The East comparator over a stream's order key — Set elements or Dict
+ *  keys; `null` for Array roots, which have no order contract. */
+function orderCmpFor(typeValue, kind) {
+    if (kind === "Array")
+        return null;
+    return compareFor(kind === "Set" ? typeValue.value : typeValue.value.key);
+}
 // =============================================================================
 // Streaming writer
 // =============================================================================
@@ -68,6 +78,9 @@ export class Beast2Writer {
     ctx;
     encodeElems;
     index = [];
+    orderCmp;
+    lastKey;
+    hasLast = false;
     bytesWritten = 0;
     finished = false;
     /**
@@ -83,6 +96,7 @@ export class Beast2Writer {
         this.codec = options?.codec ?? "deflate";
         this.selfContained = options?.selfContained ?? true;
         this.withIndex = options?.index ?? true;
+        this.orderCmp = orderCmpFor(typeValue, this.kind);
         const sourceMap = options?.sourceMap ?? null;
         this.ctx = createV5EncodeContext(sourceMap, this.selfContained);
         const typeCtx = new Map();
@@ -123,8 +137,15 @@ export class Beast2Writer {
      * Empty batches are skipped — a segment count is never zero, so the stream
      * terminator stays unambiguous.
      *
+     * Set/Dict batches must continue the stream's strict East (key) order:
+     * segment content is the canonical value split at segment boundaries, so
+     * each batch must be internally ascending and start above the previous
+     * batch's last key. Pre-sort into batches (a `SortedMap`/`SortedSet` slice,
+     * or an external sort), or encode arrival order as an Array of entries.
+     *
      * @param batch - a value of the declared collection type
-     * @throws {Error} When called after {@link finish}.
+     * @throws {Error} When called after {@link finish}, or when a Set/Dict
+     *   batch violates the stream's strict ascending (key) order.
      */
     write(batch) {
         if (this.finished)
@@ -132,6 +153,8 @@ export class Beast2Writer {
         const count = this.kind === "Array" ? batch.length : batch.size;
         if (count === 0)
             return;
+        if (this.orderCmp)
+            this.checkAscent(batch);
         if (this.selfContained) {
             this.ctx.containerIndex.clear();
             this.ctx.segmentBaseDef = this.ctx.containerCount;
@@ -163,6 +186,20 @@ export class Beast2Writer {
         }
         this.emit(tail.toUint8Array());
     }
+    /** Validates that a Set/Dict batch continues the stream's strict ascent
+     *  in East (key) order — within the batch and against the previous batch. */
+    checkAscent(batch) {
+        const keys = this.kind === "Set" ? batch : batch.keys();
+        for (const k of keys) {
+            if (this.hasLast && this.orderCmp(this.lastKey, k) >= 0) {
+                throw new Error(`beast2 v5: ${this.kind} stream batches must be strictly ascending in East ` +
+                    `${this.kind === "Dict" ? "key" : "element"} order — segment content is the canonical value; ` +
+                    `pre-sort batches, or encode arrival order as an Array`);
+            }
+            this.lastKey = k;
+            this.hasLast = true;
+        }
+    }
     emit(bytes) {
         this.bytesWritten += bytes.length;
         this.sink(bytes);
@@ -218,6 +255,129 @@ export function encodeBeast2SegmentsFor(type, options) {
     };
 }
 // =============================================================================
+// Paged whole-value encode
+// =============================================================================
+/** Default element cap per segment for {@link encodeBeast2PagedFor}. Small
+ *  enough that one segment decodes cheaply, large enough that frames stay far
+ *  above the compression threshold and per-segment overhead (frame header +
+ *  index entry) is negligible. */
+export const BEAST2_PAGED_BATCH_DEFAULT = 1_000;
+/** Default wire-byte target per segment for {@link encodeBeast2PagedFor}.
+ *  Wide rows would otherwise make element-capped segments arbitrarily large —
+ *  and a paging reader decodes whole segments, so segment size IS the random-
+ *  access cost. Batching adapts toward this target from measured output. */
+export const BEAST2_PAGED_TARGET_BYTES_DEFAULT = 2 * 1024 * 1024;
+/** The probe batch that seeds the byte-adaptive batching — small, so one
+ *  pathologically wide first batch cannot blow past the target unmeasured. */
+const PAGED_PROBE_BATCH = 16;
+/**
+ * Builds a curried paged encoder: `encode(value)` writes one whole collection
+ * value as a segmented, self-contained, indexed v5 blob — `batchSize` elements
+ * per segment.
+ *
+ * The write-side sibling of {@link openBeast2PagesFor}: a blob written this
+ * way supports random access ({@link Beast2Pages.segment} /
+ * {@link Beast2Pages.element} / {@link Beast2Pages.slice}) without decoding
+ * the rest. Decoding the whole blob through the ordinary entry points yields
+ * exactly the input value. Note the bytes differ from the whole-value
+ * `encodeBeast2For` encode of the same value (segment framing is part of the
+ * bytes), so content-addressed stores hash the two forms differently.
+ *
+ * @param type - the collection type (Array/Set/Dict)
+ * @param options - batch size, codec, and source map options
+ * @returns a function encoding a collection value to an indexed v5 blob
+ * @throws {TypeError} When `type` is not an Array, Set or Dict type.
+ */
+export function encodeBeast2PagedFor(type, options) {
+    const typeValue = asTypeValue(type);
+    const kind = checkSegmented(typeValue);
+    const cmp = orderCmpFor(typeValue, kind);
+    const batchCap = Math.max(1, Math.floor(options?.batchSize ?? BEAST2_PAGED_BATCH_DEFAULT));
+    const targetBytes = Math.max(1, Math.floor(options?.targetSegmentBytes ?? BEAST2_PAGED_TARGET_BYTES_DEFAULT));
+    const writerOptions = {
+        ...(options?.codec !== undefined && { codec: options.codec }),
+        ...(options?.sourceMap !== undefined && { sourceMap: options.sourceMap }),
+    };
+    return (value) => {
+        const makeBatch = kind === "Array" ? (items) => items
+            : kind === "Set" ? (items) => new Set(items)
+                : (items) => new Map(items);
+        // Canonical source order: SortedSet/SortedMap iterate in East order
+        // already; a plain Set/Map (insertion order) is sorted first — segments
+        // must hold the canonical value, and the writer validates the ascent.
+        const iterable = kind === "Dict"
+            ? (value instanceof SortedMap
+                ? value.entries()
+                : [...value.entries()].sort((a, b) => cmp(a[0], b[0])))
+            : kind === "Set"
+                ? (value instanceof SortedSet
+                    ? value
+                    : [...value].sort(cmp))
+                : value;
+        // Byte-adaptive batching: a throwaway scratch encode of the first few
+        // elements measures the average wire size, and batches then target
+        // `targetSegmentBytes` (never above the element cap). Re-encoding the
+        // probe costs a handful of elements; the real stream starts with
+        // full-size, right-sized segments. Batching is a pure function of the
+        // value, so the bytes stay deterministic for content-addressing.
+        const items = iterable[Symbol.iterator]();
+        const probe = [];
+        while (probe.length < PAGED_PROBE_BATCH) {
+            const n = items.next();
+            if (n.done)
+                break;
+            probe.push(n.value);
+        }
+        let nextBatch = batchCap;
+        if (probe.length > 0) {
+            let scratchBytes = 0;
+            let scratchHeader = 0;
+            const scratch = new Beast2Writer(typeValue, (b) => { scratchBytes += b.length; }, writerOptions);
+            scratchHeader = scratchBytes;
+            scratch.write(makeBatch(probe));
+            const avg = Math.max(1, (scratchBytes - scratchHeader) / probe.length);
+            nextBatch = Math.max(1, Math.min(batchCap, Math.floor(targetBytes / avg)));
+        }
+        const chunks = [];
+        let bodyBytes = 0;
+        const writer = new Beast2Writer(typeValue, (b) => {
+            chunks.push(b);
+            bodyBytes += b.length;
+        }, writerOptions);
+        const headerBytes = bodyBytes;
+        let written = 0;
+        let batch = [];
+        const flush = () => {
+            if (batch.length === 0)
+                return;
+            writer.write(makeBatch(batch));
+            written += batch.length;
+            batch = [];
+            // Refine toward the target as real output accumulates (drifting data).
+            const avg = Math.max(1, (bodyBytes - headerBytes) / written);
+            nextBatch = Math.max(1, Math.min(batchCap, Math.floor(targetBytes / avg)));
+        };
+        const pump = (item) => {
+            batch.push(item);
+            if (batch.length >= nextBatch)
+                flush();
+        };
+        for (const p of probe)
+            pump(p);
+        for (let n = items.next(); !n.done; n = items.next())
+            pump(n.value);
+        flush();
+        writer.finish();
+        const out = new Uint8Array(bodyBytes);
+        let pos = 0;
+        for (const c of chunks) {
+            out.set(c, pos);
+            pos += c.length;
+        }
+        return out;
+    };
+}
+// =============================================================================
 // Segment iterator
 // =============================================================================
 /** Verifies the v5 magic without dispatching (stream APIs are v5-only). */
@@ -243,16 +403,30 @@ function openSegmented(data, typeValue) {
     const sourceMap = readSourceMapSectionV5(reader);
     return { kind, sourceMap, frameOffset: reader.offset };
 }
-/** Builds the per-segment decode closure shared by the iterator and pages. */
+/** Builds the per-segment decode closure shared by the iterator and pages.
+ *
+ *  For Set/Dict, an `order` state threads the strict-ascent validation: each
+ *  decoded element/key must exceed `order.prev`. Passing one state across
+ *  consecutive segments extends the check over the segment boundary; a fresh
+ *  state validates a single segment in isolation. Violations are corruption
+ *  (the wire must hold the canonical value), never data to repair. */
 function buildSegmentDecoder(typeValue, kind) {
     const typeCtx = new Map();
+    const cmp = orderCmpFor(typeValue, kind);
     if (kind === "Dict") {
         const key = buildV5Decoder(typeValue.value.key, typeCtx);
         const val = buildV5Decoder(typeValue.value.value, typeCtx);
-        return (reader, ctx, n) => {
+        return (reader, ctx, n, order) => {
             const map = new Map();
             for (let i = 0; i < n; i++) {
                 const k = key(reader, ctx);
+                if (order) {
+                    if (order.has && cmp(order.prev, k) >= 0) {
+                        throw new Error(`beast2 v5: Dict keys are not strictly ascending in East order — the wire must hold the canonical value (corrupt or pre-contract blob)`);
+                    }
+                    order.prev = k;
+                    order.has = true;
+                }
                 const v = val(reader, ctx);
                 map.set(k, v);
             }
@@ -261,10 +435,19 @@ function buildSegmentDecoder(typeValue, kind) {
     }
     const elem = buildV5Decoder(typeValue.value, typeCtx);
     if (kind === "Set") {
-        return (reader, ctx, n) => {
+        return (reader, ctx, n, order) => {
             const set = new Set();
-            for (let i = 0; i < n; i++)
-                set.add(elem(reader, ctx));
+            for (let i = 0; i < n; i++) {
+                const item = elem(reader, ctx);
+                if (order) {
+                    if (order.has && cmp(order.prev, item) >= 0) {
+                        throw new Error(`beast2 v5: Set elements are not strictly ascending in East order — the wire must hold the canonical value (corrupt or pre-contract blob)`);
+                    }
+                    order.prev = item;
+                    order.has = true;
+                }
+                set.add(item);
+            }
             return set;
         };
     }
@@ -301,13 +484,16 @@ export function iterBeast2SegmentsFor(type, options) {
         // The root container is definition 0 — segments never alias it, but the
         // definition numbering must match the writer's.
         ctx.containers.push(kind === "Array" ? [] : kind === "Set" ? new Set() : new Map());
+        // One order state across all segments: Set/Dict streams must ascend
+        // strictly over the whole stream, including across segment boundaries.
+        const order = kind === "Array" ? undefined : { prev: undefined, has: false };
         for (;;) {
             if (reader.offset === reader.buffer.length)
                 reader = cursor.next();
             const n = reader.readVarint();
             if (n === 0)
                 break;
-            yield decodeSegment(reader, ctx, n);
+            yield decodeSegment(reader, ctx, n, order);
         }
         if (reader.offset !== reader.buffer.length) {
             throw new Error(`beast2 v5: ${reader.buffer.length - reader.offset} logical bytes after the root terminator`);
@@ -328,23 +514,37 @@ export function iterBeast2SegmentsFor(type, options) {
  * {@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.
+ *
+ * Set/Dict blobs page like Arrays: the wire holds the canonical value split
+ * at segment boundaries (strictly ascending, disjoint segments), so row
+ * windows ({@link slice}) and key lookups ({@link get}) address the sorted
+ * order directly. The first Set/Dict access verifies the segment fences
+ * (each segment's first key, probed without decoding whole segments) ascend
+ * strictly, and every decoded segment is validated internally and against
+ * the next fence — a blob violating the canonical-order contract fails with
+ * a corruption error rather than mis-addressing rows.
  */
 export class Beast2Pages {
     /** Per-segment element counts from the index (pairs for Dict roots). */
     counts;
-    /** Sum of all segment counts. For Array roots this is the exact element
-     *  count; for Set/Dict roots it is an upper bound (cross-segment duplicate
-     *  keys collapse on merge). */
+    /** Sum of all segment counts — the exact element (pair) count for every
+     *  root kind: Set/Dict segments are disjoint ranges of the canonical
+     *  value, so counts never overlap. */
     elementCount;
     /** Whether segments are independently decodable. */
     selfContained;
     data;
     indexData;
     kind;
+    typeValue;
     sourceMap;
     decodeSegment;
     platform;
     cumulative;
+    orderCmp;
+    /** First key/element of each segment, in segment order (Set/Dict only). */
+    fences = null;
+    fenceDec = null;
     /** @internal Use {@link openBeast2PagesFor}. */
     constructor(data, typeValue, options) {
         const { kind, sourceMap, frameOffset } = openSegmented(data, typeValue);
@@ -356,12 +556,14 @@ export class Beast2Pages {
         this.data = data;
         this.indexData = index;
         this.kind = kind;
+        this.typeValue = typeValue;
         this.sourceMap = sourceMap;
         this.decodeSegment = buildSegmentDecoder(typeValue, kind);
         this.platform = options;
         this.counts = index.counts;
         this.elementCount = index.totalCount;
         this.selfContained = index.selfContained;
+        this.orderCmp = orderCmpFor(typeValue, kind);
         this.cumulative = new Array(index.counts.length);
         let sum = 0;
         for (let i = 0; i < index.counts.length; i++) {
@@ -376,12 +578,22 @@ export class Beast2Pages {
     /**
      * Decodes one segment by index.
      *
+     * Set/Dict segments are validated for strict internal ascent as they
+     * decode (the canonical-order contract); a violation is a corruption
+     * error, not data.
+     *
      * @param i - zero-based segment index
      * @returns the segment's decoded collection
      * @throws {Error} When the blob is not self-contained (segments cannot be
-     *   decoded independently) or `i` is out of range.
+     *   decoded independently), `i` is out of range, or a Set/Dict segment
+     *   violates strict ascending order.
      */
     segment(i) {
+        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) {
         if (!this.selfContained) {
             throw new Error(`beast2 v5: blob has cross-segment aliasing — random access needs self-contained segments`);
         }
@@ -395,12 +607,67 @@ export class Beast2Pages {
             throw new Error(`beast2 v5: segment ${i} declares ${n} elements, index says ${this.indexData.counts[i]}`);
         }
         const ctx = { containers: [], sourceMap: this.sourceMap, ...buildPlatformContext(this.platform) };
-        const value = this.decodeSegment(reader, ctx, n);
+        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}`);
         }
         return value;
     }
+    /** Decodes just the first key/element of segment `i` — a bounded probe
+     *  (one frame inflate, one element decode), not a whole-segment decode. */
+    firstKey(i) {
+        if (!this.fenceDec) {
+            const keyType = this.kind === "Set" ? this.typeValue.value : this.typeValue.value.key;
+            this.fenceDec = buildV5Decoder(keyType);
+        }
+        const cursor = new FrameReader(this.data, this.indexData.offsets[i]);
+        const reader = cursor.next();
+        reader.readVarint(); // element count — segments are never empty
+        const ctx = { containers: [], sourceMap: this.sourceMap, ...buildPlatformContext(this.platform) };
+        return this.fenceDec(reader, ctx);
+    }
+    /** Probes and verifies the segment fences once: each segment's first
+     *  key/element must ascend strictly across segments. */
+    verifyFences() {
+        if (this.fences)
+            return this.fences;
+        if (!this.selfContained) {
+            throw new Error(`beast2 v5: blob has cross-segment aliasing — random access needs self-contained segments`);
+        }
+        const n = this.indexData.offsets.length;
+        const fences = new Array(n);
+        for (let i = 0; i < n; i++)
+            fences[i] = this.firstKey(i);
+        for (let i = 1; i < n; i++) {
+            if (this.orderCmp(fences[i - 1], fences[i]) >= 0) {
+                throw new Error(`beast2 v5: segments ${i - 1} and ${i} are not disjoint ascending ${this.kind === "Dict" ? "key" : "element"} ranges — the wire must hold the canonical value (corrupt or pre-contract blob)`);
+            }
+        }
+        this.fences = fences;
+        return fences;
+    }
+    /** Decodes segment `i` with order threading, then checks its tail stays
+     *  below the next segment's fence (segments must be disjoint ranges). */
+    decodeDisjoint(i, order, fences) {
+        const value = this.decodeSegmentCore(i, order);
+        if (i + 1 < fences.length && order.has && this.orderCmp(order.prev, fences[i + 1]) >= 0) {
+            throw new Error(`beast2 v5: segments ${i} and ${i + 1} are not disjoint ascending ${this.kind === "Dict" ? "key" : "element"} ranges — the wire must hold the canonical value (corrupt or pre-contract blob)`);
+        }
+        return value;
+    }
+    /** Binary-searches the cumulative counts for the segment owning `row`,
+     *  returning its index and the global row of its first element. */
+    rowSegment(row) {
+        let lo = 0, hi = this.cumulative.length - 1;
+        while (lo < hi) {
+            const mid = (lo + hi) >> 1;
+            if (this.cumulative[mid] <= row)
+                lo = mid + 1;
+            else
+                hi = mid;
+        }
+        return { seg: lo, base: lo === 0 ? 0 : this.cumulative[lo - 1] };
+    }
     /**
      * Reads one element by row index (Array roots only): binary-searches the
      * index, decodes that single segment, and returns the row.
@@ -416,18 +683,135 @@ export class Beast2Pages {
         if (row < 0 || row >= this.elementCount) {
             throw new Error(`beast2 v5: element ${row} out of range (${this.elementCount} elements)`);
         }
-        // Binary search the cumulative counts for the owning segment.
-        let lo = 0, hi = this.cumulative.length - 1;
+        const { seg, base } = this.rowSegment(row);
+        const segment = this.segment(seg);
+        return segment[row - base];
+    }
+    /**
+     * Reads a window of the collection by row range, decoding only the
+     * segments the window touches.
+     *
+     * Rows address stream order — for Array roots the element order, for
+     * Set/Dict roots the canonical East (key) order, since segments are
+     * disjoint ascending ranges. Returns a collection value of the root kind
+     * holding the window (an array, `Set`, or `Map` in that order).
+     *
+     * Clamps like `Array.prototype.slice`: a window past the end returns the
+     * available tail (or an empty collection), never throws for being short.
+     *
+     * @param offset - zero-based row of the window's first element
+     * @param limit - maximum number of elements (pairs) to return
+     * @returns a collection of the root kind with the window's contents
+     * @throws {Error} When `offset`/`limit` are negative or fractional, the
+     *   blob is not self-contained, or a Set/Dict blob violates the
+     *   canonical-order contract (non-ascending or overlapping segments).
+     */
+    slice(offset, limit) {
+        if (!Number.isInteger(offset) || offset < 0 || !Number.isInteger(limit) || limit < 0) {
+            throw new Error(`beast2 v5: slice(${offset}, ${limit}) — offset and limit must be non-negative integers`);
+        }
+        const empty = () => this.kind === "Array" ? [] : this.kind === "Set" ? new Set() : new Map();
+        if (limit === 0 || offset >= this.elementCount)
+            return empty();
+        if (this.kind === "Array") {
+            const out = [];
+            let { seg, base } = this.rowSegment(offset);
+            while (out.length < limit && seg < this.cumulative.length) {
+                const segment = this.segment(seg);
+                for (let i = Math.max(0, offset - base); i < segment.length && out.length < limit; i++) {
+                    out.push(segment[i]);
+                }
+                base += segment.length;
+                seg++;
+            }
+            return out;
+        }
+        // Set/Dict: rows address the canonical sorted order. Verify the fence
+        // chain once, then decode the touched segments with one running order
+        // state (validating ascent inside and across them) and a tail check
+        // against the fence of the first untouched segment.
+        const fences = this.verifyFences();
+        const isSet = this.kind === "Set";
+        const out = (isSet ? new Set() : new Map());
+        let taken = 0;
+        let { seg, base } = this.rowSegment(offset);
+        const order = { prev: undefined, has: false };
+        while (taken < limit && seg < this.cumulative.length) {
+            const segment = this.decodeDisjoint(seg, order, fences);
+            let skip = Math.max(0, offset - base);
+            if (isSet) {
+                for (const item of segment) {
+                    if (skip > 0) {
+                        skip--;
+                        continue;
+                    }
+                    if (taken >= limit)
+                        break;
+                    out.add(item);
+                    taken++;
+                }
+            }
+            else {
+                for (const [k, v] of segment.entries()) {
+                    if (skip > 0) {
+                        skip--;
+                        continue;
+                    }
+                    if (taken >= limit)
+                        break;
+                    out.set(k, v);
+                    taken++;
+                }
+            }
+            base += segment.size;
+            seg++;
+        }
+        return out;
+    }
+    /**
+     * 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.
+     *
+     * @param key - the Set element or Dict key to look up
+     * @returns the Dict value (or the stored Set element) for `key`, or
+     *   `undefined` when the collection does not contain it
+     * @throws {Error} When the root is an Array, the blob is not
+     *   self-contained, or the blob violates the canonical-order contract.
+     */
+    get(key) {
+        if (this.kind === "Array") {
+            throw new Error(`beast2 v5: get() addresses Set and Dict roots; this blob holds Array — use element() or slice()`);
+        }
+        if (this.elementCount === 0)
+            return undefined;
+        const fences = this.verifyFences();
+        // Greatest segment whose fence is <= key; a key below every fence is
+        // below the collection's minimum.
+        let lo = 0, hi = fences.length - 1;
+        if (this.orderCmp(key, fences[0]) < 0)
+            return undefined;
         while (lo < hi) {
-            const mid = (lo + hi) >> 1;
-            if (this.cumulative[mid] <= row)
-                lo = mid + 1;
+            const mid = (lo + hi + 1) >> 1;
+            if (this.orderCmp(fences[mid], key) <= 0)
+                lo = mid;
             else
-                hi = mid;
+                hi = mid - 1;
+        }
+        const order = { prev: undefined, has: false };
+        const segment = this.decodeDisjoint(lo, order, fences);
+        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;
         }
-        const base = lo === 0 ? 0 : this.cumulative[lo - 1];
-        const seg = this.segment(lo);
-        return seg[row - base];
+        return undefined;
     }
 }
 /**