@brass-build/client 0.1.0 → 0.2.0

package/dist/record-paging.d.ts

@@ -6,69 +6,223 @@ export declare const BODY_FIELD = "params";
 export declare const META_KEY = "meta";
 export declare const RECORDS_KEY = "instances";
 export declare const ORDER_KEY = "instance_order";
-/** `meta` key holding a paged store's page count; absent (or 0) means
- *  unpaged. The read path detects pages by tag; only an in-place edit needs
- *  the count, to hash a key to its page. */
-export declare const PAGE_COUNT_KEY = "page_count";
-/** `meta` key holding the paging codec's scheme number, stamped on a paged
- *  write. The scheme fixes the page-key hash (`pageKeyFor`), the `p<n>` key
- *  format, and the packed-record layout together: a reader that hashes a key
- *  with a different scheme than the store was written under targets the wrong
- *  page on an in-place edit, silently writing a record into a page it does not
- *  belong to. The stamp lets a pinned reader detect a store written under a
- *  scheme it does not implement and refuse the edit instead of corrupting it.
- *  Absent means the current scheme (paged stores written before the stamp
- *  existed used scheme 1's hash and layout). */
-export declare const PAGING_SCHEME_KEY = "paging_scheme";
-/** The paging scheme this build writes and can edit. Bump ONLY alongside a
- *  change to `pageKeyFor`'s hash, the `p<n>` key format, or the packed-record
- *  layout, so an older pinned reader trips `isPagingSchemeEditable` and fails
- *  loud rather than editing a store it would mis-hash. */
-export declare const CURRENT_PAGING_SCHEME = 1;
-/** Whether a store stamped with `scheme` can be edited in place by this build.
- *  Absent / non-numeric / `0` is a scheme-1 store (the stamp postdates it), so
- *  editable; any scheme at or below the current one is editable; a higher
- *  scheme is not (this reader would hash into the wrong page). Reads stay
- *  best-effort and are not gated here; only an in-place edit can persist the
- *  mis-hash, so the edit path is where the guard belongs. */
-export declare function isPagingSchemeEditable(scheme: unknown): boolean;
+/** Prefix on the `meta` key marking ONE root map paged (`meta` holds
+ *  `paged:instances` -> `true`). A root whose key is absent, or holds anything
+ *  but `true`, is unpaged; a document with no paged root carries no such key.
+ *
+ *  Per root rather than one flag for the document, so paging is a property of
+ *  a collection rather than of a reserved name. One flag would force the read
+ *  side to hardcode WHICH root it described, since a document-wide answer
+ *  handed to every root would make `meta` and `header` read as paged the
+ *  moment the records did. Keyed by root, a root with no key is simply
+ *  unpaged, which is the answer those roots want anyway.
+ *
+ *  A key per root rather than one entry naming them all. A map entry is
+ *  written whole, so an entry holding every paged root is read-modify-write:
+ *  two peers crossing the threshold on two different roots at once each write
+ *  the whole entry, the two resolve last-writer-wins, and the root the losing
+ *  write named is left unmarked. Nothing recovers it. Every reader then takes
+ *  the unpaged path over a map holding nothing but pages, so the store's own
+ *  bookkeeping keys read back as the records and the records reach nobody,
+ *  while the raw entry count sits far below the threshold that would page the
+ *  root again. A key per root means two roots are two keys, which merge.
+ *
+ *  A flag rather than a page count. Pages are keyed by writing session and
+ *  index (`brass:p:<peer>:<n>`) and a reader locates a record through the index
+ *  it builds from the pages' `keys` fields, so no reader needs to know how many
+ *  pages there are; a stored count would be a number that drifts as the store
+ *  grows and that nothing checks.
+ *
+ *  A plain value rather than a container: it is read on the hot path
+ *  (`_isPaged` on every keyed read and edit), where one `get` of a scalar is
+ *  the cheapest answer available. */
+export declare const PAGED_ROOT_PREFIX = "paged:";
+/** The `meta` key marking `rootKey` paged. */
+export declare function pagedRootKey(rootKey: string): string;
+/** Whether a value read from `meta` at `pagedRootKey(root)` marks that root
+ *  paged. The one place the marker's stored form is interpreted, so the SDK's
+ *  handle path and the store readers cannot disagree about what marks a root. */
+export declare function isPagedMarker(marker: unknown): boolean;
 /** Above this many records the store is written paged; at or below it it keeps
- *  the one-container-per-record shape. */
-export declare const UNPAGED_MAX_RECORDS = 50000;
-/** The tag a page container carries in place of a record tag, so a reader
- *  tells a page (body = record triples) from a single record (body = one
- *  plain value). */
+ *  the one-container-per-record shape.
+ *
+ *  Set where paging starts paying for itself on every axis but one. Measured
+ *  on the two shapes at equal record counts (`scripts/bench/paging-threshold.mts`),
+ *  the paged store writes ~3x faster, opens ~5x faster, and stores ~1.7x
+ *  smaller here, against ~1.4x on a single edit, and that last penalty
+ *  inverts by 25,000 records. Below a few hundred records the paged store is
+ *  actually LARGER, since per-page gzip overhead outweighs what it saves. */
+export declare const UNPAGED_MAX_RECORDS = 5000;
+/** The tag a page container carries in place of a record tag, which labels it
+ *  in a raw dump of the stored document. A READER never decides from it: what
+ *  makes an entry a page is its key (`SESSION_PAGE_PREFIX`), so a record whose
+ *  own tag happens to be this string is still a record. */
 export declare const PAGE_TAG = "__page__";
-/** A record packed inside a page body: `[key, tag, body]`. The tuple form
- *  keeps a paged snapshot compact. */
-export type PackedRecord<B> = [key: string, tag: string, body: B];
-/** Encode a page's triples as its stored body: JSON-serialised, gzipped, held
- *  as a latin1 string. A STRING body avoids loro's superlinear per-value
- *  conversion of a deeply nested triple array; gzipping keeps a heavy file in
- *  memory + export budget. (Full rationale in the substrate's `encodePageBody`.) */
-export declare function encodePageBody<B>(triples: PackedRecord<B>[]): string;
-/** Encode one record's `[key, tag, body]` triple as the JSON string it
- *  occupies inside a page body. Split from page assembly so a large write can
+/** Prefix on every key the record store writes for its own bookkeeping: the
+ *  pages, a record's own container, a delete marker, a patch.
+ *
+ *  A record and the bookkeeping about it share one map, so the two key spaces
+ *  have to be told apart by something an app cannot produce. The map handle
+ *  refuses a write under this prefix (`assertUsableRecordKey`), which makes the
+ *  space exclusive: every key outside it is a record key, and every key inside
+ *  it is the store's own. Nothing here inspects an app's VALUE to make that
+ *  call, so no record can be mistaken for a page or a tombstone whatever it
+ *  holds. */
+export declare const RESERVED_KEY_PREFIX = "brass:";
+/** Whether `key` names one of the store's own entries rather than a record. */
+export declare function isReservedKey(key: string): boolean;
+/** Refuse a record key the store cannot carry, at the moment an app writes it:
+ *  one inside the reserved space, and `__proto__`.
+ *
+ *  Rejecting the reserved space is what lets every reader decide what an entry
+ *  is from the key alone. The alternative, escaping, would put the escape on
+ *  the read of every key of every map, paged or not, and a store that pages
+ *  later cannot escape what it already holds. */
+export declare function assertUsableRecordKey(key: string): void;
+/** The prefix on a record written as its OWN container in a paged store,
+ *  which shadows the page's copy on read. A page body is one value, so an
+ *  edit that rewrote its page would make the page the merge unit; a record in
+ *  its own container merges on its own. */
+export declare const OVERLAY_PREFIX = "brass:r:";
+/** Pack one stored value into a page triple. A `null` tag is what says the
+ *  body IS the record: an app's map holds whatever the app assigned, which has
+ *  no tag to split off. A codec's records arrive already split, and a codec
+ *  tag is a string, so the two forms cannot be confused however a codec names
+ *  its records. */
+export declare function packWholeValue<B>(key: string, value: B): PackedRecord<B>;
+/** Re-pack `value` in the same triple shape `packed` already uses, so a page
+ *  rewritten in place keeps the form its readers expect: a codec's records
+ *  stay a tag beside a body, and an app's stay one whole value. A streaming
+ *  read visits a page's triples without unpacking them, so a rewrite that
+ *  changed the shape would hand it the wrong half of the record. */
+export declare function repackRecord(packed: PackedRecord<unknown>, value: unknown): PackedRecord<unknown>;
+/** The stored value a page triple carries: the value itself for a whole-value
+ *  record, else the `{ type, params }` pair a codec split it into. */
+export declare function unpackRecord(packed: PackedRecord<unknown>): unknown;
+/** The tag + body a page triple names, for a reader that walks the two
+ *  separately, or null when the triple packs a whole value that is not a
+ *  record.
+ *
+ *  A page holds both forms: a codec packs a record it has already split into a
+ *  tag and a body, and a map an app writes packs whatever the app assigned as
+ *  one whole value. Both forms occur in ONE store, because an app's bulk add
+ *  to a codec's record map seals its own pages, so a reader that took
+ *  `packed[1]` for the tag would report every record those pages hold as
+ *  having no type at all. */
+export declare function unpackRecordPair(packed: PackedRecord<unknown>): {
+    tag: string;
+    body: unknown;
+} | null;
+/** The container key a record is written under, beside the pages. */
+export declare function overlayKeyFor(recordKey: string): string;
+/** The marker key standing for a record deleted out of a paged store. */
+export declare function tombstoneKeyFor(recordKey: string): string;
+/** The prefix on a page written by ONE editing session, which fills its pages
+ *  in creation order.
+ *
+ *  An app fills a map by appending, so a rule that scattered one mutation's
+ *  records across every page would add a record or two to each of thousands of
+ *  pages and rewrite every one of them again on the next mutation, which costs
+ *  more than the per-record containers it replaces. Filling in creation order
+ *  packs each mutation's records into its own dense pages, written complete
+ *  and never rewritten.
+ *
+ *  The token makes the key space exclusive to one writer. A page body is a
+ *  single value, so two writers appending to the same page container resolve
+ *  last-writer-wins and one writer's records are lost; with a per-session
+ *  token no two writers ever address the same page. It is also what makes
+ *  filling in creation order safe on reopen: a session never inherits, and so
+ *  never rewrites, a page an earlier session sealed. */
+export declare const SESSION_PAGE_PREFIX = "brass:p:";
+/** The container key for page `index` of the session identified by `token`. */
+export declare function sessionPageKey(token: string, index: number): string;
+/** The `{ token, index }` a session page key names, or null for any other key.
+ *  Used to seed a session's next page index above what the store already
+ *  holds, so a reopened session cannot overwrite its own sealed pages. */
+export declare function parseSessionPageKey(key: string): {
+    token: string;
+    index: number;
+} | null;
+/** A record packed inside a page: `[key, tag, body]`, where a `null` tag means
+ *  the body is the record's WHOLE stored value (`packWholeValue`). The tuple
+ *  form keeps a paged snapshot compact. It is how a reader HOLDS a page's
+ *  records; a stored page splits the key off into its own field
+ *  (`PAGE_KEYS_FIELD`). */
+export type PackedRecord<B> = [key: string, tag: string | null, body: B];
+/** Field on a page container holding the keys of the records its body packs,
+ *  in the same order, so the two are zipped by index.
+ *
+ *  The keys live apart from the bodies because finding a record in a page
+ *  filled in creation order (`SESSION_PAGE_PREFIX`) means learning which page
+ *  holds which key, and that question is answered by the keys alone. Packed
+ *  beside the bodies, answering it costs decompressing and parsing every
+ *  record in the store: measured at 250,000 records, 1.85 s against 0.24 s for
+ *  the keys on their own. Splitting them costs no bytes, since the keys are
+ *  stored once either way and compress better grouped than interleaved with
+ *  the bodies. */
+export declare const PAGE_KEYS_FIELD = "keys";
+/** A page's two stored strings: the record bodies and the keys they belong
+ *  to. */
+export interface EncodedPage {
+    body: string;
+    keys: string;
+    /** The body's size BEFORE gzip, so a writer can charge a page in the same
+     *  unit an ordinary map assignment is charged in. Taken here because the
+     *  uncompressed string is built here and nothing else holds it. */
+    chars: number;
+}
+/** Encode a page's records as the two strings it stores. Each is JSON,
+ *  gzipped, held as a latin1 string. A STRING avoids loro's superlinear
+ *  per-value conversion of a nested array; gzipping keeps a heavy file in
+ *  memory + export budget. (Full rationale in the substrate's page notes.) */
+export declare function encodePage<B>(records: PackedRecord<B>[]): EncodedPage;
+/** Encode one record's `[tag, body]` pair as the JSON string it occupies
+ *  inside a page body. Split from page assembly so a large write can
  *  stringify each record as it buckets and release the parsed body before the
- *  gzip loop, rather than holding the whole parsed model live through it (see
- *  `writeRecordStoreConsuming` for why that release keeps the encode fast). */
-export declare function encodeRecordForPage<B>(key: string, tag: string, body: B): string;
-/** Assemble a page body from records already JSON-encoded by
- *  `encodeRecordForPage`: wrap in a JSON array, gzip, hold as a latin1 string.
- *  Byte-identical to `encodePageBody` over the same triples, so the wire shape
- *  is unchanged; the split exists only so the writer frees each parsed body
+ *  gzip loop: holding a whole parsed model live through that loop makes GC
+ *  marking scale with the live set and turns the encode into a wall. */
+export declare function encodeRecordForPage<B>(tag: string | null, body: B): string;
+/** Assemble a page from bodies already JSON-encoded by `encodeRecordForPage`
+ *  and the keys they belong to. Byte-identical to `encodePage` over the same
+ *  records; the split exists only so the writer frees each parsed body
  *  first. */
-export declare function encodePageBodyFromEncoded(encoded: string[]): string;
-/** Decode a page body back to its record triples. Returns [] for anything that
- *  does not decompress to a JSON array, so a reader tolerates a corrupt or
- *  stray page rather than throwing. */
-export declare function decodePageBody(body: unknown): PackedRecord<unknown>[];
-/** The page count for a record population: 0 (unpaged) at or below
- *  `UNPAGED_MAX_RECORDS`, else ~`TARGET_PAGE_SIZE` records per page, capped at
- *  `MAX_PAGES`. */
-export declare function pageCountFor(recordCount: number): number;
-/** The page key a record key lives in, for a store of `pageCount` pages. */
-export declare function pageKeyFor(key: string, pageCount: number): string;
+export declare function encodePageFromEncoded(encoded: string[], keys: string[]): EncodedPage;
+/** The record keys a page holds, from the page's own `keys` string. Reading
+ *  this field alone is what makes learning a store's key locations cost the
+ *  keys rather than every record body. */
+export declare function decodePageKeys(keysField: unknown): string[];
+/** A page's records, zipped back into `[key, tag, body]` triples from the two
+ *  strings the page stores. A key with no body (or a body with no key) is
+ *  dropped: the two arrays are written together and index each other, so a
+ *  length mismatch means a page nothing can read as records. */
+export declare function decodePageRecords(page: unknown): PackedRecord<unknown>[];
+/** Mean JSON bytes of a record body, over a stride sample of at most
+ *  `WIDTH_SAMPLE` records, which is what `recordsPerPage` sizes a page
+ *  against. `bodyOf` returns the value the caller will pack as the triple's
+ *  body: a codec's records carry a tag beside a body, and an app's map packs
+ *  its whole stored value (`packWholeValue`), so each caller weighs the bytes
+ *  its own pages will hold.
+ *
+ *  Returns 0, which keeps `recordsPerPage`'s plain record-count rule, for an
+ *  empty population and for a body `JSON.stringify` refuses. Such a body fails
+ *  the write regardless (a paged write stringifies each record, and loro
+ *  rejects a non-JSON value), so the catch is not there to rescue it; it is
+ *  there so that a page-size ESTIMATE is never what decides a write fails, and
+ *  the failure stays with the code that owns the body. */
+export declare function sampleBodyBytes<T>(records: readonly T[], bodyOf: (record: T) => unknown): number;
+/** Records one page holds: `TARGET_PAGE_SIZE`, or fewer when that many bodies
+ *  would exceed `TARGET_PAGE_BYTES`. `avgBodyBytes` of 0 or absent (a caller
+ *  with no estimate) keeps the count rule. */
+export declare function recordsPerPage(avgBodyBytes?: number): number;
+/** How many pages a record population occupies: 0 (unpaged) at or below
+ *  `UNPAGED_MAX_RECORDS`, else one page per `recordsPerPage(avgBodyBytes)`
+ *  records.
+ *
+ *  A projection, not a decision the write path takes. Pages are filled in
+ *  creation order and allocated as a write needs them, so this is what
+ *  `scripts/bench` uses to price container counts and what the hash-page
+ *  fixtures use as their bucket modulus. */
+export declare function pageCountFor(recordCount: number, avgBodyBytes?: number): number;
 /** A stored container's tag (`type`), or null for any value not in the
  *  `{ type, params }` shape, so a reader skips a corrupt entry. A page carries
  *  `PAGE_TAG`. */
@@ -79,21 +233,132 @@ export declare function decodeRecordValue(value: unknown): {
     tag: string;
     body: unknown;
 } | null;
-/** Whether a `meta.page_count` value denotes a PAGED store. The writer sets
- *  it to a positive count only when it pages, and never on an unpaged write,
- *  so a positive finite number is the authoritative "is paged" signal. */
-export declare function isPagedByPageCount(pageCount: unknown): boolean;
+/** Prefix of a RECORD PATCH: the fields one edit changed, applied over the
+ *  record's page copy on read.
+ *
+ *  Giving an edited record a container of its own instead restores the
+ *  per-container cost paging exists to remove, so a store whose records are
+ *  all eventually edited ends up slower and larger than one that never paged.
+ *  A patch keeps the record packed and costs one entry per edit rather than a
+ *  container per edited record.
+ *
+ *  The key carries the writing peer and a counter. The peer is what lets the
+ *  patches be FOLDED back into their pages later without a lock: a CRDT delete
+ *  only defeats a CONCURRENT write to the same key, and no two writers can
+ *  name the same key while the peer is in it, so a peer editing during
+ *  another's fold writes a key that fold never saw. A writer that re-mints a
+ *  key it folded away itself is ordered after its own delete, so that write is
+ *  not the race either.
+ *
+ *  The counter orders the patches on ONE record, and is minted one above every
+ *  counter that record already carries. That is what makes the fold causal: a
+ *  patch written by someone who had already merged an earlier patch sorts
+ *  above it, whoever wrote which. A counter that instead counted the WRITER's
+ *  edits would put a busy session's first-ever edit of a record above a later
+ *  session's, and the later edit would vanish as it was made.
+ *
+ *  The record key goes last because it may contain a colon; the peer and
+ *  counter may not.
+ *
+ *  Each reserved space differs from its siblings at the character after
+ *  `RESERVED_KEY_PREFIX`, so `classifyStoreKey` decides between them with one
+ *  test each and no ordering to get right. */
+export declare const PATCH_PREFIX = "brass:q:";
+export declare function patchKeyFor(recordKey: string, peer: string, counter: number): string;
+export interface ParsedPatchKey {
+    recordKey: string;
+    peer: string;
+    counter: string;
+}
+/** What one entry of a paged map is, decided from its key alone.
+ *
+ *  `record` is the ordinary case: every key outside the reserved space names a
+ *  record, whatever its value holds. `unknown` is a reserved key this build
+ *  does not recognise, which a reader skips rather than reporting as a record,
+ *  so a store written by a later build degrades to missing entries instead of
+ *  entries named after the store's own bookkeeping. */
+export type StoreEntryKind = {
+    kind: 'record';
+    recordKey: string;
+} | {
+    kind: 'page';
+} | {
+    kind: 'overlay';
+    recordKey: string;
+} | {
+    kind: 'tombstone';
+    recordKey: string;
+} | {
+    kind: 'patch';
+    parsed: ParsedPatchKey;
+} | {
+    kind: 'unknown';
+};
+/** Classify one key of a paged map. The single place the key spaces are told
+ *  apart, so a keyed read, a whole-store read, a streaming read, and the page
+ *  index cannot disagree about which entry is which. */
+export declare function classifyStoreKey(key: string): StoreEntryKind;
+/** The parts of a patch key, or null when `key` is not one.
+ *
+ *  The record key runs to the end of the string and may be empty, which is a
+ *  record key like any other: the two colons after the prefix delimit the peer
+ *  and the counter, so the tail needs no length of its own to be
+ *  unambiguous. Reading an empty tail as "not a patch" instead leaves the
+ *  entry classified `unknown`, which every reader skips, so the edit stays in
+ *  the document and reaches nobody. */
+export declare function parsePatchKey(key: string): ParsedPatchKey | null;
+/** One patch: the fields an edit changed, plus the pair that orders it. */
+export interface RecordPatch {
+    peer: string;
+    counter: string;
+    fields: unknown;
+}
+/** Apply `patches` over `base`, in the order every reader must agree on: by
+ *  counter, then by peer id. The counter is per record and minted one above
+ *  what that record already carries, so a patch whose writer had merged an
+ *  earlier one applies over it. Peer id breaks the tie between two writers who
+ *  had not seen each other, so both reach the same answer. */
+export declare function applyRecordPatches(base: unknown, patches: RecordPatch[]): unknown;
+/**
+ * Apply patches to a record a streaming read carries both as its whole stored
+ * value and as the `(tag, body)` pair split out of it, and return all three
+ * after the fold.
+ *
+ * A patch names the record's own fields, which for a codec record are
+ * `type` and `params` together, so a reader that walks tag and body
+ * separately has to re-split the result. Both readers of a paged store
+ * (the flattening one and the streaming one) resolve patches through this
+ * module, so an edit cannot read one way in the editor and another in a
+ * re-emitted file. The fold runs over the whole value for the same reason the
+ * streaming read carries one: a field beyond the pair is a field of the record
+ * and an edit may name it.
+ */
+export declare function applyPatchesToRecord(record: unknown, tag: string, body: unknown, patches: RecordPatch[]): {
+    tag: string;
+    body: unknown;
+    record: unknown;
+};
+/** Where a paged store keeps each record, reported as a flatten resolves it.
+ *  A reader that has to locate records by key (a keyed read over pages filled
+ *  in creation order) takes its index from the walk that decodes the pages
+ *  anyway, rather than decoding them a second time of its own. */
+export interface RecordLocationSink {
+    /** `recordKey` is packed in the body of page `pageKey`. */
+    page(recordKey: string, pageKey: string): void;
+    /** A container of its own answers for `recordKey`, outranking any page. */
+    contained(recordKey: string): void;
+    /** A tombstone removes `recordKey`, whatever a page still holds. */
+    removed(recordKey: string): void;
+}
 /** Flatten a possibly-PAGED `instances` lookup to the flat
  *  `key -> { type, params }` lookup a reader consumes. An unpaged lookup is
  *  returned unchanged (no allocation). The single place paging is undone on the
  *  read side.
  *
- *  `paged` is the AUTHORITATIVE page state, read from `meta.page_count` by the
- *  caller (`isPagedByPageCount`). Page interpretation MUST be gated on it, not
- *  on whether some entry is `PAGE_TAG`-tagged: a genuine record whose codec tag
- *  happens to equal `PAGE_TAG` in an UNPAGED store is a real record, not a
- *  page. Treating it as a page decodes its plain body as `decodePageBody`
- *  (which returns `[]` for a non-page body), silently DROPPING the record, and
- *  a crafted page-shaped body could forge records into the lookup. */
-export declare function flattenPagedLookup(lookup: Record<string, unknown>, paged: boolean): Record<string, unknown>;
+ *  `paged` is the AUTHORITATIVE page state, read from the root's own `meta`
+ *  key by the caller (`pagedRootKey` / `isPagedMarker`). Page interpretation
+ *  MUST be gated on it: in an UNPAGED store every key is a record key,
+ *  including one that looks reserved, because nothing refused it before the
+ *  store was written. */
+export declare function flattenPagedLookup(lookup: Record<string, unknown>, paged: boolean, into?: RecordLocationSink): Record<string, unknown>;
 //# sourceMappingURL=record-paging.d.ts.map

package/dist/record-paging.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"record-paging.d.ts","sourceRoot":"","sources":["../src/record-paging.ts"],"names":[],"mappings":"AAmEA;wEACwE;AACxE,eAAO,MAAM,SAAS,SAAS,CAAC;AAChC,eAAO,MAAM,UAAU,WAAW,CAAC;AAEnC,mEAAmE;AACnE,eAAO,MAAM,QAAQ,SAAS,CAAC;AAC/B,eAAO,MAAM,WAAW,cAAc,CAAC;AACvC,eAAO,MAAM,SAAS,mBAAmB,CAAC;AAE1C;;4CAE4C;AAC5C,eAAO,MAAM,cAAc,eAAe,CAAC;AAE3C;;;;;;;;gDAQgD;AAChD,eAAO,MAAM,iBAAiB,kBAAkB,CAAC;AAEjD;;;0DAG0D;AAC1D,eAAO,MAAM,qBAAqB,IAAI,CAAC;AAEvC;;;;;6DAK6D;AAC7D,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,OAAO,GAAG,OAAO,CAK/D;AAED;0CAC0C;AAC1C,eAAO,MAAM,mBAAmB,QAAS,CAAC;AAQ1C;;oBAEoB;AACpB,eAAO,MAAM,QAAQ,aAAa,CAAC;AAEnC;sCACsC;AACtC,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;AAElE;;;oFAGoF;AACpF,wBAAgB,cAAc,CAAC,CAAC,EAAE,OAAO,EAAE,YAAY,CAAC,CAAC,CAAC,EAAE,GAAG,MAAM,CAEpE;AAED;;;;+EAI+E;AAC/E,wBAAgB,mBAAmB,CAAC,CAAC,EACnC,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,MAAM,EACX,IAAI,EAAE,CAAC,GACN,MAAM,CAER;AAED;;;;aAIa;AACb,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,MAAM,CAEnE;AAED;;uCAEuC;AACvC,wBAAgB,cAAc,CAAC,IAAI,EAAE,OAAO,GAAG,YAAY,CAAC,OAAO,CAAC,EAAE,CASrE;AAED;;mBAEmB;AACnB,wBAAgB,YAAY,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAGxD;AAeD,4EAA4E;AAC5E,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAEjE;AAED;;kBAEkB;AAClB,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAI3D;AAED;kDACkD;AAClD,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,OAAO,GACb;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,OAAO,CAAA;CAAE,GAAG,IAAI,CAMvC;AAED;;0EAE0E;AAC1E,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,OAAO,GAAG,OAAO,CAE9D;AAED;;;;;;;;;;;sEAWsE;AACtE,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,KAAK,EAAE,OAAO,GACb,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAyBzB"}
+{"version":3,"file":"record-paging.d.ts","sourceRoot":"","sources":["../src/record-paging.ts"],"names":[],"mappings":"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"}