@elaraai/e3-ui 1.0.97 → 1.0.98

package/dist/src/plan/event-rows.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"event-rows.d.ts","sourceRoot":"","sources":["../../../src/plan/event-rows.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"event-rows.d.ts","sourceRoot":"","sources":["../../../src/plan/event-rows.ts"],"names":[],"mappings":"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"}

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

@@ -51,13 +51,24 @@
  * 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.
  *
+ * A paged kind its Plan's slice names a source after takes its windows from
+ * that source's narrowed rows themselves (#1344): the narrowing's rows, paged
+ * in the source's index's order, as the `rows` source gives the canvas its
+ * rows — never a window of every resource filtered by the keys the source
+ * shows. Its count is the narrowing's, its keys come in the order its rows
+ * draw, so a reader reads the cells of the narrowed resources in view alone,
+ * and `query` names the narrowing its windows belong to. It has no key
+ * search: the narrowing's searches run in its index's order, which a key's
+ * does not follow.
+ *
  * @packageDocumentation
  */
-import { ArrayType, BooleanType, DateTimeType, DictType, East, FunctionType, IntegerType, NullType, OptionType, SetType, StringType, StructType, isTypeEqual, none, some, variant, } from "@elaraai/east";
+import { ArrayType, BlobType, BooleanType, DateTimeType, DictType, East, FloatType, FunctionType, IntegerType, NullType, OptionType, SetType, StringType, StructType, isTypeEqual, 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 { scheduleNarrowedWindows, scheduleOwnWindows } from "../schedule/pages.js";
+import { planIndexOrder } from "./ordered-source.js";
+import { PlanBlockType, PlanBlocksType, PlanBucketEventType, PlanChipType, PlanEventMarkKindType, PlanEventMarkType, PlanHeatCellType, PlanLaneType, PlanRollupType, PlanRowIdType, PlanRowKindType, PlanRowType, PlanRowsCollectionType, PlanRunType, PlanWeightCellType, } from "./types.js";
 import { planGutter, planRow } from "./assemble.js";
 import { bucketsKind, cardsKind, eventsKind, spanKind } from "./factories.js";
 import { planHideId } from "./library.js";
@@ -75,18 +86,49 @@ export const PlanEventDraftsType = DictType(StringType, ScheduleDraftsType);
  * the resources its source shows. A kind it does not name draws every resource.
  */
 export const PlanEventShownType = DictType(StringType, SetType(StringType));
+/**
+ * What a reader read of each event kind by its series index's cells (#1039),
+ * by the kind's slot: the entries, one beast2 of the kind's `cellsType`, that
+ * the kind draws its events from — a kind past the budget, which draws its
+ * summary's shading or the notice in their place, given none. A kind it does
+ * not name is read over the window, as ever.
+ */
+export const PlanEventReadsType = DictType(StringType, BlobType);
+/**
+ * One bucket of a resource's shading (#1039): the bucket's start, and its
+ * value — the share of the bucket the resource's events book, `0` to `1`, for
+ * a way of drawing that draws bars or chips; how many of its events touch the
+ * bucket, for one that draws tiles or marks; `none` where nothing shows at
+ * this resolution, the notice's no-data hatch.
+ */
+export const PlanEventShadeType = StructType({ at: DateTimeType, value: OptionType(FloatType) });
+/**
+ * The resources' shading (#1039): by the key of the rows it stands in for —
+ * a resource kind's slot and a way of drawing, `<slot>.<draw>`, as a
+ * resource's rows are keyed — then by the resource key's text, its buckets.
+ * Each resource's row of a key it names draws heat over those buckets in
+ * place of its events: a booked-vs-free bar a bucket for bars and chips, how
+ * many for tiles and marks — the counts on one scale across every resource
+ * the key shades — and a row with a bucket of no value the no-data hatch.
+ */
+export const PlanEventShadingType = DictType(StringType, DictType(StringType, ArrayType(PlanEventShadeType)));
 /**
  * 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 resources the rail shows)` → 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 resource kind the shown resources name
- * draws those alone (#1344). 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.
+ * hides, the resources the rail shows, what a reader read of each kind by its
+ * cells, the resources' shading)` → 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 resource kind the shown resources name draws
+ * those alone (#1344). 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. A
+ * kind a reader read by its cells (#1039) places the events of the entries it
+ * was given, every draft given in place — those on no resource here, on its
+ * Unassigned row; those on the paged kind's resources through `paged.placed`
+ * — and never reads the window. Each resource's row the shading names draws
+ * its heat in place of its events.
  */
-export const PlanEventBlocksType = FunctionType([DateTimeType, DateTimeType, PlanEventDraftsType, PickStateType, PlanEventShownType], OptionType(PlanBlocksType));
+export const PlanEventBlocksType = FunctionType([DateTimeType, DateTimeType, PlanEventDraftsType, PickStateType, PlanEventShownType, PlanEventReadsType, PlanEventShadingType], OptionType(PlanBlocksType));
 /** The ways a kind draws, in the order a resource's rows take them (PB12). */
 const DRAW_ORDER = ["span", "buckets", "cards", "marks"];
 /**
@@ -233,6 +275,94 @@ const placedLanes = East.function([PlacedListType], ArrayType(PlanLaneType), ($,
     });
     return lanes.toArray(($2, lane) => East.value({ key: lane, label: some(lane) }, PlanLaneType));
 });
+/**
+ * A resource's row of a shaded way of drawing (#1039), `(its buckets, the
+ * largest count its kind's shading holds, whether it draws bars or chips)` →
+ * its heat: a booked-vs-free bar a bucket for one that draws bars or chips,
+ * each bucket's share; how many for one that draws tiles or marks, from none
+ * to the largest, printed compact in the viewer's locale; and the no-data
+ * hatch where a bucket holds no value, its row heat whatever it draws.
+ */
+const shadedKind = East.function([ArrayType(PlanEventShadeType), FloatType, BooleanType], PlanRowKindType, ($, shades, top, booked) => {
+    const valued = $.let(shades.every(($2, shade) => shade.value.hasTag("some")));
+    const most = $.let(none, OptionType(FloatType));
+    $.if(East.greater(top, 0), ($2) => { $2.assign(most, some(top)); });
+    const heat = $.let(East.value(variant("heat", {
+        cells: variant("heat", {
+            cells: shades.map(($2, shade) => East.value({ at: variant("time", shade.at), value: shade.value, label: none }, PlanHeatCellType)),
+            scale: { min: some(0), max: most, warnAt: none },
+            fold: variant("sum", null),
+            format: some(variant("compact", { display: none })),
+        }),
+        aggregate: none,
+        scale: none,
+    }), PlanRowKindType), PlanRowKindType);
+    $.if(booked.and(() => valued), ($2) => {
+        $2.assign(heat, East.value(variant("heat", {
+            cells: variant("weight", {
+                cells: shades.map(($3, shade) => East.value({ at: variant("time", shade.at), fraction: shade.value.unwrap("some"), planned: false }, PlanWeightCellType)),
+                fold: variant("mean", null),
+                format: none,
+            }),
+            aggregate: none,
+            scale: none,
+        }), PlanRowKindType));
+    });
+    return heat;
+});
+/**
+ * The resources' rows with their shading in place (#1039), `(blocks, shading,
+ * the keys of the rows that draw bars or chips)`: every resource's row of a
+ * way of drawing the shading names draws its heat in place of its events —
+ * one whose resource it holds no shading of yet draws none, at the height it
+ * will draw it at — the counts of one key on one scale, the largest it holds.
+ * Every other row stands.
+ */
+const shadedRows = East.function([PlanBlocksType, PlanEventShadingType, SetType(StringType)], PlanBlocksType, ($, blocks, shading, booked) => {
+    const kindOf = $.const(shadedKind);
+    const noShades = $.const([], ArrayType(PlanEventShadeType));
+    const tops = $.let(new Map(), DictType(StringType, FloatType));
+    $.for(shading, ($2, byKey, series) => {
+        const top = $2.let(0, FloatType);
+        $2.for(byKey, ($3, shades) => {
+            $3.for(shades, ($4, shade) => {
+                $4.match(shade.value, { some: ($5, v) => { $5.if(East.greater(v, top), ($6) => { $6.assign(top, v); }); } });
+            });
+        });
+        $2(tops.insert(series, top));
+    });
+    return blocks.map(($2, b) => East.value({
+        fixed: b.fixed,
+        parent: b.parent,
+        charts: b.charts,
+        rows: b.rows.map(($3, row) => row.id.match({
+            section: (_$4, _at) => row,
+            entry: (_$4, at) => shading.tryGet(at.series).match({
+                none: (_$5) => row,
+                some: ($5, byKey) => {
+                    // A resource's row's path ends in its key.
+                    const key = $5.let(at.path.get(at.path.size().subtract(1n)));
+                    const heat = $5.let(kindOf(byKey.get(key, () => noShades), tops.get(at.series), booked.has(at.series)));
+                    const fields = row;
+                    return East.value(Object.fromEntries(Object.keys(PlanRowType.fields).map((f) => [f, f === "kind" ? heat : fields[f]])), PlanRowType);
+                },
+            }),
+        })),
+    }, PlanBlockType));
+});
+/**
+ * The keys of the resources' rows that draw bars or chips (#1039): shaded,
+ * they draw booked-vs-free bars.
+ *
+ * @param resources - The resource kinds, by slot
+ * @param events - The event kinds, by slot
+ * @returns Each `<slot>.span` and `<slot>.cards` the kinds draw
+ */
+function bookedKeys(resources, events) {
+    return new Set(resources.flatMap(([slot]) => eventDrawsOf(slot, events)
+        .filter((draw) => draw === "span" || draw === "cards")
+        .map((draw) => `${slot}.${draw}`)));
+}
 /**
  * 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
@@ -401,6 +531,24 @@ function resourceBlocks($, slot, kind, all, placed, events, hidden, fixed = true
     else {
         blocks = applySeries([views], roots);
     }
+    // ── What each resource makes of chart rows (#1398) ──
+    // A paged kind's window is its source's entries, a resource each, and a paged kind nests and groups none: each
+    // makes its measures' chart rows that the viewer shows — a chart measure's one, or as many as its own `match`
+    // takes, which no definition fixes. A kind read whole is fixed blocks, which no entry makes.
+    const charts = $.let(East.value(fixed ? none : some(0n), OptionType(IntegerType)), OptionType(IntegerType));
+    if (!fixed) {
+        for (const facts of kind.measures.map((m) => planSeriesFacts(m, collection, where))) {
+            const each = facts.charts;
+            if (each === 0)
+                continue;
+            $.if(hidden.has(planHideId.measures(facts.key)).not(), ($2) => {
+                if (each === undefined)
+                    $2.assign(charts, none);
+                else
+                    $2.match(charts, { some: ($3, n) => { $3.assign(charts, some(n.add(BigInt(each)))); } });
+            });
+        }
+    }
     // ── 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
@@ -413,7 +561,7 @@ function resourceBlocks($, slot, kind, all, placed, events, hidden, fixed = true
         }),
     ];
     if (hiders.length === 0) {
-        return $.let(blocks.map(($2, b) => ({ fixed, parent: b.parent, rows: b.rows })), PlanBlocksType);
+        return $.let(blocks.map(($2, b) => ({ fixed, parent: b.parent, charts, rows: b.rows })), PlanBlocksType);
     }
     const dropped = $.let(new Set(), SetType(StringType));
     for (const [series, ids] of hiders) {
@@ -423,6 +571,7 @@ function resourceBlocks($, slot, kind, all, placed, events, hidden, fixed = true
     return $.let(blocks.map(($2, b) => ({
         fixed,
         parent: b.parent,
+        charts,
         rows: b.rows.filter(($3, row) => dropped.has(row.id.match({
             entry: (_$4, at) => at.series,
             section: (_$4, at) => at.series,
@@ -457,13 +606,15 @@ function unassignedBlock($, events, lost) {
             })));
         });
     });
-    return $.let({ fixed: true, parent: none, rows }, PlanBlockType);
+    return $.let({ fixed: true, parent: none, charts: none, rows }, PlanBlockType);
 }
 /**
- * The `blocks` seam (see the module docs): `(from, to, drafts, hidden, shown)`
- * → the resources' rows over `[from, to)`, every kind's drafts in place, what
- * the viewer hides left out, and of a resource kind the rail narrows the
- * resources it shows.
+ * The `blocks` seam (see the module docs): `(from, to, drafts, hidden, shown,
+ * reads, shading)` → the resources' rows over `[from, to)`, every kind's
+ * drafts in place, what the viewer hides left out, of a resource kind the
+ * rail narrows the resources it shows, each kind a reader read by its cells
+ * drawn from what it read, and each resource's row the shading names drawing
+ * its heat.
  *
  * @remarks
  * Made inside the function that assembles the payload, so `built` is the
@@ -477,17 +628,23 @@ function unassignedBlock($, events, lost) {
  * @internal
  */
 export function createEventBlocks(resources, events, built) {
-    return East.function([DateTimeType, DateTimeType, PlanEventDraftsType, PickStateType, PlanEventShownType], OptionType(PlanBlocksType), ($, from, to, drafts, hiding, shown) => {
+    // The keys of the rows that draw bars or chips (#1039): a shaded one draws booked-vs-free bars.
+    const booked = bookedKeys(resources, events);
+    return East.function([
+        DateTimeType, DateTimeType, PlanEventDraftsType, PickStateType, PlanEventShownType, PlanEventReadsType, PlanEventShadingType,
+    ], OptionType(PlanBlocksType), ($, from, to, drafts, hiding, shown, given, shading) => {
         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 shade = $.const(shadedRows);
+        const drawsBars = $.const(booked, SetType(StringType));
+        // Each kind's events over the window, its drafts in place (PB17) — a kind a reader read by its cells from
+        // what it read (#1039). 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)); });
+            $.if(hidden.has(planHideId.events(slot)).not(), ($2) => { $2.assign(read, kind.planItems(from, to, kindDrafts, given.tryGet(slot))); });
             return read;
         });
         const ready = reads.reduce((all, read) => all.and(() => read.hasTag("some")), East.value(true, BooleanType));
@@ -543,8 +700,9 @@ export function createEventBlocks(resources, events, built) {
             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)));
+                    // `paged` fills a window at a time — there whether or not the viewer hides the kind. What its
+                    // resources make of chart rows is the window's block's to say (#1398).
+                    $2(blocks.pushLast(East.value({ fixed: false, parent: none, charts: none, rows: [] }, PlanBlockType)));
                     continue;
                 }
                 // A hidden resource kind draws no rows; its events stay its own, off the Unassigned row.
@@ -561,7 +719,7 @@ export function createEventBlocks(resources, events, built) {
                             return keyed.filter((_$5, _row, key) => keys.has(key));
                         }, () => keyed));
                     }
-                    $3(blocks.append(resourceBlocks($3, slot, kind, drawn, placed.get(slot), events, hidden)));
+                    $3(blocks.append(shade(resourceBlocks($3, slot, kind, drawn, placed.get(slot), events, hidden), shading, drawsBars)));
                 });
             }
             $2(blocks.pushLast(unassignedBlock($2, events, lost)));
@@ -580,26 +738,32 @@ export function createEventBlocks(resources, events, built) {
  * 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.
+ * resources are never read whole. Narrowed by its source of the slice
+ * (#1344), its windows are the narrowing's rows, in the source's index's
+ * order, and it has no key search.
  *
  * @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 id - The identity of the kind's resources' window: the source's, the same under every narrowing, when its source of the slice narrows it
+ * @property placed - `(from, to, drafts by kind, the ids the viewer hides, what a reader read of each kind by its cells)` → 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. A kind a reader read by its cells (#1039) places the events of the entries it was given, and never reads the window
+ * @property rows - `(offset, limit, placed, shading, the ids the viewer hides)` → the kind's rows for its resources `[offset, offset + limit)` — a whole window of them, in the resources' key order, or the narrowing's in its index's order (#1344) — with the events given placed on them, and each resource's row whose key the shading names drawing its heat in their place (#1039): one block, not fixed (an empty one while the viewer hides the kind); `none` while the window is in flight
+ * @property keys - `(offset, limit)` → the texts of the keys of the kind's resources `[offset, offset + limit)`, in the order `rows` draws them (#1039): the resources a reader reads the cells of; `none` while the window is in flight
+ * @property total - How many resources the kind has — the narrowing holds, when its source narrows it — once known
+ * @property seek - Where a key search lands among the kind's resources: the window's own key search; `none` when its source narrows it, whose searches run in its index's order
  * @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
+ * @property query - The narrowing the windows, the total and the keys belong to, as text (#1344): it moves when a choice does, and the windows are read again under it; `none` when no source narrows the kind
  */
 export const PlanEventPagedType = StructType({
     kind: StringType,
     id: StringType,
-    placed: FunctionType([DateTimeType, DateTimeType, PlanEventDraftsType, PickStateType], OptionType(PlanEventPlacedType)),
-    rows: FunctionType([IntegerType, IntegerType, PlanEventPlacedType, PickStateType], OptionType(PlanBlocksType)),
+    placed: FunctionType([DateTimeType, DateTimeType, PlanEventDraftsType, PickStateType, PlanEventReadsType], OptionType(PlanEventPlacedType)),
+    rows: FunctionType([IntegerType, IntegerType, PlanEventPlacedType, PlanEventShadingType, PickStateType], OptionType(PlanBlocksType)),
+    keys: FunctionType([IntegerType, IntegerType], OptionType(ArrayType(StringType))),
     total: FunctionType([], OptionType(IntegerType)),
     seek: OptionType(FunctionType([SeekQueryType], OptionType(SeekRangeType))),
     revision: FunctionType([], OptionType(StringType)),
     refresh: FunctionType([OptionType(StringType)], NullType),
+    query: OptionType(FunctionType([], StringType)),
 });
 /**
  * The paged resource kind's rows (see {@link PlanEventPagedType}), when a
@@ -607,41 +771,40 @@ export const PlanEventPagedType = StructType({
  *
  * @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.
+ * is, so `built` is the payload's own array of event kinds — and `narrowed`
+ * is the kind's source of the slice as the payload's block bound it, so the
+ * kind's rows hold that source alone (#1356).
  *
  * @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
+ * @param narrowed - The paged kind's source of the slice's narrowed data, when the slice names one after its slot (#1344): its windows are then the narrowing's rows
  * @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
+ * @throws {Error} When the kind's paged read is not a paged source of its resources, or its source's rows are not the kind's
  * @internal
  */
-export function createEventPaged(resources, events, built) {
+export function createEventPaged(resources, events, built, narrowed) {
     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 pages = narrowed === undefined ? scheduleOwnWindows(kind, where) : scheduleNarrowedWindows(kind, slot, narrowed, "Plan");
+    const handle = pages.handle;
     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 placed = East.function([DateTimeType, DateTimeType, PlanEventDraftsType, PickStateType, PlanEventReadsType], OptionType(PlanEventPlacedType), ($, from, to, drafts, hiding, given) => {
         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.
+        // Each kind's events over the window, its drafts in place — a kind a reader read by its cells from what it
+        // read (#1039); 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)); });
+            $.if(hidden.has(planHideId.events(s)).not(), ($2) => { $2.assign(read, k.planItems(from, to, kindDrafts, given.tryGet(s))); });
             return read;
         });
         const ready = reads.reduce((all, read) => all.and(() => read.hasTag("some")), East.value(true, BooleanType));
@@ -676,40 +839,62 @@ export function createEventPaged(resources, events, built) {
         });
         return result;
     });
-    const rows = East.function([IntegerType, IntegerType, PlanEventPlacedType, PickStateType], OptionType(PlanBlocksType), ($, offset, limit, given, hiding) => {
+    // The keys of its rows that draw bars or chips (#1039): a shaded one draws booked-vs-free bars.
+    const booked = bookedKeys([[slot, kind]], events);
+    const rows = East.function([IntegerType, IntegerType, PlanEventPlacedType, PlanEventShadingType, PickStateType], OptionType(PlanBlocksType), ($, offset, limit, given, shading, 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)));
+            // A hidden kind draws no rows: its place stands empty in every window, and its resources make no chart row (#1398).
+            $2.assign(result, some(East.value([{ fixed: false, parent: none, charts: some(0n), rows: [] }], PlanBlocksType)));
         }).else(($2) => {
-            const read = $2.const(window);
+            const read = $2.const(pages.read);
+            const shade = $2.const(shadedRows);
+            const drawsBars = $2.const(booked, SetType(StringType));
             const got = $2.let(read(offset, limit));
             $2.match(got, {
-                some: ($3, all) => {
+                some: ($3, page) => {
+                    const all = $3.let(pages.rows(page));
                     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)));
+                    const blocks = $3.let(resourceBlocks($3, slot, kind, all, onIt, events, hidden, false));
+                    // A narrowed window's rows in its index's order (#1344), each resource's rows together.
+                    const drawn = pages.indexed ? $3.let(planIndexOrder(blocks, pages.keys($3, page))) : blocks;
+                    $3.assign(result, some(shade(drawn, shading, drawsBars)));
                 },
             });
         });
         return result;
     });
+    // The keys of a window's resources as the rows name them, in the order they draw (#1039): what a reader reads the cells of.
+    const keys = East.function([IntegerType, IntegerType], OptionType(ArrayType(StringType)), ($, offset, limit) => {
+        const read = $.const(pages.read);
+        const result = $.let(none, OptionType(ArrayType(StringType)));
+        $.match(read(offset, limit), {
+            some: ($2, page) => { $2.assign(result, some(pages.keys($2, page))); },
+        });
+        return result;
+    });
     // A source that names no snapshot is read at none, and moves nowhere.
-    const revision = resolved.pinned
+    const revision = pages.pinned
         ? handle.revision
         : East.function([], OptionType(StringType), (_$) => East.value(none, OptionType(StringType)));
-    const refresh = resolved.pinned
+    const refresh = pages.pinned
         ? handle.refresh
         : East.function([OptionType(StringType)], NullType, (_$, _target) => East.value(null, NullType));
+    const Seek = PlanEventPagedType.fields.seek;
+    const Query = PlanEventPagedType.fields.query;
     return East.value({
         kind: slot,
         id: handle.id,
         placed,
         rows,
+        keys,
         total: handle.total,
-        seek: handle.seek,
+        // A narrowing's searches run in its index's order, which a resource's key does not follow: no key search.
+        seek: pages.indexed ? East.value(none, Seek) : handle.seek,
         revision,
         refresh,
+        query: pages.query ? East.value(some(handle.query), Query) : East.value(none, Query),
     }, PlanEventPagedType);
 }
 //# sourceMappingURL=event-rows.js.map