@elaraai/east 1.0.78 → 1.0.80

package/dist/src/serialization/beast2/v5/sha256.spec.js

@@ -0,0 +1,42 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * SHA-256, the name of every object a manifest directory holds: the FIPS
+ * 180-4 vectors, pinned in east-c's `tests/test_sha256.c` as well, and
+ * agreement with Node's own digest at every length across the padding
+ * boundaries.
+ */
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { createHash } from "node:crypto";
+import { sha256Hex } from "../index.js";
+describe("sha256Hex", () => {
+    test("matches the FIPS 180-4 vectors", () => {
+        const of = (s) => sha256Hex(new TextEncoder().encode(s));
+        assert.equal(of(""), "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855");
+        assert.equal(of("abc"), "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad");
+        assert.equal(of("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"), "248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1");
+        assert.equal(sha256Hex(new Uint8Array(1_000_000).fill(0x61)), "cdc76e5c9914fb9281a1c7e284d73e67f1809a48a497200e046d39ccc7112cd0");
+    });
+    test("agrees with Node's digest at every length across the padding boundaries", () => {
+        // Lengths 55, 56 and 64 are where the length field moves to a second
+        // block, and where the rest is empty.
+        let seed = 0x9e3779b9;
+        for (let n = 0; n <= 300; n++) {
+            const bytes = new Uint8Array(n);
+            for (let i = 0; i < n; i++) {
+                seed = (Math.imul(seed, 1664525) + 1013904223) >>> 0;
+                bytes[i] = seed >>> 24;
+            }
+            assert.equal(sha256Hex(bytes), createHash("sha256").update(bytes).digest("hex"), `length ${n}`);
+        }
+    });
+    test("hashes a view by its own bytes, not its buffer's", () => {
+        const buffer = new Uint8Array(200).map((_, i) => i);
+        const view = buffer.subarray(37, 150);
+        assert.equal(sha256Hex(view), createHash("sha256").update(view).digest("hex"));
+    });
+});
+//# sourceMappingURL=sha256.spec.js.map

package/dist/src/serialization/beast2/v5/sha256.spec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sha256.spec.js","sourceRoot":"","sources":["../../../../../src/serialization/beast2/v5/sha256.spec.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;GAKG;AAEH,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAC3C,OAAO,MAAM,MAAM,oBAAoB,CAAC;AACxC,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAExC,QAAQ,CAAC,WAAW,EAAE,GAAG,EAAE;IACzB,IAAI,CAAC,gCAAgC,EAAE,GAAG,EAAE;QAC1C,MAAM,EAAE,GAAG,CAAC,CAAS,EAAU,EAAE,CAAC,SAAS,CAAC,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;QACzE,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,kEAAkE,CAAC,CAAC;QACzF,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,EAAE,kEAAkE,CAAC,CAAC;QAC5F,MAAM,CAAC,KAAK,CACV,EAAE,CAAC,0DAA0D,CAAC,EAC9D,kEAAkE,CACnE,CAAC;QACF,MAAM,CAAC,KAAK,CACV,SAAS,CAAC,IAAI,UAAU,CAAC,SAAS,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,EAC/C,kEAAkE,CACnE,CAAC;IACJ,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,yEAAyE,EAAE,GAAG,EAAE;QACnF,qEAAqE;QACrE,sCAAsC;QACtC,IAAI,IAAI,GAAG,UAAU,CAAC;QACtB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC;YAC9B,MAAM,KAAK,GAAG,IAAI,UAAU,CAAC,CAAC,CAAC,CAAC;YAChC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;gBAC3B,IAAI,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,OAAO,CAAC,GAAG,UAAU,CAAC,KAAK,CAAC,CAAC;gBACrD,KAAK,CAAC,CAAC,CAAC,GAAG,IAAI,KAAK,EAAE,CAAC;YACzB,CAAC;YACD,MAAM,CAAC,KAAK,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,UAAU,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,UAAU,CAAC,EAAE,CAAC,CAAC;QAClG,CAAC;IACH,CAAC,CAAC,CAAC;IAEH,IAAI,CAAC,kDAAkD,EAAE,GAAG,EAAE;QAC5D,MAAM,MAAM,GAAG,IAAI,UAAU,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC;QACpD,MAAM,IAAI,GAAG,MAAM,CAAC,QAAQ,CAAC,EAAE,EAAE,GAAG,CAAC,CAAC;QACtC,MAAM,CAAC,KAAK,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,UAAU,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;IACjF,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC"}

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

@@ -5,9 +5,15 @@
 /**
  * Beast2 v5 streaming and paging APIs.
  *
+ * - {@link Beast2ElementWriter} — the canonical writer: elements in, segments
+ *   out where the content-defined cut rule places them, so a collection's
+ *   bytes are a function of its value alone — as one blob, or as the
+ *   standalone segment blobs a manifest names. Every writer of a stored
+ *   collection writes through it.
+ * - {@link encodeBeast2PagedFor} — one whole value through the element writer.
  * - {@link Beast2Writer} — append-only streaming writer: each `write(batch)`
  *   becomes one root segment (one frame), so writer memory is O(batch), never
- *   the whole collection.
+ *   the whole collection. The geometry is the caller's.
  * - {@link encodeBeast2SegmentsFor} — in-memory convenience over the writer.
  * - {@link iterBeast2SegmentsFor} — sequential segment iterator: yields one
  *   decoded collection per root segment with O(segment) decoded memory.
@@ -15,22 +21,28 @@
  *   `elementCount`, per-segment decode via footer + index seeks.
  *
  * Streaming roots are collections (Array/Set/Dict). Writers default to
- * self-contained segments (aliasing scoped per segment) so their output is
- * pageable and parallel-decodable; pass `selfContained: false` to keep
- * whole-stream aliasing at the cost of random access.
+ * self-contained output — aliasing scoped per root element — so segments are
+ * pageable and parallel-decodable and an element's bytes depend on the element
+ * alone; pass `selfContained: false` to keep whole-stream aliasing at the cost
+ * of random access.
  */
 import { type EastTypeValue } from "../../../type_of_type.js";
-import type { EastType, ValueTypeOf } from "../../../types.js";
+import type { ArrayType, DictType, EastType, SetType, ValueTypeOf } from "../../../types.js";
+import { BufferWriter } from "../../binary-utils.js";
 import { SourceMap } from "../../../location.js";
 import { type Beast2DecodeOptions } from "../shared.js";
 import { type Beast2Codec } from "./frames.js";
 import { type Beast2SyncRangeReader } from "./range.js";
+import { type Beast2ManifestSource } from "./manifest.js";
 /** Options accepted by {@link Beast2Writer} and {@link encodeBeast2SegmentsFor}. */
 export type Beast2WriterOptions = {
     /** Per-frame codec. Defaults to `"deflate"`. */
     codec?: Beast2Codec;
-    /** Scope aliasing per segment so the output is pageable and segments decode
-     *  independently. Defaults to `true`. */
+    /** Scope aliasing per root element, so segments decode independently and an
+     *  element's bytes never depend on which objects its neighbours share: the
+     *  same collection encodes to the same bytes however it was built, and an
+     *  encoded element can move between segments by byte copy. Defaults to
+     *  `true`. */
     selfContained?: boolean;
     /** Write the trailing index + footer at {@link Beast2Writer.finish}.
      *  Defaults to `true`. */
@@ -46,14 +58,10 @@ export type Beast2WriterOptions = {
     /**
      * Deflate frames on worker threads (issue #763). Defaults to `false`.
      *
-     * The bytes are identical either way — frames reach the sink in order and
-     * index offsets are assigned as they land — but with frames in flight the
-     * sink has only received the ones already done. A caller that sizes its
-     * next batch from the bytes written must therefore read
-     * {@link Beast2Writer.emittedBounds} rather than count sink bytes, or its
-     * segmentation would depend on thread timing. The pool has one worker per
-     * CPU the process may use, at most 32 — a writer keeps two frames per worker
-     * in flight, and throughput flattens well before that. Node only; elsewhere,
+     * The bytes are identical either way: frames reach the sink in order, and
+     * index offsets are assigned as they land. The pool has one worker per CPU
+     * the process may use, at most 32 — a writer keeps two frames per worker in
+     * flight, and throughput flattens well before that. Node only; elsewhere,
      * and on a single CPU, the writer frames inline.
      */
     parallel?: boolean;
@@ -68,6 +76,10 @@ export type Beast2WriterOptions = {
  * {@link finish} appends the terminator (plus index and footer by default),
  * so the byte stream is append-only end to end.
  *
+ * Where the segments fall is the caller's choice here. A collection that is
+ * stored is written through {@link Beast2ElementWriter} instead, which cuts
+ * where the content-defined rule says, so equal values store as equal bytes.
+ *
  * @example
  * ```ts
  * const chunks: Uint8Array[] = [];
@@ -84,7 +96,6 @@ export declare class Beast2Writer<T extends EastType = EastType> {
     segments: number;
     private readonly kind;
     private readonly sink;
-    private readonly codec;
     private readonly selfContained;
     private readonly withIndex;
     private readonly ctx;
@@ -95,15 +106,9 @@ export declare class Beast2Writer<T extends EastType = EastType> {
     private hasLast;
     private bytesWritten;
     private finished;
-    private readonly parallel;
-    /** `undefined` until decided; `null` when frames are written inline. */
-    private pool;
-    private logicalWritten;
-    /** Frames submitted to the pool and not yet on the sink, in order. */
-    private readonly inflight;
-    private inflightLogical;
-    /** {@link settle} calls that found frames in flight. */
-    private settlesInflight;
+    /** Frames each segment and puts it on the sink as it lands, recording its
+     *  index entry there. */
+    private readonly frames;
     /**
      * @param type - the collection type this stream holds (Array/Set/Dict)
      * @param sink - receives output bytes as they are produced
@@ -133,37 +138,34 @@ export declare class Beast2Writer<T extends EastType = EastType> {
      */
     write(batch: ValueTypeOf<T>): void;
     /**
-     * Brackets the total bytes the writer will have passed to its sink once
-     * every in-flight frame lands.
+     * Writes one root segment from elements that are already encoded — each in
+     * its canonical bytes, with aliasing scoped to itself — which is how
+     * {@link Beast2ElementWriter} writes the segments it cuts.
+     *
+     * The elements are copied before this returns, so the caller may reuse the
+     * buffer. Their order is the caller's to keep: nothing here decodes them to
+     * check a Set or Dict's ascent.
      *
-     * `lo` is exactly the bytes the sink has received; `hi` adds each
-     * in-flight frame's logical bytes plus a header bound (a frame's payload
-     * never exceeds its logical bytes). A serial writer has `lo === hi`. A
-     * decision that is monotone in the byte count — the paged encoders' batch
-     * refinement — is exact when it agrees at both bounds; otherwise
-     * {@link settle} first.
+     * @param count - the elements (pairs, for a Dict) the bytes hold; a
+     *   zero-count segment is skipped
+     * @param elements - the elements' bytes, back to back
+     * @throws {Error} When called after {@link finish}, or — for a parallel
+     *   writer — when a frame worker failed (see {@link write}).
+     */
+    writeEncodedSegment(count: number, elements: Uint8Array): void;
+    /** Frames one segment's logical bytes — inline, or on the frame pool — and
+     *  records its index entry as its frame lands. */
+    private frameSegment;
+    /**
+     * Waits for every in-flight frame and passes it to the sink, so the sink
+     * holds every segment written so far. A writer about to go quiet then holds
+     * nothing on the pool, which lets an idle pool retire its workers. A no-op
+     * for a serial writer.
      *
-     * @returns the bounds, in bytes
+     * @throws {Error} For a parallel writer, when an in-flight frame's worker
+     *   failed or stopped responding (see {@link write}).
      */
-    emittedBounds(): {
-        lo: number;
-        hi: number;
-    };
-    /** Waits for every in-flight frame and passes it to the sink, after which
-     *  {@link emittedBounds} is exact. A no-op for a serial writer. */
     settle(): void;
-    /** The pool to frame on — decided once a parallel writer has produced
-     *  enough bytes to be worth it. While frames are in flight the writer keeps
-     *  the pool they are on, so frames cannot interleave out of order; with none
-     *  in flight it follows the process's current pool — a new one after an idle
-     *  pool retired its workers, `null` once a pool has lost a worker — so a
-     *  writer never submits to terminated workers. A writer demoted to inline
-     *  framing stays inline. */
-    private poolFor;
-    /** Passes the done frames at the head of the in-flight queue to the sink,
-     *  in order, assigning index offsets as they land; blocks until at least
-     *  `minimum` have been passed (`Infinity` settles the queue). */
-    private appendFrames;
     /**
      * Terminates the stream: writes the terminator frame and, unless disabled,
      * the index and footer. Idempotent.
@@ -188,31 +190,186 @@ export declare class Beast2Writer<T extends EastType = EastType> {
  * @throws {TypeError} When `type` is not an Array, Set or Dict type.
  */
 export declare function encodeBeast2SegmentsFor<T extends EastType>(type: T | EastTypeValue, options?: Beast2WriterOptions): (batches: Iterable<ValueTypeOf<T>>) => Uint8Array;
-/** 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 declare const BEAST2_PAGED_BATCH_DEFAULT = 1000;
-/** 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 declare const BEAST2_PAGED_TARGET_BYTES_DEFAULT: number;
-/** The probe batch that seeds the byte-adaptive batching — small, so one
- *  pathologically wide first batch cannot blow past the target unmeasured.
- *  Exported so every writer of a collection blob seeds the same way: an
- *  emit sink that opened at the element cap instead segmented a wide-rowed
- *  value differently from this encoder, giving one value two hashes. */
-export declare const BEAST2_PAGED_PROBE_BATCH = 16;
+/** An element of a collection type as {@link Beast2ElementWriter.add} takes
+ *  it: an Array or Set element, or a Dict's `[key, value]` pair. */
+export type Beast2ElementOf<T> = T extends DictType<infer K, infer V> ? [ValueTypeOf<K>, ValueTypeOf<V>] : T extends SetType<infer E> ? ValueTypeOf<E> : T extends ArrayType<infer E> ? ValueTypeOf<E> : unknown;
+/** Options accepted by {@link Beast2ElementWriter}. Its blobs are always
+ *  indexed and self-contained, so neither is an option here. */
+export type Beast2ElementWriterOptions = Omit<Beast2WriterOptions, "selfContained" | "index">;
+/**
+ * One segment of a collection as a store keeps it: a standalone blob, and what
+ * a manifest entry records of it.
+ */
+export interface Beast2Segment {
+    /** Elements (pairs, for a Dict) in the segment. */
+    readonly count: number;
+    /** Set/Dict: the segment's first key in its canonical bare encoding
+     *  (`encodeBeast2FenceFor`) — its fence. Array: empty. */
+    readonly fence: Uint8Array;
+    /** The segment's logical size: its elements' canonical bytes before
+     *  compression, which is what the cut rule measures a segment by. */
+    readonly logicalBytes: number;
+    /** The segment as a standalone v5 blob: the collection's header, the
+     *  segment's frame, the terminator, and an index of the one segment. */
+    readonly blob: Uint8Array;
+}
+/** Where a {@link Beast2ElementWriter} puts a collection written as separate
+ *  segment blobs rather than one blob. */
+export interface Beast2SegmentSink {
+    /**
+     * Receives each segment once it is written, in order.
+     *
+     * @param segment - the segment
+     */
+    segment(segment: Beast2Segment): void;
+}
+/**
+ * Builds an encoder of a collection's root elements, one at a time, each in
+ * its canonical bytes: aliasing is scoped to the element, so no REF reaches a
+ * neighbour and the element's bytes depend on it alone.
+ *
+ * @param typeValue - the collection type (Array/Set/Dict)
+ * @param sourceMap - the stream's source map, for function values
+ * @returns a function appending one element's bytes to a writer and returning
+ *   the length of its key: a Set element's whole length, a Dict pair's key, 0
+ *   for an Array element, which has none
+ * @throws {TypeError} When `typeValue` is not an Array, Set or Dict type.
+ * @internal
+ */
+export declare function elementEncoderFor(typeValue: EastTypeValue, sourceMap: SourceMap | null): (element: unknown, writer: BufferWriter) => number;
+/**
+ * The canonical writer of a collection: elements go in one at a time, in
+ * canonical order, and segments come out wherever the content-defined cut rule
+ * ({@link SegmentCutter}) places them — as one blob, or as the standalone
+ * segment blobs a manifest names, one at a time to a {@link Beast2SegmentSink}.
+ *
+ * Each element is encoded as it arrives, with aliasing scoped to itself, so
+ * its bytes depend on the element alone — and the cut rule reads nothing but
+ * those bytes. The blob is therefore a function of the value: whichever
+ * process writes a collection, in whichever runtime, and however its elements
+ * were produced, it writes the same bytes. That is what lets a
+ * content-addressed store keep an equal value once and diff two values by
+ * segment.
+ *
+ * Memory is one open segment. Elements that are already encoded — sorted runs,
+ * a merge, a re-cut — go in through {@link addEncoded}, without a decode.
+ *
+ * @example
+ * ```ts
+ * const chunks: Uint8Array[] = [];
+ * const type = DictType(StringType, IntegerType);
+ * const writer = new Beast2ElementWriter(type, (b) => chunks.push(b));
+ * writer.add(["a", 1n]);
+ * writer.add(["b", 2n]);
+ * writer.finish();
+ * decodeBeast2For(type)(Buffer.concat(chunks));  // Map { "a" => 1n, "b" => 2n }
+ *
+ * const segments: Beast2Segment[] = [];
+ * const split = new Beast2ElementWriter(type, { segment: (s) => segments.push(s) });
+ * split.add(["a", 1n]);
+ * split.finish();
+ * segments[0].blob;  // segment 0 as a standalone blob, under split.header
+ * ```
+ */
+export declare class Beast2ElementWriter<T extends EastType = EastType> {
+    private readonly kind;
+    /** The writer of the one blob, when that is the output. */
+    private readonly blob;
+    /** The framing of the segment blobs, when those are the output. */
+    private readonly frames;
+    private readonly head;
+    private readonly encodeElement;
+    private readonly orderCmp;
+    private cutter;
+    /** The open segment's elements, back to back. */
+    private readonly open;
+    /** Elements in the open segment. */
+    private count;
+    /** The length of the open segment's first key — its fence. */
+    private firstKeyLength;
+    private written;
+    private lastKey;
+    private hasLast;
+    private finished;
+    /**
+     * @param type - the collection type (Array/Set/Dict)
+     * @param sink - receives the blob's bytes as they are produced; or, as a
+     *   {@link Beast2SegmentSink}, each segment as a standalone blob
+     * @param options - codec, source map, header prefix and parallel framing
+     * @throws {TypeError} When `type` is not an Array, Set or Dict type, or
+     *   when `options.headerPrefix` is not a v5 header of exactly `type`.
+     */
+    constructor(type: T | EastTypeValue, sink: ((bytes: Uint8Array) => void) | Beast2SegmentSink, options?: Beast2ElementWriterOptions);
+    /** Segments written so far; the open segment is not among them until the
+     *  cut rule closes it or {@link finish} does. */
+    get segments(): number;
+    /** The header every segment is written under — magic, type section,
+     *  source-map section and root tag — which a manifest names as its header. */
+    get header(): Uint8Array;
+    /**
+     * Encodes one element and appends it to the collection.
+     *
+     * @param element - an Array or Set element, or a Dict's `[key, value]` pair
+     * @throws {Error} When called after {@link finish}, when a Set element or
+     *   Dict key does not ascend strictly from the last in East order, or when
+     *   the element cannot be encoded — which leaves the writer as it was.
+     */
+    add(element: Beast2ElementOf<T>): void;
+    /**
+     * Appends one element that is already in its canonical bytes — encoded
+     * with aliasing scoped to itself, as {@link add} encodes one — without
+     * decoding it.
+     *
+     * Order is the caller's to keep: a Set or Dict's elements must arrive
+     * strictly ascending, and nothing here decodes them to check.
+     *
+     * @param element - the element's canonical bytes (a Dict pair's key, then
+     *   its value)
+     * @param keyLength - the length of the key at the front of `element`: a Set
+     *   element's whole length, a Dict pair's key; ignored for an Array
+     * @throws {Error} When called after {@link finish}.
+     */
+    addEncoded(element: Uint8Array, keyLength: number): void;
+    /** Accounts for the element just appended at `start`, and when the cut rule
+     *  starts a segment at it, writes out the segment that closes. */
+    private place;
+    /**
+     * Waits for every in-flight frame and passes it to the sink, so the sink
+     * holds every segment written so far. A no-op for a serial writer.
+     *
+     * @throws {Error} For a parallel writer, when an in-flight frame's worker
+     *   failed or stopped responding (see {@link Beast2Writer.write}).
+     */
+    settle(): void;
+    /** Elements in the open segment.
+     *  @internal */
+    get openCount(): number;
+    /** Logical bytes in the open segment.
+     *  @internal */
+    get openBytes(): number;
+    /**
+     * Ends the open segment here, for a caller that knows the cut rule starts
+     * one at what comes next without handing it over: writes the open segment,
+     * and makes the next element the first of a segment.
+     *
+     * @throws {Error} When called after {@link finish}.
+     * @internal
+     */
+    closeSegment(): void;
+    /**
+     * Writes the open segment and — for a blob — the terminator, index and
+     * footer. Idempotent.
+     *
+     * @throws {Error} For a parallel writer, when an in-flight frame's worker
+     *   failed or stopped responding (see {@link Beast2Writer.write}).
+     */
+    finish(): void;
+    /** Writes the open segment, whose elements are `elements`, unless it is
+     *  empty. */
+    private writeSegment;
+}
 /** Options accepted by {@link encodeBeast2PagedFor}. */
 export type Beast2PagedEncodeOptions = {
-    /** Element (pair for Dict roots) cap per segment. Defaults to
-     *  {@link BEAST2_PAGED_BATCH_DEFAULT}. */
-    batchSize?: number;
-    /** Wire-byte target per segment — batches shrink below `batchSize` when
-     *  measured element size would exceed it. Defaults to
-     *  {@link BEAST2_PAGED_TARGET_BYTES_DEFAULT}. */
-    targetSegmentBytes?: number;
     /** Per-frame codec. Defaults to `"deflate"`. */
     codec?: Beast2Codec;
     /** Source map for function values in the stream, written to the header. */
@@ -220,8 +377,8 @@ export type Beast2PagedEncodeOptions = {
 };
 /**
  * Builds a curried paged encoder: `encode(value)` writes one whole collection
- * value as a segmented, self-contained, indexed v5 blob — `batchSize` elements
- * per segment.
+ * value as a segmented, self-contained, indexed v5 blob, cut by the
+ * content-defined rule through {@link Beast2ElementWriter}.
  *
  * The write-side sibling of {@link openBeast2PagesFor}: a blob written this
  * way supports random access ({@link Beast2Pages.segment} /
@@ -232,7 +389,7 @@ export type Beast2PagedEncodeOptions = {
  * 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
+ * @param options - 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.
  */
@@ -287,12 +444,17 @@ export declare class Beast2Pages<T extends EastType = EastType> {
     /** Whether segments are independently decodable. */
     readonly selfContained: boolean;
     private readonly source;
+    /** The manifest behind this reader, when the segments are separate blobs
+     *  rather than runs of one. */
+    private readonly manifestSource;
     /** Wire offset of the terminator frame — where the last segment's frame ends. */
     private readonly segmentsEnd;
     private readonly indexData;
     private readonly kind;
     private readonly typeValue;
-    private readonly sourceMap;
+    /** The stream's source map. For a manifest it starts empty and is replaced
+     *  by the first segment's own header map, which every segment shares. */
+    private sourceMap;
     private readonly decodeSegment;
     private readonly platform;
     private readonly cumulative;
@@ -300,6 +462,8 @@ export declare class Beast2Pages<T extends EastType = EastType> {
     /** First key/element of each segment, in segment order (Set/Dict only). */
     private fences;
     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
@@ -309,14 +473,19 @@ export declare class Beast2Pages<T extends EastType = EastType> {
      *  container walk. */
     private readonly segmentCache;
     /** @internal Use {@link openBeast2PagesFor}. */
-    constructor(source: Uint8Array | Beast2SyncRangeReader, typeValue: EastTypeValue, options?: Beast2DecodeOptions);
+    constructor(source: Uint8Array | Beast2SyncRangeReader | Beast2ManifestSource, typeValue: EastTypeValue, options?: Beast2DecodeOptions);
     /** Number of segments in the blob. */
     get segmentCount(): number;
     /** 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
-     *  source touches one frame per decode. */
+     *  source touches one frame per decode, and a manifest source touches one
+     *  segment blob. */
     private frameReader;
+    /** Segment `i`'s frame out of its own standalone blob: the blob's geometry
+     *  names exactly one frame, and its header carries the source map every
+     *  segment of this collection shares. */
+    private manifestFrameReader;
     /**
      * Decodes one segment by index.
      *
@@ -386,7 +555,7 @@ export declare class Beast2Pages<T extends EastType = EastType> {
      * 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).
+     * holding the window (an array, `SortedSet`, or `SortedMap` 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.
@@ -418,6 +587,23 @@ export declare class Beast2Pages<T extends EastType = EastType> {
      *   self-contained, or its segment fences do not ascend.
      */
     segmentFor(key: ValueTypeOf<T> extends Map<infer K, any> ? K : ValueTypeOf<T> extends Set<infer E> ? E : never): number;
+    /**
+     * Decodes one segment of a Set or Dict for a walk in canonical order
+     * (Set/Dict roots only), as east-c's paged loops read one: the fences are
+     * probed and verified to ascend strictly first, once per reader, and the
+     * segment's last key is checked to fall below the next segment's fence. A
+     * walk from segment 0 over a blob that violates the canonical-order contract
+     * therefore fails at the first segment it reads: before any element when the
+     * fences are out of order, and before the elements of the first segment
+     * that overlaps the next.
+     *
+     * @param i - zero-based segment index
+     * @returns the segment's decoded collection
+     * @throws {Error} When the root is an Array, `i` is out of range, the blob
+     *   is not self-contained, or the blob violates the canonical-order
+     *   contract.
+     */
+    segmentDisjoint(i: number): ValueTypeOf<T>;
     /**
      * 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
@@ -435,14 +621,15 @@ export declare class Beast2Pages<T extends EastType = EastType> {
  * Builds a curried pages opener: `open(source)` parses the header, footer and
  * index once and returns a {@link Beast2Pages} for random access.
  *
- * `source` is the whole blob, or a {@link Beast2SyncRangeReader} over it —
- * then only the tail, the head and the segments actually read are ever
- * fetched.
+ * `source` is the whole blob, a {@link Beast2SyncRangeReader} over it — then
+ * only the tail, the head and the segments actually read are ever fetched —
+ * or a {@link Beast2ManifestSource}, whose segments are separate blobs and
+ * 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
  * @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) => Beast2Pages<T>;
+export declare function openBeast2PagesFor<T extends EastType>(type: T | EastTypeValue, options?: Beast2DecodeOptions): (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":"AAAA;;;GAGG;AAEH;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,EAAE,KAAK,aAAa,EAAuC,MAAM,0BAA0B,CAAC;AACnG,OAAO,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAE7F,OAAO,EAAE,YAAY,EAAgB,MAAM,uBAAuB,CAAC;AACnE,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAIjD,OAAO,EAAE,KAAK,mBAAmB,EAAwB,MAAM,cAAc,CAAC;AAE9E,OAAO,EAAE,KAAK,WAAW,EAA4C,MAAM,aAAa,CAAC;AAiBzF,OAAO,EAAE,KAAK,qBAAqB,EAA8G,MAAM,YAAY,CAAC;AAEpK,OAAO,EAA0B,KAAK,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAuBlF,oFAAoF;AACpF,MAAM,MAAM,mBAAmB,GAAG;IAChC,gDAAgD;IAChD,KAAK,CAAC,EAAE,WAAW,CAAC;IACpB;;;;kBAIc;IACd,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB;8BAC0B;IAC1B,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,2EAA2E;IAC3E,SAAS,CAAC,EAAE,SAAS,GAAG,IAAI,CAAC;IAC7B;;;;6EAIyE;IACzE,YAAY,CAAC,EAAE,UAAU,CAAC;IAC1B;;;;;;;;OAQG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,CAAC;AAkIF;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,qBAAa,YAAY,CAAC,CAAC,SAAS,QAAQ,GAAG,QAAQ;IACrD,yCAAyC;IACzC,QAAQ,SAAK;IACb,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAgB;IACrC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAA8B;IACnD,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAU;IACxC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAU;IACpC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAkB;IACtC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA8C;IAC1E,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA2C;IACjE,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAsC;IAC/D,OAAO,CAAC,OAAO,CAAM;IACrB,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,YAAY,CAAK;IACzB,OAAO,CAAC,QAAQ,CAAS;IACzB;6BACyB;IACzB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAwB;IAE/C;;;;;;OAMG;gBACS,IAAI,EAAE,CAAC,GAAG,aAAa,EAAE,IAAI,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,EAAE,OAAO,CAAC,EAAE,mBAAmB;IAuDrG;;;;;;;;;;;;;;;;;;OAkBG;IACH,KAAK,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC,GAAG,IAAI;IAYlC;;;;;;;;;;;;;;OAcG;IACH,mBAAmB,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,UAAU,GAAG,IAAI;IAS9D;sDACkD;IAClD,OAAO,CAAC,YAAY;IAKpB;;;;;;;;OAQG;IACH,MAAM,IAAI,IAAI;IAId;;;;;;OAMG;IACH,MAAM,IAAI,IAAI;IAed;iFAC6E;IAC7E,OAAO,CAAC,WAAW;IAenB,OAAO,CAAC,IAAI;CAIb;AAuBD;;;;;;;;;GASG;AACH,wBAAgB,uBAAuB,CAAC,CAAC,SAAS,QAAQ,EAAE,IAAI,EAAE,CAAC,GAAG,aAAa,EAAE,OAAO,CAAC,EAAE,mBAAmB,GAAG,CAAC,OAAO,EAAE,QAAQ,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,KAAK,UAAU,CAcrK;AAMD;oEACoE;AACpE,MAAM,MAAM,eAAe,CAAC,CAAC,IAC3B,CAAC,SAAS,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC,CAAC,GACvE,CAAC,SAAS,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,GAC3C,CAAC,SAAS,SAAS,CAAC,MAAM,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,GAC7C,OAAO,CAAC;AAEV;gEACgE;AAChE,MAAM,MAAM,0BAA0B,GAAG,IAAI,CAAC,mBAAmB,EAAE,eAAe,GAAG,OAAO,CAAC,CAAC;AAE9F;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,mDAAmD;IACnD,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB;8DAC0D;IAC1D,QAAQ,CAAC,KAAK,EAAE,UAAU,CAAC;IAC3B;yEACqE;IACrE,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B;4EACwE;IACxE,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAC;CAC3B;AAED;0CAC0C;AAC1C,MAAM,WAAW,iBAAiB;IAChC;;;;OAIG;IACH,OAAO,CAAC,OAAO,EAAE,aAAa,GAAG,IAAI,CAAC;CACvC;AAKD;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,aAAa,EAAE,SAAS,EAAE,SAAS,GAAG,IAAI,GAAG,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,YAAY,KAAK,MAAM,CA4B3I;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,qBAAa,mBAAmB,CAAC,CAAC,SAAS,QAAQ,GAAG,QAAQ;IAC5D,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAgB;IACrC,2DAA2D;IAC3D,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAyB;IAC9C,mEAAmE;IACnE,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAqC;IAC5D,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAa;IAClC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAqD;IACnF,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAsC;IAC/D,OAAO,CAAC,MAAM,CAAuB;IACrC,iDAAiD;IACjD,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAsB;IAC3C,oCAAoC;IACpC,OAAO,CAAC,KAAK,CAAK;IAClB,8DAA8D;IAC9D,OAAO,CAAC,cAAc,CAAK;IAC3B,OAAO,CAAC,OAAO,CAAK;IACpB,OAAO,CAAC,OAAO,CAAU;IACzB,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,QAAQ,CAAS;IAEzB;;;;;;;OAOG;gBACS,IAAI,EAAE,CAAC,GAAG,aAAa,EAAE,IAAI,EAAE,CAAC,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAAC,GAAG,iBAAiB,EAAE,OAAO,CAAC,EAAE,0BAA0B;IAiBlI;qDACiD;IACjD,IAAI,QAAQ,IAAI,MAAM,CAErB;IAED;kFAC8E;IAC9E,IAAI,MAAM,IAAI,UAAU,CAEvB;IAED;;;;;;;OAOG;IACH,GAAG,CAAC,OAAO,EAAE,eAAe,CAAC,CAAC,CAAC,GAAG,IAAI;IA6BtC;;;;;;;;;;;;;OAaG;IACH,UAAU,CAAC,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI;IAOxD;sEACkE;IAClE,OAAO,CAAC,KAAK;IAgBb;;;;;;OAMG;IACH,MAAM,IAAI,IAAI;IAKd;oBACgB;IAChB,IAAI,SAAS,IAAI,MAAM,CAEtB;IAED;oBACgB;IAChB,IAAI,SAAS,IAAI,MAAM,CAEtB;IAED;;;;;;;OAOG;IACH,YAAY,IAAI,IAAI;IAQpB;;;;;;OAMG;IACH,MAAM,IAAI,IAAI;IAQd;iBACa;IACb,OAAO,CAAC,YAAY;CAgBrB;AAMD,wDAAwD;AACxD,MAAM,MAAM,wBAAwB,GAAG;IACrC,gDAAgD;IAChD,KAAK,CAAC,EAAE,WAAW,CAAC;IACpB,2EAA2E;IAC3E,SAAS,CAAC,EAAE,SAAS,GAAG,IAAI,CAAC;CAC9B,CAAC;AAEF;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,SAAS,QAAQ,EAAE,IAAI,EAAE,CAAC,GAAG,aAAa,EAAE,OAAO,CAAC,EAAE,wBAAwB,GAAG,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC,CAAC,KAAK,UAAU,CAgC3J;AA6FD;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,SAAS,QAAQ,EAAE,IAAI,EAAE,CAAC,GAAG,aAAa,EAAE,OAAO,CAAC,EAAE,mBAAmB,GAAG,CAAC,IAAI,EAAE,UAAU,KAAK,SAAS,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAoCjK;AAmBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,qBAAa,WAAW,CAAC,CAAC,SAAS,QAAQ,GAAG,QAAQ;IACpD,wEAAwE;IACxE,QAAQ,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IACnC;;0CAEsC;IACtC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,oDAAoD;IACpD,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;IAChC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAwB;IAC/C;mCAC+B;IAC/B,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAqC;IACpE,iFAAiF;IACjF,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAc;IACxC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAgB;IACrC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAgB;IAC1C;6EACyE;IACzE,OAAO,CAAC,SAAS,CAAY;IAC7B,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAuF;IACrH,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAkC;IAC3D,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAW;IACtC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAsC;IAC/D,2EAA2E;IAC3E,OAAO,CAAC,MAAM,CAAsB;IACpC,OAAO,CAAC,QAAQ,CAAsE;IACtF,0EAA0E;IAC1E,OAAO,CAAC,gBAAgB,CAA6C;IACrE;;;;;;0BAMsB;IACtB,OAAO,CAAC,QAAQ,CAAC,YAAY,CAA0D;IAEvF,gDAAgD;gBACpC,MAAM,EAAE,UAAU,GAAG,qBAAqB,GAAG,oBAAoB,EAAE,SAAS,EAAE,aAAa,EAAE,OAAO,CAAC,EAAE,mBAAmB;IA2DtI,sCAAsC;IACtC,IAAI,YAAY,IAAI,MAAM,CAEzB;IAED;;;;wBAIoB;IACpB,OAAO,CAAC,WAAW;IAOnB;;6CAEyC;IACzC,OAAO,CAAC,mBAAmB;IAc3B;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,CAAC,EAAE,MAAM,GAAG,WAAW,CAAC,CAAC,CAAC;IAKlC,4EAA4E;IAC5E,OAAO,CAAC,iBAAiB;IAoBzB;;;;2CAIuC;IACvC,OAAO,CAAC,aAAa;IA8BrB;;;;sCAIkC;IAClC,OAAO,CAAC,QAAQ;IAsChB;;;;;;;;;;;;;OAaG;IACH,KAAK,CAAC,CAAC,EAAE,MAAM,GAAG,WAAW,CAAC,CAAC,CAAC,SAAS,GAAG,CAAC,MAAM,CAAC,EAAE,GAAG,CAAC,GAAG,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,SAAS,GAAG,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,EAAE,GAAG,CAAC,GAAG,KAAK;IAUzJ;4DACwD;IACxD,OAAO,CAAC,YAAY;IAiBpB;;iFAE6E;IAC7E,OAAO,CAAC,cAAc;IAQtB;uEACmE;IACnE,OAAO,CAAC,UAAU;IAUlB;;;;;;;OAOG;IACH,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,WAAW,CAAC,CAAC,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,EAAE,GAAG,CAAC,GAAG,KAAK;IAYpE;;;;;;;;;;;;;;;;;;OAkBG;IACH,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,WAAW,CAAC,CAAC,CAAC;IAwDpD;;;;;;;;;;;;;;;;;OAiBG;IACH,UAAU,CACR,GAAG,EAAE,WAAW,CAAC,CAAC,CAAC,SAAS,GAAG,CAAC,MAAM,CAAC,EAAE,GAAG,CAAC,GAAG,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,SAAS,GAAG,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,GAClG,MAAM;IAeT;;;;;;;;;;;;;;;OAeG;IACH,eAAe,CAAC,CAAC,EAAE,MAAM,GAAG,WAAW,CAAC,CAAC,CAAC;IAO1C;;;;;;;;;;OAUG;IACH,GAAG,CACD,GAAG,EAAE,WAAW,CAAC,CAAC,CAAC,SAAS,GAAG,CAAC,MAAM,CAAC,EAAE,GAAG,CAAC,GAAG,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,SAAS,GAAG,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,GAClG,CAAC,WAAW,CAAC,CAAC,CAAC,SAAS,GAAG,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,SAAS,GAAG,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC,GAAG,SAAS;CAqBhH;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,SAAS,QAAQ,EAAE,IAAI,EAAE,CAAC,GAAG,aAAa,EAAE,OAAO,CAAC,EAAE,mBAAmB,GAAG,CAAC,MAAM,EAAE,UAAU,GAAG,qBAAqB,GAAG,oBAAoB,KAAK,WAAW,CAAC,CAAC,CAAC,CAIpM"}