@elaraai/e3-ui 1.0.97 → 1.0.99

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,32 +96,31 @@ 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"];
+/**
+ * A kind built in a block of its own, which holds each function its parts
+ * share once ({@link Once}): a kind built for a view is a struct of functions,
+ * and each of them calling the kind's reads and its item would otherwise
+ * write them again.
+ *
+ * @param build - The kind's build, given what holds its shared functions
+ * @returns The kind
+ */
+function heldKind(build) {
+    return Expr.block(($) => build((value) => $.const(value)));
+}
 export function scheduleEvents(record, input) {
     const config = input;
     const where = `Schedule.events: "${config.name}"`;
@@ -125,7 +136,7 @@ export function scheduleEvents(record, input) {
     const read = handleType.type === "Struct" ? handleType.fields["read"] : undefined;
     if (handleType.type !== "Struct" || read === undefined || read.type !== "Function"
         || handleType.fields["binding"] === undefined) {
-        throw new Error(`${where}: \`record\` is a record bound with its patch mutation — Record.bind(record, [e3.mutation.patch(record)])`);
+        throw new Error(`${where}: \`record\` is a record bound with its patch mutation — Record.bind(record), its record declaring patch: mutation.patch()`);
     }
     const recordType = read.output;
     if (recordType.type !== "Dict" || recordType.value.type !== "Struct") {
@@ -183,38 +194,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 +331,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 +379,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 +416,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 +445,46 @@ 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 = (once, 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);
+            const unscheduled = backlogWindow === undefined ? undefined
+                : once(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 : once(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
+                : once(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();
-                }),
-                withDrafts: withDraftsFor(false),
+                // A day index under a cap counts the days' entries first, and past it reads no page (#1039).
+                days: dayWindow === undefined ? capped : once(scheduleDayWindow(dayWindow, keyType, rowType, where, cap)),
+                backlog,
+                alone: backlog,
+                withDrafts: once(withDraftsFor(false)),
+                pagedBacklog: false,
             };
         }
         if (dayWindow !== undefined || backlogWindow !== undefined) {
@@ -530,14 +494,21 @@ 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 = once(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: once(withDraftsFor(true)), pagedBacklog: false };
+        const backlogged = once(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: once(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 both = once(East.function([DateTimeType, DateTimeType], OptionType(HeldType), ($, from, to) => {
             const inWindow = $.const(scheduled);
             const inBacklog = $.const(backlogged);
             const result = $.let(East.value(none, OptionType(HeldType)), OptionType(HeldType));
@@ -553,8 +524,8 @@ export function scheduleEvents(record, input) {
                 },
             });
             return result;
-        });
-        return { days: both, backlog: both, withDrafts: withDraftsFor(true) };
+        }));
+        return { days: both, backlog: both, alone: backlogged, withDrafts: once(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 +593,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`; an event past a year its cells repeat, year by
+    // year, 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 +733,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,14 +750,116 @@ 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 = (once, slot, part, form, cap, pagedBacklog = false) => {
+        const reads = readsOf(once, slot, part, cap, pagedBacklog);
         // One event, as every view draws it.
-        const itemOf = East.function([EntryRowType], ScheduleItemType, ($, entry) => {
+        const itemOf = once(East.function([EntryRowType], ScheduleItemType, ($, entry) => {
             const row = entry.row;
             const ref = $.const(refOf);
             const start = $.const(instant(row, startField));
@@ -710,9 +901,14 @@ export function scheduleEvents(record, input) {
                 minutes,
                 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 +999,30 @@ 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) },
+                status: config.status === undefined ? none : some(config.status.field),
+                quantity: quantityField === undefined ? none : some(quantityField),
+                parts: partsField === undefined ? none : some(partsField),
+                // A duty's shift and group, which place it on the Roster; a bin's bay, each at its own minute.
+                withTimes: shiftField !== undefined && groupField !== undefined ? [shiftField, groupField]
+                    : allocationGiven.length > 0 && resource !== undefined ? [resource.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,225 +1092,237 @@ 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 heldKind((once) => East.value(kindParts(once, 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.
-            if (instantKind) {
-                throw new Error(`${where}: the Roster reads a duty's \`start\` and \`end\`; this kind is one instant (\`at\`) — give \`start\` and \`end\` in its place`);
-            }
-            if (optional)
-                throw new Error(`${where}: a duty has its times — \`start\` and \`end\` are DateTime fields, not Options`);
-            if (keyType.type !== "String") {
-                throw new Error(`${where}: the Roster's duties are keyed by String — a duty is named by its key, and this record is keyed by ${printType(keyType)}`);
-            }
-            if (shiftField === undefined || groupField === undefined) {
-                throw new Error(`${where}: the Roster places a duty by its \`shift\` and its \`group\` — give both`);
-            }
-            if (resource === undefined || resourceValue === undefined) {
-                throw new Error(`${where}: the Roster rosters each duty to a person or an agency, its \`resource\` — give it, resource: { field, of: "people" }`);
-            }
-            oneFieldEach("Roster", [["start", startField], ["end", endField], ["resource.field", resource.field], ["shift", shiftField],
-                ["group", groupField], ["position", positionField], ["activity", activityField]]);
-            const shift = shiftField;
-            const group = groupField;
-            const who = resource.field;
-            const whoOf = resourceValue;
-            const parts = kindParts(slot, part, formOver([startField, endField, who, shift, group, positionField, activityField]));
-            const Roles = ScheduleRosterRolesType;
-            // A row with the Roster's roles written from `roles`, the resource field from `value`, and every other field
-            // from `source`: the row as it was, or a new row's defaults. A kind with no `position` writes none.
-            const rosterRow = (source, roles, value) => East.value(Object.fromEntries(Object.keys(fields).map((f) => [f,
-                f === startField ? roles.start
-                    : f === endField ? roles.end
-                        : f === who ? value
-                            : f === shift ? roles.shift
-                                : f === group ? roles.group
-                                    : f === positionField ? roles.position.match({ some: (_$, held) => held, none: () => fieldOf(source, f) })
-                                        : f === activityField ? roles.activity
-                                            : fieldOf(source, f)])), rowType);
-            // A duty's roles, from its row and its key: its times and who, its shift and group, its position and
-            // activity, and the hours it counts.
-            const rolesOf = East.function([rowType, StringType], Roles, ($, row, key) => {
-                const ref = $.const(refOf);
-                const start = $.const(fieldOf(row, startField));
-                const end = $.const(fieldOf(row, endField));
-                let hours;
-                if (hoursOf === undefined) {
-                    // Its length.
-                    hours = $.const(start.durationMinutes(end).divide(60.0));
+            return heldKind((once) => {
+                // A duty runs from its start to its end, keyed by String, on its slot's shift and group, rostered to someone.
+                if (instantKind) {
+                    throw new Error(`${where}: the Roster reads a duty's \`start\` and \`end\`; this kind is one instant (\`at\`) — give \`start\` and \`end\` in its place`);
                 }
-                else {
-                    const count = $.const(hoursOf);
-                    hours = $.const(count(row, key));
+                if (optional)
+                    throw new Error(`${where}: a duty has its times — \`start\` and \`end\` are DateTime fields, not Options`);
+                if (keyType.type !== "String") {
+                    throw new Error(`${where}: the Roster's duties are keyed by String — a duty is named by its key, and this record is keyed by ${printType(keyType)}`);
                 }
-                return East.value({
-                    start, end, resource: ref(row), shift: fieldOf(row, shift), group: fieldOf(row, group),
-                    position: positionField === undefined ? none : some(fieldOf(row, positionField)),
-                    activity: activityField === undefined ? none : fieldOf(row, activityField),
-                    hours,
-                }, Roles);
-            });
-            // A drafted duty's roles, from its bytes: what `rows` gives a stored one in the pass that reads it.
-            const read = East.function([BlobType, StringType], Roles, ($, bytes, key) => {
-                const of = $.const(rolesOf);
-                return of(bytes.decodeBeast(rowType, "v2"), key);
-            });
-            // The row with its roles written, and every other field as it was (B1); `none` for a resource the kind refuses.
-            const write = East.function([BlobType, Roles], OptionType(BlobType), ($, bytes, roles) => {
-                const row = $.const(bytes.decodeBeast(rowType, "v2"));
-                const resolve = $.const(whoOf);
-                const result = $.let(East.value(none, OptionType(BlobType)), OptionType(BlobType));
-                $.match(resolve(roles.resource), {
-                    some: ($2, value) => { $2.assign(result, East.value(some(East.Blob.encodeBeast(rosterRow(row, roles, value), "v2")), OptionType(BlobType))); },
+                if (shiftField === undefined || groupField === undefined) {
+                    throw new Error(`${where}: the Roster places a duty by its \`shift\` and its \`group\` — give both`);
+                }
+                if (resource === undefined || resourceValue === undefined) {
+                    throw new Error(`${where}: the Roster rosters each duty to a person or an agency, its \`resource\` — give it, resource: { field, of: "people" }`);
+                }
+                oneFieldEach("Roster", [["start", startField], ["end", endField], ["resource.field", resource.field], ["shift", shiftField],
+                    ["group", groupField], ["position", positionField], ["activity", activityField]]);
+                const shift = shiftField;
+                const group = groupField;
+                const who = resource.field;
+                const whoOf = resourceValue;
+                const parts = kindParts(once, slot, part, formOver([startField, endField, who, shift, group, positionField, activityField]));
+                const Roles = ScheduleRosterRolesType;
+                // A row with the Roster's roles written from `roles`, the resource field from `value`, and every other field
+                // from `source`: the row as it was, or a new row's defaults. A kind with no `position` writes none.
+                const rosterRow = (source, roles, value) => East.value(Object.fromEntries(Object.keys(fields).map((f) => [f,
+                    f === startField ? roles.start
+                        : f === endField ? roles.end
+                            : f === who ? value
+                                : f === shift ? roles.shift
+                                    : f === group ? roles.group
+                                        : f === positionField ? roles.position.match({ some: (_$, held) => held, none: () => fieldOf(source, f) })
+                                            : f === activityField ? roles.activity
+                                                : fieldOf(source, f)])), rowType);
+                // A duty's roles, from its row and its key: its times and who, its shift and group, its position and
+                // activity, and the hours it counts.
+                const rolesOf = East.function([rowType, StringType], Roles, ($, row, key) => {
+                    const ref = $.const(refOf);
+                    const start = $.const(fieldOf(row, startField));
+                    const end = $.const(fieldOf(row, endField));
+                    let hours;
+                    if (hoursOf === undefined) {
+                        // Its length.
+                        hours = $.const(start.durationMinutes(end).divide(60.0));
+                    }
+                    else {
+                        const count = $.const(hoursOf);
+                        hours = $.const(count(row, key));
+                    }
+                    return East.value({
+                        start, end, resource: ref(row), shift: fieldOf(row, shift), group: fieldOf(row, group),
+                        position: positionField === undefined ? none : some(fieldOf(row, positionField)),
+                        activity: activityField === undefined ? none : fieldOf(row, activityField),
+                        hours,
+                    }, Roles);
                 });
-                return result;
-            });
-            // A new duty: its roles written, and every other field its type's default.
-            const blank = East.value(defaultValue(rowType), rowType);
-            const create = East.function([Roles], OptionType(BlobType), ($, roles) => {
-                const row = $.const(blank);
-                const resolve = $.const(whoOf);
-                const result = $.let(East.value(none, OptionType(BlobType)), OptionType(BlobType));
-                $.match(resolve(roles.resource), {
-                    some: ($2, value) => { $2.assign(result, East.value(some(East.Blob.encodeBeast(rosterRow(row, roles, value), "v2")), OptionType(BlobType))); },
+                // A drafted duty's roles, from its bytes: what `rows` gives a stored one in the pass that reads it.
+                const read = East.function([BlobType, StringType], Roles, ($, bytes, key) => {
+                    const of = $.const(rolesOf);
+                    return of(bytes.decodeBeast(rowType, "v2"), key);
                 });
-                return result;
+                // The row with its roles written, and every other field as it was (B1); `none` for a resource the kind refuses.
+                const write = East.function([BlobType, Roles], OptionType(BlobType), ($, bytes, roles) => {
+                    const row = $.const(bytes.decodeBeast(rowType, "v2"));
+                    const resolve = $.const(whoOf);
+                    const result = $.let(East.value(none, OptionType(BlobType)), OptionType(BlobType));
+                    $.match(resolve(roles.resource), {
+                        some: ($2, value) => { $2.assign(result, East.value(some(East.Blob.encodeBeast(rosterRow(row, roles, value), "v2")), OptionType(BlobType))); },
+                    });
+                    return result;
+                });
+                // A new duty: its roles written, and every other field its type's default.
+                const blank = East.value(defaultValue(rowType), rowType);
+                const create = East.function([Roles], OptionType(BlobType), ($, roles) => {
+                    const row = $.const(blank);
+                    const resolve = $.const(whoOf);
+                    const result = $.let(East.value(none, OptionType(BlobType)), OptionType(BlobType));
+                    $.match(resolve(roles.resource), {
+                        some: ($2, value) => { $2.assign(result, East.value(some(East.Blob.encodeBeast(rosterRow(row, roles, value), "v2")), OptionType(BlobType))); },
+                    });
+                    return result;
+                });
+                return East.value({
+                    kind: East.value(parts.fields, ScheduleKindType),
+                    rows: storedRows(parts.reads, ScheduleRosterEntryType, rolesOf),
+                    read,
+                    write,
+                    create,
+                    roles: { position: positionField !== undefined, activity: activityField !== undefined },
+                    rowType: toEastTypeValue(rowType),
+                }, ScheduleRosterKindType);
             });
-            return East.value({
-                kind: East.value(parts.fields, ScheduleKindType),
-                rows: storedRows(parts.reads, ScheduleRosterEntryType, rolesOf),
-                read,
-                write,
-                create,
-                roles: { position: positionField !== undefined, activity: activityField !== undefined },
-                rowType: toEastTypeValue(rowType),
-            }, ScheduleRosterKindType);
         },
         buildAllocation(slot, part) {
-            // A bin is one instant, keyed by String, in one lane, booking an arrival, its quantity on its parts for its hold.
-            if (!instantKind) {
-                throw new Error(`${where}: the Allocation's bins are an instant kind: give \`at\` in place of \`start\` and \`end\``);
-            }
-            if (keyType.type !== "String") {
-                throw new Error(`${where}: the Allocation's bins are keyed by String — a bin is named by its key, and this record is keyed by ${printType(keyType)}`);
-            }
-            if (resource === undefined)
-                throw new Error(`${where}: the Allocation books a bin into a lane, its \`resource\` — give it`);
-            if (resource.shape !== "key" || resource.optional) {
-                throw new Error(`${where}: the Allocation books each bin into one lane — \`resource\` names a String field, a key of the lanes' kind, ` +
-                    `and "${resource.field}" holds ${typeText(fields[resource.field])}`);
-            }
-            if (arrivalField === undefined)
-                throw new Error(`${where}: the Allocation books a bin's \`arrival\` — give it`);
-            if (quantityField === undefined)
-                throw new Error(`${where}: the Allocation reads a bin's \`quantity\` — give it`);
-            if (partsField === undefined || config.parts === undefined)
-                throw new Error(`${where}: the Allocation allocates a bin's \`parts\` — give it`);
-            if (holdField === undefined)
-                throw new Error(`${where}: the Allocation holds a bin for its \`hold\` — give it`);
-            oneFieldEach("Allocation", [["at", startField], ["resource.field", resource.field], ["arrival", arrivalField], ["quantity.field", quantityField],
-                ["parts.field", partsField], ["hold", holdField], ["kind", kindField]]);
-            const lane = resource.field;
-            const arrival = arrivalField;
-            const quantity = quantityField;
-            const shares = partsField;
-            const hold = holdField;
-            // The fields no role maps (`allocationValues`): what an arrival's values give a booked bin, a reservation's their type's default.
-            const mapped = allocationMapped;
-            const ValuesType = allocationValues;
-            const parts = kindParts(slot, part, formOver([...mapped]));
-            const Roles = ScheduleAllocationRolesType;
-            // A row with the Allocation's roles written from `roles`, and every other field from `source`: the row as it
-            // was, or a booked bin's values. A kind with no `kind` writes none.
-            const binRow = (source, roles) => East.value(Object.fromEntries(Object.keys(fields).map((f) => [f,
-                f === startField ? roles.at
-                    : f === lane ? roles.lane
-                        : f === arrival ? roles.arrival
-                            : f === quantity ? roles.quantity
-                                : f === shares ? roles.parts
-                                    : f === hold ? roles.hold
-                                        : f === kindField ? roles.kind
-                                            : fieldOf(source, f)])), rowType);
-            // A bin's roles, from its row: its time and lane, the arrival it books, its quantity and parts, its hold and kind.
-            const rolesOf = East.function([rowType, StringType], Roles, (_$, row, _key) => East.value({
-                at: fieldOf(row, startField), lane: fieldOf(row, lane), arrival: fieldOf(row, arrival), quantity: fieldOf(row, quantity),
-                parts: fieldOf(row, shares), hold: fieldOf(row, hold), kind: kindField === undefined ? none : fieldOf(row, kindField),
-            }, Roles));
-            // A drafted bin's roles, from its bytes: what `rows` gives a stored one in the pass that reads it.
-            const read = East.function([BlobType], Roles, ($, bytes) => {
-                const of = $.const(rolesOf);
-                return of(bytes.decodeBeast(rowType, "v2"), "");
-            });
-            // The row with its roles written, and every other field as it was (B1).
-            const write = East.function([BlobType, Roles], BlobType, ($, bytes, roles) => {
-                const row = $.const(bytes.decodeBeast(rowType, "v2"));
-                return East.Blob.encodeBeast(binRow(row, roles), "v2");
-            });
-            // A new bin: its roles written, and every other field the arrival's values' — or, with none, its type's default (B13).
-            const blank = East.value(defaultValue(ValuesType), ValuesType);
-            const create = East.function([Roles, OptionType(BlobType)], BlobType, ($, roles, values) => {
-                const given = $.const(values.match({
-                    some: (_$2, bytes) => bytes.decodeBeast(ValuesType, "v2"),
-                    none: (_$2) => blank,
-                }));
-                return East.Blob.encodeBeast(binRow(given, roles), "v2");
+            return heldKind((once) => {
+                // A bin is one instant, keyed by String, in one lane, booking an arrival, its quantity on its parts for its hold.
+                if (!instantKind) {
+                    throw new Error(`${where}: the Allocation's bins are an instant kind: give \`at\` in place of \`start\` and \`end\``);
+                }
+                if (keyType.type !== "String") {
+                    throw new Error(`${where}: the Allocation's bins are keyed by String — a bin is named by its key, and this record is keyed by ${printType(keyType)}`);
+                }
+                if (resource === undefined)
+                    throw new Error(`${where}: the Allocation books a bin into a lane, its \`resource\` — give it`);
+                if (resource.shape !== "key" || resource.optional) {
+                    throw new Error(`${where}: the Allocation books each bin into one lane — \`resource\` names a String field, a key of the lanes' kind, ` +
+                        `and "${resource.field}" holds ${typeText(fields[resource.field])}`);
+                }
+                if (arrivalField === undefined)
+                    throw new Error(`${where}: the Allocation books a bin's \`arrival\` — give it`);
+                if (quantityField === undefined)
+                    throw new Error(`${where}: the Allocation reads a bin's \`quantity\` — give it`);
+                if (partsField === undefined || config.parts === undefined)
+                    throw new Error(`${where}: the Allocation allocates a bin's \`parts\` — give it`);
+                if (holdField === undefined)
+                    throw new Error(`${where}: the Allocation holds a bin for its \`hold\` — give it`);
+                oneFieldEach("Allocation", [["at", startField], ["resource.field", resource.field], ["arrival", arrivalField], ["quantity.field", quantityField],
+                    ["parts.field", partsField], ["hold", holdField], ["kind", kindField]]);
+                const lane = resource.field;
+                const arrival = arrivalField;
+                const quantity = quantityField;
+                const shares = partsField;
+                const hold = holdField;
+                // The fields no role maps (`allocationValues`): what an arrival's values give a booked bin, a reservation's their type's default.
+                const mapped = allocationMapped;
+                const ValuesType = allocationValues;
+                const parts = kindParts(once, slot, part, formOver([...mapped]));
+                const Roles = ScheduleAllocationRolesType;
+                // A row with the Allocation's roles written from `roles`, and every other field from `source`: the row as it
+                // was, or a booked bin's values. A kind with no `kind` writes none.
+                const binRow = (source, roles) => East.value(Object.fromEntries(Object.keys(fields).map((f) => [f,
+                    f === startField ? roles.at
+                        : f === lane ? roles.lane
+                            : f === arrival ? roles.arrival
+                                : f === quantity ? roles.quantity
+                                    : f === shares ? roles.parts
+                                        : f === hold ? roles.hold
+                                            : f === kindField ? roles.kind
+                                                : fieldOf(source, f)])), rowType);
+                // A bin's roles, from its row: its time and lane, the arrival it books, its quantity and parts, its hold and kind.
+                const rolesOf = East.function([rowType, StringType], Roles, (_$, row, _key) => East.value({
+                    at: fieldOf(row, startField), lane: fieldOf(row, lane), arrival: fieldOf(row, arrival), quantity: fieldOf(row, quantity),
+                    parts: fieldOf(row, shares), hold: fieldOf(row, hold), kind: kindField === undefined ? none : fieldOf(row, kindField),
+                }, Roles));
+                // A drafted bin's roles, from its bytes: what `rows` gives a stored one in the pass that reads it.
+                const read = East.function([BlobType], Roles, ($, bytes) => {
+                    const of = $.const(rolesOf);
+                    return of(bytes.decodeBeast(rowType, "v2"), "");
+                });
+                // The row with its roles written, and every other field as it was (B1).
+                const write = East.function([BlobType, Roles], BlobType, ($, bytes, roles) => {
+                    const row = $.const(bytes.decodeBeast(rowType, "v2"));
+                    return East.Blob.encodeBeast(binRow(row, roles), "v2");
+                });
+                // A new bin: its roles written, and every other field the arrival's values' — or, with none, its type's default (B13).
+                const blank = East.value(defaultValue(ValuesType), ValuesType);
+                const create = East.function([Roles, OptionType(BlobType)], BlobType, ($, roles, values) => {
+                    const given = $.const(values.match({
+                        some: (_$2, bytes) => bytes.decodeBeast(ValuesType, "v2"),
+                        none: (_$2) => blank,
+                    }));
+                    return East.Blob.encodeBeast(binRow(given, roles), "v2");
+                });
+                return East.value({
+                    kind: East.value(parts.fields, ScheduleKindType),
+                    rows: storedRows(parts.reads, ScheduleAllocationEntryType, rolesOf),
+                    read,
+                    write,
+                    create,
+                    lanes: resource.of,
+                    parts: config.parts.of,
+                    kinded: kindField !== undefined,
+                    unit: config.quantity?.unit === undefined ? none : some(config.quantity.unit),
+                    values: toEastTypeValue(ValuesType),
+                    rowType: toEastTypeValue(rowType),
+                }, ScheduleAllocationKindType);
             });
-            return East.value({
-                kind: East.value(parts.fields, ScheduleKindType),
-                rows: storedRows(parts.reads, ScheduleAllocationEntryType, rolesOf),
-                read,
-                write,
-                create,
-                lanes: resource.of,
-                parts: config.parts.of,
-                kinded: kindField !== undefined,
-                unit: config.quantity?.unit === undefined ? none : some(config.quantity.unit),
-                values: toEastTypeValue(ValuesType),
-                rowType: toEastTypeValue(rowType),
-            }, ScheduleAllocationKindType);
         },
         buildPlan(slot, part) {
-            const parts = kindParts(slot, part, formSpecs);
-            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.
-            const planItemOf = East.function([EntryRowType], PlanEventItemType, ($, entry) => {
-                const make = $.const(parts.itemOf);
-                const item = $.const(make(entry));
-                const row = entry.row;
-                const read = item;
+            return heldKind((once) => {
+                // Its window through its source counted first, and read only within the cap (#1039): past it, no page is read.
+                const parts = kindParts(once, 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.
+                const planItemOf = once(East.function([EntryRowType], PlanEventItemType, ($, entry) => {
+                    const make = $.const(parts.itemOf);
+                    const item = $.const(make(entry));
+                    const row = entry.row;
+                    const read = item;
+                    return East.value({
+                        ...Object.fromEntries(Object.keys(ScheduleItemType.fields).map((f) => [f, read[f]])),
+                        state: stateField === undefined ? variant("confirmed", null) : fieldOf(row, stateField),
+                        quantity: quantityField === undefined ? none : some({
+                            value: fieldOf(row, quantityField),
+                            unit: quantity?.unit === undefined ? none : some(quantity.unit),
+                            format: format === undefined ? none : some(format),
+                            text: none,
+                        }),
+                        lane: laneField === undefined ? none : some(fieldOf(row, laneField)),
+                    }, PlanEventItemType);
+                }));
+                // 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({
-                    ...Object.fromEntries(Object.keys(ScheduleItemType.fields).map((f) => [f, read[f]])),
-                    state: stateField === undefined ? variant("confirmed", null) : fieldOf(row, stateField),
-                    quantity: quantityField === undefined ? none : some({
-                        value: fieldOf(row, quantityField),
-                        unit: quantity?.unit === undefined ? none : some(quantity.unit),
-                        format: format === undefined ? none : some(format),
-                        text: none,
-                    }),
-                    lane: laneField === undefined ? none : some(fieldOf(row, laneField)),
-                }, PlanEventItemType);
+                    ...parts.fields,
+                    draw: variant(draw, null),
+                    instant: instantKind,
+                    overlaps: variant(overlaps, null),
+                    roles: { state: name(stateField), quantity: name(quantityField), lane: name(laneField) },
+                    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);
             });
-            // 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);
-            const name = (field) => (field === undefined ? none : some(field));
-            return East.value({
-                ...parts.fields,
-                draw: variant(draw, null),
-                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,
-                inspector: inspector === undefined ? East.value(none, OptionType(RowInspectorType)) : East.value(some(inspector), OptionType(RowInspectorType)),
-            }, PlanEventKindType);
         },
     };
 }