@elaraai/east-ui 1.0.97 → 1.0.98

package/dist/src/runtime/record-slice-source.d.ts

@@ -18,6 +18,104 @@ export interface RecordSliceReader<T> {
     total(index: string): option<bigint>;
     /** Shared record revision, tracked by the binding. */
     revision(): option<string>;
+    /**
+     * Several searches of one source in one request (#1351): each query's
+     * bounds, as {@link seek} answers them, in order — none while any is
+     * pending. A binding whose runtime batches its reads has it; without it,
+     * a plan's searches are its single seeks.
+     */
+    seekAll?(index: string, queries: readonly Query[]): option<Range[]>;
+    /**
+     * The entries of several runs of one source in one request, in order
+     * (#1351) — none while pending. A binding whose runtime batches its reads
+     * has it, and a window across several runs reads through it; without it,
+     * a window pages each run.
+     */
+    runsAll?(index: string, runs: readonly Range[]): option<T[]>;
+    /**
+     * Where a narrowing's runs of one source sit in the record (#1349): how
+     * many of their entries each record segment holds, as far as they are
+     * placed — none until the first window lands. A binding whose runtime
+     * reads placements has it; without it, a narrowing has no placement.
+     */
+    placeAll?(index: string, runs: readonly Range[]): option<RecordSlicePlacement>;
+    /**
+     * Which of some entries a narrowing's runs of one source hold (#1349): for
+     * each, its index key's `.east` text beside its primary key, whether it lies
+     * in one of the runs — none while pending. A binding whose runtime reads
+     * memberships has it.
+     */
+    withinAll?(index: string, runs: readonly Range[], entries: readonly RecordSliceEntryKey[]): option<boolean[]>;
+    /**
+     * The rows the record holds under several of its own keys, in one request
+     * (#1039): each key's row, or `none` for a key the record does not hold,
+     * in the order asked — none while pending. A binding whose runtime batches
+     * its reads has it; without it, each row is read by its key.
+     */
+    rowsAll?(keys: readonly unknown[]): option<option<unknown>[]>;
+    /**
+     * The rows another Dict holds under the keys the entries of several runs
+     * of one source name, in one request (#1393): each entry's key and the
+     * Dict's row under it, or `none`, in the runs' order — none while pending.
+     * The keys are read from the source where its rows are kept, so none is
+     * sent: a Schematic's details, read for the cells of its area index. A
+     * binding whose runtime batches its reads has it.
+     */
+    joinAll?(index: string, runs: readonly Range[], dict: string): option<RecordSliceJoined[]>;
+}
+/** One entry's row of another Dict, as a read by runs answers it (#1393). */
+export interface RecordSliceJoined {
+    /** The key the entry names: one of the record's keys, of the Dict's key type. */
+    readonly key: unknown;
+    /** The Dict's row under it, or none. */
+    readonly row: option<unknown>;
+}
+/** One index entry of a row, as a membership read names it: its index key's `.east` text, and the row's primary key. */
+export interface RecordSliceEntryKey {
+    /** The entry's index key, as the binding's maintained keys print it. */
+    ik: string;
+    /** The row's primary key, an East value of the record's key type. */
+    key: unknown;
+}
+/** A record segment some of a narrowing's rows fall in (#1349). */
+export interface RecordSlicePlacedSegment {
+    /** Its first row in the record's order. */
+    offset: bigint;
+    /** How many rows it holds. */
+    count: bigint;
+    /** How many of the narrowing's rows it holds. */
+    rows: bigint;
+}
+/** Where a narrowing's rows sit in its record, as far as they are placed (#1349). */
+export interface RecordSlicePlacement {
+    /** The record segments holding some of the placed rows, in the record's order. */
+    segments: readonly RecordSlicePlacedSegment[];
+    /** How many of the narrowing's rows are placed. */
+    placed: bigint;
+    /** How many rows the narrowing holds. */
+    total: bigint;
+    /** The record's row count. */
+    records: bigint;
+    /** Whether every row is placed: until then a segment the placement does not list may yet hold some. */
+    complete: boolean;
+}
+/**
+ * One cell a reader wants of a series or a summary index (#1039): some keys in
+ * one tile, its searches as `tileCellQueries` plans them, under a name the
+ * reader gives it.
+ */
+export interface RecordSliceCell {
+    /** The reader's name for it: unique among the cells it asks for at once. */
+    readonly id: string;
+    /** Its searches, a key's entries in the tile each. */
+    readonly queries: readonly Query[];
+}
+/** Where a cell's entries are, at one revision (#1039). */
+export interface RecordSliceCellRuns {
+    /** Each of its searches' bounds, in their order. */
+    readonly ranges: readonly Range[];
+    /** How many entries its searches hold: exact, before one is read. */
+    readonly total: bigint;
 }
 /** Resolved, ascending, disjoint ranges within one immutable revision. */
 export interface RecordSliceRuns {
@@ -30,6 +128,14 @@ export interface RecordSliceRuns {
     /** Exact sum of the runs. */
     total: bigint;
 }
+/**
+ * Searches whose bounds are kept per revision; a window over an interval index is some fifty-five. A reader that keeps
+ * its searches within it — the Schematic's window across a led area index's choices (§10.4) — never asks one twice.
+ */
+export declare const MAX_LANDED_SEARCHES = 1024;
+/** The most searches one batch asks (#1351): e3 answers at most 10,000 in a
+ *  request, so a plan with more is asked as several batches, all at once. */
+export declare const MAX_RECORD_SLICE_BATCH = 10000;
 /**
  * Adapts an indexed source to the pinned-source paging contract. Work depends
  * on the selected ranges and requested window, not the record's size. The
@@ -40,6 +146,20 @@ export interface RecordSliceRuns {
  * bounds are kept once they land, per revision, so a selection read again
  * while some of its searches are pending asks the source only for those.
  *
+ * A reader that batches (#1351) is asked a plan's searches in one request
+ * (`seekAll`, a batch per {@link MAX_RECORD_SLICE_BATCH} of them, all at once)
+ * and a window across several runs in one (`runsAll`): a window costs two
+ * requests however many ranges its narrowing selects. A window inside one run
+ * is the page it is, read as one.
+ *
+ * The cells of a series or a summary index (#1039) are read the same way: the
+ * searches of every cell a reader wants in one request, and the entries of
+ * every cell it reads in one more, each cell's runs kept per revision. A cell
+ * whose searches, or a run whose entries, a request still in flight asks waits
+ * on that request — asked again as it was, which asks the reader nothing new —
+ * so a reader wanting other cells while one read is in flight asks only for
+ * what no request asks.
+ *
  * @typeParam T - An entry; its contents are opaque to this adapter.
  */
 export declare class RecordSliceSource<T> {
@@ -47,11 +167,28 @@ export declare class RecordSliceSource<T> {
     private revision;
     private readonly resolved;
     private readonly landed;
+    private readonly cells;
+    private readonly askedCells;
+    private readonly askedRuns;
     private readonly pages;
     private pageCount;
     /** @param reader - Existing indexed-source reads, sharing one revision. */
     constructor(reader: RecordSliceReader<T>);
+    /**
+     * The record's revision now, and what is kept let go when it moves. A
+     * revision not known for the moment — read again, say — lets nothing go:
+     * what was kept is the revision's it was kept at, and stands for it again
+     * when that revision is known again.
+     */
     private current;
+    /**
+     * Several searches of one source, in order: in one request when the reader
+     * batches them (a batch for each {@link MAX_RECORD_SLICE_BATCH}, all asked
+     * in this pass), else each its own search, all started together.
+     *
+     * @returns Each search's bounds, in order; none while any is pending
+     */
+    private searchAll;
     /** One search's bounds: kept once they land, so a read again asks the source only while they are pending. */
     private search;
     /**
@@ -61,6 +198,140 @@ export declare class RecordSliceSource<T> {
      * @returns Complete ranges, or none while pending.
      */
     resolve(plan: RecordSlicePlan): option<RecordSliceRuns>;
+    /**
+     * Find several cells of a series or a summary index (#1039): each cell's
+     * searches' bounds and how many entries they hold — exact, before one is
+     * read. The searches of every cell not yet found go in one request (a batch
+     * for each {@link MAX_RECORD_SLICE_BATCH} of them, all asked in this pass),
+     * and a cell found is kept for its revision, so one asked again asks
+     * nothing. A cell a request still in flight asks waits on it: that request
+     * is asked again as it was, and only the cells no request asks go in a new
+     * one.
+     *
+     * @param index - The index the cells are of
+     * @param cells - The cells
+     * @returns Each cell's runs, by its name; none while any is pending
+     * @throws {Error} When two cells share a name, or the source answers a search with bounds no search has
+     */
+    cellRuns(index: string, cells: readonly RecordSliceCell[]): option<Map<string, RecordSliceCellRuns>>;
+    /**
+     * Find the bounds of several searches of one source (#1393): where each one's
+     * entries sit and how many it holds, in one request (a batch for each
+     * {@link MAX_RECORD_SLICE_BATCH} of them, all asked in this pass), no entry
+     * read and nothing kept here — what a density raster asks of an area
+     * index's cells, its counted ranges and the coarser levels' keys
+     * (`areaRaster`), whose entries {@link RecordSliceSource.runEntries} reads
+     * while they are few. A read again answers from the reader's own channels
+     * for the searches that landed.
+     *
+     * @param index - The source searched
+     * @param queries - The searches
+     * @returns Each search's bounds, in order; none while any is pending
+     * @throws {Error} When the source answers a search with bounds no search has
+     */
+    bounds(index: string, queries: readonly Query[]): option<Range[]>;
+    /**
+     * Read the entries of some runs of one source (#1393): the runs as searches
+     * found them at the record's revision now — ascending, disjoint and none
+     * empty — read in one request however many there are, a run a read still in
+     * flight asks waiting on it. Nothing is kept: the reader holds what it read.
+     *
+     * @param index - The source
+     * @param runs - The runs
+     * @returns Their entries, run after run; none while the read is pending
+     * @throws {Error} When the runs are not ascending, disjoint and each non-empty, or the entries read disagree with them
+     */
+    runEntries(index: string, runs: readonly Range[]): option<T[]>;
+    /**
+     * Read the rows another Dict holds under the keys the entries of some runs
+     * of one source name (#1393): the runs as {@link RecordSliceSource.runEntries}
+     * takes them, read in one request however many there are, a run a read
+     * still in flight asks waiting on it — each entry's key and the Dict's row
+     * under it, run after run. The keys are read where the source's entries
+     * are kept: none is sent. Nothing is kept: the reader holds what it read.
+     *
+     * @param index - The source
+     * @param runs - The runs
+     * @param dict - The Dict read: the `id` of its paged read
+     * @returns Each entry's key and its row there, run after run; none while the read is pending
+     * @throws {Error} When the reader reads no Dict by runs, the runs are not ascending, disjoint and each non-empty, or
+     *   the rows read disagree with them
+     */
+    runJoins(index: string, runs: readonly Range[], dict: string): option<RecordSliceJoined[]>;
+    /** Some runs' entries, or their rows of a Dict, by `read`: the runs checked, each asked once (see {@link RecordSliceSource.runEntries}). */
+    private runsRead;
+    /**
+     * Read several cells' entries (#1039): the entries of every cell's runs in
+     * one request — each run once, ascending, however many cells share it —
+     * handed back cell by cell, each in its searches' order. A run a read still
+     * in flight asks waits on it: that read is asked again as it was, and only
+     * the runs no read asks go in a new one. Nothing is kept once read: the
+     * reader holds the cells it draws.
+     *
+     * @param index - The index the cells are of
+     * @param cells - The cells
+     * @returns Each cell's entries, by its name; none while its runs or the read are pending
+     * @throws {Error} As {@link RecordSliceSource.cellRuns} does; when two of the
+     *   cells' searches overlap without being one, or the entries read disagree
+     *   with their bounds
+     */
+    cellEntries(index: string, cells: readonly RecordSliceCell[]): option<Map<string, T[]>>;
+    /**
+     * Read the rows another Dict holds under the keys several cells' entries
+     * name (#1393): every cell's runs in one request — each run once,
+     * ascending, however many cells share it — the keys read where the
+     * entries are kept, none sent, handed back cell by cell, each in its
+     * searches' order: each entry's key and the Dict's row under it. A run a
+     * read still in flight asks waits on it, as {@link RecordSliceSource.cellEntries}'s
+     * does. Nothing is kept once read: the reader holds the cells it draws —
+     * a Schematic's details, for the cells its window reads of its area index.
+     *
+     * @param index - The index the cells are of
+     * @param cells - The cells
+     * @param dict - The Dict read: the `id` of its paged read
+     * @returns Each cell's rows of the Dict, by its name; none while its runs or the read are pending
+     * @throws {Error} As {@link RecordSliceSource.cellEntries} does, and when the reader reads no Dict by runs
+     */
+    cellJoins(index: string, cells: readonly RecordSliceCell[], dict: string): option<Map<string, RecordSliceJoined[]>>;
+    /** Several cells' entries, or their rows of a Dict, by `read`: every cell's runs read once (see {@link RecordSliceSource.cellEntries}). */
+    private cellsRead;
+    /**
+     * Some runs of one source, read by `read` — their entries, or their rows of
+     * a Dict — each by its first row: a run a read of the same kind still in
+     * flight asks waits on that read — asked again as it was, which asks the
+     * reader nothing new — and the rest are read together, in one more.
+     *
+     * @param index - The source
+     * @param dict - The Dict whose rows are read; `undefined` for the entries
+     * @param runs - The runs: ascending, disjoint, none empty
+     * @param revision - The revision they were found at
+     * @param read - The read of some of the runs, in order
+     * @returns Each run's part, by its first row; `undefined` while a read is pending, or once the revision moved
+     */
+    private readAsked;
+    /**
+     * The rows a Dict holds under the keys the entries of some runs of one
+     * source name, in order: in one request through the reader, the keys read
+     * where the entries are kept.
+     *
+     * @param index - The source
+     * @param runs - The runs: ascending, disjoint, none empty
+     * @param dict - The Dict read: the `id` of its paged read
+     * @returns Each entry's key and its row there, in order; none while pending
+     * @throws {Error} When the reader reads no Dict by runs, or its rows disagree with the runs' entries
+     */
+    private readJoins;
+    /**
+     * The entries of some runs of one source, in order: in one request when the
+     * reader batches its reads, else a page at a time, every run's pages asked
+     * together.
+     *
+     * @param index - The source
+     * @param runs - The runs: ascending, disjoint, none empty
+     * @returns Their entries, in order; none while any is pending
+     * @throws {Error} When the source's entries disagree with the runs
+     */
+    private readRuns;
     /**
      * Read only the requested part of the union, filling short provider pages.
      * A bounded short result is valid under the shared paged-source contract.
@@ -70,6 +341,33 @@ export declare class RecordSliceSource<T> {
      * @returns The complete bounded window, or none while any piece is pending.
      */
     page(plan: RecordSlicePlan, offset: bigint, limit: bigint): option<T[]>;
+    /**
+     * Read a window of the union as the entries of the runs it covers, in one
+     * request (#1351): the window's part of each run, read together, however
+     * many runs it spans.
+     */
+    private pageByRuns;
+    /**
+     * Where a narrowing's rows sit in the record (#1349): its resolved runs
+     * placed by the reader, a window at a time, as far as they are placed.
+     *
+     * @param plan - Current narrowing
+     * @returns The placement so far, or none while the runs or the first window are pending
+     * @throws {Error} When the reader reads no placements
+     */
+    place(plan: RecordSlicePlan): option<RecordSlicePlacement>;
+    /**
+     * Which of some entries a narrowing's resolved runs hold (#1349), each
+     * answered by the reader from the runs: no row is examined here. Past
+     * {@link MAX_RECORD_SLICE_BATCH} entries, they are asked as several reads,
+     * all in this pass, as `resolve` asks a plan's searches.
+     *
+     * @param plan - Current narrowing
+     * @param entries - The entries asked of: each one's index key text and primary key
+     * @returns Whether each entry lies in the narrowing's runs, or none while pending
+     * @throws {Error} When the reader reads no memberships
+     */
+    within(plan: RecordSlicePlan, entries: readonly RecordSliceEntryKey[]): option<boolean[]>;
     /**
      * Intersect a key search with the selected ranges, translating both hits
      * and misses to positions in the narrowed view. No row reads are needed.

package/dist/src/runtime/record-slice-source.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"record-slice-source.d.ts","sourceRoot":"","sources":["../../../src/runtime/record-slice-source.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,+EAA+E;AAC/E,OAAO,EAAmC,KAAK,MAAM,EAAE,KAAK,WAAW,EAAE,MAAM,eAAe,CAAC;AAC/F,OAAO,EAAE,aAAa,EAAE,KAAK,aAAa,EAAE,MAAM,wBAAwB,CAAC;AAC3E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AAExE,KAAK,KAAK,GAAG,WAAW,CAAC,aAAa,CAAC,CAAC;AACxC,KAAK,KAAK,GAAG,WAAW,CAAC,aAAa,CAAC,CAAC;AAExC,0DAA0D;AAC1D,MAAM,WAAW,iBAAiB,CAAC,CAAC;IAChC,8CAA8C;IAC9C,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC;IAChE,mDAAmD;IACnD,IAAI,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;IACjD,8CAA8C;IAC9C,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,CAAC;IACrC,sDAAsD;IACtD,QAAQ,IAAI,MAAM,CAAC,MAAM,CAAC,CAAC;CAC9B;AAED,0EAA0E;AAC1E,MAAM,WAAW,eAAe;IAC5B,oBAAoB;IACpB,KAAK,EAAE,MAAM,CAAC;IACd,yBAAyB;IACzB,QAAQ,EAAE,MAAM,CAAC;IACjB,+DAA+D;IAC/D,IAAI,EAAE,KAAK,EAAE,CAAC;IACd,6BAA6B;IAC7B,KAAK,EAAE,MAAM,CAAC;CACjB;AAgBD;;;;;;;;;;;GAWG;AACH,qBAAa,iBAAiB,CAAC,CAAC;IAQhB,OAAO,CAAC,QAAQ,CAAC,MAAM;IAPnC,OAAO,CAAC,QAAQ,CAAqB;IACrC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAsC;IAC/D,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA4B;IACnD,OAAO,CAAC,QAAQ,CAAC,KAAK,CAA6E;IACnG,OAAO,CAAC,SAAS,CAAK;IAEtB,2EAA2E;gBAC9C,MAAM,EAAE,iBAAiB,CAAC,CAAC,CAAC;IAEzD,OAAO,CAAC,OAAO;IAaf,6GAA6G;IAC7G,OAAO,CAAC,MAAM;IASd;;;;;OAKG;IACH,OAAO,CAAC,IAAI,EAAE,eAAe,GAAG,MAAM,CAAC,eAAe,CAAC;IAyCvD;;;;;;;OAOG;IACH,IAAI,CAAC,IAAI,EAAE,eAAe,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC,CAAC,EAAE,CAAC;IA0CvE;;;;;;OAMG;IACH,IAAI,CAAC,IAAI,EAAE,eAAe,EAAE,KAAK,EAAE,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC;CAmB3D"}
+{"version":3,"file":"record-slice-source.d.ts","sourceRoot":"","sources":["../../../src/runtime/record-slice-source.ts"],"names":[],"mappings":"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"}