@elaraai/e3-ui 1.0.98 → 1.0.99

package/dist/src/plan/series.js

@@ -34,11 +34,12 @@
  *
  * @packageDocumentation
  */
-import { East, Expr, ArrayType, BlobType, BooleanType, DateTimeType, DictType, EastTypeType, FloatType, FunctionType, IntegerType, OptionType, RefType, StringType, StructType, VariantType, isTypeEqual, printFor, toEastTypeValue, variant, some, none, } from "@elaraai/east";
+import { East, Expr, ArrayType, BlobType, BooleanType, DateTimeType, DictType, EastTypeType, FloatType, FunctionType, IntegerType, NullType, OptionType, RefType, StringType, StructType, VariantType, isTypeEqual, isVariant, printFor, printTypeSummary, toEastTypeValue, variant, some, none, } from "@elaraai/east";
 import { IconType, StatusValueType } from "@elaraai/east-ui";
 import { TableAggregateType, TickFormatType, reifyAccessor, resolveTag } from "@elaraai/east-ui/internal";
-import { PlanAggregateType, PlanExpandType, PlanGroupSummaryType, PlanHeatCellsType, PlanLaneType, PlanBucketEventType, PlanCellMarkerType, PlanChipType, PlanEventMarkType, PlanRunType, PlanDecisionMarkType, PlanPortType, PlanRollupType, PlanRowIdType, PlanRowKindType, PlanRowType, PlanRowsCollectionType, PlanBlockType, PlanBlocksType, PlanGestureType, PlanDropType, PlanInstantType, } from "./types.js";
-import { resolveIcon } from "./builders.js";
+import { PlanAggregateType, PlanExpandType, PlanGroupSummaryType, PlanHeatCellsType, PlanLaneType, PlanBucketEventType, PlanCellMarkerType, PlanChipType, PlanEventMarkType, PlanRunType, PlanDecisionMarkType, PlanPortType, PlanRollupType, PlanRowIdType, PlanRowKindType, PlanRowType, PlanRowsCollectionType, PlanBlockType, PlanBlocksType, PlanGestureType, PlanDropType, PlanInstantType, PlanFoldType, } from "./types.js";
+import { PLAN_LOOKS, resolveIcon, resolveInstant, } from "./builders.js";
+import { PlanReadsBrand, PlanUseBrand, planReadOf, planUseOf, } from "./reads.js";
 import { planRow, planGutter, normalizeRows, REBASE_ROWS } from "./assemble.js";
 import { spanKind, bucketsKind, chartKind, heatKind, tableKind, cardsKind, eventsKind, groupKind, groupSummary, } from "./factories.js";
 // ============================================================================
@@ -106,15 +107,35 @@ export const PlanSeriesType = seriesShape;
 /** Marks a {@link PlanChildren} step-down. */
 const PLAN_CHILDREN = Symbol("PlanChildren");
 /**
- * Step down from an entry to a child collection of another entry type (#822).
+ * Step down from an entry to its child rows (#822, #1436): a `Dict` field of
+ * the entry, keyed by an id, its rows laid out by `series` like a top-level
+ * list.
  *
  * @typeParam R - The parent entry type (inferred from where the step-down is used)
- * @typeParam KT - The parent entries' key type
- * @param of - The child collection — an `Array` (index order) or a `Dict` (key order) — from the parent entry
- * @param series - The series over the child entries, laid out like a top-level list
+ * @typeParam F - The field holding the child rows
+ * @typeParam S - The series over them, as written
+ * @param field - A Dict field of the entry holding the child rows, keyed by an id
+ * @param series - The series over the child rows
  * @returns The step-down, for a series' `children`
  */
-export function createChildren(of, series) {
+export function createChildren(field, series) {
+    if (typeof field !== "string") {
+        throw new Error("Plan.children: name the field holding the child rows — a Dict of the row, keyed by an id: Plan.children(\"members\", [series…])");
+    }
+    return { [PLAN_CHILDREN]: true, field, series };
+}
+/**
+ * Step down from an entry to a collection an accessor computes (#1194) — the
+ * event kinds' own: a resource's events come from another record, so its
+ * child rows are no field of it. An author's step-down names its field
+ * ({@link createChildren}).
+ *
+ * @internal
+ * @param of - The child collection, from the parent entry's value and key
+ * @param series - The series over the child entries
+ * @returns The step-down
+ */
+export function createChildrenOf(of, series) {
     return { [PLAN_CHILDREN]: true, of, series };
 }
 function isStepDown(x) {
@@ -127,6 +148,36 @@ const PathType = ArrayType(StringType);
 const IdOptType = OptionType(PlanRowIdType);
 /** Every series value a builder made, with its build spec. */
 const SPECS = new WeakMap();
+/** A spec's facts for the nested checks (#1435). */
+function nestFactsOf(spec) {
+    return { key: spec.key, arm: spec.arm, reads: spec.reads, nest: spec.nest };
+}
+/**
+ * The facts a Plan holds to its rows' nested series index (#1435), of a
+ * series value a `Plan.series.*` builder made, and of each series its spec
+ * nests: `facts(spec)` for any of them.
+ *
+ * @param series - The series value
+ * @returns Its facts; `undefined` for a value no builder made in place (a bound, picked or stored one)
+ * @internal
+ */
+export function planSeriesNestOf(series) {
+    const spec = specOf(series);
+    return spec === undefined ? undefined : nestFactsOf(spec);
+}
+/**
+ * The facts of the series a spec nests (#1435), as {@link planSeriesNestOf} gives them.
+ *
+ * @param nest - A series' nest
+ * @returns Its step-downs' series and its members, each with its facts
+ * @internal
+ */
+export function planNestedSeriesFacts(nest) {
+    return {
+        steps: nest.steps.map((step) => ({ field: step.field, of: step.of, series: step.series.map(nestFactsOf) })),
+        members: nest.members.map(nestFactsOf),
+    };
+}
 /** The spec of a series value a `Plan.series.*` builder made, if it was one. */
 function specOf(s) {
     return typeof s === "object" && s !== null ? SPECS.get(s) : undefined;
@@ -308,85 +359,34 @@ function collectionOps(collection) {
         put: (c, k, v) => array(c).update(index(k), v),
     };
 }
-/** The instant fields a kind's elements have (#825): two ends (a run, a chip) or one instant (a tile, a mark). */
-function editShapeOf(arm) {
-    return arm === "span" || arm === "cards" ? "span" : "point";
-}
-/** The item field types a move can write an instant into (#825). */
-const INSTANT_FIELD_TYPES = [DateTimeType, FloatType, IntegerType, StringType, PlanInstantType];
+/** The item field types a move can write an instant into (#825, #1436). */
+const INSTANT_FIELD_TYPES = [DateTimeType, FloatType, IntegerType, StringType, PlanInstantType, OptionType(DateTimeType)];
 /** Print an item type as the text rows of one item type share (#825) — East's own printer over its type value. */
 const printType = printFor(EastTypeType);
 /**
- * Check what a series' `edit` declares for a move (#825), against its item
- * type — `undefined` when it declares no move (only `create`).
+ * What a move writes, from the read that names the collection (#1436) — its
+ * times, checked against the item type by the read's build.
  *
- * @param edit - The declaration
- * @param itemType - The type of the items in `edit.items`
- * @param arm - The series' kind
- * @param where - The series, for the message
+ * @param read - The elements' read
+ * @param item - The collection's item type
  * @returns The move's fields
- * @throws {Error} Naming the field and what is wrong with it
  */
-function moveFieldsOf(edit, itemType, arm, where) {
-    const shape = editShapeOf(arm);
-    if (shape === "span" && edit.at !== undefined) {
-        throw new Error(`${where}: \`edit.at\` is a tile's or a mark's instant — a ${arm} element has two ends: name them with \`start\` and \`end\``);
-    }
-    if (shape === "point" && (edit.start !== undefined || edit.end !== undefined)) {
-        throw new Error(`${where}: a ${arm} element has one instant — name it with \`edit.at\`, not \`start\` / \`end\``);
-    }
-    const start = shape === "span" ? edit.start : edit.at;
-    const end = shape === "span" ? edit.end : undefined;
-    if (shape === "span" && (start === undefined) !== (end === undefined)) {
-        throw new Error(`${where}: a move writes both ends of a ${arm} element — give \`edit.start\` and \`edit.end\` together`);
-    }
-    if (start === undefined) {
-        if (edit.create === undefined) {
-            throw new Error(`${where}: \`edit\` declares neither \`create\` (what a dropped card becomes) nor the item fields a move ` +
-                `writes (\`key\` and ${shape === "span" ? "`start` / `end`" : "`at`"}) — declare one or both`);
-        }
-        return undefined;
-    }
-    const item = itemType;
-    if (item.type !== "Struct") {
-        throw new Error(`${where}: a move writes fields of the item — the items in "${edit.items}" must be structs`);
-    }
-    if (edit.key === undefined) {
-        throw new Error(`${where}: a move finds its element's item by key — name the item's String key field with \`edit.key\``);
-    }
-    const keyType = item.fields[edit.key];
-    if (keyType === undefined || !isTypeEqual(keyType, StringType)) {
-        throw new Error(`${where}: \`edit.key\` names "${edit.key}", which is not a String field of the item`);
-    }
-    const instant = (name, what) => {
-        const type = item.fields[name];
-        if (type === undefined || !INSTANT_FIELD_TYPES.some((t) => isTypeEqual(t, type))) {
-            throw new Error(`${where}: \`edit.${what}\` names "${name}", which is not an instant field of the item — a DateTime, a Float or ` +
-                "an Integer, a String, or a Plan.Types.Instant");
-        }
-        if (name === edit.key) {
-            throw new Error(`${where}: \`edit.${what}\` names the key field "${name}" — a move would change the item's identity; name its instant field`);
-        }
-        return { name, type };
-    };
-    if (end !== undefined && end === start) {
-        throw new Error(`${where}: \`edit.start\` and \`edit.end\` both name "${start}" — a move writes two different fields`);
-    }
-    return {
-        item,
-        key: edit.key,
-        start: instant(start, shape === "span" ? "start" : "at"),
-        end: end !== undefined ? instant(end, "end") : undefined,
-        edits: { items: printType(toEastTypeValue(itemType)), resize: shape === "span" },
-    };
+function moveFieldsOf(read, item) {
+    const field = (name) => ({ name, type: item.fields[name] });
+    const times = read.times;
+    const edits = { items: printType(toEastTypeValue(item)), resize: !("at" in times) };
+    return "at" in times
+        ? { item, start: field(times.at), end: undefined, edits }
+        : { item, start: field(times.from), end: field(times.to), edits };
 }
 /** Each instant field type's converter, built once (#825). */
 const instantConverters = new ByType();
 /**
  * The converter from an axis instant into an item field's type (#825): the
- * instant on the arm the field holds — a time instant's DateTime, a number
- * instant's Float (an Integer field takes it rounded, half away from zero), an
- * ordinal instant's String, or the instant itself — else `none`.
+ * instant on the arm the field holds — a time instant's DateTime (an `Option`
+ * of one takes it as `some`, #1436), a number instant's Float (an Integer field
+ * takes it rounded, half away from zero), an ordinal instant's String, or the
+ * instant itself — else `none`.
  *
  * @param fieldType - The field's type (one of {@link INSTANT_FIELD_TYPES})
  * @returns `(instant) → Option<field>`
@@ -396,6 +396,7 @@ function instantInto(fieldType) {
         const out = OptionType(fieldType);
         const kind = fieldType.type;
         const whole = isTypeEqual(fieldType, PlanInstantType);
+        const optional = isTypeEqual(fieldType, OptionType(DateTimeType));
         return East.function([PlanInstantType], out, ($, t) => {
             const result = $.let(none, out);
             if (whole) {
@@ -406,6 +407,9 @@ function instantInto(fieldType) {
                 time: ($2, d) => {
                     if (kind === "DateTime")
                         $2.assign(result, some(d));
+                    // An Option of a DateTime holds the instant as `some` (#1436).
+                    if (optional)
+                        $2.assign(result, some(some(d)));
                 },
                 number: ($2, n) => {
                     if (kind === "Float") {
@@ -425,6 +429,570 @@ function instantInto(fieldType) {
         });
     });
 }
+/** An East type's name as a message reads it: `an Array`, `a Dict`. */
+function anOf(type) {
+    const name = type.type;
+    return /^[AEIOU]/.test(name) ? `an ${name}` : `a ${name}`;
+}
+/** A row type's shape as a message reads it: its fields, `{ name, load }`, or East's summary of another type. */
+function shapeName(type) {
+    const t = type;
+    if (t.type === "Recursive" && t.node !== undefined)
+        return shapeName(t.node);
+    if (t.type === "Struct" && t.fields !== undefined)
+        return `{ ${Object.keys(t.fields).join(", ")} }`;
+    return printTypeSummary(type);
+}
+/** The fields of an entry type — a struct's own, or a recursive entry's node's. */
+function entryFieldsOf(rowType) {
+    const t = rowType;
+    if (t.type === "Struct")
+        return t.fields;
+    if (t.type === "Recursive" && t.node?.type === "Struct")
+        return t.node.fields;
+    return undefined;
+}
+/** The key types a values collection may be keyed by: its instants. */
+const VALUE_KEY_TYPES = [DateTimeType, FloatType, IntegerType, StringType];
+/**
+ * The collection a read names, checked against the entry type (#1436).
+ *
+ * @param rowType - The entry type
+ * @param read - The read
+ * @param where - The series, for the messages
+ * @returns The collection's shape
+ * @throws {Error} In the refusals' words: no Dict field of the row, an items collection keyed by an instant or holding no
+ *   struct, a time that is no instant field of its items, a values collection keyed by no instant
+ */
+function collectionOfRead(rowType, read, where) {
+    const what = read.kind === "items" ? "Plan.items" : "Plan.values";
+    const fields = entryFieldsOf(rowType);
+    const t = fields?.[read.field];
+    if (t === undefined) {
+        throw new Error(`${where}: ${what} reads "${read.field}", which is no field of its rows — name a Dict field of the row`);
+    }
+    if (t.type !== "Dict") {
+        throw new Error(`${what}: "${read.field}" is ${anOf(t)} — a collection a series reads by name is a Dict, keyed by an id, ` +
+            "or by its instant for values");
+    }
+    const key = t.key;
+    const item = t.value;
+    const keyName = key.type;
+    if (read.kind === "values") {
+        if (!VALUE_KEY_TYPES.some((k) => isTypeEqual(k, key))) {
+            throw new Error(`Plan.values: "${read.field}" is keyed by ${keyName} — values are keyed by their instant: a DateTime, a Float, ` +
+                "an Integer or a String");
+        }
+        return { dict: t, key, item };
+    }
+    if (!isTypeEqual(key, StringType)) {
+        throw new Error(`Plan.items: "${read.field}" is keyed by ${keyName} — things people drag are keyed by an id, a String: read values ` +
+            `with Plan.values("${read.field}", draw)`);
+    }
+    const struct = item;
+    if (struct.type !== "Struct" || struct.fields === undefined) {
+        throw new Error(`Plan.items: "${read.field}" holds ${anOf(item)}, not an item — things people drag are structs, their times fields ` +
+            `of them: read values with Plan.values("${read.field}", draw)`);
+    }
+    const names = "at" in read.times ? [read.times.at] : [read.times.from, read.times.to];
+    if (names.length === 2 && names[0] === names[1]) {
+        throw new Error(`Plan.items: "${read.field}" names "${names[0]}" as both its from and its to — a run's start and end are two fields of its items`);
+    }
+    for (const name of names) {
+        const ft = struct.fields[name];
+        if (ft === undefined) {
+            throw new Error(`Plan.items: "${read.field}" names its times by "${name}", which is no field of its items — name a time field of the item`);
+        }
+        if (!INSTANT_FIELD_TYPES.some((k) => isTypeEqual(k, ft))) {
+            throw new Error(`Plan.items: "${read.field}" names "${name}", ${anOf(ft)} field of its items, as a time — a time is a DateTime or an ` +
+                "Option of one, a Float, an Integer, a String, or a Plan.Types.Instant");
+        }
+    }
+    return { dict: t, key, item };
+}
+/** Each element's look type: its type without its key and its instants. */
+const lookTypes = new Map();
+/** What `draw` gives for an element of `kind`, as an East struct: the element without its key and its instants. */
+function lookTypeOf(kind) {
+    let type = lookTypes.get(kind);
+    if (type === undefined) {
+        const spec = PLAN_LOOKS[kind];
+        const omit = [...(spec.key !== undefined ? [spec.key] : []), ...spec.instants];
+        type = StructType(Object.fromEntries(Object.entries(spec.type.fields).filter(([f]) => !omit.includes(f))));
+        lookTypes.set(kind, type);
+    }
+    return type;
+}
+/** What each element kind is called where a refusal names it. */
+const ELEMENT_NAMES = {
+    run: "runs", decision: "decisions", port: "ports", event: "events", marker: "markers", chip: "chips", mark: "marks",
+    heat: "heat cells", weight: "weight cells", segment: "segment cells", table: "table cells", point: "points", band: "band points",
+};
+/** Each read's builds, by what it completes and the entry type. */
+const readBuilds = new WeakMap();
+/**
+ * A read built for one entry type (#1436): `(collection, entry) → elements` —
+ * each item an element at its times, keyed by its id, or each value one at its
+ * instant, its look `draw`'s. The collection is an argument, so the same build
+ * draws an inline row's own collection and one read a cell at a time.
+ *
+ * @param rowType - The entry type
+ * @param read - The read
+ * @param kind - What each item or value completes to
+ * @param where - The series, for messages
+ * @returns The built function
+ * @throws {Error} When the read does not build for the entry type, in the refusals' words
+ */
+function buildRead(rowType, read, kind, where) {
+    let byKind = readBuilds.get(read);
+    if (byKind === undefined) {
+        byKind = new Map();
+        readBuilds.set(read, byKind);
+    }
+    let byType = byKind.get(kind);
+    if (byType === undefined) {
+        byType = new ByType();
+        byKind.set(kind, byType);
+    }
+    return byType.get(rowType, () => {
+        const shape = collectionOfRead(rowType, read, where);
+        const spec = PLAN_LOOKS[kind];
+        const elemType = spec.type;
+        const lookType = lookTypeOf(kind);
+        const recursive = rowType.type === "Recursive";
+        const what = read.kind === "items" ? `Plan.items("${read.field}", …)` : `Plan.values("${read.field}", …)`;
+        // The look, reified once: `(item or value, id or instant, entry) → look`.
+        const look = (() => {
+            try {
+                return East.function([shape.item, shape.key, rowType], lookType, ($, item, key, row) => {
+                    const node = recursive ? $.let(row.unwrap()) : row;
+                    const given = read.draw(item, key, node);
+                    if (given === null || typeof given !== "object" || given instanceof Expr) {
+                        throw new Error(`its draw gives the look of each of its ${ELEMENT_NAMES[kind]}, an object of their fields`);
+                    }
+                    return East.value(spec.look(given), lookType);
+                });
+            }
+            catch (err) {
+                const reason = err instanceof Error ? err.message : String(err);
+                throw new Error(`${where}: ${what} does not build for its rows (${reason})`);
+            }
+        })();
+        const fieldsOf = (l) => Object.fromEntries(Object.keys(lookType.fields).map((f) => [f, l[f]]));
+        const out = ArrayType(elemType);
+        if (read.kind === "values") {
+            const at = spec.instants[0];
+            return East.function([shape.dict, rowType], out, ($, coll, row) => {
+                const draw = $.const(look);
+                return coll.toArray(($2, value, key) => {
+                    const l = $2.let(draw(value, key, row));
+                    return East.value({ [at]: resolveInstant(key, `${what} key`), ...fieldsOf(l) }, elemType);
+                });
+            });
+        }
+        // Things people drag: each at its named times, keyed by its id. An item whose
+        // start is an Option holding none is drawn nowhere; one whose end holds none is
+        // an instant (#1434's filing).
+        const item = shape.item;
+        const times = read.times;
+        const names = "at" in times ? [times.at] : [times.from, times.to];
+        if (names.length !== spec.instants.length) {
+            throw new Error(spec.instants.length === 2
+                ? `${where}: its ${ELEMENT_NAMES[kind]} run from a start to an end — read them with Plan.items("${read.field}", { from, to }, draw)`
+                : `${where}: its ${ELEMENT_NAMES[kind]} sit at an instant — read them with Plan.items("${read.field}", { at }, draw)`);
+        }
+        const optional = (name) => isTypeEqual(item.fields[name], OptionType(DateTimeType));
+        const instantOf = (v) => resolveInstant(v, `${what} times`);
+        const keyField = spec.key;
+        return East.function([shape.dict, rowType], out, ($, coll, row) => {
+            const draw = $.const(look);
+            const result = $.let([], out);
+            $.for(coll, ($2, value, key) => {
+                const fields = value;
+                const id = key;
+                const emit = ($3, instants) => {
+                    const l = $3.let(draw(value, id, row));
+                    $3(result.pushLast(East.value({
+                        [keyField]: id,
+                        ...Object.fromEntries(spec.instants.map((name, i) => [name, instants[i]])),
+                        ...fieldsOf(l),
+                    }, elemType)));
+                };
+                const withStart = ($3, start) => {
+                    if (names.length === 1) {
+                        emit($3, [start]);
+                        return;
+                    }
+                    const to = names[1];
+                    if (!optional(to)) {
+                        emit($3, [start, instantOf(fields[to])]);
+                        return;
+                    }
+                    const end = $3.let(fields[to].match({
+                        some: (_$4, d) => East.value(variant("time", d), PlanInstantType),
+                        none: () => start,
+                    }), PlanInstantType);
+                    emit($3, [start, end]);
+                };
+                const from = names[0];
+                if (!optional(from)) {
+                    withStart($2, $2.let(instantOf(fields[from]), PlanInstantType));
+                    return;
+                }
+                $2.match(fields[from], {
+                    some: ($3, d) => withStart($3, $3.let(East.value(variant("time", d), PlanInstantType), PlanInstantType)),
+                });
+            });
+            return result;
+        });
+    });
+}
+/** A collection field of the entry, for one row: the field read off its node. */
+function collectionOn(node, field) {
+    return node[field];
+}
+/** The record of a read a series makes. */
+function readRecord(rowType, read, via, where) {
+    return { field: read.field, read, key: collectionOfRead(rowType, read, where).key, via };
+}
+/**
+ * An element field of a series config, resolved for its entry type (#1436): a
+ * function of the row as before, or a read — of items for the things people
+ * drag (runs, decisions, tiles, chips, marks), of values for ports and
+ * markers.
+ *
+ * @param rowType - The entry type
+ * @param input - The field as given
+ * @param kind - What each element is
+ * @param where - The series, for messages
+ * @param via - The field's name
+ * @returns The field, or `undefined` when it is not given
+ * @throws {Error} When a read of the other sort, or a consumer, is given
+ */
+function elementField(rowType, input, kind, where, via) {
+    if (input === undefined)
+        return undefined;
+    if (typeof input === "function") {
+        const accessor = input;
+        return { at: (node, key) => accessor(node, key), reads: [] };
+    }
+    const read = planReadOf(input);
+    if (read === undefined) {
+        throw new Error(`${where}: ${via} is a function of the row, or a read of its collection — ${PLAN_LOOKS[kind].key !== undefined ? "Plan.items(field, times, draw)" : "Plan.values(field, draw)"}`);
+    }
+    const keyed = PLAN_LOOKS[kind].key !== undefined;
+    if (keyed && read.kind !== "items") {
+        throw new Error(`${where}: its ${via} are things people drag, keyed by an id — read them with Plan.items(field, ${PLAN_LOOKS[kind].instants.length === 2 ? "{ from, to }" : "{ at }"}, draw)`);
+    }
+    if (!keyed && read.kind !== "values") {
+        throw new Error(`${where}: its ${via} have no id of their own, so each is keyed by its instant — read them with Plan.values(field, draw)`);
+    }
+    const built = buildRead(rowType, read, kind, where);
+    return { at: (node, _key, value) => built(collectionOn(node, read.field), value), reads: [readRecord(rowType, read, via, where)] };
+}
+/** What each consumer is, where a refusal names what a field takes. */
+const CONSUMER_HINTS = {
+    heat: "Plan.heatCells, Plan.weightCells or Plan.segmentCells over Plan.values(field, draw)",
+    tableCells: "Plan.tableCells(Plan.values(field, draw))",
+    tableSeries: "Plan.tableSeries({ cells: Plan.tableCells(Plan.values(field, draw)) })",
+    layer: "Plan.line, Plan.area, Plan.column, Plan.scatter or Plan.band over Plan.values(field, draw)",
+};
+/**
+ * A consumer of a values read, resolved for the entry type (#1436): the row's
+ * values completed into its cells, and what the consumer makes of them.
+ *
+ * @param rowType - The entry type
+ * @param use - The consumer
+ * @param makes - What the field takes
+ * @param where - The series, for messages
+ * @param via - The field's name
+ * @returns The field
+ */
+function useField(rowType, use, makes, where, via) {
+    if (use.makes !== makes)
+        throw new Error(`${where}: ${via} takes ${CONSUMER_HINTS[makes]}`);
+    const built = buildRead(rowType, use.read, use.cell, where);
+    // The consumer's fold and flag beside the read (#1435): what a parent subtotals its values by.
+    const read = { ...readRecord(rowType, use.read, via, where), ...(use.fold !== undefined ? { fold: use.fold } : {}), flagged: use.rollup };
+    return {
+        at: (node, _key, value) => use.wrap(built(collectionOn(node, use.read.field), value)),
+        reads: [read],
+    };
+}
+/**
+ * A field whose value is one consumer's (cells, a group's summary) resolved
+ * for the entry type (#1436): a function of the row as before, or a consumer
+ * of a values read.
+ *
+ * @param rowType - The entry type
+ * @param input - The field as given
+ * @param makes - What it takes
+ * @param where - The series, for messages
+ * @param via - The field's name
+ * @returns The field, or `undefined` when it is not given
+ */
+function consumerField(rowType, input, makes, where, via) {
+    if (input === undefined)
+        return undefined;
+    if (typeof input === "function") {
+        const accessor = input;
+        return { at: (node, key) => accessor(node, key), reads: [] };
+    }
+    const use = planUseOf(input);
+    if (use !== undefined)
+        return useField(rowType, use, makes, where, via);
+    const read = planReadOf(input);
+    throw new Error(read !== undefined
+        ? `${where}: ${via} takes ${CONSUMER_HINTS[makes]} — give "${read.field}" to it, as ${via}: ${CONSUMER_HINTS[makes].split(" over ")[0].split(",")[0]}(Plan.values("${read.field}", draw))`
+        : `${where}: ${via} is a function of the row, or ${CONSUMER_HINTS[makes]}`);
+}
+/**
+ * A field whose value is a list (a table's positions, a chart's layers)
+ * resolved for the entry type (#1436): a function of the row as before, or a
+ * TS array whose consumers are built per row and whose other members pass as
+ * they are.
+ *
+ * @param rowType - The entry type
+ * @param input - The field as given
+ * @param makes - What its consumers make
+ * @param where - The series, for messages
+ * @param via - The field's name
+ * @returns The field, its value a TS array per row (each consumer's value in its place), or `undefined` when not given
+ */
+function listField(rowType, input, makes, where, via) {
+    if (input === undefined)
+        return undefined;
+    if (typeof input === "function") {
+        const accessor = input;
+        return { at: (node, key) => accessor(node, key), reads: [] };
+    }
+    if (!Array.isArray(input))
+        throw new Error(`${where}: ${via} is a function of the row, or a list of ${CONSUMER_HINTS[makes]}`);
+    const members = input.map((member, i) => {
+        const use = planUseOf(member);
+        if (use !== undefined)
+            return useField(rowType, use, makes, where, `${via}[${i}]`);
+        const read = planReadOf(member);
+        if (read !== undefined)
+            throw new Error(`${where}: ${via}[${i}] takes ${CONSUMER_HINTS[makes]}, not the read "${read.field}" alone`);
+        return { at: () => member, reads: [] };
+    });
+    return {
+        at: (node, key, value) => members.map((m) => m.at(node, key, value)),
+        reads: members.flatMap((m) => m.reads),
+    };
+}
+/**
+ * A table's positions whose values take typed numbers (#1436): its `cells`
+ * when the series declares `edit: true`, and each `Plan.tableSeries` position
+ * declaring its own — each drawing every value as it is stored.
+ *
+ * @param rowType - The entry type
+ * @param cfg - The table's `cells`, `series` and `edit`, as given
+ * @param where - The series, for messages
+ * @returns The typed positions, in order
+ * @throws {Error} In the refusals' words: `edit` beside cells given as a function, or over a draw giving another number than each value
+ */
+function tableEditsOf(rowType, cfg, where) {
+    const out = [];
+    if (cfg.edit !== undefined) {
+        if (cfg.edit !== true)
+            throw new Error(`${where}: edit is true — its cells' values take typed numbers — or left out`);
+        if (cfg.series !== undefined) {
+            throw new Error(`${where}: edit is its cells' — with positions, each declares its own: Plan.tableSeries({ cells, edit: true })`);
+        }
+        const use = planUseOf(cfg.cells);
+        if (use === undefined) {
+            throw new Error(`${where}: edit writes the values its cells read — give cells as Plan.tableCells(Plan.values(field, draw))`);
+        }
+        out.push({ position: 0, read: use.read });
+    }
+    if (Array.isArray(cfg.series)) {
+        cfg.series.forEach((member, position) => {
+            const use = planUseOf(member);
+            if (use?.edit === true)
+                out.push({ position, read: use.read });
+        });
+    }
+    for (const typed of out)
+        refuseDrawnOtherwise(rowType, typed.read, where);
+    return out;
+}
+/**
+ * Whether a values read's cells draw each value as it is stored (#1436,
+ * #1435): a `Float`'s `some(v)` (or `v`), an `Option` of a `Float`'s `v`, an
+ * `Integer`'s `some(v.toFloat())` (or `v.toFloat()`) — what a typed number is
+ * written as, and what e3 keeps a parent's subtotals of. Read off the draw's
+ * expression, as an accessor's field is (`childRefOf`).
+ *
+ * @param rowType - The entry type
+ * @param read - The values read
+ * @param where - The series, for messages
+ * @returns Whether each value draws as it is stored
+ * @internal
+ */
+export function drawsAsStored(rowType, read, where) {
+    const shape = collectionOfRead(rowType, read, where);
+    const kind = isTypeEqual(shape.item, FloatType) ? "float"
+        : isTypeEqual(shape.item, OptionType(FloatType)) ? "option"
+            : isTypeEqual(shape.item, IntegerType) ? "integer" : undefined;
+    let asStored = false;
+    if (kind !== undefined) {
+        const recursive = rowType.type === "Recursive";
+        East.function([shape.item, shape.key, rowType], NullType, ($, value, at, row) => {
+            const node = recursive ? $.let(row.unwrap()) : row;
+            const given = read.draw(value, at, node);
+            const param = Expr.ast(value);
+            const astOf = (x) => (x instanceof Expr ? Expr.ast(x) : undefined);
+            const isValue = (x) => astOf(x) === param;
+            const isWidened = (x) => {
+                const ast = astOf(x);
+                return ast !== undefined && ast.ast_type === "Builtin" && ast.builtin === "IntegerToFloat" && ast.arguments?.[0] === param;
+            };
+            const drawn = given === null || typeof given !== "object" ? undefined : given.value;
+            const wrapped = typeof drawn === "object" && drawn !== null && !(drawn instanceof Expr) && drawn.type === "some"
+                ? drawn.value : undefined;
+            asStored = kind === "option" ? isValue(drawn)
+                : kind === "float" ? isValue(drawn) || isValue(wrapped)
+                    : isWidened(drawn) || isWidened(wrapped);
+            return null;
+        });
+    }
+    return asStored;
+}
+/**
+ * Refuse a typed position whose cells draw another number than each value
+ * (#1436): a typed number is stored as the value, so each value must draw as
+ * it is ({@link drawsAsStored}).
+ *
+ * @param rowType - The entry type
+ * @param read - The position's values read
+ * @param where - The series, for the message
+ * @throws {Error} In the refusal's words
+ */
+function refuseDrawnOtherwise(rowType, read, where) {
+    if (!drawsAsStored(rowType, read, where)) {
+        throw new Error(`${where}: edit writes a typed number as its readings, and its cells draw another number than each reading — ` +
+            "draw value: some(v), and show it another way through format");
+    }
+}
+/**
+ * A tag given as a literal — its name, or a variant value's case — as the
+ * build reads it (#1435); `undefined` for an East expression, known only as
+ * the Plan is evaluated.
+ *
+ * @param given - The tag, as given
+ * @param fallback - Its default, where it is not given
+ * @returns Its name, or `undefined`
+ */
+function tagOf(given, fallback) {
+    if (given === undefined)
+        return fallback;
+    if (typeof given === "string")
+        return given;
+    return isVariant(given) ? given.type : undefined;
+}
+/**
+ * A series config's functions of the row (#1435), each by the field it is
+ * given as — its accessors, its element fields and its consumers given as
+ * functions, and a list's members that are — what a Plan walks for a
+ * collection read in a function.
+ *
+ * @param cfg - The config, as given
+ * @returns Its functions of the row
+ */
+function accessorsOf(cfg) {
+    const out = [];
+    for (const [via, value] of Object.entries(cfg)) {
+        if (typeof value === "function")
+            out.push({ via, fn: value });
+        else if (Array.isArray(value)) {
+            value.forEach((member, i) => {
+                if (typeof member === "function")
+                    out.push({ via: `${via}[${i}]`, fn: member });
+            });
+        }
+    }
+    return out;
+}
+/**
+ * Refuse a tree's `children` field that is not a Dict of the row's own type,
+ * keyed by an id (#1436).
+ *
+ * @param rowType - The entry type
+ * @param field - The field `children` names
+ * @param where - The series, for the message
+ */
+function checkTree(rowType, field, where) {
+    const t = entryFieldsOf(rowType)?.[field];
+    if (t === undefined) {
+        throw new Error(`${where}: children names "${field}", which is no field of its rows — name the Dict field holding more of its ` +
+            "rows, or step down to rows of another type with Plan.children(field, [series…])");
+    }
+    if (t.type !== "Dict") {
+        throw new Error(`${where}: children names "${field}", ${anOf(t)} — a tree's children are a Dict of the row's own type, keyed by an id`);
+    }
+    if (!isTypeEqual(t.value, rowType)) {
+        throw new Error(`${where}: children "${field}" holds ${shapeName(t.value)}, not ${shapeName(rowType)} — step down to it with Plan.children("${field}", [series…])`);
+    }
+    if (!isTypeEqual(t.key, StringType)) {
+        throw new Error(`${where}: children "${field}" is keyed by ${t.key.type} — child rows are keyed by an id, a String`);
+    }
+}
+/**
+ * Refuse a step-down's field that is not a Dict of child rows keyed by an id
+ * (#1436).
+ *
+ * @param rowType - The parent entry type
+ * @param field - The field `Plan.children` names
+ * @param where - The series, for the message
+ */
+function checkStepField(rowType, field, where) {
+    const t = entryFieldsOf(rowType)?.[field];
+    if (t === undefined) {
+        throw new Error(`${where}: Plan.children("${field}", …) steps down to "${field}", which is no field of its rows — name the Dict field holding the child rows`);
+    }
+    if (t.type !== "Dict") {
+        throw new Error(`Plan.children: "${field}" is ${anOf(t)} — child rows are a Dict, keyed by an id`);
+    }
+    if (!isTypeEqual(t.key, StringType)) {
+        throw new Error(`Plan.children: "${field}" is keyed by ${t.key.type} — child rows are keyed by an id, a String`);
+    }
+    const child = t.value.type;
+    if (child !== "Struct" && child !== "Recursive") {
+        throw new Error(`Plan.children: "${field}" holds ${anOf(t.value)}, not rows — child rows are structs`);
+    }
+}
+/**
+ * A series' `edit`, checked against the element field it writes through
+ * (#1436): `true` or `{ create }`, beside a read of items.
+ *
+ * @param edit - The declaration as given
+ * @param elements - The element field: `runs`, `events`, `chips` or `marks`
+ * @param times - The times those elements take
+ * @param input - The element field as given
+ * @param where - The series, for the messages
+ * @returns The recipe, or `undefined` when no `edit` is declared
+ * @throws {Error} In the refusals' words
+ */
+function editRecipeOf(edit, elements, times, input, where) {
+    if (edit === undefined)
+        return undefined;
+    const create = typeof edit === "object" && edit !== null ? edit.create : undefined;
+    if (edit !== true && (typeof create !== "function" || Object.keys(edit).some((k) => k !== "create"))) {
+        throw new Error(`${where}: edit names nothing — its ${elements}' read names the collection and its times: give edit: true, or ` +
+            "edit: { create } to take dropped cards too");
+    }
+    const read = planReadOf(input);
+    if (read === undefined) {
+        throw new Error(`${where}: edit moves the items its ${elements} name — give ${elements} as Plan.items(field, ${times}, draw)`);
+    }
+    if (read.kind !== "items") {
+        throw new Error(`${where}: edit moves the items its ${elements} name, and they read values — what people move is keyed by an id: ` +
+            `give ${elements} as Plan.items(field, ${times}, draw)`);
+    }
+    return { edit: edit, elements, times, input };
+}
 /**
  * The build spec of a data series (span / buckets / chart / heat / table /
  * cards / events / group).
@@ -434,25 +1002,12 @@ function instantInto(fieldType) {
  * row facts through the one envelope) and the membership, collapse and
  * children functions, each reified once and CALLED in the block's loop. The
  * block walks the collection in order; each matched entry's row is followed by
- * its children's rows — a bare `children` accessor walks the entry's subtree
+ * its children's rows — a tree (`children: field`) walks the entry's subtree
  * with an explicit pre-order stack (its depth is data), a step-down calls its
  * child series' blocks on the child collection.
  */
 function dataSpec(rowType, cfg, recipe) {
     const where = `Plan.series.${recipe.arm} "${cfg.key}"`;
-    const children = cfg.children;
-    const steps = children === undefined || typeof children === "function"
-        ? [] : (Array.isArray(children) ? children : [children]);
-    for (const step of steps) {
-        if (!isStepDown(step)) {
-            throw new Error(`${where}: \`children\` is an accessor for more of this series, or \`Plan.children(of, [series…])\` step-downs`);
-        }
-    }
-    const nested = steps.flatMap((s) => s.series.map((x) => nestedSpec(x, `${where} › children`)));
-    // How many chart rows each entry makes (#1398): a chart series' own row, and below it a bare accessor's walk of
-    // more of this series' rows, or a step-down's series' over the child collection.
-    const ownCharts = recipe.arm === "chart" ? 1 : 0;
-    const charts = entryCharts(ownCharts, children === undefined ? 0 : typeof children === "function" ? ownCharts : chartsOf(nested), cfg.match !== undefined);
     // A recursive entry reaches the accessors as its NODE (`PlanEntryExpr`),
     // so they read its fields directly at every depth.
     const recursive = rowType.type === "Recursive";
@@ -461,6 +1016,33 @@ function dataSpec(rowType, cfg, recipe) {
         : value;
     /** An accessor over entries, applied to an entry value (its node, when recursive). */
     const onEntry = (accessor) => (v, k) => accessor(nodeOf(v), k);
+    const children = cfg.children;
+    // A tree (#1436): a field of the entry holding more of its entries — or, the
+    // event kinds' own (#1194), an accessor computing them.
+    const treeField = typeof children === "string" ? children : undefined;
+    const tree = treeField !== undefined
+        ? (v) => collectionOn(v, treeField)
+        : typeof children === "function" ? children : undefined;
+    if (treeField !== undefined)
+        checkTree(rowType, treeField, where);
+    const steps = children === undefined || tree !== undefined
+        ? [] : (Array.isArray(children) ? children : [children]);
+    for (const step of steps) {
+        if (!isStepDown(step)) {
+            throw new Error(`${where}: \`children\` is a field of the row holding more of its rows, or Plan.children(field, [series…]) step-downs`);
+        }
+        if (step.field !== undefined)
+            checkStepField(rowType, step.field, where);
+    }
+    /** A step-down's child collection, from the entry (its node). */
+    const stepOf = (step) => (step.field !== undefined
+        ? (v) => collectionOn(v, step.field)
+        : step.of);
+    const nested = steps.flatMap((s) => s.series.map((x) => nestedSpec(x, `${where} › children`)));
+    // How many chart rows each entry makes (#1398): a chart series' own row, and below it a tree's walk of more of
+    // this series' rows, or a step-down's series' over the child collection.
+    const ownCharts = recipe.arm === "chart" ? 1 : 0;
+    const charts = entryCharts(ownCharts, children === undefined ? 0 : tree !== undefined ? ownCharts : chartsOf(nested), cfg.match !== undefined);
     // The removed verdict, named (#1260) — a plain JS caller would otherwise
     // lose it silently.
     for (const removed of ["review", "approval"]) {
@@ -468,30 +1050,25 @@ function dataSpec(rowType, cfg, recipe) {
             throw new Error(`${where}: \`${removed}\` is removed (#1260) — a Plan approves and rejects nothing: its changes are drafts of the root's \`editing\` session`);
         }
     }
-    // What a gesture writes (#880, #825) — a dropped card into `edit.items`, a
-    // moved element into its item's fields — each a FIELD of the entry (its
-    // node, when recursive) or of its items, checked here so a misnamed field
-    // fails the build.
+    // What a gesture writes (#880, #825, #1436) — through the collection its
+    // elements' read names: a dropped card's item under its minted id, a moved
+    // element's item re-timed under its id, or taken to another row.
     const edit = recipe.edit;
-    const nodeType = (recursive ? rowType.node : rowType);
-    if (edit !== undefined && nodeType.type !== "Struct") {
-        throw new Error(`${where}: \`edit\` writes a field of the entry — its entries must be structs (a recursive entry's node included)`);
-    }
-    const entryFields = nodeType.fields ?? {};
-    let itemType;
-    let move;
-    if (edit !== undefined) {
-        const t = entryFields[edit.items];
-        if (t === undefined || t.type !== "Array") {
-            throw new Error(`${where}: \`edit.items\` names "${edit.items}", which is not an Array field of the entry — a gesture writes a list of items`);
-        }
-        itemType = t.value;
-        move = moveFieldsOf(edit, itemType, recipe.arm, where);
-    }
-    const edits = edit !== undefined
+    const editRead = edit !== undefined ? planReadOf(edit.input) : undefined;
+    const editShape = editRead !== undefined ? collectionOfRead(rowType, editRead, where) : undefined;
+    const itemType = editShape?.item;
+    const move = editRead !== undefined ? moveFieldsOf(editRead, editShape.item) : undefined;
+    const create = edit !== undefined && edit.edit !== true ? edit.edit.create : undefined;
+    // What a typed number writes (#1436): each typed position's collection, keyed by the bucket's start.
+    const typedWrites = (recipe.values ?? []).map((typed) => {
+        const shape = collectionOfRead(rowType, typed.read, where);
+        return { position: typed.position, field: typed.read.field, key: shape.key, value: shape.item, keyAs: instantInto(shape.key) };
+    });
+    const edits = move !== undefined || typedWrites.length > 0
         ? {
-            drop: edit.create !== undefined,
+            drop: create !== undefined,
             move: move !== undefined ? some(move.edits) : none,
+            values: typedWrites.map((typed) => ({ position: BigInt(typed.position), whole: isTypeEqual(typed.value, IntegerType) })),
         }
         : undefined;
     const rows = new ByType();
@@ -514,7 +1091,7 @@ function dataSpec(rowType, cfg, recipe) {
                 ...(cfg.value !== undefined ? { value: cfg.value(entry, key) } : {}),
                 ...(recipe.swatches !== undefined ? { swatches: recipe.swatches } : {}),
             }),
-            kind: recipe.kind(entry, key, hasChildren),
+            kind: recipe.kind(entry, key, hasChildren, value),
             collapsed,
             ...(recipe.pinned !== undefined ? { pinned: recipe.pinned(entry, key) } : {}),
             ...(cfg.status !== undefined ? { status: cfg.status(entry, key) } : {}),
@@ -536,13 +1113,13 @@ function dataSpec(rowType, cfg, recipe) {
             ? East.value(collapsed, BooleanType)
             : East.value(collapsed(nodeOf(value), key), BooleanType)));
     });
-    /** A bare `children` accessor, built for entries keyed by `kt` — the child collection's type is its output. */
-    const childOf = (kt) => building(where, kt, () => reifyAccessor([rowType, kt], onEntry(children)));
+    /** The tree's children, built for entries keyed by `kt` — the child collection's type is its output. */
+    const childOf = (kt) => building(where, kt, () => reifyAccessor([rowType, kt], onEntry(tree)));
     /** The subtree walk below one entry — every level's entries in pre-order, over the child collection type. */
     const walkFor = (cc) => walks.get(cc, () => {
         const at = `${where} › children`;
         const { entry, key: kc } = shapeOf(cc, at);
-        assertEntry(entry, rowType, `${at} (a bare accessor returns more of this series' entries — step down to another type with Plan.children)`);
+        assertEntry(entry, rowType, `${at} (a tree's children are more of this series' rows — step down to another type with Plan.children)`);
         const next = childOf(kc);
         const nextType = Expr.type(next).output;
         if (!isTypeEqual(nextType, cc)) {
@@ -598,7 +1175,7 @@ function dataSpec(rowType, cfg, recipe) {
     const childrenFor = (kt) => kids.get(kt, () => {
         if (children === undefined)
             return undefined;
-        if (typeof children === "function") {
+        if (tree !== undefined) {
             const of = childOf(kt);
             const cc = Expr.type(of).output;
             const walk = walkFor(cc);
@@ -606,7 +1183,7 @@ function dataSpec(rowType, cfg, recipe) {
         }
         const parts = steps.map((step, i) => {
             const at = `${where} › children[${i}]`;
-            const of = building(at, kt, () => reifyAccessor([rowType, kt], onEntry(step.of)));
+            const of = building(at, kt, () => reifyAccessor([rowType, kt], onEntry(stepOf(step))));
             const cc = Expr.type(of).output;
             const blocks = step.series.map((s) => nestedSpec(s, at).emitter(cc, at));
             return { of, cc, blocks };
@@ -622,20 +1199,20 @@ function dataSpec(rowType, cfg, recipe) {
             return out;
         });
     });
-    // ── Writing a gesture back (#880) ─────────────────────────────────────
+    // ── Writing a gesture back (#880, #1436) ──────────────────────────────
     // The entry a writer is handed is DETACHED (the series value's `write`
     // copies it), so a nested entry is written in place in its collection and
-    // a dropped card's item joins its list in place.
+    // an item joins its collection in place, under its id.
     const owns = new ByType();
     const writers = new ByType();
     const entryAccess = (value) => nodeOf(value);
     /** The item a dropped card becomes, for entries keyed by `kt`. */
-    const createFor = (kt, create) => building(where, kt, () => East.function([PlanDropType, rowType, kt], itemType, (_$, drop, value, key) => create(drop, nodeOf(value), key)));
+    const createFor = (kt, make) => building(where, kt, () => East.function([PlanDropType, rowType, kt], itemType, (_$, drop, value, key) => make(drop, nodeOf(value), key)));
     /**
-     * An item at a move's instants (#825) — its declared instant fields set
-     * from the axis's instants, each on its own arm, every other field as it
-     * was; `none` when an instant rides an arm the field cannot hold (a time
-     * instant into a Float field).
+     * An item at a move's instants (#825, #1436) — the instant fields its read
+     * names set from the axis's instants, each on its own arm, every other
+     * field as it was; `none` when an instant rides an arm the field cannot
+     * hold (a time instant into a Float field).
      */
     const placed = move === undefined ? undefined : (() => {
         const m = move;
@@ -667,92 +1244,74 @@ function dataSpec(rowType, cfg, recipe) {
         });
     })();
     /**
-     * Whether a list holds an item keyed `k` (#825) — the key a move finds its
-     * item by, so a row's list keeps its keys unique: a card whose item repeats
-     * one, or a move onto a row already holding the moved item's key, is
-     * refused rather than leaving two items one key names.
-     */
-    const holds = move === undefined ? undefined : (list, k) => list.some((_$, item) => East.equal(item[move.key], k));
-    /**
-     * This series' own edit on one of its entries — the row at `path` is its
-     * own: a dropped card's item into its list, and a moved element's item
-     * re-timed where it is, taken out of the list, or put into it (#825).
+     * This series' own edit on one of its entries (#1436) — the row at `path`
+     * is its own: a dropped card's item into the collection its elements'
+     * read names, under the id the Plan minted; a moved element's item, found
+     * by its id (the element's key), re-timed where it is, taken out of the
+     * collection, or put into it under the same id. A collection already
+     * holding the id refuses the item. A number typed into one of its table
+     * positions sets that position's value at the bucket's start.
      */
     const ownFor = (kt) => owns.get(kt, () => {
-        if (edit === undefined)
+        const moves = editRead !== undefined && placed !== undefined && move !== undefined;
+        if (!moves && typedWrites.length === 0)
             return undefined;
-        const create = edit.create !== undefined ? createFor(kt, edit.create) : undefined;
+        const made = moves && create !== undefined ? createFor(kt, create) : undefined;
+        const field = editRead?.field ?? "";
+        const item = move?.item;
         return East.function([rowType, kt, PathType, PlanGestureType, PlanCarriedType], OptionType(rowType), ($, value, key, path, gesture, carried) => {
-            const make = create === undefined ? undefined : $.const(create);
-            const place = placed === undefined ? undefined : $.const(placed);
+            const make = made === undefined ? undefined : $.const(made);
+            const place = moves ? $.const(placed) : undefined;
             const result = $.let(none, OptionType(rowType));
             $.match(gesture, {
                 drop: ($2, drop) => {
-                    if (make === undefined || edit === undefined)
+                    if (make === undefined)
                         return;
-                    const list = $2.let(entryAccess(value)[edit.items]);
-                    const item = $2.let(make(drop, value, key), itemType);
-                    const add = ($3) => {
-                        $3(list.pushLast(item));
+                    const coll = $2.let(entryAccess(value)[field]);
+                    // The minted id, unless the collection already holds it.
+                    $2.if(coll.has(drop.id).not(), ($3) => {
+                        $3(coll.insert(drop.id, make(drop, value, key)));
                         $3.assign(result, some(value));
-                    };
-                    // With the item's key declared, a card whose item
-                    // repeats a key in the list is refused (#825).
-                    if (holds === undefined || move === undefined)
-                        add($2);
-                    else
-                        $2.if(holds(list, item[move.key]).not(), add);
+                    });
                 },
                 move: ($2, mv) => {
-                    if (place === undefined || move === undefined || edit === undefined)
+                    if (place === undefined || item === undefined)
                         return;
-                    const keyField = move.key;
-                    const itemOf = move.item;
                     const here = $2.let(East.value(variant("entry", { series: cfg.key, path }), PlanRowIdType), PlanRowIdType);
-                    const list = $2.let(entryAccess(value)[edit.items]);
-                    // The element's item, by its key.
-                    const at = $2.let(list.firstMap(($3, item, i) => East.equal(item[keyField], mv.key).ifElse(() => East.value(some(i), OptionType(IntegerType)), () => East.value(none, OptionType(IntegerType)))), OptionType(IntegerType));
+                    const coll = $2.let(entryAccess(value)[field]);
                     $2.if(East.equal(here, mv.from).and(() => East.equal(here, mv.to)), ($3) => {
-                        // Along its row, or resized: its instants set where it is.
-                        $3.match(at, {
-                            some: ($4, i) => {
-                                const moved = $4.let(place(list.get(i), mv.start, mv.end), OptionType(itemOf));
-                                $4.match(moved, {
-                                    some: ($5, item) => {
-                                        $5(list.update(i, item));
-                                        $5.assign(result, some(value));
-                                    },
-                                });
-                            },
+                        // Along its row, or resized: its times set where it is.
+                        $3.if(coll.has(mv.key), ($4) => {
+                            const moved = $4.let(place(coll.get(mv.key), mv.start, mv.end), OptionType(item));
+                            $4.match(moved, {
+                                some: ($5, next) => {
+                                    $5(coll.update(mv.key, next));
+                                    $5.assign(result, some(value));
+                                },
+                            });
                         });
                     }).else(($3) => {
-                        // Its source: taken out of the list, and carried.
+                        // Its source: taken out of the collection, and carried.
                         $3.if(East.equal(here, mv.from), ($4) => {
-                            $4.match(at, {
-                                some: ($5, i) => {
-                                    $5(carried.update(East.value(some(East.Blob.encodeBeast(list.get(i), "v2")), OptionType(BlobType))));
-                                    const before = $5.let(list.slice(0n, i));
-                                    const after = $5.let(list.slice(i.add(1n), list.size()));
-                                    $5(list.clear());
-                                    $5(list.append(before));
-                                    $5(list.append(after));
-                                    $5.assign(result, some(value));
-                                },
+                            $4.if(coll.has(mv.key), ($5) => {
+                                $5(carried.update(East.value(some(East.Blob.encodeBeast(coll.get(mv.key), "v2")), OptionType(BlobType))));
+                                $5(coll.delete(mv.key));
+                                $5.assign(result, some(value));
                             });
                         });
-                        // Its target: the carried item put in, at its new
-                        // instants — unless the list already holds its key,
-                        // when it is put nowhere and the move lands nowhere.
+                        // Its target: the carried item put in under its id, at its new
+                        // times — unless the collection already holds the id, when it
+                        // is put nowhere and the move lands nowhere.
                         $3.if(East.equal(here, mv.to), ($4) => {
                             const held = $4.let(carried.get(), OptionType(BlobType));
                             $4.match(held, {
                                 some: ($5, bytes) => {
-                                    $5.if(holds(list, mv.key).not(), ($6) => {
-                                        const item = $6.let(bytes.decodeBeast(itemOf, "v2"), itemOf);
-                                        const moved = $6.let(place(item, mv.start, mv.end), OptionType(itemOf));
+                                    $5.if(coll.has(mv.key).not(), ($6) => {
+                                        const taken = $6.let(bytes.decodeBeast(item, "v2"), item);
+                                        const moved = $6.let(place(taken, mv.start, mv.end), OptionType(item));
                                         $6.match(moved, {
-                                            some: ($7, placedItem) => {
-                                                $7(list.pushLast(placedItem));
+                                            some: ($7, next) => {
+                                                $7(coll.insert(mv.key, next));
                                                 $7(carried.update(East.value(none, OptionType(BlobType))));
                                                 $7.assign(result, some(value));
                                             },
@@ -763,11 +1322,55 @@ function dataSpec(rowType, cfg, recipe) {
                         });
                     });
                 },
+                // A number typed into a cell (#1436): its position's value at the bucket's start set, or added
+                // where the collection holds none; cleared, deleted. An Integer collection takes a whole number,
+                // and an instant on an arm its keys cannot hold writes nothing.
+                value: ($2, typed) => {
+                    if (typedWrites.length === 0)
+                        return;
+                    const here = $2.let(East.value(variant("entry", { series: cfg.key, path }), PlanRowIdType), PlanRowIdType);
+                    $2.if(East.equal(here, typed.row), ($3) => {
+                        for (const write of typedWrites) {
+                            $3.if(typed.position.equal(BigInt(write.position)), ($4) => {
+                                const keyAs = $4.const(write.keyAs);
+                                const at = $4.let(keyAs(typed.at), OptionType(write.key));
+                                $4.match(at, {
+                                    some: ($5, k) => {
+                                        const coll = $5.let(entryAccess(value)[write.field]);
+                                        $5.match(typed.value, {
+                                            some: ($6, n) => {
+                                                const put = ($7, stored) => {
+                                                    $7(coll.insertOrUpdate(k, stored));
+                                                    $7.assign(result, some(value));
+                                                };
+                                                if (isTypeEqual(write.value, IntegerType)) {
+                                                    $6.if(n.remainder(1).equal(0), ($7) => { put($7, n.toInteger()); });
+                                                }
+                                                else if (isTypeEqual(write.value, OptionType(FloatType))) {
+                                                    put($6, some(n));
+                                                }
+                                                else {
+                                                    put($6, n);
+                                                }
+                                            },
+                                            none: ($6) => {
+                                                $6.if(coll.has(k), ($7) => {
+                                                    $7(coll.delete(k));
+                                                    $7.assign(result, some(value));
+                                                });
+                                            },
+                                        });
+                                    },
+                                });
+                            });
+                        }
+                    });
+                },
             });
             return result;
         });
     });
-    /** The walk's writer — a bare `children` accessor: the rows below an entry are this series' own. */
+    /** The tree's writer: the rows below an entry are this series' own. */
     const walkWriterFor = (kt) => {
         const at = `${where} › children`;
         const of = childOf(kt);
@@ -776,10 +1379,10 @@ function dataSpec(rowType, cfg, recipe) {
         const own = ownFor(kc);
         if (own === undefined)
             return undefined;
-        const ref = childRefOf(rowType, kt, children);
+        const ref = treeField !== undefined ? { kind: "field", field: treeField } : childRefOf(rowType, kt, tree);
         if (ref === undefined) {
             throw new Error(`${at}: this series takes gestures, and one on a child row is written back into its entry through ` +
-                "`children` — which must read a field of the entry (`r => r.children`), not compute a collection");
+                "`children` — which must read a field of the entry, not compute a collection");
         }
         const ops = collectionOps(cc);
         const collOf = (entry) => (ref.kind === "field" ? entryAccess(entry)[ref.field] : nodeOf(entry));
@@ -824,7 +1427,7 @@ function dataSpec(rowType, cfg, recipe) {
     const stepsWriterFor = (kt) => {
         const parts = steps.flatMap((step, i) => {
             const at = `${where} › children[${i}]`;
-            const accessor = step.of;
+            const accessor = stepOf(step);
             const of = building(at, kt, () => reifyAccessor([rowType, kt], onEntry(accessor)));
             const cc = Expr.type(of).output;
             const writes = step.series
@@ -832,11 +1435,11 @@ function dataSpec(rowType, cfg, recipe) {
                 .filter((w) => w !== undefined);
             if (writes.length === 0)
                 return [];
-            const ref = childRefOf(rowType, kt, accessor);
+            const ref = step.field !== undefined ? { kind: "field", field: step.field } : childRefOf(rowType, kt, accessor);
             if (ref === undefined) {
                 throw new Error(`${at}: a series under this step-down takes gestures, and one on its rows is written back into ` +
-                    "the entry through `Plan.children(of, …)` — `of` must read a field of the entry (`r => r.presses`) " +
-                    "or be the entry itself (`g => g`), not compute a collection");
+                    "the entry through the step-down — which must read a field of the entry, or be the entry itself, not " +
+                    "compute a collection");
             }
             const { entry: childType, key: kc } = shapeOf(cc, at);
             return [{ ref, cc, kc, childType, writes }];
@@ -875,7 +1478,7 @@ function dataSpec(rowType, cfg, recipe) {
     const writerFor = (kt) => writers.get(kt, () => {
         const own = ownFor(kt);
         const below = children === undefined ? undefined
-            : typeof children === "function" ? walkWriterFor(kt) : stepsWriterFor(kt);
+            : tree !== undefined ? walkWriterFor(kt) : stepsWriterFor(kt);
         if (own === undefined && below === undefined)
             return undefined;
         return East.function([rowType, kt, PathType, IntegerType, StringType, PlanGestureType, PlanCarriedType], OptionType(rowType), ($, value, key, path, depth, series, gesture, carried) => {
@@ -901,6 +1504,21 @@ function dataSpec(rowType, cfg, recipe) {
         nested,
         nests: children !== undefined,
         charts,
+        reads: recipe.reads ?? [],
+        nest: {
+            rowType,
+            keyType: cfg.keyType ?? StringType,
+            accessors: accessorsOf(cfg),
+            tree: treeField,
+            steps: steps.map((step, i) => ({
+                field: step.field, of: step.of,
+                series: step.series.map((x) => nestedSpec(x, `${where} › children[${i}]`)),
+            })),
+            members: [],
+            aggregate: recipe.aggregate,
+            subtotalsOwn: recipe.subtotalsOwn === true,
+            rollup: recipe.rollup,
+        },
         emitter(collection, at) {
             return emitters.get(collection, () => {
                 const { entry, key: kt } = shapeOf(collection, at);
@@ -993,10 +1611,13 @@ function viewsSpec(rowType, cfg, members) {
     const emitters = new ByType();
     const blockLists = new ByType();
     const writerLists = new ByType();
-    // ── A bare `children` accessor: more of the views' own entries (#1219) ──
-    const bare = typeof cfg.children === "function"
-        ? cfg.children
-        : undefined;
+    // ── A tree: more of the views' own entries (#1219, #1436) — a field of the
+    // entry, or the event kinds' accessor computing them (#1194) ──
+    const children = cfg.children;
+    const treeField = typeof children === "string" ? children : undefined;
+    const bare = treeField !== undefined
+        ? (v) => collectionOn(v, treeField)
+        : typeof children === "function" ? children : undefined;
     const recursive = rowType.type === "Recursive";
     const nodeOf = (value) => recursive
         ? value.unwrap()
@@ -1015,7 +1636,7 @@ function viewsSpec(rowType, cfg, members) {
     const walkFor = (cc) => walks.get(cc, () => {
         const at = `${where} › children`;
         const { entry, key: kc } = shapeOf(cc, at);
-        assertEntry(entry, rowType, `${at} (a bare accessor returns more of this series' entries — step down to another type with Plan.children)`);
+        assertEntry(entry, rowType, `${at} (a tree's children are more of this series' rows — step down to another type with Plan.children)`);
         const next = childOf(kc);
         const nextType = Expr.type(next).output;
         if (!isTypeEqual(nextType, cc)) {
@@ -1123,10 +1744,10 @@ function viewsSpec(rowType, cfg, members) {
         });
         if (owns.length === 0)
             return undefined;
-        const ref = childRefOf(rowType, kt, bare);
+        const ref = treeField !== undefined ? { kind: "field", field: treeField } : childRefOf(rowType, kt, bare);
         if (ref === undefined) {
             throw new Error(`${at}: a member takes gestures, and one on a child row is written back into its entry through ` +
-                "`children` — which must read a field of the entry (`r => r.children`), not compute a collection");
+                "`children` — which must read a field of the entry, not compute a collection");
         }
         const ops = collectionOps(cc);
         const collOf = (value) => (ref.kind === "field" ? entryAccess(value)[ref.field] : nodeOf(value));
@@ -1170,7 +1791,7 @@ function viewsSpec(rowType, cfg, members) {
         });
     });
     // How many chart rows each entry makes (#1398): a row a member — a chart member's own `match` deciding by entry
-    // whether its row shows — and below them a bare accessor's walk of more of the views' entries, each its members'
+    // whether its row shows — and below them a tree's walk of more of the views' entries, each its members'
     // rows, or a step-down's series' over the child collection.
     const memberCharts = chartsOf(memberSpecs);
     const charts = entryCharts(memberCharts, cfg.children === undefined ? 0 : bare !== undefined ? memberCharts : chartsOf(host.nested), cfg.match !== undefined);
@@ -1181,6 +1802,9 @@ function viewsSpec(rowType, cfg, members) {
         nested: [...memberSpecs, ...host.nested],
         nests: cfg.children !== undefined,
         charts,
+        reads: [],
+        // Its members read its own entries; its children are the host envelope's (#1435).
+        nest: { ...host.nest, members: memberSpecs },
         emitter(collection, at) {
             return emitters.get(collection, () => {
                 const { entry, key: kt } = shapeOf(collection, at);
@@ -1323,6 +1947,12 @@ function sectionSpec(cfg, members) {
         nests: false,
         // Each entry makes its members' rows; the header is no entry's (#1398).
         charts: chartsOf(memberSpecs),
+        reads: [],
+        // Its members read the section's entries; it reads nothing of its own (#1435).
+        nest: {
+            rowType: undefined, keyType: StringType, accessors: [], tree: undefined, steps: [], members: memberSpecs,
+            aggregate: undefined, subtotalsOwn: false, rollup: undefined,
+        },
         emitter(collection, at) {
             return emitters.get(collection, () => {
                 const blocks = memberSpecs.map((m) => m.emitter(collection, `${at} › ${where}`));
@@ -1393,6 +2023,7 @@ function rowsSpec(identity, rows) {
         // Its rows' kinds are an East value the build does not read (#1398): laid out below an entry, their chart rows are
         // not known.
         charts: undefined,
+        reads: [],
         emitter,
         // A FIXED block: no entry produces hand-built rows, so every window
         // serves them alike and the canvas draws them once (#823).
@@ -1520,17 +2151,34 @@ export function applySeriesValue(s, data) {
 }
 /**
  * Check a TS series list before it is applied — its keys unique across the
- * whole tree. An East expression list is checked at render (a repeated id is
- * a row diagnostic), since its series are not known until it runs.
+ * whole tree, and its values collections keyed by the axis's instants (#1436).
+ * An East expression list is checked at render (a repeated id is a row
+ * diagnostic), since its series are not known until it runs.
  *
  * @param series - The `series` input
  * @param where - Who is asking, for the message
+ * @param axisKind - The axis's kind, when its declaration says it
  */
-export function checkSeries(series, where) {
+export function checkSeries(series, where, axisKind) {
     if (!Array.isArray(series))
         return;
     const specs = series.map((s) => specOf(s)).filter((s) => s !== undefined);
     assertUniqueKeys(specs, where);
+    // A values collection is keyed by its instant (#1436): one keyed by String
+    // rides only an ordinal axis.
+    if (axisKind === undefined || axisKind === "ordinal")
+        return;
+    const walk = (spec) => {
+        for (const use of spec.reads) {
+            if (use.read.kind !== "values" || !isTypeEqual(use.key, StringType))
+                continue;
+            throw new Error(`Plan.values: "${use.field}" is keyed by String, and the axis is ${axisKind} — values are keyed by their ` +
+                `instant, ${axisKind === "time" ? "a DateTime" : "a Float or an Integer"} here: read things people drag ` +
+                `with Plan.items("${use.field}", times, draw)`);
+        }
+        spec.nested.forEach(walk);
+    };
+    specs.forEach(walk);
 }
 /**
  * Reads a series value's facts off the spec its builder recorded (#1190).
@@ -1669,9 +2317,6 @@ export function seriesWriteFn(series, collection) {
         return result;
     });
 }
-// ============================================================================
-// Builders — Plan.series.*
-// ============================================================================
 /**
  * A span series — one state-run row per entry; a row with children shows its
  * own runs plus bands over its subtree's runs (`rollup`) — each band sums its
@@ -1680,27 +2325,46 @@ export function seriesWriteFn(series, collection) {
  * @typeParam R - The entry type
  * @typeParam K - The axis kind the runs imply (inferred from `runs`; `never` when erased)
  * @typeParam KT - The entries' key type (`keyType`; `String` by default)
+ * @typeParam FR - The collection its runs read
+ * @typeParam UR - What its runs read
+ * @typeParam UD - What its decisions read
+ * @typeParam UP - What its ports read
+ * @typeParam CT - A tree's field, as `children` names it
+ * @typeParam CU - One step-down's reads
+ * @typeParam CF - The folds of its cells
+ * @typeParam CS - Several step-downs' reads
+ * @typeParam RL - Its `rollup`, as written
  * @param rowType - The entry type (every builder takes it first — the `Slice.config` shape)
- * @param config - The accessors and nesting ({@link PlanSpanSeriesConfig})
- * @returns A series value, branded with its kind
+ * @param config - The reads, accessors and nesting ({@link PlanSpanSeriesConfig})
+ * @returns A series value, branded with its kind and what it reads
  */
 export function createSeriesSpan(rowType, config) {
     const cfg = config;
+    const where = `Plan.series.span "${cfg.key}"`;
+    const edit = editRecipeOf(cfg.edit, "runs", "{ from, to }", cfg.runs, where);
     // A row rolls up its children: its own (`children`), or — declared on a
     // views member — the ones the views nest under it (#1219).
     const rollup = cfg.children !== undefined || cfg.rollup !== undefined ? resolveTag(cfg.rollup ?? "union", PlanRollupType) : undefined;
+    const runs = elementField(rowType, cfg.runs, "run", where, "runs");
+    if (runs === undefined)
+        throw new Error(`${where}: give its runs — Plan.items(field, { from, to }, draw), or a function of the row`);
+    const decisions = elementField(rowType, cfg.decisions, "decision", where, "decisions");
+    const ports = elementField(rowType, cfg.ports, "port", where, "ports");
     const spec = dataSpec(rowType, cfg, {
         arm: "span",
-        kind: (value, key, hasChildren) => spanKind({
-            runs: cfg.runs(value, key),
-            ...(cfg.decisions !== undefined ? { decisions: cfg.decisions(value, key) } : {}),
-            ...(cfg.ports !== undefined ? { ports: cfg.ports(value, key) } : {}),
+        kind: (node, key, hasChildren, value) => spanKind({
+            runs: runs.at(node, key, value),
+            ...(decisions !== undefined ? { decisions: decisions.at(node, key, value) } : {}),
+            ...(ports !== undefined ? { ports: ports.at(node, key, value) } : {}),
         }, rollup === undefined
             ? East.value(none, OptionType(PlanRollupType))
             // A row rolls up only when it HAS child rows — a leaf's bands
             // would repeat its own runs.
             : hasChildren.ifElse(() => East.value(some(rollup), OptionType(PlanRollupType)), () => East.value(none, OptionType(PlanRollupType)))),
-        edit: cfg.edit,
+        edit,
+        reads: [...runs.reads, ...(decisions?.reads ?? []), ...(ports?.reads ?? [])],
+        // Its runs roll up into its bands where it has children or declares a rollup (#1435).
+        ...(cfg.children !== undefined || cfg.rollup !== undefined ? { rollup: tagOf(cfg.rollup, "union") } : {}),
     });
     return seriesValue(rowType, cfg.keyType, spec, cfg);
 }
@@ -1711,21 +2375,33 @@ export function createSeriesSpan(rowType, config) {
  * @typeParam R - The entry type
  * @typeParam K - The axis kind the cells imply (inferred from `cells`; `never` when erased)
  * @typeParam KT - The entries' key type
+ * @typeParam UC - What its cells read
+ * @typeParam FO - How a bucket folds them
+ * @typeParam A - Its `aggregate`, as written
+ * @typeParam CT - A tree's field, as `children` names it
+ * @typeParam CU - One step-down's reads
+ * @typeParam CF - The folds of its cells
+ * @typeParam CS - Several step-downs' reads
  * @param rowType - The entry type
- * @param config - The accessors and nesting ({@link PlanHeatSeriesConfig})
- * @returns A series value, branded with its kind
+ * @param config - The reads, accessors and nesting ({@link PlanHeatSeriesConfig})
+ * @returns A series value, branded with its kind, what it reads and the fold of its cells
  */
 export function createSeriesHeat(rowType, config) {
     const cfg = config;
+    const where = `Plan.series.heat "${cfg.key}"`;
     const aggregate = cfg.children !== undefined
         ? East.value(some(resolveTag(cfg.aggregate ?? "mean", PlanAggregateType)), OptionType(PlanAggregateType))
         : East.value(none, OptionType(PlanAggregateType));
+    const cells = consumerField(rowType, cfg.cells, "heat", where, "cells");
     const spec = dataSpec(rowType, cfg, {
         arm: "heat",
-        kind: (value, key) => heatKind({
-            cells: cfg.cells(value, key),
+        kind: (node, key, _hasChildren, value) => heatKind({
+            ...(cells !== undefined ? { cells: cells.at(node, key, value) } : {}),
             ...(cfg.scale !== undefined ? { scale: cfg.scale } : {}),
         }, aggregate),
+        reads: cells?.reads ?? [],
+        // Its row derives its children's numbers by its aggregate: a tree's own values, or a step-down's (#1435).
+        ...(cfg.children !== undefined ? { aggregate: tagOf(cfg.aggregate, "mean"), subtotalsOwn: true } : {}),
     });
     return seriesValue(rowType, cfg.keyType, spec, cfg);
 }
@@ -1736,28 +2412,48 @@ export function createSeriesHeat(rowType, config) {
  * @typeParam R - The entry type
  * @typeParam K - The axis kind the cells imply (inferred from `cells` / `series`; `never` when erased)
  * @typeParam KT - The entries' key type
+ * @typeParam UC - What its `cells` read
+ * @typeParam S - Its `series` positions, as written
+ * @typeParam FO - Its `cells`' fold, as written
+ * @typeParam A - Its `aggregate`, as written
+ * @typeParam CT - A tree's field, as `children` names it
+ * @typeParam CU - One step-down's reads
+ * @typeParam CF - The folds of its cells
+ * @typeParam CS - Several step-downs' reads
  * @param rowType - The entry type
- * @param config - The accessors and nesting ({@link PlanTableSeriesOfConfig})
- * @returns A series value, branded with its kind
+ * @param config - The reads, accessors and nesting ({@link PlanTableSeriesOfConfig})
+ * @returns A series value, branded with its kind, what it reads and the folds of its positions
  */
 export function createSeriesTable(rowType, config) {
     const cfg = config;
+    const where = `Plan.series.table "${cfg.key}"`;
     if (cfg.cells !== undefined && cfg.series !== undefined) {
-        throw new Error(`Plan.series.table "${cfg.key}": pass \`cells\` (one plain value series) OR \`series\` — not both`);
+        throw new Error(`${where}: pass \`cells\` (one plain value series) OR \`series\` — not both`);
     }
     const aggregate = cfg.children !== undefined
         ? East.value(some(resolveTag(cfg.aggregate ?? "sum", TableAggregateType)), OptionType(TableAggregateType))
         : East.value(none, OptionType(TableAggregateType));
+    const cells = consumerField(rowType, cfg.cells, "tableCells", where, "cells");
+    // Its cells fold as the row declares, `sum` unless it says (#1436): what a parent subtotals them by (#1435, #1438).
+    const rowFold = tagOf(cfg.fold, "sum");
+    const cellReads = (cells?.reads ?? []).map((read) => (read.fold !== undefined || rowFold === undefined ? read : { ...read, fold: rowFold }));
+    const positions = listField(rowType, cfg.series, "tableSeries", where, "series");
+    // The positions a typed number writes (#1436), each read checked as it built above.
+    const values = tableEditsOf(rowType, cfg, where);
     const spec = dataSpec(rowType, cfg, {
         arm: "table",
-        kind: (value, key) => tableKind({
-            ...(cfg.cells !== undefined ? { cells: cfg.cells(value, key) } : {}),
+        kind: (node, key, _hasChildren, value) => tableKind({
+            ...(cells !== undefined ? { cells: cells.at(node, key, value) } : {}),
             ...(cfg.fold !== undefined ? { fold: cfg.fold } : {}),
-            ...(cfg.series !== undefined ? { series: cfg.series(value, key) } : {}),
+            ...(positions !== undefined ? { series: positions.at(node, key, value) } : {}),
             ...(cfg.split !== undefined ? { split: cfg.split } : {}),
             ...(cfg.format !== undefined ? { format: cfg.format } : {}),
             ...(cfg.emphasis !== undefined ? { emphasis: cfg.emphasis } : {}),
         }, aggregate),
+        reads: [...cellReads, ...(positions?.reads ?? [])],
+        values,
+        // Its row derives its children's numbers by its aggregate: a tree's own values, or a step-down's (#1435).
+        ...(cfg.children !== undefined ? { aggregate: tagOf(cfg.aggregate, "sum"), subtotalsOwn: true } : {}),
     });
     return seriesValue(rowType, cfg.keyType, spec, cfg);
 }
@@ -1767,20 +2463,34 @@ export function createSeriesTable(rowType, config) {
  * @typeParam R - The entry type
  * @typeParam K - The axis kind the tiles imply (inferred from `events` / `markers`; `never` when erased)
  * @typeParam KT - The entries' key type
+ * @typeParam FE - The collection its tiles read
+ * @typeParam UE - What its tiles read
+ * @typeParam UM - What its markers read
+ * @typeParam CT - A tree's field, as `children` names it
+ * @typeParam CU - One step-down's reads
+ * @typeParam CF - The folds of its cells
+ * @typeParam CS - Several step-downs' reads
  * @param rowType - The entry type
- * @param config - The accessors ({@link PlanBucketsSeriesConfig})
- * @returns A series value, branded with its kind
+ * @param config - The reads and accessors ({@link PlanBucketsSeriesConfig})
+ * @returns A series value, branded with its kind and what it reads
  */
 export function createSeriesBuckets(rowType, config) {
     const cfg = config;
+    const where = `Plan.series.buckets "${cfg.key}"`;
+    const edit = editRecipeOf(cfg.edit, "events", "{ at }", cfg.events, where);
+    const events = elementField(rowType, cfg.events, "event", where, "events");
+    if (events === undefined)
+        throw new Error(`${where}: give its events — Plan.items(field, { at }, draw), or a function of the row`);
+    const markers = elementField(rowType, cfg.markers, "marker", where, "markers");
     const spec = dataSpec(rowType, cfg, {
         arm: "buckets",
-        kind: (value, key) => bucketsKind({
-            ...(cfg.lanes !== undefined ? { lanes: cfg.lanes(value, key) } : {}),
-            events: cfg.events(value, key),
-            ...(cfg.markers !== undefined ? { markers: cfg.markers(value, key) } : {}),
+        kind: (node, key, _hasChildren, value) => bucketsKind({
+            ...(cfg.lanes !== undefined ? { lanes: cfg.lanes(node, key) } : {}),
+            events: events.at(node, key, value),
+            ...(markers !== undefined ? { markers: markers.at(node, key, value) } : {}),
         }),
-        edit: cfg.edit,
+        edit,
+        reads: [...events.reads, ...(markers?.reads ?? [])],
     });
     return seriesValue(rowType, cfg.keyType, spec, cfg);
 }
@@ -1790,16 +2500,28 @@ export function createSeriesBuckets(rowType, config) {
  * @typeParam R - The entry type
  * @typeParam K - The axis kind the chips imply (inferred from `chips`; `never` when erased)
  * @typeParam KT - The entries' key type
+ * @typeParam FC - The collection its chips read
+ * @typeParam UC - What its chips read
+ * @typeParam CT - A tree's field, as `children` names it
+ * @typeParam CU - One step-down's reads
+ * @typeParam CF - The folds of its cells
+ * @typeParam CS - Several step-downs' reads
  * @param rowType - The entry type
- * @param config - The accessors ({@link PlanCardsSeriesConfig})
- * @returns A series value, branded with its kind
+ * @param config - The reads and accessors ({@link PlanCardsSeriesConfig})
+ * @returns A series value, branded with its kind and what it reads
  */
 export function createSeriesCards(rowType, config) {
     const cfg = config;
+    const where = `Plan.series.cards "${cfg.key}"`;
+    const edit = editRecipeOf(cfg.edit, "chips", "{ from, to }", cfg.chips, where);
+    const chips = elementField(rowType, cfg.chips, "chip", where, "chips");
+    if (chips === undefined)
+        throw new Error(`${where}: give its chips — Plan.items(field, { from, to }, draw), or a function of the row`);
     const spec = dataSpec(rowType, cfg, {
         arm: "cards",
-        kind: (value, key) => cardsKind(cfg.chips(value, key)),
-        edit: cfg.edit,
+        kind: (node, key, _hasChildren, value) => cardsKind(chips.at(node, key, value)),
+        edit,
+        reads: chips.reads,
     });
     return seriesValue(rowType, cfg.keyType, spec, cfg);
 }
@@ -1809,37 +2531,61 @@ export function createSeriesCards(rowType, config) {
  * @typeParam R - The entry type
  * @typeParam K - The axis kind the marks imply (inferred from `marks`; `never` when erased)
  * @typeParam KT - The entries' key type
+ * @typeParam FM - The collection its marks read
+ * @typeParam UM - What its marks read
+ * @typeParam CT - A tree's field, as `children` names it
+ * @typeParam CU - One step-down's reads
+ * @typeParam CF - The folds of its cells
+ * @typeParam CS - Several step-downs' reads
  * @param rowType - The entry type
- * @param config - The accessors ({@link PlanEventsSeriesConfig})
- * @returns A series value, branded with its kind
+ * @param config - The reads and accessors ({@link PlanEventsSeriesConfig})
+ * @returns A series value, branded with its kind and what it reads
  */
 export function createSeriesEvents(rowType, config) {
     const cfg = config;
+    const where = `Plan.series.events "${cfg.key}"`;
+    const edit = editRecipeOf(cfg.edit, "marks", "{ at }", cfg.marks, where);
+    const marks = elementField(rowType, cfg.marks, "mark", where, "marks");
+    if (marks === undefined)
+        throw new Error(`${where}: give its marks — Plan.items(field, { at }, draw), or a function of the row`);
     const spec = dataSpec(rowType, cfg, {
         arm: "events",
-        kind: (value, key) => eventsKind(cfg.marks(value, key)),
-        edit: cfg.edit,
+        kind: (node, key, _hasChildren, value) => eventsKind(marks.at(node, key, value)),
+        edit,
+        reads: marks.reads,
     });
     return seriesValue(rowType, cfg.keyType, spec, cfg);
 }
 /**
- * A chart series — one chart row per entry, layers built from the entry's own
- * data. Kind-ERASED: a Chart layer's TS face does not expose its x type, so a
- * chart series constrains no axis at compile time — the render-time
- * diagnostic holds it to the axis like any row.
+ * A chart series — one chart row per entry, its layers over the entry's own
+ * values (`Plan.line` … `Plan.band` over `Plan.values`), or built from the
+ * entry by a function. Its layers over values brand it with the axis kind
+ * their keys ride; a Chart layer's face hides its x type, so a series whose
+ * layers are all Chart layers constrains no axis at compile time — the
+ * render-time diagnostic holds it to the axis like any row.
  *
  * @typeParam R - The entry type
  * @typeParam KT - The entries' key type
+ * @typeParam K - The axis kind its layers' values ride
+ * @typeParam L - Its `layers`, as written
+ * @typeParam CT - A tree's field, as `children` names it
+ * @typeParam CU - One step-down's reads
+ * @typeParam CF - The folds of its cells
+ * @typeParam CS - Several step-downs' reads
  * @param rowType - The entry type
- * @param config - The accessors and shared axes ({@link PlanChartSeriesConfig})
- * @returns A series value
+ * @param config - The layers, accessors and shared axes ({@link PlanChartSeriesConfig})
+ * @returns A series value, branded with its kind and what it reads
  */
 export function createSeriesChart(rowType, config) {
     const cfg = config;
+    const where = `Plan.series.chart "${cfg.key}"`;
+    const layers = listField(rowType, cfg.layers, "layer", where, "layers");
+    if (layers === undefined)
+        throw new Error(`${where}: give its layers — Plan.line(Plan.values(field, draw)) and the like, or a function of the row`);
     const spec = dataSpec(rowType, cfg, {
         arm: "chart",
-        kind: (value, key) => chartKind({
-            layers: cfg.layers(value, key),
+        kind: (node, key, _hasChildren, value) => chartKind({
+            layers: layers.at(node, key, value),
             ...(cfg.left !== undefined ? { left: cfg.left } : {}),
             ...(cfg.right !== undefined ? { right: cfg.right } : {}),
             ...(cfg.height !== undefined ? { height: cfg.height } : {}),
@@ -1850,6 +2596,7 @@ export function createSeriesChart(rowType, config) {
             ? { pinned: (value, key) => East.value(cfg.pinned(value, key), BooleanType) }
             : {}),
         ...(cfg.swatches !== undefined ? { swatches: cfg.swatches } : {}),
+        reads: layers.reads,
     });
     return seriesValue(rowType, cfg.keyType, spec, cfg);
 }
@@ -1860,19 +2607,25 @@ export function createSeriesChart(rowType, config) {
  * its member count is derived.
  *
  * @remarks
- * Hierarchy comes from the data's nesting: to group a flat source, reshape it
- * first — inline, one East `groupToDicts` in the canvas function (the entries
- * are then `Dict<String, Row>` and a group's label is its key); a paged source
- * is grouped in the dataflow. The `by` form and the static
- * `group(R, chrome, children)` form are gone — see `Plan.series.section` for a
- * fixed titled block.
+ * Hierarchy comes from the data's nesting: a group's members are a `Dict` of
+ * the entry (`Plan.children(field, [series…])`), so a flat source is grouped
+ * in the dataflow, or reshaped inline into entries that hold their members.
+ * The `by` form and the static `group(R, chrome, children)` form are gone —
+ * see `Plan.series.section` for a fixed titled block.
  *
  * @typeParam R - The entry type
  * @typeParam K - The axis kind the summary cells imply
  * @typeParam KT - The entries' key type
+ * @typeParam US - What its `summary` reads
+ * @typeParam FO - How a bucket folds its summary cells
+ * @typeParam A - Its `summaryAggregate`, as written
+ * @typeParam CT - A tree's field, as `children` names it
+ * @typeParam CU - One step-down's reads
+ * @typeParam CF - The folds of its cells
+ * @typeParam CS - Several step-downs' reads
  * @param rowType - The entry type
  * @param config - The strip's accessors and its members ({@link PlanGroupSeriesConfig})
- * @returns A series value, branded with its kind
+ * @returns A series value, branded with its kind and what it reads
  * @throws {Error} When called with the removed `by` or static forms
  */
 export function createSeriesGroup(rowType, config) {
@@ -1888,17 +2641,20 @@ export function createSeriesGroup(rowType, config) {
     if (cfg.children === undefined) {
         throw new Error(`${where}: a group strip needs its members — declare \`children\``);
     }
-    const summary = cfg.summary;
-    // The strip's ONE summary (#824): the per-entry cells, the declared
-    // aggregate, or a plain band — both at once is refused here.
-    const declared = summary === undefined ? groupSummary(undefined, cfg.summaryAggregate, where) : undefined;
-    if (summary !== undefined && cfg.summaryAggregate !== undefined) {
+    if (cfg.summary !== undefined && cfg.summaryAggregate !== undefined) {
         throw new Error(`${where}: give \`summary\` (explicit strip cells) OR \`summaryAggregate\` (cells derived from the ` +
             "members) — a collapsed strip shows one or the other");
     }
+    const summary = consumerField(rowType, cfg.summary, "heat", where, "summary");
+    // The strip's ONE summary (#824): the per-entry cells, the declared
+    // aggregate, or a plain band.
+    const declared = summary === undefined ? groupSummary(undefined, cfg.summaryAggregate, where) : undefined;
     const spec = dataSpec(rowType, cfg, {
         arm: "group",
-        kind: (value, key) => groupKind(declared ?? East.value(variant("cells", East.value(summary(value, key), PlanHeatCellsType)), PlanGroupSummaryType)),
+        kind: (node, key, _hasChildren, value) => groupKind(declared ?? East.value(variant("cells", East.value(summary.at(node, key, value), PlanHeatCellsType)), PlanGroupSummaryType)),
+        reads: summary?.reads ?? [],
+        // Its strip derives its members' numbers by its summaryAggregate (#1435).
+        ...(cfg.summaryAggregate !== undefined ? { aggregate: tagOf(cfg.summaryAggregate, "mean") } : {}),
     });
     return seriesValue(rowType, cfg.keyType, spec, cfg);
 }
@@ -1910,10 +2666,11 @@ export function createSeriesGroup(rowType, config) {
  *
  * @typeParam R - The entry type (the members' — they share the section's entries)
  * @typeParam K - The union of the members' axis kinds (inferred; `never` when all are erased)
+ * @typeParam S - The members, as written
  * @param rowType - The entry type
  * @param config - The header ({@link PlanSectionSeriesConfig})
  * @param members - The member series, in order
- * @returns A series value, branded with its members' kinds
+ * @returns A series value, branded with its members' kinds and what they read
  */
 export function createSeriesSection(rowType, config, members) {
     const cfg = config;
@@ -1932,7 +2689,7 @@ export function createSeriesSection(rowType, config, members) {
  * view row's id is its member series' key and the entry's path, and a seek on
  * the entry lands on its first view row.
  *
- * The views' `children` are a step-down's series, or — a bare accessor — more
+ * The views' `children` are a step-down's series, or — a tree's field — more
  * of the views' own entries, each drawn as its members' rows, to any depth,
  * the views' `match` and `collapsed` at every level (#1219). A span member that
  * declares `rollup` rolls up the children nested under its row.
@@ -1940,10 +2697,15 @@ export function createSeriesSection(rowType, config, members) {
  * @typeParam R - The entry type
  * @typeParam K - The union of the members' axis kinds (inferred; `never` when all are erased)
  * @typeParam KT - The entries' key type
+ * @typeParam S - The members, as written
+ * @typeParam CT - A tree's field, as `children` names it
+ * @typeParam CU - One step-down's reads
+ * @typeParam CF - The folds of its cells
+ * @typeParam CS - Several step-downs' reads
  * @param rowType - The entry type
  * @param config - Membership, collapse and children ({@link PlanViewsSeriesConfig})
  * @param members - The member series — one row each per entry, in order
- * @returns A series value, branded with its members' kinds
+ * @returns A series value, branded with its members' kinds and what it reads
  */
 export function createSeriesViews(rowType, config, members) {
     const cfg = config;