@elaraai/e3-ui 1.0.96 → 1.0.98

package/dist/src/schedule/events.js

@@ -43,10 +43,22 @@
  * part)`, and the kind reads overlap queries through its declared interval
  * indexes (the source's `range` naming the start field). It shares the
  * toolbar's filters and window, counts original events once, and reads backlog
- * through the same choices with an Unset start. It requires `entries` for
+ * through the same choices with an Unset start — the Plan's with its window, as
+ * one; the Calendar's never, as it pages the backlog through the source itself
+ * (#1424), its window reading the window's rows alone. It requires `entries` for
  * original-key inspection and Save. Existing drafts outside a new narrowing
  * remain in the session; Save includes them. A kind narrowed so takes no
- * `window` or `backlogWindow`.
+ * `window` or `backlogWindow`. Every kind counts its events before one is read
+ * (`count`, #1039) — through its source, the count its window's read asks
+ * first; through its day index, the days' entries the search its read asks
+ * first answers; its record read whole, in memory — and the Calendar's and the
+ * Plan's builds read its window only within `SCHEDULE_EVENT_CAP`, counted
+ * first (#1424). A day index files an event under each day it runs on, so its
+ * count is an upper bound on the events, never their number (`countExact`).
+ * A builder over resources read a window at a time reads a kind placed on them
+ * a cell at a time through the shared schedule reader, which hands each read
+ * seam — the events over a window, the backlog, one event by key — what it
+ * read of the kind's series index's cells (`cellsType`, `seriesKey`).
  *
  * A large record may also be read a window at a time (#1199, `window.ts`): given
  * `window`, a paged read of a day index keyed by `Schedule.days`, the kind's
@@ -84,30 +96,17 @@ import { EventStateType, TimeStepType } from "@elaraai/east-ui";
 import { EditingDraftFieldType, EditingReadinessType, Fields, FieldSpecType, TickFormatType } from "@elaraai/east-ui/internal";
 import { RowInspectorType, rowInspector } from "../utils/row-inspector.js";
 import { scheduleAccessor } from "./accessor.js";
+import { checkKeyField, fieldOf, fieldSetters, keyFieldRef, keyFieldSlots, keyFieldValue } from "./fields.js";
 import { SCHEDULE_TEMPLATES, checkedTemplates } from "./templates.js";
 import { SCHEDULE_DEF } from "./resources.js";
-import { scheduleRecordWindow } from "./record-window.js";
+import { SCHEDULE_EVENT_CAP, scheduleRecordCount, scheduleRecordWindow } from "./record-window.js";
 import { scheduleRecordSession } from "./session.js";
-import { checkEntries, checkIndexWindow, optionOf, scheduleBacklogWindow, scheduleDayWindow, typeText } from "./window.js";
+import { checkEntries, checkIndexWindow, optionOf, scheduleBacklogWindow, scheduleDayCount, scheduleDayWindow, typeText } from "./window.js";
 import { PlanEventItemType, PlanEventKindType, PlanEventReadType, ScheduleAllocationEntryType, ScheduleAllocationKindType, ScheduleAllocationRolesType, ScheduleClockType, ScheduleDraftsType, ScheduleDurationType, ScheduleItemType, ScheduleKindType, ScheduleReadyEntryType, ScheduleResourceRefType, ScheduleRosterEntryType, ScheduleRosterKindType, ScheduleRosterRolesType, ScheduleStatusCasesFor, ScheduleStatusType, ScheduleWriteType, ScheduleTemplateType, ScheduleReadType, } from "./types.js";
 /** The Roster's roles, as a kind's options name them. */
 const ROSTER_ROLES = ["shift", "group", "position", "activity", "hours"];
 /** The Allocation's roles, as a kind's options name them. */
 const ALLOCATION_ROLES = ["arrival", "parts", "hold", "kind"];
-// ============================================================================
-// Reading East types
-// ============================================================================
-/** A variant's cases, when every one of them holds a String. */
-function stringCases(type) {
-    if (type.type !== "Variant" || optionOf(type) !== undefined)
-        return undefined;
-    const cases = Object.entries(type.cases);
-    return cases.length > 0 && cases.every(([, t]) => isTypeEqual(t, StringType)) ? cases.map(([c]) => c) : undefined;
-}
-/** A field of a struct as an East expression, by name. */
-function fieldOf(row, name) {
-    return row[name];
-}
 /** The ways a kind draws. */
 const DRAWS = ["span", "buckets", "cards", "marks"];
 export function scheduleEvents(record, input) {
@@ -183,38 +182,10 @@ export function scheduleEvents(record, input) {
             ? `${where}: \`backlog\` is a kind's rows with no time, and an instant kind's \`at\` is a plain DateTime field — it has none`
             : `${where}: \`backlog\` is a kind's rows with no time, and its times are plain DateTime fields — make \`start\` and \`end\` Options for a backlog`);
     }
-    let resource;
-    if (config.resource !== undefined) {
-        const { field, of } = config.resource;
-        const type = fieldType("resource.field", field);
-        const inner = optionOf(type) ?? type;
-        const isOptional = optionOf(type) !== undefined;
-        const cases = stringCases(inner);
-        if (isTypeEqual(inner, StringType)) {
-            if (typeof of !== "string" || of === "") {
-                throw new Error(`${where}: \`resource.of\` names the resource slot "${field}" holds keys of — a String field holds one kind's keys`);
-            }
-            resource = { field, shape: "key", of, optional: isOptional };
-        }
-        else if (cases !== undefined) {
-            if (typeof of !== "object" || of === null) {
-                throw new Error(`${where}: "${field}" is a variant — \`resource.of\` names a resource slot per case: { ${cases.map((c) => `${c}: "…"`).join(", ")} }`);
-            }
-            const named = Object.keys(of);
-            if (named.length !== cases.length || !named.every((c) => cases.includes(c))) {
-                throw new Error(`${where}: \`resource.of\` names a resource slot for each of "${field}"'s cases (${cases.join(", ")}) — and it names ${named.join(", ") || "none"}`);
-            }
-            const kinds = Object.values(of);
-            if (new Set(kinds).size !== kinds.length) {
-                throw new Error(`${where}: \`resource.of\` names each resource slot once — a case per kind of resource — and it names ${kinds.join(", ")}`);
-            }
-            resource = { field, shape: "cases", of, cases, optional: isOptional, variant: inner };
-        }
-        else {
-            throw new Error(`${where}: \`resource.field\` names a field holding a resource's key — a String, a variant of String cases, or an Option of either — and "${field}" holds ${typeText(type)}`);
-        }
-    }
-    const takes = resource === undefined ? [] : resource.shape === "key" ? [resource.of] : Object.values(resource.of);
+    // The resource: a key of one kind, or a case per kind (`fields.ts`).
+    const resource = config.resource === undefined ? undefined
+        : checkKeyField(config.resource.field, fieldType("resource.field", config.resource.field), config.resource.of, { where, prop: "resource", noun: "resource" });
+    const takes = resource === undefined ? [] : keyFieldSlots(resource);
     // The status: a variant, a Status per case.
     let statusCases;
     let statusTable;
@@ -348,6 +319,8 @@ export function scheduleEvents(record, input) {
     // ── The East the seams share ─────────────────────────────────────────
     const draftType = EditingDraftFieldType(rowType);
     const EntryRowType = StructType({ id: StringType, key: keyType, row: rowType });
+    // The stored entries a reader read by a series index's cells (#1039), each its key and its row.
+    const CellsType = ArrayType(StructType({ key: keyType, row: rowType }));
     // The entry a draft leaves: the drafted entry, none for one deleted, the held one for a draft it cannot read.
     const drafted = East.function([BlobType, OptionType(rowType)], OptionType(rowType), (_$, bytes, held) => bytes.decodeBeast(draftType, "v2").match({
         value: (_$2, row) => East.value(some(row), OptionType(rowType)),
@@ -394,6 +367,31 @@ export function scheduleEvents(record, input) {
         : East.value(some(fieldOf(row, name)), OptionType(DateTimeType));
     // A time as its field holds it: an Option field holds `some`.
     const placedAt = (t) => (optional ? East.value(some(t), OptionType(DateTimeType)) : t);
+    // How many of the record's stored events overlap [from, to), its record read whole, counted in memory (#1039): by the
+    // views' rule, an optional missing end an instant at its start, as the views place it.
+    const countWhole = East.function([DateTimeType, DateTimeType], OptionType(IntegerType), ($, from, to) => {
+        const all = $.const(readAll());
+        const n = $.let(0n, IntegerType);
+        $.for(all, ($2, row) => {
+            const start = $2.const(instant(row, startField));
+            const end = $2.const(instant(row, endField).match({
+                none: () => start,
+                some: (_$3, e) => East.value(some(e), OptionType(DateTimeType)),
+            }));
+            $2.match(start, {
+                some: ($3, s) => {
+                    $3.match(end, {
+                        some: ($4, e) => {
+                            $4.if(East.less(s, to).and(() => East.greater(e, from).or(() => East.greaterEqual(s, from))), ($5) => {
+                                $5.assign(n, n.add(1n));
+                            });
+                        },
+                    });
+                },
+            });
+        });
+        return East.value(some(n), OptionType(IntegerType));
+    });
     // A duration in minutes — a month counts 30 days.
     const minutesOf = East.function([ScheduleDurationType], IntegerType, (_$, step) => East.Float.roundHalf(step.match({
         minutes: (_$2, n) => n,
@@ -406,53 +404,12 @@ export function scheduleEvents(record, input) {
         : East.function([rowType, keyType], ScheduleDurationType, (_$, row, key) => config.backlog.duration(row, key));
     const dueOf = config.backlog?.due === undefined ? undefined
         : East.function([rowType, keyType], OptionType(DateTimeType), (_$, row, key) => config.backlog.due(row, key));
-    // The resource a row is on.
+    // The resource a row is on (`fields.ts`).
     const RefOption = OptionType(ScheduleResourceRefType);
-    const refOf = East.function([rowType], RefOption, (_$, row) => {
-        if (resource === undefined)
-            return East.value(none, RefOption);
-        const value = fieldOf(row, resource.field);
-        if (resource.shape === "key") {
-            const kind = resource.of;
-            const ref = (key) => East.value(some(East.value({ kind, key }, ScheduleResourceRefType)), RefOption);
-            return resource.optional
-                ? value.match({ none: (_$2) => East.value(none, RefOption), some: (_$2, key) => ref(key) })
-                : ref(value);
-        }
-        const of = resource.of;
-        const byCase = (v) => v.match(Object.fromEntries(resource.cases.map((c) => [c, (_$2, key) => East.value(some(East.value({ kind: of[c], key }, ScheduleResourceRefType)), RefOption)])));
-        return resource.optional
-            ? value.match({ none: (_$2) => East.value(none, RefOption), some: (_$2, v) => byCase(v) })
-            : byCase(value);
-    });
+    const refOf = keyFieldRef(resource, rowType);
     // The value a resource field takes for a placement's resource; `none` where the kind refuses it: a resource of a
     // kind it does not take, or none for a field that must hold one.
-    const resourceValue = resource === undefined ? undefined : (() => {
-        const valueType = fields[resource.field];
-        return East.function([RefOption], OptionType(valueType), ($, ref) => {
-            const result = $.let(East.value(none, OptionType(valueType)), OptionType(valueType));
-            $.match(ref, {
-                none: ($2) => {
-                    if (resource.optional)
-                        $2.assign(result, East.value(some(East.value(none, valueType)), OptionType(valueType)));
-                },
-                some: ($2, r) => {
-                    if (resource.shape === "key") {
-                        const key = resource.optional ? East.value(some(r.key), valueType) : r.key;
-                        $2.if(East.equal(r.kind, resource.of), ($3) => { $3.assign(result, East.value(some(key), OptionType(valueType))); });
-                    }
-                    else {
-                        for (const c of resource.cases) {
-                            const caseValue = East.value(variant(c, r.key), resource.variant);
-                            const held = resource.optional ? East.value(some(caseValue), valueType) : caseValue;
-                            $2.if(East.equal(r.kind, resource.of[c]), ($3) => { $3.assign(result, East.value(some(held), OptionType(valueType))); });
-                        }
-                    }
-                },
-            });
-            return result;
-        });
-    })();
+    const resourceValue = resource === undefined ? undefined : keyFieldValue(resource, fields[resource.field]);
     // A row of the record's type, field by field: its times and resource from a placement, the rest from `source`.
     // An instant kind's `at` is its start.
     const rowWith = (source, start, end, resourceField) => East.value(Object.fromEntries(Object.keys(fields).map((f) => [f,
@@ -476,51 +433,45 @@ export function scheduleEvents(record, input) {
         return result;
     });
     // A setter for every field, at any depth: an inspector edit writes one (`field`), its value as bytes at the field's type.
-    const setters = [];
-    const setterOf = (prefix, name, type) => East.function([rowType, BlobType], rowType, (_$, row, bytes) => {
-        const value = bytes.decodeBeast(type, "v2");
-        // The structs down the path, each with the field below it replaced, rebuilt from the leaf up.
-        const chain = [];
-        let at = row;
-        let struct = rowType;
-        for (const step of prefix) {
-            chain.push({ struct, field: step, at });
-            at = fieldOf(at, step);
-            struct = struct.fields[step];
-        }
-        const leaf = struct;
-        const leafAt = at;
-        let next = East.value(Object.fromEntries(Object.keys(leaf.fields).map((f) => [f, f === name ? value : fieldOf(leafAt, f)])), leaf);
-        for (let i = chain.length - 1; i >= 0; i--) {
-            const link = chain[i];
-            const inner = next;
-            next = East.value(Object.fromEntries(Object.keys(link.struct.fields).map((f) => [f, f === link.field ? inner : fieldOf(link.at, f)])), link.struct);
-        }
-        return next;
-    });
-    const collect = (struct, prefix) => {
-        for (const [name, type] of Object.entries(struct.fields)) {
-            setters.push({ path: [...prefix, name], set: setterOf(prefix, name, type) });
-            if (type.type === "Struct")
-                collect(type, [...prefix, name]);
-        }
-    };
-    collect(rowType, []);
-    const readsOf = (slot, part) => {
+    const setters = fieldSetters(rowType);
+    /**
+     * The reads, through the kind's source of its builder's slice when it has one — given `cap` (#1039, #1424), the
+     * Calendar's and the Plan's, its window counted first, through the source, through its day index or in memory, and
+     * read only within `cap`, its backlog whole. Given `pagedBacklog` (#1424, the Calendar's), a kind with a backlog
+     * narrowed through its source reads its window's rows alone: its builder pages the backlog through the source itself.
+     */
+    const readsOf = (slot, part, cap, pagedBacklog = false) => {
         if (part === undefined) {
             if (entries !== undefined && dayWindow === undefined) {
                 throw new Error(`${where}: \`entries\` reads one event by its key beside \`window\`, or beside the kind's source of its builder's ` +
                     `Slice.bindRecords (one named "${slot}") — give one of those with it`);
             }
             const unscheduled = backlogWindow === undefined ? undefined : scheduleBacklogWindow(backlogWindow, keyType, rowType, where);
+            // A backlog index's read takes no window: the window is given, and read past.
+            const backlog = unscheduled === undefined ? undefined : East.function([DateTimeType, DateTimeType], OptionType(HeldType), ($, _from, _to) => {
+                const read = $.const(unscheduled);
+                return read();
+            });
+            // A record read whole under a cap (#1039): its window counted in memory first, and drawn only within the cap —
+            // past it the window answers none, and none of its events draws.
+            const capped = cap === undefined || dayWindow !== undefined ? undefined
+                : East.function([DateTimeType, DateTimeType], OptionType(HeldType), ($, from, to) => {
+                    const count = $.const(countWhole);
+                    const result = $.let(East.value(none, OptionType(HeldType)), OptionType(HeldType));
+                    $.match(count(from, to), {
+                        some: ($2, n) => {
+                            $2.if(n.lessEqual(BigInt(cap)), ($3) => { $3.assign(result, East.value(some(readAll()), OptionType(HeldType))); });
+                        },
+                    });
+                    return result;
+                });
             return {
-                days: dayWindow === undefined ? undefined : scheduleDayWindow(dayWindow, keyType, rowType, where),
-                // A backlog index's read takes no window: the window is given, and read past.
-                backlog: unscheduled === undefined ? undefined : East.function([DateTimeType, DateTimeType], OptionType(HeldType), ($, _from, _to) => {
-                    const read = $.const(unscheduled);
-                    return read();
-                }),
+                // A day index under a cap counts the days' entries first, and past it reads no page (#1039).
+                days: dayWindow === undefined ? capped : scheduleDayWindow(dayWindow, keyType, rowType, where, cap),
+                backlog,
+                alone: backlog,
                 withDrafts: withDraftsFor(false),
+                pagedBacklog: false,
             };
         }
         if (dayWindow !== undefined || backlogWindow !== undefined) {
@@ -530,13 +481,20 @@ export function scheduleEvents(record, input) {
             throw new Error(`${where}: the builder's source "${slot}" reads only its narrowing — and one event, the inspector's ` +
                 "or its editing's, is read by its key: give `entries` beside it, Data.bindPaged(record), the record's own entries");
         }
-        const scheduled = scheduleRecordWindow(part, slot, keyType, rowType, startField, endField, optional, false, where);
+        const scheduled = scheduleRecordWindow(part, slot, keyType, rowType, startField, endField, optional, false, where, cap);
         if (!optional)
-            return { days: scheduled, backlog: undefined, withDrafts: withDraftsFor(true) };
+            return { days: scheduled, backlog: undefined, alone: undefined, withDrafts: withDraftsFor(true), pagedBacklog: false };
+        const backlogged = scheduleRecordWindow(part, slot, keyType, rowType, startField, endField, optional, true, where);
+        if (pagedBacklog) {
+            // Its builder pages its backlog through the source itself (#1424): the window is its rows alone, and a draft
+            // its host gives draws where it places its event — a backlog event scheduled into the window among them — the
+            // host having left out those of events the narrowing does not hold. Its backlog whole is `unscheduled`'s
+            // alone, which such a builder never asks.
+            return { days: scheduled, backlog: backlogged, alone: backlogged, withDrafts: withDraftsFor(false), pagedBacklog: true };
+        }
         // A kind with a backlog reads both through its source as one: what its narrowing holds over the window and in
         // its backlog. A draft then moves an event between the two by its times alone, and a draft the narrowing does
         // not hold never shows in either (#1343).
-        const backlogged = scheduleRecordWindow(part, slot, keyType, rowType, startField, endField, optional, true, where);
         const both = East.function([DateTimeType, DateTimeType], OptionType(HeldType), ($, from, to) => {
             const inWindow = $.const(scheduled);
             const inBacklog = $.const(backlogged);
@@ -554,7 +512,7 @@ export function scheduleEvents(record, input) {
             });
             return result;
         });
-        return { days: both, backlog: both, withDrafts: withDraftsFor(true) };
+        return { days: both, backlog: both, alone: backlogged, withDrafts: withDraftsFor(true), pagedBacklog: false };
     };
     /** An item seam over a window: the events whose items `itemFn` makes that overlap `[from, to)`. */
     const windowOf = (itemType, itemFn, reads) => East.function([DateTimeType, DateTimeType, ScheduleDraftsType], OptionType(ArrayType(itemType)), ($, from, to, drafts) => {
@@ -622,6 +580,123 @@ export function scheduleEvents(record, input) {
         }
         return result;
     });
+    // ── A kind a reader reads by a series index's cells (#1039) ──────────
+    // The reader gives the entries it read as one beast2 of `CellsType`; a long event its cells repeat, tile by tile,
+    // is one entry, held once by its key. Every draft it gives shows: it gives a draft of an entry it did not read only
+    // where its narrowing holds the entry, or the record does not.
+    /** The entries a reader read by cells, as the record's rows by key. */
+    const cellsHeld = East.function([BlobType], HeldType, ($, bytes) => {
+        const entries = $.const(bytes.decodeBeast(CellsType, "v2"));
+        const held = $.let(new Map(), HeldType);
+        $.for(entries, ($2, entry) => {
+            $2(held.insertOrUpdate(entry.key, entry.row, (_$3, _was, now) => now));
+        });
+        return held;
+    });
+    /** Every draft given in place over the entries a reader read by cells, as `withDraftsFor` gives them. */
+    const cellsInPlace = withDraftsFor(false);
+    /** An item seam over the entries a reader read by cells: the events whose items `itemFn` makes that overlap `[from, to)`, by the views' rule. */
+    const cellsOf = (itemType, itemFn) => East.function([BlobType, DateTimeType, DateTimeType, ScheduleDraftsType], ArrayType(itemType), ($, bytes, from, to, drafts) => {
+        const hold = $.const(cellsHeld);
+        const inPlace = $.const(cellsInPlace);
+        const item = $.const(itemFn);
+        const out = $.let([], ArrayType(itemType));
+        $.for(inPlace(hold(bytes), drafts), ($2, entry) => {
+            const one = $2.const(item(entry));
+            $2.match(one.start, {
+                some: ($3, s) => {
+                    $3.match(one.end, {
+                        some: ($4, e) => {
+                            $4.if(East.less(s, to).and(() => East.greater(e, from).or(() => East.greaterEqual(s, from))), ($5) => {
+                                $5(out.pushLast(one));
+                            });
+                        },
+                    });
+                },
+            });
+        });
+        return out;
+    });
+    /**
+     * A backlog seam beside the entries a reader read by cells: the backlog read alone, never the window, with those
+     * entries held beside it — a draft moves an event between them by its times alone — the rows with no time, as
+     * `itemFn` makes them.
+     */
+    const backlogBeside = (itemType, itemFn, reads) => East.function([BlobType, DateTimeType, DateTimeType, ScheduleDraftsType], OptionType(ArrayType(itemType)), ($, bytes, from, to, drafts) => {
+        const result = $.let(East.value(some([]), OptionType(ArrayType(itemType))), OptionType(ArrayType(itemType)));
+        if (optional) {
+            const hold = $.const(cellsHeld);
+            const inPlace = $.const(cellsInPlace);
+            const item = $.const(itemFn);
+            let read;
+            if (reads.alone === undefined) {
+                read = $.let(East.value(some(readAll()), OptionType(HeldType)));
+            }
+            else {
+                const alone = $.const(reads.alone);
+                read = $.let(alone(from, to));
+            }
+            $.assign(result, East.value(none, OptionType(ArrayType(itemType))));
+            $.match(read, {
+                some: ($2, rows) => {
+                    const all = $2.let(hold(bytes));
+                    $2(all.unionInPlace(rows, (_$3, held) => held));
+                    const out = $2.let([], ArrayType(itemType));
+                    $2.for(inPlace(all, drafts), ($3, entry) => {
+                        const one = $3.const(item(entry));
+                        $3.if(one.start.hasTag("none"), ($4) => { $4(out.pushLast(one)); });
+                    });
+                    $2.assign(result, East.value(some(out), OptionType(ArrayType(itemType))));
+                },
+            });
+        }
+        return result;
+    });
+    /**
+     * One event by its key's text, the drafts in place, of a kind a reader reads by cells: the drafts, then its row as
+     * the reader holds it (`held`, none for one it does not), then the backlog read alone — but where its builder pages
+     * the backlog itself (#1424) — then its key; never the window.
+     */
+    const readBeside = (makeItem, readType, reads) => East.function([StringType, ScheduleDraftsType, DateTimeType, DateTimeType, OptionType(BlobType)], OptionType(readType), ($, id, drafts, from, to, held) => {
+        const parse = $.const(keyOf);
+        const make = $.const(makeItem);
+        const key = $.const(parse(id));
+        const row = $.let(East.value(none, OptionType(rowType)), OptionType(rowType));
+        const unread = $.let(true, BooleanType);
+        $.if(drafts.has(id), ($2) => {
+            $2.match(drafts.get(id).decodeBeast(draftType, "v2"), {
+                value: ($3, entry) => {
+                    $3.assign(row, East.value(some(entry), OptionType(rowType)));
+                    $3.assign(unread, false);
+                },
+                missing: ($3) => { $3.assign(unread, false); },
+            });
+        });
+        $.if(unread, ($2) => {
+            $2.match(held, { some: ($3, bytes) => { $3.assign(row, East.value(some(bytes.decodeBeast(rowType, "v2")), OptionType(rowType))); } });
+            // A builder that pages the backlog itself never has it read whole (#1424): its key reads one event.
+            if (reads.alone !== undefined && !reads.pagedBacklog) {
+                const alone = $2.const(reads.alone);
+                $2.if(row.hasTag("none"), ($3) => {
+                    $3.match(alone(from, to), { some: ($4, rows) => { $4.assign(row, rows.tryGet(key)); } });
+                });
+            }
+            if (byKey === undefined) {
+                const all = $2.const(readAll());
+                $2.if(row.hasTag("none"), ($3) => { $3.assign(row, all.tryGet(key)); });
+            }
+            else {
+                const find = $2.const(byKey);
+                $2.if(row.hasTag("none"), ($3) => {
+                    $3.match(find(id), { held: ($4, stored) => { $4.assign(row, East.value(some(stored), OptionType(rowType))); } });
+                });
+            }
+        });
+        return row.match({
+            some: (_$2, r) => East.value(some({ item: make({ id, key, row: r }), row: East.Blob.encodeBeast(r, "v2") }), OptionType(readType)),
+            none: (_$2) => East.value(none, OptionType(readType)),
+        });
+    });
     const readEvent = (makeItem, readType, reads) => East.function([StringType, ScheduleDraftsType, DateTimeType, DateTimeType], OptionType(readType), ($, id, drafts, from, to) => {
         const parse = $.const(keyOf);
         const make = $.const(makeItem);
@@ -645,7 +720,8 @@ export function scheduleEvents(record, input) {
             }
             const days = $2.const(reads.days);
             $2.match(days(from, to), { some: ($3, held) => { $3.assign(row, held.tryGet(key)); } });
-            if (reads.backlog !== undefined) {
+            // A builder that pages the backlog itself never has it read whole (#1424): its key reads one event.
+            if (reads.backlog !== undefined && !reads.pagedBacklog) {
                 const backlog = $2.const(reads.backlog);
                 $2.if(row.hasTag("none"), ($3) => {
                     $3.match(backlog(from, to), { some: ($4, held) => { $4.assign(row, held.tryGet(key)); } });
@@ -661,12 +737,114 @@ export function scheduleEvents(record, input) {
             none: (_$2) => East.value(none, OptionType(readType)),
         });
     });
+    /**
+     * A kind's three read seams over its events as `itemFn` makes them (#1039): its events over a window, its backlog,
+     * and one event by its key — each from what a reader read by its series index's cells when it is given that, and
+     * never the window then; else over the window, as `reads` reads it.
+     */
+    const readSeams = (itemType, itemFn, readType, reads) => {
+        const window = windowOf(itemType, itemFn, reads);
+        const cells = cellsOf(itemType, itemFn);
+        const items = East.function([DateTimeType, DateTimeType, ScheduleDraftsType, OptionType(BlobType)], OptionType(ArrayType(itemType)), ($, from, to, drafts, read) => {
+            const overWindow = $.const(window);
+            const fromCells = $.const(cells);
+            return read.match({
+                none: (_$2) => overWindow(from, to, drafts),
+                some: (_$2, bytes) => East.value(some(fromCells(bytes, from, to, drafts)), OptionType(ArrayType(itemType))),
+            });
+        });
+        const backlog = backlogOf(itemType, itemFn, reads);
+        const besideCells = backlogBeside(itemType, itemFn, reads);
+        const unscheduled = East.function([DateTimeType, DateTimeType, ScheduleDraftsType, OptionType(BlobType)], OptionType(ArrayType(itemType)), ($, from, to, drafts, read) => {
+            const overWindow = $.const(backlog);
+            const beside = $.const(besideCells);
+            return read.match({
+                none: (_$2) => overWindow(from, to, drafts),
+                some: (_$2, bytes) => beside(bytes, from, to, drafts),
+            });
+        });
+        const windowed = readEvent(itemFn, readType, reads);
+        const besideRead = readBeside(itemFn, readType, reads);
+        const event = East.function([StringType, ScheduleDraftsType, DateTimeType, DateTimeType, OptionType(OptionType(BlobType))], OptionType(readType), ($, id, drafts, from, to, held) => {
+            const overWindow = $.const(windowed);
+            const byCells = $.const(besideRead);
+            return held.match({
+                none: (_$2) => overWindow(id, drafts, from, to),
+                some: (_$2, row) => byCells(id, drafts, from, to, row),
+            });
+        });
+        return { items, unscheduled, event };
+    };
+    /**
+     * A kind's events' rows over a window and its backlog's beside them, by key, the drafts in place, read once (#1409,
+     * R24): the reads `event` finds one row in — the window's rows, then the backlog's where it is read apart from them —
+     * as the record's own Dict's bytes, so a run's request finds every event's row there rather than reading them all
+     * again an event. `none` while a read is in flight. It reads the window, never a reader's cells: a kind read by them
+     * carries no request.
+     */
+    const rowsOver = (reads) => {
+        // A backlog read apart from the window's rows — a backlog index's, beside a day index — is read beside them; one
+        // read through the kind's source is read with them, and a record read whole holds it already.
+        const apart = reads.backlog !== undefined && !Object.is(reads.backlog, reads.days) && !reads.pagedBacklog;
+        // The entries held, the drafts in place, as the record's own Dict, by key: its bytes.
+        const heldBytes = East.function([ArrayType(EntryRowType)], BlobType, ($, entries) => {
+            const out = $.let(new Map(), HeldType);
+            $.for(entries, ($2, entry) => { $2(out.insert(entry.key, entry.row)); });
+            return East.Blob.encodeBeast(out, "v2");
+        });
+        return East.function([DateTimeType, DateTimeType, ScheduleDraftsType], OptionType(BlobType), ($, from, to, drafts) => {
+            const inPlace = $.const(reads.withDrafts);
+            const bytesOf = $.const(heldBytes);
+            const result = $.let(East.value(none, OptionType(BlobType)), OptionType(BlobType));
+            let read;
+            if (reads.days === undefined) {
+                read = $.let(East.value(some(readAll()), OptionType(HeldType)));
+            }
+            else {
+                const days = $.const(reads.days);
+                read = $.let(days(from, to));
+            }
+            $.match(read, {
+                some: ($2, rows) => {
+                    if (!apart) {
+                        $2.assign(result, East.value(some(bytesOf(inPlace(rows, drafts))), OptionType(BlobType)));
+                        return;
+                    }
+                    const backlog = $2.const(reads.backlog);
+                    $2.match(backlog(from, to), {
+                        some: ($3, more) => {
+                            const all = $3.let(rows.copy());
+                            $3(all.unionInPlace(more, (_$4, held) => held));
+                            $3.assign(result, East.value(some(bytesOf(inPlace(all, drafts))), OptionType(BlobType)));
+                        },
+                    });
+                },
+            });
+            return result;
+        });
+    };
+    // The `.east` text of the value the resource field holds for a resource, or for none: what a series or a summary
+    // index of the record files the resource's events under (#1039), the key a reader's cells search for.
+    const seriesKey = East.function([RefOption], OptionType(StringType), ($, ref) => {
+        const result = $.let(none, OptionType(StringType));
+        if (resourceValue !== undefined) {
+            const resolve = $.const(resourceValue);
+            $.match(resolve(ref), { some: ($2, value) => { $2.assign(result, some(East.print(value))); } });
+        }
+        return result;
+    });
     /**
      * The Calendar's kind, part by part, under its slot and through its source's part, its form `form` — and the
-     * function that makes one of its events.
+     * function that makes one of its events. Given `cap`, its window — through its source, through its day index or in
+     * memory, its record read whole — is counted first and read only within it (#1039, #1424): the Calendar's and the
+     * Plan's. Every kind is counted before one of its events is read (`count`), through its source's interval index —
+     * the count its window's read asks first, so none of its own — through its day index, the days' entries the search
+     * its window's read asks first answers (an upper bound, never their number: `countExact` false), or in memory. Given
+     * `pagedBacklog` (#1424, the Calendar's), a kind with a backlog narrowed through its source reads its window's rows
+     * alone, its builder paging the backlog through the source itself.
      */
-    const kindParts = (slot, part, form) => {
-        const reads = readsOf(slot, part);
+    const kindParts = (slot, part, form, cap, pagedBacklog = false) => {
+        const reads = readsOf(slot, part, cap, pagedBacklog);
         // One event, as every view draws it.
         const itemOf = East.function([EntryRowType], ScheduleItemType, ($, entry) => {
             const row = entry.row;
@@ -711,8 +889,13 @@ export function scheduleEvents(record, input) {
                 due,
             }, ScheduleItemType);
         });
-        const items = windowOf(ScheduleItemType, itemOf, reads);
-        const unscheduled = backlogOf(ScheduleItemType, itemOf, reads);
+        const seams = readSeams(ScheduleItemType, itemOf, ScheduleReadType, reads);
+        // How many of its stored events overlap [from, to), counted before one is read (#1039): through its source's
+        // interval index — the count its window's read asks first, so none of its own; through its day index, the days'
+        // entries the search its window's read asks first answers — an event under each day it runs on, so an upper
+        // bound on them, never their number; or, its record read whole, in memory, by the views' rule.
+        const count = part !== undefined ? scheduleRecordCount(part, slot, keyType, rowType, startField, endField, optional, where)
+            : dayWindow !== undefined ? scheduleDayCount(dayWindow, where) : countWhole;
         // Each template's values, by key, as the templates on the wire carry them.
         const templateRows = boundTemplates ?? East.value(templates.map((t) => ({
             key: t.key, name: t.name, group: t.group === undefined ? none : some(t.group),
@@ -803,20 +986,25 @@ export function scheduleEvents(record, input) {
             templates: templateRows,
             templatesSource: templatesSource === undefined ? none : some(templatesSource),
             fields: East.value(form, ArrayType(FieldSpecType)),
-            items,
-            unscheduled,
+            items: seams.items,
+            unscheduled: seams.unscheduled,
             write,
             ready: ready === undefined ? none : some(ready),
             editing,
             entries: entriesSeam,
             history: session.history,
-            event: readEvent(itemOf, ScheduleReadType, reads),
+            event: seams.event,
             // A kind with no title names none: the Calendar and Plan, whose inspectors draw it, refuse one.
             schedule: { title: titleField ?? "", start: startField, end: endField,
                 resource: resource === undefined ? none : some(resource.field),
                 status: config.status === undefined ? none : some(config.status.field) },
             overlaps: variant(overlaps, null),
             inspector: inspector === undefined ? none : some(inspector),
+            seriesKey,
+            cellsType: toEastTypeValue(CellsType),
+            count,
+            // Every count but a day index's counts the events themselves.
+            countExact: part !== undefined || dayWindow === undefined,
         };
         return { fields: fieldsOfKind, itemOf, reads };
     };
@@ -886,8 +1074,13 @@ export function scheduleEvents(record, input) {
         roles: [...rosterGiven, ...allocationGiven],
         partsOf: config.parts?.of,
         allocationValues,
+        times: { start: startField, end: endField },
+        resourceField: resource?.field,
+        windowed: dayWindow !== undefined,
         build(slot, part) {
-            return East.value(kindParts(slot, part, formSpecs).fields, ScheduleKindType);
+            // Its window counted first, and read only within the cap (#1424): past it, no page is read. The Calendar pages
+            // a narrowed kind's backlog through its source itself, so its window reads the window's rows alone.
+            return East.value(kindParts(slot, part, formSpecs, SCHEDULE_EVENT_CAP, true).fields, ScheduleKindType);
         },
         buildRoster(slot, part) {
             // A duty runs from its start to its end, keyed by String, on its slot's shift and group, rostered to someone.
@@ -1066,7 +1259,8 @@ export function scheduleEvents(record, input) {
             }, ScheduleAllocationKindType);
         },
         buildPlan(slot, part) {
-            const parts = kindParts(slot, part, formSpecs);
+            // Its window through its source counted first, and read only within the cap (#1039): past it, no page is read.
+            const parts = kindParts(slot, part, formSpecs, SCHEDULE_EVENT_CAP);
             const quantity = config.quantity;
             const format = quantity?.format === undefined ? undefined : East.value(quantity.format, TickFormatType);
             // One event as Plan draws it: what every view draws, with its roles read from their fields.
@@ -1087,12 +1281,10 @@ export function scheduleEvents(record, input) {
                     lane: laneField === undefined ? none : some(fieldOf(row, laneField)),
                 }, PlanEventItemType);
             });
-            // One event by its id, the drafts in place: as Plan draws it, and its row as bytes. A draft holds its
-            // event as drafted, or says it was deleted; an event never drafted — or one whose draft can't be read —
-            // is the record's: read whole, or for a kind read a window at a time (#1199) looked for first among the
-            // rows its windows hold over [from, to) and its backlog's, where a gesture's event is drawn, then read
-            // by its key.
-            const planEvent = readEvent(planItemOf, PlanEventReadType, parts.reads);
+            // One event by its id, the drafts in place, as Plan draws it, and its events and its backlog as Plan draws
+            // them: the kind's three read seams over its own item (`readSeams`) — a kind a reader reads by its series
+            // index's cells (#1039) given what it read, and never reading the window.
+            const plan = readSeams(PlanEventItemType, planItemOf, PlanEventReadType, parts.reads);
             const name = (field) => (field === undefined ? none : some(field));
             return East.value({
                 ...parts.fields,
@@ -1100,9 +1292,11 @@ export function scheduleEvents(record, input) {
                 instant: instantKind,
                 overlaps: variant(overlaps, null),
                 roles: { state: name(stateField), quantity: name(quantityField), lane: name(laneField) },
-                planItems: windowOf(PlanEventItemType, planItemOf, parts.reads),
-                planUnscheduled: backlogOf(PlanEventItemType, planItemOf, parts.reads),
-                planEvent,
+                planItems: plan.items,
+                planUnscheduled: plan.unscheduled,
+                planEvent: plan.event,
+                // Every event's row at once, for a run's request (#1409, R24): read once, never once an event.
+                planRows: rowsOver(parts.reads),
                 inspector: inspector === undefined ? East.value(none, OptionType(RowInspectorType)) : East.value(some(inspector), OptionType(RowInspectorType)),
             }, PlanEventKindType);
         },