@elaraai/e3-ui 1.0.86 → 1.0.88

package/dist/src/plan/event-rows.js

@@ -0,0 +1,689 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * Events into rows (#1192, `Plan Builder Spec.md` §9.4, PB12–PB18): the
+ * resources' rows a Plan of event kinds draws over a window, every kind's
+ * drafts in place — the payload's `blocks`.
+ *
+ * The rows are series' rows (#822), with the events joined in, so they are
+ * derived the way every other row of the canvas is. Each resource kind is a
+ * `Plan.series.views` over its resources: one member per way the event kinds
+ * placed on it draw (bars, tiles, chips, marks, in that order), each element
+ * an event in the window wearing its kind's icon, then the kind's measures,
+ * each applied to the resource's row (PB12, PB13). A resource that names
+ * another of its kind as its parent nests under it, and the parent's bars roll
+ * its children's up (PB14, #1219); a kind with `group` sits under its group
+ * strips. A row's id is its series' key and its path (PB15):
+ * `entry { series: "<kind>.<draw>", path: [group?, …parents, key] }`, a
+ * measure's its own key, a strip's `"<kind>.group"`.
+ *
+ * An event whose resource is none, or names a resource its kind does not have,
+ * draws on its kind's Unassigned row, after every resource kind (PB16). Every
+ * kind's events are read with its drafts in place, so a draft draws as Save
+ * would leave it (PB17).
+ *
+ * Every block is fixed: no entry of the canvas's `data` makes these rows, so a
+ * paged canvas serves them with every window and draws them once.
+ *
+ * What a viewer hides in the library's Series tab stays out (PB29, #1195): a
+ * hidden event kind is not read, so its elements draw nowhere, its Unassigned
+ * row included, and a row only hidden kinds draw on goes with them; a hidden
+ * resource kind draws no rows; a hidden measure no row under each resource. A
+ * resource's first row is its own, and stays while its kind shows.
+ *
+ * A resource kind given its resources as a paged read (#1199, PB55) is PAGED,
+ * as a paged canvas pages its blocks: its rows come a window of resources at a
+ * time as the canvas scrolls, through the payload's `paged`
+ * ({@link createEventPaged}), and the key search seeks a resource by its key. The `blocks` seam keeps its
+ * place among the kinds' blocks with an empty paged block (`fixed: false`,
+ * the one block it serves that is not fixed) and never reads its resources;
+ * the events placed on them are read with the rest, by way of drawing and by
+ * the resource's key (`placed`), and each window of its resources draws the
+ * ones placed on it (`rows`). An event on a paged kind is never on the
+ * Unassigned row: whether the kind has its resource would take every window
+ * to know, so an event naming a resource it has not draws nowhere.
+ *
+ * @packageDocumentation
+ */
+import { ArrayType, BooleanType, DateTimeType, DictType, East, FunctionType, IntegerType, NullType, OptionType, SetType, StringType, StructType, none, some, variant, } from "@elaraai/east";
+import { IconType, PickStateType, SeekQueryType, SeekRangeType, StatusValueType } from "@elaraai/east-ui";
+import { buildPagedWindow, resolveRowSource } from "@elaraai/east-ui/internal";
+import { PlanEventItemType, PlanEventKindType, ScheduleDraftsType, ScheduleEventRefType, ScheduleStatusType } from "../schedule/types.js";
+import { PlanBlockType, PlanBlocksType, PlanBucketEventType, PlanChipType, PlanEventMarkKindType, PlanEventMarkType, PlanLaneType, PlanRollupType, PlanRowIdType, PlanRowsCollectionType, PlanRunType, } from "./types.js";
+import { planGutter, planRow } from "./assemble.js";
+import { bucketsKind, cardsKind, eventsKind, spanKind } from "./factories.js";
+import { planHideId } from "./library.js";
+import { applySeries, createChildren, createSeriesBuckets, createSeriesCards, createSeriesEvents, createSeriesGroup, createSeriesSpan, createSeriesViews, planSeriesFacts, } from "./series.js";
+// ============================================================================
+// The seam
+// ============================================================================
+/**
+ * Every event kind's drafts, by the kind's slot, then by entry id — each the
+ * entry's draft as bytes, as a kind's seams read them.
+ */
+export const PlanEventDraftsType = DictType(StringType, ScheduleDraftsType);
+/**
+ * The resources' rows over a window, every event kind's drafts in place
+ * (#1192): `(from, to, drafts by kind, then by entry id, the ids the viewer
+ * hides)` → the canvas's blocks, `none` while a kind's read is in flight. The
+ * hidden ids are the library's Series tab's (#1195): `resources.<slot>`,
+ * `events.<slot>` and `measures.<key>` stay out, and the rest are not this
+ * seam's. A paged resource kind's place (#1199) is an empty block that is not
+ * fixed, which the payload's `paged` fills a window at a time.
+ */
+export const PlanEventBlocksType = FunctionType([DateTimeType, DateTimeType, PlanEventDraftsType, PickStateType], OptionType(PlanBlocksType));
+/** The ways a kind draws, in the order a resource's rows take them (PB12). */
+const DRAW_ORDER = ["span", "buckets", "cards", "marks"];
+/**
+ * The ways the event kinds placed on a resource kind draw, in the order its
+ * rows take them.
+ *
+ * @param slot - The resource kind's slot
+ * @param events - The event kinds, by slot
+ * @returns The draw styles, each once
+ */
+export function eventDrawsOf(slot, events) {
+    return DRAW_ORDER.filter((d) => events.some(([, k]) => k.draw === d && k.takes.includes(slot)));
+}
+/**
+ * The names of the event kinds that draw one way on a resource kind — what
+ * that row of each resource is labelled with, after its first.
+ *
+ * @param slot - The resource kind's slot
+ * @param draw - The way they draw
+ * @param events - The event kinds, by slot
+ * @returns Their names, in `events` order
+ */
+function kindNamesOf(slot, draw, events) {
+    return events.filter(([, k]) => k.draw === draw && k.takes.includes(slot)).map(([, k]) => k.name).join(", ");
+}
+/**
+ * The slots of the event kinds that draw one way on a resource kind — what
+ * hides that row of each resource, once every one of them is hidden.
+ *
+ * @param slot - The resource kind's slot
+ * @param draw - The way they draw
+ * @param events - The event kinds, by slot
+ * @returns Their slots, in `events` order
+ */
+function kindSlotsOf(slot, draw, events) {
+    return events.filter(([, k]) => k.draw === draw && k.takes.includes(slot)).map(([s]) => s);
+}
+// ============================================================================
+// Elements — one event as each way of drawing shows it
+// ============================================================================
+/**
+ * One event placed on a row: the event as Plan draws it, its two times (an
+ * event drawn has both), and its kind's icon.
+ */
+const PlacedType = StructType({ item: PlanEventItemType, start: DateTimeType, end: DateTimeType, icon: IconType });
+/** The events placed on one row. */
+const PlacedListType = ArrayType(PlacedType);
+/** The events placed on one way of drawing for each resource of a kind, by the resource key's text. */
+const PlacedByKeyType = DictType(StringType, PlacedListType);
+/**
+ * The events placed on a paged resource kind's resources (#1199): by the way
+ * they draw (`span`, `buckets`, `cards`, `marks`), then by the resource key's
+ * text — each event as Plan draws it, its two times and its kind's icon. What
+ * each window of the kind's resources draws on its rows.
+ */
+export const PlanEventPlacedType = DictType(StringType, PlacedByKeyType);
+/**
+ * An element's key: its event, as East prints a `Schedule.Types.EventRef`
+ * (`printFor`) — unique on a row the kinds that draw alike share, and read
+ * back with `parseFor`.
+ */
+const elementKey = East.function([PlanEventItemType], StringType, ($, item) => {
+    const ref = $.let({ kind: item.kind, key: item.key }, ScheduleEventRefType);
+    return East.print(ref);
+});
+/** The warning an element is ringed with: its status's, when the status's tone is a warning (`Plan Builder Spec.md` §4.1). */
+const warningOf = East.function([OptionType(ScheduleStatusType)], OptionType(StatusValueType), ($, status) => {
+    const out = $.let(none, OptionType(StatusValueType));
+    $.match(status, {
+        some: ($2, s) => {
+            $2.if(s.tone.hasTag("warning"), ($3) => { $3.assign(out, some(variant("warning", null))); });
+        },
+    });
+    return out;
+});
+/** The events as bars. */
+const placedRuns = East.function([PlacedListType], ArrayType(PlanRunType), ($, list) => {
+    const keyOf = $.const(elementKey);
+    const ring = $.const(warningOf);
+    return list.map(($2, p) => East.value({
+        key: keyOf(p.item),
+        start: variant("time", p.start),
+        end: variant("time", p.end),
+        label: p.item.title,
+        quantity: p.item.quantity,
+        state: p.item.state,
+        status: ring(p.item.status),
+        moved: none,
+        icon: some(p.icon),
+    }, PlanRunType));
+});
+/** The events as tiles in their start's bucket, each in its lane. */
+const placedTiles = East.function([PlacedListType], ArrayType(PlanBucketEventType), ($, list) => {
+    const keyOf = $.const(elementKey);
+    const ring = $.const(warningOf);
+    return list.map(($2, p) => East.value({
+        key: keyOf(p.item),
+        at: variant("time", p.start),
+        lane: p.item.lane,
+        label: some(p.item.title),
+        icon: some(p.icon),
+        state: p.item.state,
+        tone: ring(p.item.status),
+        color: none,
+        colorPalette: none,
+        stretch: none,
+        content: none,
+        animation: none,
+    }, PlanBucketEventType));
+});
+/** The events as chips over the buckets they span. */
+const placedChips = East.function([PlacedListType], ArrayType(PlanChipType), ($, list) => {
+    const keyOf = $.const(elementKey);
+    return list.map(($2, p) => East.value({
+        key: keyOf(p.item),
+        from: variant("time", p.start),
+        to: variant("time", p.end),
+        label: p.item.title,
+        state: p.item.state,
+        icon: some(p.icon),
+    }, PlanChipType));
+});
+/** The events as marks at their start: an exception where a warning rings it, else a milestone. */
+const placedMarks = East.function([PlacedListType], ArrayType(PlanEventMarkType), ($, list) => {
+    const keyOf = $.const(elementKey);
+    const ring = $.const(warningOf);
+    return list.map(($2, p) => {
+        const kind = $2.let(variant("milestone", null), PlanEventMarkKindType);
+        $2.if(ring(p.item.status).hasTag("some"), ($3) => { $3.assign(kind, variant("exception", null)); });
+        return East.value({
+            key: keyOf(p.item),
+            at: variant("time", p.start),
+            kind,
+            icon: some(p.icon),
+            label: some(p.item.title),
+        }, PlanEventMarkType);
+    });
+});
+/** The lanes a row's tiles sit in: each lane an event names, once, in order. */
+const placedLanes = East.function([PlacedListType], ArrayType(PlanLaneType), ($, list) => {
+    const lanes = $.let(new Set(), SetType(StringType));
+    $.for(list, ($2, p) => {
+        $2.match(p.item.lane, { some: ($3, lane) => { $3(lanes.tryInsert(lane)); } });
+    });
+    return lanes.toArray(($2, lane) => East.value({ key: lane, label: some(lane) }, PlanLaneType));
+});
+/**
+ * One resource kind's rows over the window: its resources as a views series
+ * — a member per way the kinds placed on it draw, then its measures — nested
+ * by parent and under group strips, each block fixed. A measure the viewer
+ * hides draws no row, nor does a way of drawing whose kinds they all hide,
+ * after a resource's first row, its own.
+ *
+ * @param $ - The blocks function's scope
+ * @param slot - The resource kind's slot
+ * @param kind - The resource kind
+ * @param all - Its resources, read once in this scope
+ * @param placed - The events placed on its resources, by way of drawing
+ * @param events - The event kinds, by slot
+ * @param hidden - The ids the viewer hides
+ * @param fixed - Whether its blocks are fixed: the resources whole, served with every window; or a paged kind's
+ *   window of them (#1199), which a paged canvas pages
+ * @returns Its blocks
+ */
+function resourceBlocks($, slot, kind, all, placed, events, hidden, fixed = true) {
+    const where = `Plan: resources.${slot}`;
+    const keyType = kind.keyType;
+    const rowType = kind.rowType;
+    const collection = DictType(keyType, rowType);
+    // A resource's key as the text a placed event and a parent name it by.
+    const textOf = keyType.type === "String"
+        ? (key) => key
+        : (key) => East.print(key);
+    const resolve = $.const(kind.planRow);
+    const resolved = $.let(all.map(($2, row, key) => resolve(row, key)));
+    const noEvents = $.const([], PlacedListType);
+    // A resource's own row, resolved — what its first row's gutter and its collapse read.
+    const own = (key) => resolved.get(key);
+    // ── Nesting: each resource under the one its parent names (PB14) ─────
+    // A parent that names a resource the kind has, unless following parents
+    // from it comes back round: a resource on such a cycle draws at the top,
+    // so every resource draws once and the walk ends.
+    let roots = all;
+    let children;
+    if (kind.nested) {
+        const byText = $.let(new Map(), DictType(StringType, keyType));
+        $.for(all, ($2, _row, key) => { $2(byText.insert(textOf(key), key)); });
+        const parentOf = $.let(new Map(), DictType(StringType, StringType));
+        $.for(resolved, ($2, row, key) => {
+            const parent = row.parent;
+            $2.match(parent, {
+                some: ($3, p) => { $3.if(byText.has(p), ($4) => { $4(parentOf.insert(textOf(key), p)); }); },
+            });
+        });
+        // Each walk up from a resource not yet seen: 1 while on the walk, 2 once done.
+        const seen = $.let(new Map(), DictType(StringType, IntegerType));
+        const cyclic = $.let(new Set(), SetType(StringType));
+        $.for(byText, ($2, _key, start) => {
+            $2.if(seen.has(start).not(), ($3) => {
+                const path = $3.let([], ArrayType(StringType));
+                const at = $3.let(start, StringType);
+                const walking = $3.let(true, BooleanType);
+                $3.while(walking, ($4) => {
+                    $4(seen.insert(at, 1n));
+                    $4(path.pushLast(at));
+                    $4.if(parentOf.has(at), ($5) => {
+                        const next = $5.let(parentOf.get(at), StringType);
+                        $5.if(seen.has(next), ($6) => {
+                            // On this walk already: from it to here is a cycle.
+                            $6.if(seen.get(next).equal(1n), ($7) => {
+                                const i = $7.let(path.size().subtract(1n), IntegerType);
+                                const back = $7.let(true, BooleanType);
+                                $7.while(back, ($8) => {
+                                    const member = $8.let(path.get(i), StringType);
+                                    $8(cyclic.tryInsert(member));
+                                    $8.if(member.equal(next), ($9) => { $9.assign(back, false); })
+                                        .else(($9) => { $9.assign(i, i.subtract(1n)); });
+                                });
+                            });
+                            $6.assign(walking, false);
+                        }).else(($6) => { $6.assign(at, next); });
+                    }).else(($5) => { $5.assign(walking, false); });
+                });
+                $3.for(path, ($4, member) => { $4(seen.update(member, 2n)); });
+            });
+        });
+        const nests = East.function([keyType], BooleanType, ($2, key) => {
+            const text = $2.let(textOf(key), StringType);
+            return parentOf.has(text).and(() => cyclic.has(text).not());
+        });
+        const nested = $.const(nests);
+        const top = $.let(all.filter(($2, _row, key) => nested(key).not()));
+        roots = top;
+        const empty = $.const(new Map(), collection);
+        const under = $.let(all.filter(($2, _row, key) => nested(key)).groupReduce(($2, _row, key) => parentOf.get(textOf(key)), (_$2, _parent) => East.value(new Map(), collection), ($2, acc, row, key) => {
+            $2(acc.insert(key, row));
+            return acc;
+        }));
+        children = (_row, key) => under.get(textOf(key), () => empty);
+    }
+    // ── A member per way the kinds placed on it draw, then its measures ──
+    const draws = eventDrawsOf(slot, events);
+    const members = draws.map((draw, i) => {
+        const into = placed.get(draw);
+        const eventsOf = (key) => into.get(textOf(key), () => noEvents);
+        const names = kindNamesOf(slot, draw, events);
+        // The first row of a resource carries its gutter; the rest name the kinds that draw that way.
+        const gutter = i === 0
+            ? {
+                label: (_row, key) => own(key).label,
+                sub: (_row, key) => own(key).sub,
+                value: (_row, key) => own(key).value,
+                status: (_row, key) => own(key).status,
+            }
+            : { label: () => names };
+        const base = {
+            key: `${slot}.${draw}`,
+            title: `${kind.name}: ${names}`,
+            keyType,
+            ...gutter,
+        };
+        switch (draw) {
+            case "span":
+                return createSeriesSpan(rowType, {
+                    ...base,
+                    runs: (_row, key) => placedRuns(eventsOf(key)),
+                    rollup: kind.rollup,
+                });
+            case "buckets":
+                return createSeriesBuckets(rowType, {
+                    ...base,
+                    lanes: (_row, key) => placedLanes(eventsOf(key)),
+                    events: (_row, key) => placedTiles(eventsOf(key)),
+                });
+            case "cards":
+                return createSeriesCards(rowType, {
+                    ...base,
+                    chips: (_row, key) => placedChips(eventsOf(key)),
+                });
+            case "marks":
+                return createSeriesEvents(rowType, {
+                    ...base,
+                    marks: (_row, key) => placedMarks(eventsOf(key)),
+                });
+        }
+    });
+    const views = createSeriesViews(rowType, {
+        key: slot,
+        title: kind.name,
+        keyType,
+        ...(children !== undefined ? { children } : {}),
+        collapsed: (_row, key) => own(key).collapsed,
+    }, [...members, ...kind.measures]);
+    // ── Group strips (PB14): the kind's top resources by group, in name order ──
+    let blocks;
+    if (kind.grouped) {
+        const groups = $.let(roots.groupReduce(($2, _row, key) => own(key).group.unwrap("some"), (_$2, _group) => East.value(new Map(), collection), ($2, acc, row, key) => {
+            $2(acc.insert(key, row));
+            return acc;
+        }));
+        // A collapsed strip shows its members' heat when a measure paints any.
+        const heat = kind.measures.some((m) => planSeriesFacts(m, collection, where)?.arm === "heat");
+        const strips = createSeriesGroup(collection, {
+            key: `${slot}.group`,
+            title: kind.name,
+            label: (_group, name) => name,
+            children: createChildren((group) => group, [views]),
+            ...(heat ? { summaryAggregate: "mean" } : {}),
+        });
+        blocks = applySeries([strips], groups);
+    }
+    else {
+        blocks = applySeries([views], roots);
+    }
+    // ── What the viewer hides (PB29): rows by their series' key ──
+    // A measure's rows, and a way of drawing's after the first once all its
+    // kinds are hidden: each a leaf, since a resource's children nest under its
+    // first row.
+    const hiders = [
+        ...draws.slice(1).map((draw) => [`${slot}.${draw}`, kindSlotsOf(slot, draw, events).map(planHideId.events)]),
+        ...kind.measures.map((m) => {
+            const key = planSeriesFacts(m, collection, where).key;
+            return [key, [planHideId.measures(key)]];
+        }),
+    ];
+    if (hiders.length === 0) {
+        return $.let(blocks.map(($2, b) => ({ fixed, parent: b.parent, rows: b.rows })), PlanBlocksType);
+    }
+    const dropped = $.let(new Set(), SetType(StringType));
+    for (const [series, ids] of hiders) {
+        const gone = ids.reduce((every, id) => every.and(() => hidden.has(id)), East.value(true, BooleanType));
+        $.if(gone, ($2) => { $2(dropped.insert(series)); });
+    }
+    return $.let(blocks.map(($2, b) => ({
+        fixed,
+        parent: b.parent,
+        rows: b.rows.filter(($3, row) => dropped.has(row.id.match({
+            entry: (_$4, at) => at.series,
+            section: (_$4, at) => at.series,
+        })).not()),
+    })), PlanBlocksType);
+}
+/**
+ * The Unassigned rows (PB16): for each event kind with events in the window
+ * that no resource of the Plan holds, one row of its draw style, after every
+ * resource kind — a fixed block, there whether or not it holds a row.
+ *
+ * @param $ - The blocks function's scope
+ * @param events - The event kinds, by slot
+ * @param lost - Each kind's unassigned events, in `events` order
+ * @returns The block
+ */
+function unassignedBlock($, events, lost) {
+    const rows = $.let([], PlanRowsCollectionType);
+    events.forEach(([slot, kind], i) => {
+        const list = lost[i];
+        $.if(list.size().greater(0n), ($2) => {
+            const id = $2.let(East.value(variant("entry", { series: `${slot}.unassigned`, path: [kind.draw] }), PlanRowIdType));
+            const rowKind = kind.draw === "span" ? spanKind({ runs: placedRuns(list) }, East.value(none, OptionType(PlanRollupType)))
+                : kind.draw === "buckets" ? bucketsKind({ lanes: placedLanes(list), events: placedTiles(list) })
+                    : kind.draw === "cards" ? cardsKind(placedChips(list))
+                        : eventsKind(placedMarks(list));
+            $2(rows.pushLast(planRow({
+                id,
+                parent: East.value(none, OptionType(PlanRowIdType)),
+                gutter: planGutter({ label: "Unassigned", sub: some(kind.name) }),
+                kind: rowKind,
+            })));
+        });
+    });
+    return $.let({ fixed: true, parent: none, rows }, PlanBlockType);
+}
+/**
+ * The `blocks` seam (see the module docs): `(from, to, drafts, hidden)` → the
+ * resources' rows over `[from, to)`, every kind's drafts in place, what the
+ * viewer hides left out.
+ *
+ * @remarks
+ * Made inside the function that assembles the payload, so `built` is the
+ * payload's own array of event kinds: the seam captures it, and the payload
+ * carries each kind once.
+ *
+ * @param resources - The resource kinds, by slot, in order
+ * @param events - The event kinds, by slot, in order
+ * @param built - The event kinds as the payload holds them, in the same order
+ * @returns The seam
+ * @internal
+ */
+export function createEventBlocks(resources, events, built) {
+    return East.function([DateTimeType, DateTimeType, PlanEventDraftsType, PickStateType], OptionType(PlanBlocksType), ($, from, to, drafts, hiding) => {
+        const result = $.let(none, OptionType(PlanBlocksType));
+        const noDrafts = $.const(new Map(), ScheduleDraftsType);
+        const hidden = $.let(hiding.toSet(), SetType(StringType));
+        // Each kind's events over the window, its drafts in place (PB17). A
+        // hidden kind is not read: it places nothing, so nothing waits on it.
+        const reads = events.map(([slot], i) => {
+            const kind = $.let(built.get(BigInt(i)));
+            const kindDrafts = $.let(drafts.get(slot, () => noDrafts));
+            const read = $.let(some([]), OptionType(ArrayType(PlanEventItemType)));
+            $.if(hidden.has(planHideId.events(slot)).not(), ($2) => { $2.assign(read, kind.planItems(from, to, kindDrafts)); });
+            return read;
+        });
+        const ready = reads.reduce((all, read) => all.and(() => read.hasTag("some")), East.value(true, BooleanType));
+        // A kind whose read is in flight leaves the rows to come.
+        $.if(ready, ($2) => {
+            const items = reads.map((read) => $2.let(read.unwrap("some"), ArrayType(PlanEventItemType)));
+            // Each resource kind's resources, read once — but a paged kind's (#1199), which come a window at a time.
+            const whole = resources.filter(([, kind]) => kind.window === undefined);
+            const sources = new Map(whole.map(([slot, kind]) => [slot, $2.let(kind.source)]));
+            // The events each way of drawing places on each resource kind, by the resource's key.
+            const placed = new Map(whole.map(([slot]) => [slot, new Map(eventDrawsOf(slot, events).map((draw) => [draw, $2.let(new Map(), PlacedByKeyType)]))]));
+            const paged = new Set(resources.filter(([, kind]) => kind.window !== undefined).map(([slot]) => slot));
+            const lost = events.map(() => $2.let([], PlacedListType));
+            events.forEach(([, kind], i) => {
+                const icon = $2.const({ prefix: "fas", name: kind.icon, label: none, style: none }, IconType);
+                const unplaced = lost[i];
+                $2.for(items[i], ($3, item) => {
+                    $3.match(item.start, {
+                        some: ($4, start) => {
+                            $4.match(item.end, {
+                                some: ($5, end) => {
+                                    const one = $5.let({ item, start, end, icon }, PlacedType);
+                                    const held = $5.let(false, BooleanType);
+                                    $5.match(item.resource, {
+                                        some: ($6, ref) => {
+                                            // On a resource of a kind it takes, which the kind has.
+                                            for (const slot of kind.takes) {
+                                                if (paged.has(slot)) {
+                                                    // A paged kind's own (#1199), drawn by the window its resource is in.
+                                                    $6.if(ref.kind.equal(slot), ($7) => { $7.assign(held, true); });
+                                                    continue;
+                                                }
+                                                const into = placed.get(slot).get(kind.draw);
+                                                const all = sources.get(slot);
+                                                $6.if(ref.kind.equal(slot).and(() => all.has(ref.key)), ($7) => {
+                                                    $7.if(into.has(ref.key).not(), ($8) => {
+                                                        $8(into.insert(ref.key, East.value([], PlacedListType)));
+                                                    });
+                                                    $7(into.get(ref.key).pushLast(one));
+                                                    $7.assign(held, true);
+                                                });
+                                            }
+                                        },
+                                    });
+                                    $5.if(held.not(), ($6) => { $6(unplaced.pushLast(one)); });
+                                },
+                            });
+                        },
+                    });
+                });
+            });
+            const blocks = $2.let([], PlanBlocksType);
+            for (const [slot, kind] of resources) {
+                if (paged.has(slot)) {
+                    // A paged kind's place (#1199): the one block that is not fixed, which the payload's
+                    // `paged` fills a window at a time — there whether or not the viewer hides the kind.
+                    $2(blocks.pushLast(East.value({ fixed: false, parent: none, rows: [] }, PlanBlockType)));
+                    continue;
+                }
+                // A hidden resource kind draws no rows; its events stay its own, off the Unassigned row.
+                $2.if(hidden.has(planHideId.resources(slot)).not(), ($3) => {
+                    $3(blocks.append(resourceBlocks($3, slot, kind, sources.get(slot), placed.get(slot), events, hidden)));
+                });
+            }
+            $2(blocks.pushLast(unassignedBlock($2, events, lost)));
+            $2.assign(result, some(blocks));
+        });
+        return result;
+    });
+}
+// ============================================================================
+// A paged resource kind's rows (#1199)
+// ============================================================================
+/**
+ * A paged resource kind's rows (#1199, PB55): its resources a window at a
+ * time, as a paged canvas pages its blocks. The renderer reads `placed` over
+ * the range it draws with the `blocks` seam, and serves the canvas a paged
+ * source whose every window is the event kinds' blocks with this kind's place
+ * filled by `rows` over that window of its resources — so its rows come as
+ * the canvas scrolls, its key search seeks a resource by its key, and its
+ * resources are never read whole.
+ *
+ * @property kind - The paged resource kind's slot
+ * @property id - The identity of the kind's resources' window
+ * @property placed - `(from, to, drafts by kind, the ids the viewer hides)` → the events placed on the kind's resources over `[from, to)`, every kind's drafts in place, by way of drawing and by the resource key's text; `none` while a kind's read is in flight
+ * @property rows - `(offset, limit, placed, the ids the viewer hides)` → the kind's rows for its resources `[offset, offset + limit)` — a whole window of them — with the events given placed on them: one block, not fixed (an empty one while the viewer hides the kind); `none` while the window is in flight
+ * @property total - How many resources the kind has, once known
+ * @property seek - Where a key search lands among the kind's resources: the window's own key search
+ * @property revision - The snapshot of the resources the windows are read at
+ * @property refresh - Moves the resources' window to a snapshot, or to the one it holds now
+ */
+export const PlanEventPagedType = StructType({
+    kind: StringType,
+    id: StringType,
+    placed: FunctionType([DateTimeType, DateTimeType, PlanEventDraftsType, PickStateType], OptionType(PlanEventPlacedType)),
+    rows: FunctionType([IntegerType, IntegerType, PlanEventPlacedType, PickStateType], OptionType(PlanBlocksType)),
+    total: FunctionType([], OptionType(IntegerType)),
+    seek: OptionType(FunctionType([SeekQueryType], OptionType(SeekRangeType))),
+    revision: FunctionType([], OptionType(StringType)),
+    refresh: FunctionType([OptionType(StringType)], NullType),
+});
+/**
+ * The paged resource kind's rows (see {@link PlanEventPagedType}), when a
+ * resource kind is given its resources as a paged read.
+ *
+ * @remarks
+ * Made inside the function that assembles the payload, as the `blocks` seam
+ * is, so `built` is the payload's own array of event kinds.
+ *
+ * @param resources - The resource kinds, by slot, in order — at most one of them paged (the Plan refuses more)
+ * @param events - The event kinds, by slot, in order
+ * @param built - The event kinds as the payload holds them, in the same order
+ * @returns The paged rows, or `undefined` when no resource kind is paged
+ * @throws {Error} When the kind's paged read is not a paged source of its resources
+ * @internal
+ */
+export function createEventPaged(resources, events, built) {
+    const at = resources.find(([, kind]) => kind.window !== undefined);
+    if (at === undefined)
+        return undefined;
+    const [slot, kind] = at;
+    const where = `Plan: resources.${slot}`;
+    // The resources a window at a time — each window whole, a piece the source cut short read on to its end.
+    const resolved = resolveRowSource(kind.window, where);
+    if (resolved.kind === "inline") {
+        throw new Error(`${where}: a paged kind's resources are a paged read — Data.bindPaged(record) over the resources' record`);
+    }
+    const window = buildPagedWindow(resolved);
+    const handle = resolved.source;
+    const draws = eventDrawsOf(slot, events);
+    // The event kinds placed on it, with their place in `events` — the payload's array of them.
+    const takers = events.flatMap(([s, k], i) => (k.takes.includes(slot) ? [[s, k, i]] : []));
+    const placed = East.function([DateTimeType, DateTimeType, PlanEventDraftsType, PickStateType], OptionType(PlanEventPlacedType), ($, from, to, drafts, hiding) => {
+        const result = $.let(none, OptionType(PlanEventPlacedType));
+        const noDrafts = $.const(new Map(), ScheduleDraftsType);
+        const hidden = $.let(hiding.toSet(), SetType(StringType));
+        // Each kind's events over the window, its drafts in place; a hidden kind is not read.
+        const reads = takers.map(([s, , i]) => {
+            const k = $.let(built.get(BigInt(i)));
+            const kindDrafts = $.let(drafts.get(s, () => noDrafts));
+            const read = $.let(some([]), OptionType(ArrayType(PlanEventItemType)));
+            $.if(hidden.has(planHideId.events(s)).not(), ($2) => { $2.assign(read, k.planItems(from, to, kindDrafts)); });
+            return read;
+        });
+        const ready = reads.reduce((all, read) => all.and(() => read.hasTag("some")), East.value(true, BooleanType));
+        $.if(ready, ($2) => {
+            const out = $2.let(new Map(), PlanEventPlacedType);
+            for (const draw of draws)
+                $2(out.insert(draw, East.value(new Map(), PlacedByKeyType)));
+            takers.forEach(([, k], j) => {
+                const icon = $2.const({ prefix: "fas", name: k.icon, label: none, style: none }, IconType);
+                const into = $2.let(out.get(k.draw));
+                $2.for(reads[j].unwrap("some"), ($3, item) => {
+                    $3.match(item.start, {
+                        some: ($4, start) => {
+                            $4.match(item.end, {
+                                some: ($5, end) => {
+                                    $5.match(item.resource, {
+                                        some: ($6, ref) => {
+                                            // On one of this kind's resources, by its key: the window holding it draws it.
+                                            $6.if(ref.kind.equal(slot), ($7) => {
+                                                $7.if(into.has(ref.key).not(), ($8) => { $8(into.insert(ref.key, East.value([], PlacedListType))); });
+                                                $7(into.get(ref.key).pushLast(East.value({ item, start, end, icon }, PlacedType)));
+                                            });
+                                        },
+                                    });
+                                },
+                            });
+                        },
+                    });
+                });
+            });
+            $2.assign(result, some(out));
+        });
+        return result;
+    });
+    const rows = East.function([IntegerType, IntegerType, PlanEventPlacedType, PickStateType], OptionType(PlanBlocksType), ($, offset, limit, given, hiding) => {
+        const result = $.let(none, OptionType(PlanBlocksType));
+        const hidden = $.let(hiding.toSet(), SetType(StringType));
+        $.if(hidden.has(planHideId.resources(slot)), ($2) => {
+            // A hidden kind draws no rows: its place stands empty in every window.
+            $2.assign(result, some(East.value([{ fixed: false, parent: none, rows: [] }], PlanBlocksType)));
+        }).else(($2) => {
+            const read = $2.const(window);
+            const got = $2.let(read(offset, limit));
+            $2.match(got, {
+                some: ($3, all) => {
+                    const onIt = new Map(draws.map((draw) => [draw, $3.let(given.get(draw, () => East.value(new Map(), PlacedByKeyType)))]));
+                    $3.assign(result, some(resourceBlocks($3, slot, kind, all, onIt, events, hidden, false)));
+                },
+            });
+        });
+        return result;
+    });
+    // A source that names no snapshot is read at none, and moves nowhere.
+    const revision = resolved.pinned
+        ? handle.revision
+        : East.function([], OptionType(StringType), (_$) => East.value(none, OptionType(StringType)));
+    const refresh = resolved.pinned
+        ? handle.refresh
+        : East.function([OptionType(StringType)], NullType, (_$, _target) => East.value(null, NullType));
+    return East.value({
+        kind: slot,
+        id: handle.id,
+        placed,
+        rows,
+        total: handle.total,
+        seek: handle.seek,
+        revision,
+        refresh,
+    }, PlanEventPagedType);
+}
+//# sourceMappingURL=event-rows.js.map