@elaraai/east-ui 1.0.80 → 1.0.82

package/dist/src/collections/plan/series.js

@@ -3,410 +3,1708 @@
  * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
  */
 /**
- * Plan series (`Plan Data Interface.md` §3.5/§3.5a) — the data-driven row
- * series of a `data` + `series` canvas. Series are REAL EAST VALUES:
- * {@link PlanSeriesType} is a type constructor (the `DataBindHandleType`
- * pattern) instantiated per row type, and every `Plan.series.*` builder
- * reifies its accessors ONCE into the arm's typed `derive` function
- * (`Fn(Dict<String, R>) → Dict<String, PlanRow>` — Table's per-column `valueFn` move)
- * and returns `variant(kind, { derive })`. Application is eager expression
- * composition, typed end to end: the inline arm applies each series' `derive`
- * to the data expression (Table's `rows_mapped`); the paged arm (P-c) wraps
- * the same `derive`s over a `Data.bindPaged` handle's `page` method.
+ * Plan series (#822) — the row recipes of a `data` + `series` canvas.
+ *
+ * A canvas is its `data` (keyed entries) plus a list of series. Each series
+ * says which entries it takes (`match`), what kind of row each becomes, and
+ * how to read that row's content from the entry; several series over one
+ * source give each entry several rows. The top-level list IS the layout: each
+ * series contributes its rows in declared order, as BLOCKS kept apart
+ * (`PlanBlockType`, #823) — a data series one block of its entries' rows (an
+ * ordered stream, `Array<PlanRow>`), which a paged canvas pages on its own; a
+ * section its header's fixed block, then its members' blocks; hand-built rows
+ * a fixed block.
+ *
+ * Hierarchy comes only from the data's own nesting. Every data series takes
+ * `children`: a bare accessor returns more of THIS series' entries (to any
+ * depth — a `RecursiveType` entry), and `Plan.children(of, [series…])` steps
+ * down to a child collection of another type, laid out like a top-level list.
+ * `Plan.series.section` puts a titled block over series, `Plan.series.views`
+ * gives each entry one adjacent row per member series, and `Plan.series.rows`
+ * places hand-built rows.
+ *
+ * Every row has a typed id — `{ series, path }`, the path the entry keys that
+ * lead to it — and every series is a REAL EAST VALUE (the `DataBindHandleType`
+ * pattern): its `derive` is a reified East function from the source to its
+ * rows, so a series list can be bound, picked (`Plan.pick`) and stored. Each
+ * builder also records how to BUILD the series for any collection type, which
+ * is what lets a step-down compile its child series for the child collection's
+ * type, the root compile them for a source keyed by any type, and the root
+ * refuse two series sharing a key.
  *
  * @packageDocumentation
  */
-import { East, Expr, ArrayType, BooleanType, DictType, FunctionType, OptionType, StringType, StructType, VariantType, variant, some, none, } from "@elaraai/east";
+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 { StatusValueType } from "../../feedback/status/types.js";
 import { IconType } from "../../display/icon/types.js";
 import { ApprovalStateType } from "../../contracts/approval.js";
-import { foldEntriesToDict } from "../../shared/reify.js";
 import { TableAggregateType } from "../table/types.js";
-import { PlanAggregateType, PlanExpandType, PlanRowKindType, PlanLaneType, PlanBucketEventType, PlanCellMarkerType, PlanChipType, PlanEventMarkType, PlanRowsCollectionType, } from "./types.js";
-import { resolveTag, resolveIcon, emptyRows } from "./builders.js";
-import { groupParentFn, applyRowOverrides, normalizeRows, LAST_WINS } from "./assemble.js";
-import { createBuckets, createCards, createEvents, createChart, createGroup, } from "./factories.js";
-import { rowKey, reifyLevelKey, groupRows, spanParentKind, spanRowOf, heatParentKind, heatRowOf, tableParentKind, tableRowOf, } from "./data-forms.js";
+import { TickFormatType } from "../../format/types.js";
+import { reifyAccessor } from "../../shared/reify.js";
+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 { resolveTag, resolveIcon } from "./builders.js";
+import { planRow, planGutter, normalizeRows, REBASE_ROWS } from "./assemble.js";
+import { spanKind, bucketsKind, chartKind, heatKind, tableKind, cardsKind, eventsKind, groupKind, groupSummary, } from "./factories.js";
 // ============================================================================
 // The series type — a constructor, instantiated per row type
 // ============================================================================
 /**
- * The Plan series type CONSTRUCTOR — given the domain row type it returns
- * the concrete variant type of one series value (the `DataBindHandleType`
- * precedent: the row type lives structurally in each arm's `derive`
- * signature, so a series bound to one row type is a compile error against
- * data of another).
+ * The item a move to another row carries between its two writes (#825) — its
+ * bytes, from the source row's write, which takes it out of its list, to the
+ * target row's, which puts it into its own; `none` while nothing is in
+ * transit. The canvas threads ONE through every row a gesture writes, in
+ * order, and an item still carried at the end is a move that landed nowhere.
+ *
+ * @internal
+ */
+export const PlanCarriedType = RefType(OptionType(BlobType));
+/**
+ * The Plan series type CONSTRUCTOR — given the entry type (and the entries'
+ * key type, `String` by default) it returns the concrete variant type of one
+ * series value (the `DataBindHandleType` precedent: the entry type lives
+ * structurally in each arm's `derive` signature, so a series built for one
+ * entry type is a compile error against data of another).
  *
  * @remarks
- * Every kind arm carries `derive: Fn(Dict<String, R>) → Dict<String, PlanRow>` — the
- * series' whole pipeline (match filter → per-entry construction → groupBy
- * parents) reified once by its builder, taking the source's KEYED collection
- * and producing the canvas's. A leaf row's key is the source entry's key, so
- * the canvas is addressable by the keys the source is searched by (#568). The `rows` arm is literal one-off chrome and carries the
- * finished rows directly.
- *
- * @typeParam R - The East row type of the canvas's data source
- * @param r - The row type value
- * @returns The concrete `VariantType` of a series over `r`
+ * Every arm carries the series' identity and `derive: Fn(Dict<K, R>) →
+ * Array<PlanBlock>` — the blocks the series contributes (#823: a data series'
+ * one block of its entries' rows, each followed by its subtree; a section's
+ * header block, then its members'), reified once by its builder. The arm is
+ * the series' kind, which is all the series library reads beyond the identity.
+ *
+ * It carries its writer too (#880), `write: Fn(R, K, RowId, Gesture,
+ * Ref<Option<Blob>>) → Option<R>` — a gesture on one of its rows written into
+ * the entry the row came from, through the fields the series declares
+ * (`review.verdict`, `edit`), at whatever depth the row sits; `none` when no
+ * series in its tree takes the gesture on that row. The `Ref` is the item a
+ * move to another row carries (#825): the source row's write takes the item
+ * out of its list into it, as bytes, and the target row's write puts it into
+ * its own list — the two rows may be different series' and different
+ * entries'. A series list is an East value (a pick, a stored list), so the
+ * writer travels with the series rather than being rebuilt by the canvas.
+ *
+ * @param r - The entry type value
+ * @param k - The entries' key type (default `StringType`)
+ * @returns The concrete `VariantType` of a series over entries of `r` keyed by `k`
  */
-const seriesShape = (r) => {
-    // Every data-driven arm carries the same identity + the same reified
-    // pipeline. `key` and `title` are what let a series be listed, ordered and
-    // persisted (#590 phase 1); `derive` is the pipeline itself.
-    const identity = {
+const seriesShape = (r, k = StringType) => {
+    const arm = StructType({
         key: StringType,
         title: StringType,
         subtitle: OptionType(StringType),
         icon: OptionType(IconType),
-    };
-    const identified = (rt) => ({
-        ...identity,
-        derive: FunctionType([DictType(StringType, rt)], PlanRowsCollectionType),
+        derive: FunctionType([DictType(k, r)], PlanBlocksType),
+        write: FunctionType([r, k, PlanRowIdType, PlanGestureType, PlanCarriedType], OptionType(r)),
     });
     return VariantType({
-        span: StructType(identified(r)),
-        buckets: StructType(identified(r)),
-        chart: StructType(identified(r)),
-        heat: StructType(identified(r)),
-        table: StructType(identified(r)),
-        cards: StructType(identified(r)),
-        events: StructType(identified(r)),
-        // `group` and `rows` carry identity too (#590 §6.1, resolved). A GROUP
-        // is the unit a person actually picks — "add Machines" — and hiding one
-        // takes its whole subtree with it, because the children are built by
-        // the group's own `derive`. Without this the library could only offer
-        // top-level series, which on a grouped canvas is almost nothing.
-        group: StructType(identified(r)),
-        rows: StructType({ ...identity, rows: PlanRowsCollectionType }),
+        span: arm, buckets: arm, chart: arm, heat: arm, table: arm, cards: arm, events: arm,
+        group: arm, section: arm, views: arm, rows: arm,
     });
 };
+/**
+ * The Plan series type constructor — `Plan.Types.Series(RowType)` for a list
+ * of series over `Dict<String, RowType>` entries, `Plan.Types.Series(RowType,
+ * IntegerType)` over `Dict<Integer, RowType>`.
+ */
 export const PlanSeriesType = seriesShape;
-/** Pin one arm value against the instantiated series type. */
-function seriesValue(rowType, tag, payload, 
-/** The series identity (#590) — every arm carries one. */
-identity) {
-    const id = {
-        key: identity.key,
-        title: identity.title,
-        subtitle: identity.subtitle !== undefined ? some(identity.subtitle) : none,
-        icon: identity.icon !== undefined ? some(resolveIcon(identity.icon)) : none,
+/** 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).
+ *
+ * @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
+ * @returns The step-down, for a series' `children`
+ */
+export function createChildren(of, series) {
+    return { [PLAN_CHILDREN]: true, of, series };
+}
+function isStepDown(x) {
+    return typeof x === "object" && x !== null && x[PLAN_CHILDREN] === true;
+}
+// ============================================================================
+// Build specs — how each series is built for a collection type
+// ============================================================================
+const PathType = ArrayType(StringType);
+const IdOptType = OptionType(PlanRowIdType);
+/** Every series value a builder made, with its build spec. */
+const SPECS = new WeakMap();
+/** 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;
+}
+/** A series value inside a composite series — it must come from a builder, since the parent builds it for its own entries. */
+function nestedSpec(s, where) {
+    const spec = specOf(s);
+    if (spec === undefined) {
+        throw new Error(`${where}: a nested series must be a \`Plan.series.*\` value written in place — the parent builds it ` +
+            "for its own entries, so a series bound to a variable elsewhere cannot be nested here");
+    }
+    return spec;
+}
+/** A readable name for a series, in messages. */
+function nameOf(spec) {
+    return `${spec.arm} "${spec.title}"`;
+}
+/** A collection type's entry and key types — a `Dict`'s value and key, an `Array`'s element and `Integer` index. */
+function shapeOf(collection, where) {
+    if (collection.type === "Dict")
+        return { entry: collection.value, key: collection.key };
+    if (collection.type === "Array")
+        return { entry: collection.value, key: IntegerType };
+    throw new Error(`${where}: entries come from a Dict (keyed) or an Array (by index) — got a ${collection.type}`);
+}
+/** Refuse a collection whose entries are not the series' entry type. */
+function assertEntry(entry, rowType, where) {
+    if (!isTypeEqual(entry, rowType)) {
+        throw new Error(`${where}: the series is built over one entry type and applied to entries of another — ` +
+            `pass the entries' own type as the series' first argument`);
+    }
+}
+/** A path segment from a key — a String key as is, any other key as its `.east` text. */
+function segmentOf(keyType) {
+    return keyType.type === "String"
+        ? (key) => key
+        : (key) => East.print(key);
+}
+/**
+ * A series' rows as ONE block (#823) — a data series' entries (`fixed: false`),
+ * or rows no entry produces (`fixed: true`: hand-built rows), under the parent
+ * the block nests in.
+ *
+ * @param collection - The collection type the rows are built for
+ * @param rows - The series' rows emitter for that collection
+ * @param fixed - Whether no entry produces the rows
+ * @returns The block list's emitter
+ */
+function oneBlock(collection, rows, fixed) {
+    return East.function([collection, PathType, IdOptType], PlanBlocksType, ($, coll, prefix, parent) => {
+        const block = $.let(East.value({ fixed, parent, rows: rows(coll, prefix, parent) }, PlanBlockType), PlanBlockType);
+        return East.value([block], PlanBlocksType);
+    });
+}
+/** A cache of built functions by East type. */
+class ByType {
+    entries = [];
+    get(type, build) {
+        const hit = this.entries.find((e) => isTypeEqual(e.type, type));
+        if (hit !== undefined)
+            return hit.value;
+        const value = build();
+        this.entries.push({ type, value });
+        return value;
+    }
+}
+/** Build `fn`, naming the series and the key type when its accessors do not build for it. */
+function building(where, keyType, fn) {
+    try {
+        return fn();
+    }
+    catch (err) {
+        const kt = keyType.type;
+        const reason = err instanceof Error ? err.message : String(err);
+        throw new Error(`${where}: its accessors do not build for entries keyed by ${kt} (${reason}) — the key an accessor ` +
+            `receives is the collection's: the source's key, a Dict child's key, or an Array child's Integer ` +
+            "index. Declare the key type the accessors expect with `keyType`, or leave the key unread.");
+    }
+}
+/**
+ * How `accessor` reaches the child collection it returns, read off the
+ * expression it builds (#880): a plain field of the entry (`r => r.children`,
+ * `Plan.children(r => r.lines, …)`), or the entry itself (`g => g`). A write
+ * follows either back into the entry. Anything else — a filtered or computed
+ * collection — is a copy a write would be lost in, and is `undefined`.
+ *
+ * @param rowType - The entry type
+ * @param keyType - The entries' key type
+ * @param accessor - The accessor, over the entry (its node, when recursive) and key
+ * @returns How it reaches its collection, or `undefined` when a write cannot follow it
+ */
+function childRefOf(rowType, keyType, accessor) {
+    const recursive = rowType.type === "Recursive";
+    let found;
+    East.function([rowType, keyType], undefined, (_$, v, k) => {
+        const node = recursive ? v.unwrap() : v;
+        const out = accessor(node, k);
+        const ast = Expr.ast(out);
+        const param = Expr.ast(v);
+        const nodeAst = Expr.ast(node);
+        if (ast === param || ast === nodeAst)
+            found = { kind: "self" };
+        else if (ast.ast_type === "GetField" && ast.field !== undefined && (ast.struct === nodeAst || ast.struct === param)) {
+            found = { kind: "field", field: ast.field };
+        }
+        return out;
+    });
+    return found;
+}
+/** Each key type's segment reader, built once. */
+const segmentKeys = new ByType();
+/**
+ * A path segment read back as its collection's key (#880) — the inverse of
+ * {@link segmentOf}: a String key as it is, any other key its `.east` text
+ * parsed (an `Array` child's segment is its Integer index).
+ *
+ * @param keyType - The collection's key type
+ * @returns `(segment) → key`
+ */
+function segmentKeyOf(keyType) {
+    return segmentKeys.get(keyType, () => (keyType.type === "String"
+        ? East.function([StringType], StringType, (_$, s) => s)
+        : East.function([StringType], keyType, (_$, s) => s.parse(keyType))));
+}
+/**
+ * A child collection's part of a write (#880) — whether it holds a key, its
+ * entry at it, and that entry written back in place. A `Dict` by key; an
+ * `Array` by index.
+ */
+function collectionOps(collection) {
+    if (collection.type === "Dict") {
+        const dict = (c) => c;
+        return {
+            has: (c, k) => dict(c).has(k),
+            get: (c, k) => dict(c).get(k),
+            put: (c, k, v) => dict(c).update(k, v),
+        };
+    }
+    const array = (c) => c;
+    const index = (k) => k;
+    return {
+        has: (c, k) => index(k).greaterEqual(0n).and(() => index(k).less(array(c).size())),
+        get: (c, k) => array(c).get(index(k)),
+        put: (c, k, v) => array(c).update(index(k), v),
     };
-    return East.value(variant(tag, { ...id, ...payload }), PlanSeriesType(rowType));
 }
-/** Filter the source ENTRIES by the reified match predicate (all when omitted). */
-function matchedRows(entries, rowType, match) {
-    if (match === undefined)
-        return entries;
-    const pred = East.function([rowType, StringType], BooleanType, (_$, r, k) => match(r, k));
-    return entries.filter((_$, r, k) => pred(r, k));
+/** 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 envelope's accessor-supplied Option fields for one data entry. */
-function envelopeOverrides(cfg, r, k) {
+/** The item field types a move can write an instant into (#825). */
+const INSTANT_FIELD_TYPES = [DateTimeType, FloatType, IntegerType, StringType, PlanInstantType];
+/** 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`).
+ *
+ * @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
+ * @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 {
-        ...(cfg.sub !== undefined ? { sub: cfg.sub(r, k) } : {}),
-        ...(cfg.value !== undefined ? { value: cfg.value(r, k) } : {}),
-        ...(cfg.status !== undefined ? { status: cfg.status(r, k) } : {}),
-        ...(cfg.approval !== undefined ? { approval: cfg.approval(r, k) } : {}),
-        ...(cfg.expand !== undefined ? { expand: cfg.expand(r, k) } : {}),
+        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" },
     };
 }
+/** Each instant field type's converter, built once (#825). */
+const instantConverters = new ByType();
 /**
- * The shared scaffolding for ONE series' `derive` — the `series.ts` twin of
- * `data-forms.ts`'s `ofScaffold`: match filter → optional groupBy levels →
- * leaf rows, inside that single series' own reified function. NOT a
- * canvas-level compiler — the canvas never composes series into one
- * function; `applySeries` calls each series' `derive` in declared order.
+ * 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`.
+ *
+ * @param fieldType - The field's type (one of {@link INSTANT_FIELD_TYPES})
+ * @returns `(instant) → Option<field>`
  */
-function seriesScaffold(rowType, match, groupBy, parentFn, row, prefix) {
-    const sourceType = DictType(StringType, rowType);
-    return East.function([sourceType], PlanRowsCollectionType, ($, entries) => {
-        const matched = $.let(matchedRows(entries, rowType, match), sourceType);
-        if (groupBy === undefined || groupBy.length === 0 || parentFn === undefined) {
-            return foldEntriesToDict(matched, PlanRowsCollectionType, LAST_WINS, row);
+function instantInto(fieldType) {
+    return instantConverters.get(fieldType, () => {
+        const out = OptionType(fieldType);
+        const kind = fieldType.type;
+        const whole = isTypeEqual(fieldType, PlanInstantType);
+        return East.function([PlanInstantType], out, ($, t) => {
+            const result = $.let(none, out);
+            if (whole) {
+                $.assign(result, some(t));
+                return result;
+            }
+            $.match(t, {
+                time: ($2, d) => {
+                    if (kind === "DateTime")
+                        $2.assign(result, some(d));
+                },
+                number: ($2, n) => {
+                    if (kind === "Float") {
+                        $2.assign(result, some(n));
+                    }
+                    else if (kind === "Integer") {
+                        const rounded = $2.let(n.greaterEqual(0).ifElse(() => n.add(0.5).subtract(n.add(0.5).remainder(1)), () => n.subtract(0.5).subtract(n.subtract(0.5).remainder(1))), FloatType);
+                        $2.assign(result, some(rounded.toInteger()));
+                    }
+                },
+                ordinal: ($2, s) => {
+                    if (kind === "String")
+                        $2.assign(result, some(s));
+                },
+            });
+            return result;
+        });
+    });
+}
+/**
+ * The build spec of a data series (span / buckets / chart / heat / table /
+ * cards / events / group).
+ *
+ * @remarks
+ * Per key type it builds ONE entry-row function (the entry's gutter, kind and
+ * 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
+ * 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`)));
+    // A recursive entry reaches the accessors as its NODE (`PlanEntryExpr`),
+    // so they read its fields directly at every depth.
+    const recursive = rowType.type === "Recursive";
+    const nodeOf = (value) => recursive
+        ? value.unwrap()
+        : value;
+    /** An accessor over entries, applied to an entry value (its node, when recursive). */
+    const onEntry = (accessor) => (v, k) => accessor(nodeOf(v), k);
+    // What a gesture writes (#880, #825) — a verdict into `review.verdict`, 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.
+    const review = cfg.review;
+    const edit = recipe.edit;
+    const nodeType = (recursive ? rowType.node : rowType);
+    if ((review !== undefined || edit !== undefined) && nodeType.type !== "Struct") {
+        throw new Error(`${where}: \`review\` and \`edit\` write a field of the entry — its entries must be structs (a recursive entry's node included)`);
+    }
+    const entryFields = nodeType.fields ?? {};
+    if (review !== undefined) {
+        if (cfg.approval !== undefined) {
+            throw new Error(`${where}: give \`review.verdict\` (the field a verdict writes, which the row shows) or \`approval\` (a verdict the canvas only shows) — not both`);
+        }
+        const t = entryFields[review.verdict];
+        if (t === undefined || !isTypeEqual(t, ApprovalStateType)) {
+            throw new Error(`${where}: \`review.verdict\` names "${review.verdict}", which is not an ApprovalStateType field of the entry`);
+        }
+    }
+    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 = review !== undefined || edit !== undefined
+        ? {
+            verdict: review !== undefined,
+            drop: edit?.create !== undefined,
+            move: move !== undefined ? some(move.edits) : none,
+        }
+        : undefined;
+    const rows = new ByType();
+    const matches = new ByType();
+    const collapses = new ByType();
+    const kids = new ByType();
+    const walks = new ByType();
+    const emitters = new ByType();
+    const blockLists = new ByType();
+    const rowFor = (kt) => rows.get(kt, () => building(where, kt, () => East.function([rowType, kt, PlanRowIdType, IdOptType, BooleanType, BooleanType], PlanRowType, ($, value, key, id, parent, hasChildren, collapsed) => {
+        // The node every accessor reads, unwrapped once.
+        const entry = recursive ? $.let(nodeOf(value)) : value;
+        return planRow({
+            id, parent,
+            gutter: planGutter({
+                label: cfg.label(entry, key),
+                ...(cfg.id !== undefined ? { id: cfg.id } : {}),
+                ...(cfg.stacked !== undefined ? { stacked: cfg.stacked } : {}),
+                ...(cfg.sub !== undefined ? { sub: cfg.sub(entry, key) } : {}),
+                ...(cfg.value !== undefined ? { value: cfg.value(entry, key) } : {}),
+                ...(recipe.swatches !== undefined ? { swatches: recipe.swatches } : {}),
+            }),
+            kind: recipe.kind(entry, key, hasChildren),
+            collapsed,
+            ...(recipe.pinned !== undefined ? { pinned: recipe.pinned(entry, key) } : {}),
+            ...(cfg.status !== undefined ? { status: cfg.status(entry, key) } : {}),
+            // A verdict the canvas takes shows from its field (#880) — so
+            // a drafted verdict draws where it was made.
+            ...(review !== undefined
+                ? { approval: some(entry[review.verdict]) }
+                : cfg.approval !== undefined ? { approval: cfg.approval(entry, key) } : {}),
+            ...(cfg.expand !== undefined ? { expand: cfg.expand(entry, key) } : {}),
+            ...(edits !== undefined ? { edits } : {}),
+        });
+    })));
+    const matchFor = (kt) => matches.get(kt, () => {
+        const match = cfg.match;
+        if (match === undefined)
+            return undefined;
+        return building(where, kt, () => East.function([rowType, kt], BooleanType, (_$, value, key) => match(nodeOf(value), key)));
+    });
+    const collapsedFor = (kt) => collapses.get(kt, () => {
+        const collapsed = cfg.collapsed;
+        if (collapsed === undefined)
+            return undefined;
+        return building(where, kt, () => East.function([rowType, kt], BooleanType, (_$, value, key) => typeof collapsed === "boolean"
+            ? 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 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)`);
+        const next = childOf(kc);
+        const nextType = Expr.type(next).output;
+        if (!isTypeEqual(nextType, cc)) {
+            throw new Error(`${at}: a recursive series' children must be the same collection type at every level`);
+        }
+        const row = rowFor(kc);
+        const match = matchFor(kc);
+        const collapsed = collapsedFor(kc);
+        const seg = segmentOf(kc);
+        const Frame = StructType({ value: rowType, key: kc, path: PathType, parent: PlanRowIdType });
+        const Frames = ArrayType(Frame);
+        // A level's matched entries as frames, REVERSED — so the stack
+        // pops the first of them first.
+        const framesOf = East.function([cc, PathType, PlanRowIdType], Frames, ($, coll, path, parentId) => {
+            const frames = $.let([], Frames);
+            const member = match === undefined ? undefined : $.const(match);
+            $.for(coll, ($2, value, key) => {
+                const add = ($3) => {
+                    const segs = $3.let(East.value([seg(key)], PathType), PathType);
+                    $3(frames.pushLast(East.value({ value, key, path: path.concat(segs), parent: parentId }, Frame)));
+                };
+                if (member === undefined)
+                    add($2);
+                else
+                    $2.if(member(value, key), add);
+            });
+            $(frames.reverseInPlace());
+            return frames;
+        });
+        return East.function([cc, PathType, PlanRowIdType], PlanRowsCollectionType, ($, coll, path0, parent0) => {
+            // Every function the loop calls, bound ONCE — a captured function
+            // referenced in the loop would be re-inlined per use.
+            const frames = $.const(framesOf);
+            const childrenOf = $.const(next);
+            const entryRow = $.const(row);
+            const collapse = collapsed === undefined ? undefined : $.const(collapsed);
+            const out = $.let([], PlanRowsCollectionType);
+            const stack = $.let(frames(coll, path0, parent0), Frames);
+            $.while(stack.size().greater(0n), ($2) => {
+                const f = $2.let(stack.popLast(), Frame);
+                const id = $2.let(East.value(variant("entry", { series: cfg.key, path: f.path }), PlanRowIdType), PlanRowIdType);
+                const below = $2.let(frames(childrenOf(f.value, f.key), f.path, id), Frames);
+                const parent = $2.let(East.value(some(f.parent), IdOptType), IdOptType);
+                const fold = $2.let(collapse === undefined
+                    ? East.value(false, BooleanType)
+                    : collapse(f.value, f.key), BooleanType);
+                $2(out.pushLast(entryRow(f.value, f.key, id, parent, below.size().greater(0n), fold)));
+                $2(stack.append(below));
+            });
+            return out;
+        });
+    });
+    const childrenFor = (kt) => kids.get(kt, () => {
+        if (children === undefined)
+            return undefined;
+        if (typeof children === "function") {
+            const of = childOf(kt);
+            const cc = Expr.type(of).output;
+            const walk = walkFor(cc);
+            return East.function([rowType, kt, PlanRowIdType, PathType], PlanRowsCollectionType, (_$, value, key, id, path) => walk(of(value, key), path, id));
+        }
+        const parts = steps.map((step, i) => {
+            const at = `${where} › children[${i}]`;
+            const of = building(at, kt, () => reifyAccessor([rowType, kt], onEntry(step.of)));
+            const cc = Expr.type(of).output;
+            const blocks = step.series.map((s) => nestedSpec(s, at).emitter(cc, at));
+            return { of, cc, blocks };
+        });
+        return East.function([rowType, kt, PlanRowIdType, PathType], PlanRowsCollectionType, ($, value, key, id, path) => {
+            const out = $.let([], PlanRowsCollectionType);
+            const under = $.let(East.value(some(id), IdOptType), IdOptType);
+            for (const part of parts) {
+                const coll = $.let(part.of(value, key), part.cc);
+                for (const block of part.blocks)
+                    $(out.append(block(coll, path, under)));
+            }
+            return out;
+        });
+    });
+    // ── Writing a gesture back (#880) ─────────────────────────────────────
+    // 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: only an entry whose OWN
+    // field changes — a verdict — is rebuilt.
+    const owns = new ByType();
+    const writers = new ByType();
+    const entryAccess = (value) => nodeOf(value);
+    /** The entry with its verdict field set — rebuilt, every other field as it was. */
+    const withVerdict = review === undefined ? undefined : East.function([rowType, ApprovalStateType], rowType, ($, value, verdict) => {
+        const node = recursive ? $.let(nodeOf(value)) : value;
+        const read = node;
+        const rebuilt = East.value(Object.fromEntries(Object.keys(entryFields).map((f) => [f, f === review.verdict ? verdict : read[f]])), nodeType);
+        return recursive ? East.wrapRecursive(rebuilt, rowType) : rebuilt;
+    });
+    /** 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)));
+    /**
+     * 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).
+     */
+    const placed = move === undefined ? undefined : (() => {
+        const m = move;
+        const startAs = instantInto(m.start.type);
+        const endAs = m.end !== undefined ? instantInto(m.end.type) : undefined;
+        return East.function([m.item, PlanInstantType, PlanInstantType], OptionType(m.item), ($, item, start, end) => {
+            const result = $.let(none, OptionType(m.item));
+            const asStart = $.const(startAs);
+            const s = $.let(asStart(start), OptionType(m.start.type));
+            const read = item;
+            const rebuild = (fields) => East.value(Object.fromEntries(Object.keys(m.item.fields).map((f) => [f, fields[f] ?? read[f]])), m.item);
+            $.match(s, {
+                some: ($2, sv) => {
+                    if (endAs === undefined || m.end === undefined) {
+                        $2.assign(result, some(rebuild({ [m.start.name]: sv })));
+                        return;
+                    }
+                    const endName = m.end.name;
+                    const asEnd = $2.const(endAs);
+                    const e = $2.let(asEnd(end), OptionType(m.end.type));
+                    $2.match(e, {
+                        some: ($3, ev) => {
+                            $3.assign(result, some(rebuild({ [m.start.name]: sv, [endName]: ev })));
+                        },
+                    });
+                },
+            });
+            return result;
+        });
+    })();
+    /**
+     * 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 verdict into its field, 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).
+     */
+    const ownFor = (kt) => owns.get(kt, () => {
+        if (review === undefined && edit === undefined)
+            return undefined;
+        const create = edit?.create !== undefined ? createFor(kt, edit.create) : undefined;
+        return East.function([rowType, kt, PathType, PlanGestureType, PlanCarriedType], OptionType(rowType), ($, value, key, path, gesture, carried) => {
+            const setVerdict = withVerdict === undefined ? undefined : $.const(withVerdict);
+            const make = create === undefined ? undefined : $.const(create);
+            const place = placed === undefined ? undefined : $.const(placed);
+            const result = $.let(none, OptionType(rowType));
+            $.match(gesture, {
+                verdict: ($2, verdict) => {
+                    if (setVerdict !== undefined)
+                        $2.assign(result, some(setVerdict(value, verdict)));
+                },
+                drop: ($2, drop) => {
+                    if (make === undefined || edit === 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));
+                        $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)
+                        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));
+                    $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));
+                                    },
+                                });
+                            },
+                        });
+                    }).else(($3) => {
+                        // Its source: taken out of the list, 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));
+                                },
+                            });
+                        });
+                        // 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.
+                        $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));
+                                        $6.match(moved, {
+                                            some: ($7, placedItem) => {
+                                                $7(list.pushLast(placedItem));
+                                                $7(carried.update(East.value(none, OptionType(BlobType))));
+                                                $7.assign(result, some(value));
+                                            },
+                                        });
+                                    });
+                                },
+                            });
+                        });
+                    });
+                },
+            });
+            return result;
+        });
+    });
+    /** The walk's writer — a bare `children` accessor: the rows below an entry are this series' own. */
+    const walkWriterFor = (kt) => {
+        const at = `${where} › children`;
+        const of = childOf(kt);
+        const cc = Expr.type(of).output;
+        const { key: kc } = shapeOf(cc, at);
+        const own = ownFor(kc);
+        if (own === undefined)
+            return undefined;
+        const ref = childRefOf(rowType, kt, children);
+        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");
         }
-        // Every level shares ONE parent constructor (the ofScaffold shape).
-        const shared = parentFn();
-        const levels = groupBy.map((by) => ({
-            by: reifyLevelKey(rowType, by),
-            parentFn: shared,
-        }));
-        // The prefix keys the SYNTHESIZED parents; leaf keys are the source's
-        // own, carried through by `row` — see `groupRows`.
-        return groupRows(matched, levels, (subset, _prefix) => foldEntriesToDict(subset, PlanRowsCollectionType, LAST_WINS, row), prefix ?? "");
+        const ops = collectionOps(cc);
+        const collOf = (entry) => (ref.kind === "field" ? entryAccess(entry)[ref.field] : nodeOf(entry));
+        return East.function([rowType, kt, PathType, IntegerType, StringType, PlanGestureType, PlanCarriedType], OptionType(rowType), ($, value, _key, path, depth, series, gesture, carried) => {
+            const result = $.let(none, OptionType(rowType));
+            // The walk's rows are this series' own, at every depth.
+            $.if(series.equal(cfg.key), ($2) => {
+                const write = $2.const(own);
+                const keyOf = $2.const(segmentKeyOf(kc));
+                const cur = $2.let(value, rowType);
+                const d = $2.let(depth, IntegerType);
+                const last = $2.let(path.size().subtract(1n), IntegerType);
+                // Down to the target's parent, then the target itself.
+                $2.while(d.less(last), ($3) => {
+                    const coll = $3.let(collOf(cur), cc);
+                    $3.assign(cur, ops.get(coll, keyOf(path.get(d))));
+                    $3.assign(d, d.add(1n));
+                });
+                const coll = $2.let(collOf(cur), cc);
+                const k = $2.let(keyOf(path.get(last)), kc);
+                const written = $2.let(write(ops.get(coll, k), k, path, gesture, carried), OptionType(rowType));
+                $2.match(written, {
+                    some: ($3, entry) => {
+                        $3(ops.put(coll, k, entry));
+                        $3.assign(result, some(value));
+                    },
+                });
+            });
+            return result;
+        });
+    };
+    /** The step-downs' writer: a row below an entry is one of a step-down's series', in that step's collection. */
+    const stepsWriterFor = (kt) => {
+        const parts = steps.flatMap((step, i) => {
+            const at = `${where} › children[${i}]`;
+            const accessor = step.of;
+            const of = building(at, kt, () => reifyAccessor([rowType, kt], onEntry(accessor)));
+            const cc = Expr.type(of).output;
+            const writes = step.series
+                .map((s) => nestedSpec(s, at).writer(cc, at))
+                .filter((w) => w !== undefined);
+            if (writes.length === 0)
+                return [];
+            const ref = 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.lines`) " +
+                    "or be the entry itself (`g => g`), not compute a collection");
+            }
+            const { entry: childType, key: kc } = shapeOf(cc, at);
+            return [{ ref, cc, kc, childType, writes }];
+        });
+        if (parts.length === 0)
+            return undefined;
+        return East.function([rowType, kt, PathType, IntegerType, StringType, PlanGestureType, PlanCarriedType], OptionType(rowType), ($, value, _key, path, depth, series, gesture, carried) => {
+            const result = $.let(none, OptionType(rowType));
+            for (const part of parts) {
+                const ops = collectionOps(part.cc);
+                const keyOf = $.const(segmentKeyOf(part.kc));
+                const writes = part.writes.map((w) => $.const(w));
+                $.if(result.hasTag("none"), ($2) => {
+                    const coll = $2.let(part.ref.kind === "field" ? entryAccess(value)[part.ref.field] : nodeOf(value), part.cc);
+                    const k = $2.let(keyOf(path.get(depth)), part.kc);
+                    $2.if(ops.has(coll, k), ($3) => {
+                        const child = $3.let(ops.get(coll, k), part.childType);
+                        for (const write of writes) {
+                            $3.if(result.hasTag("none"), ($4) => {
+                                const written = $4.let(write(child, k, path, depth.add(1n), series, gesture, carried), OptionType(part.childType));
+                                $4.match(written, {
+                                    some: ($5, entry) => {
+                                        $5(ops.put(coll, k, entry));
+                                        $5.assign(result, some(value));
+                                    },
+                                });
+                            });
+                        }
+                    });
+                });
+            }
+            return result;
+        });
+    };
+    /** This series' writer for entries keyed by `kt`: its own rows' edits, and the rows below them. */
+    const writerFor = (kt) => writers.get(kt, () => {
+        const own = ownFor(kt);
+        const below = children === undefined ? undefined
+            : typeof children === "function" ? 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) => {
+            const result = $.let(none, OptionType(rowType));
+            $.if(depth.equal(path.size()), ($2) => {
+                if (own === undefined)
+                    return;
+                const write = $2.const(own);
+                $2.if(series.equal(cfg.key), ($3) => { $3.assign(result, write(value, key, path, gesture, carried)); });
+            }).else(($2) => {
+                if (below === undefined)
+                    return;
+                const write = $2.const(below);
+                $2.assign(result, write(value, key, path, depth, series, gesture, carried));
+            });
+            return result;
+        });
     });
+    const spec = {
+        key: cfg.key,
+        title: cfg.title,
+        arm: recipe.arm,
+        nested,
+        nests: children !== undefined,
+        emitter(collection, at) {
+            return emitters.get(collection, () => {
+                const { entry, key: kt } = shapeOf(collection, at);
+                assertEntry(entry, rowType, where);
+                const row = rowFor(kt);
+                const match = matchFor(kt);
+                const collapsed = collapsedFor(kt);
+                const below = childrenFor(kt);
+                const seg = segmentOf(kt);
+                return East.function([collection, PathType, IdOptType], PlanRowsCollectionType, ($, coll, prefix, parent) => {
+                    // Every function the loop calls, bound ONCE (see the walk).
+                    const entryRow = $.const(row);
+                    const member = match === undefined ? undefined : $.const(match);
+                    const collapse = collapsed === undefined ? undefined : $.const(collapsed);
+                    const childRows = below === undefined ? undefined : $.const(below);
+                    const out = $.let([], PlanRowsCollectionType);
+                    $.for(coll, ($2, value, key) => {
+                        const emit = ($3) => {
+                            const segs = $3.let(East.value([seg(key)], PathType), PathType);
+                            const path = $3.let(prefix.concat(segs), PathType);
+                            const id = $3.let(East.value(variant("entry", { series: cfg.key, path }), PlanRowIdType), PlanRowIdType);
+                            const fold = $3.let(collapse === undefined
+                                ? East.value(false, BooleanType)
+                                : collapse(value, key), BooleanType);
+                            if (childRows === undefined) {
+                                $3(out.pushLast(entryRow(value, key, id, parent, false, fold)));
+                                return;
+                            }
+                            // The children are built first: a row rolls up
+                            // (span bands) only when it has child rows.
+                            const sub = $3.let(childRows(value, key, id, path), PlanRowsCollectionType);
+                            $3(out.pushLast(entryRow(value, key, id, parent, sub.size().greater(0n), fold)));
+                            $3(out.append(sub));
+                        };
+                        if (member === undefined)
+                            emit($2);
+                        else
+                            $2.if(member(value, key), emit);
+                    });
+                    return out;
+                });
+            });
+        },
+        // One block of the entries' rows — what a paged canvas pages (#823).
+        blocks(collection, at) {
+            return blockLists.get(collection, () => oneBlock(collection, spec.emitter(collection, at), false));
+        },
+        entryParts(entry, kt, at) {
+            assertEntry(entry, rowType, at);
+            return { match: matchFor(kt), row: rowFor(kt) };
+        },
+        childrenFor,
+        collapsedFor,
+        writer(collection, at) {
+            const { entry, key: kt } = shapeOf(collection, at);
+            assertEntry(entry, rowType, where);
+            return writerFor(kt);
+        },
+        ownFor,
+    };
+    return spec;
 }
-/** Apply one series value to a rows expression (the exhaustive-arm call). */
-export function applySeriesValue(s, rows) {
+/** The build spec of a `views` series. */
+function viewsSpec(rowType, cfg, members) {
+    const where = `Plan.series.views "${cfg.key}"`;
+    if (members.length === 0)
+        throw new Error(`${where}: a views series lists at least one member series`);
+    const memberSpecs = members.map((m, i) => {
+        const spec = nestedSpec(m, `${where}[${i}]`);
+        if (spec.entryParts === undefined || spec.arm === "group") {
+            throw new Error(`${where}: member ${nameOf(spec)} is not a row series — a view is one row per entry (span, buckets, chart, heat, table, cards or events)`);
+        }
+        if (spec.nests) {
+            throw new Error(`${where}: member ${nameOf(spec)} declares \`children\` — an entry's children belong to the views (they nest under its first view row); move \`children\` there`);
+        }
+        return spec;
+    });
+    // The views' own membership, collapse and children are a data series'
+    // envelope without a row of its own — built by the same machinery, so a
+    // views' children nest and recurse exactly as a data series' do.
+    const host = dataSpec(rowType, {
+        key: cfg.key, title: cfg.title, label: () => "",
+        ...(cfg.keyType !== undefined ? { keyType: cfg.keyType } : {}),
+        ...(cfg.match !== undefined ? { match: cfg.match } : {}),
+        ...(cfg.children !== undefined ? { children: cfg.children } : {}),
+        ...(cfg.collapsed !== undefined ? { collapsed: cfg.collapsed } : {}),
+    }, { arm: "views", kind: () => groupKind(East.value(variant("none", null), PlanGroupSummaryType)) });
+    const emitters = new ByType();
+    const blockLists = new ByType();
+    const writerLists = new ByType();
+    const spec = {
+        key: cfg.key,
+        title: cfg.title,
+        arm: "views",
+        nested: [...memberSpecs, ...host.nested],
+        nests: cfg.children !== undefined,
+        emitter(collection, at) {
+            return emitters.get(collection, () => {
+                const { entry, key: kt } = shapeOf(collection, at);
+                assertEntry(entry, rowType, where);
+                const parts = memberSpecs.map((m) => m.entryParts(entry, kt, `${where} › ${nameOf(m)}`));
+                const hostParts = host.entryParts(entry, kt, where);
+                const hostKids = host.childrenFor(kt);
+                const hostCollapse = host.collapsedFor(kt);
+                const seg = segmentOf(kt);
+                return East.function([collection, PathType, IdOptType], PlanRowsCollectionType, ($, coll, prefix, parent) => {
+                    // Every function the loop calls, bound ONCE (see the data walk).
+                    const rowsOf = parts.map((p) => $.const(p.row));
+                    const showsOf = parts.map((p) => (p.match === undefined ? undefined : $.const(p.match)));
+                    const member = hostParts.match === undefined ? undefined : $.const(hostParts.match);
+                    const childRows = hostKids === undefined ? undefined : $.const(hostKids);
+                    const collapse = hostCollapse === undefined ? undefined : $.const(hostCollapse);
+                    const out = $.let([], PlanRowsCollectionType);
+                    $.for(coll, ($2, value, key) => {
+                        const emit = ($3) => {
+                            const segs = $3.let(East.value([seg(key)], PathType), PathType);
+                            const path = $3.let(prefix.concat(segs), PathType);
+                            const ids = memberSpecs.map((m) => $3.let(East.value(variant("entry", { series: m.key, path }), PlanRowIdType), PlanRowIdType));
+                            const present = showsOf.map((shows) => (shows === undefined
+                                ? undefined
+                                : $3.let(shows(value, key), BooleanType)));
+                            // The first member whose row shows — the entry's
+                            // children nest under it.
+                            const first = $3.let(-1n, IntegerType);
+                            for (let i = parts.length - 1; i >= 0; i--) {
+                                const shows = present[i];
+                                if (shows === undefined)
+                                    $3.assign(first, BigInt(i));
+                                else
+                                    $3.if(shows, ($4) => { $4.assign(first, BigInt(i)); });
+                            }
+                            let sub;
+                            if (childRows !== undefined) {
+                                const firstId = $3.let(ids[0], PlanRowIdType);
+                                for (let i = 1; i < ids.length; i++) {
+                                    $3.if(first.equal(BigInt(i)), ($4) => { $4.assign(firstId, ids[i]); });
+                                }
+                                sub = $3.let(first.greaterEqual(0n).ifElse(() => childRows(value, key, firstId, path), () => East.value([], PlanRowsCollectionType)), PlanRowsCollectionType);
+                            }
+                            const fold = $3.let(collapse === undefined
+                                ? East.value(false, BooleanType)
+                                : collapse(value, key), BooleanType);
+                            const noFold = $3.let(East.value(false, BooleanType), BooleanType);
+                            parts.forEach((_p, i) => {
+                                const isFirst = $3.let(first.equal(BigInt(i)), BooleanType);
+                                const kids = sub;
+                                const hasChildren = $3.let(kids === undefined
+                                    ? East.value(false, BooleanType)
+                                    : isFirst.and(() => kids.size().greater(0n)), BooleanType);
+                                const viewRow = rowsOf[i];
+                                const push = ($4) => {
+                                    $4(out.pushLast(viewRow(value, key, ids[i], parent, hasChildren, isFirst.ifElse(() => fold, () => noFold))));
+                                };
+                                const shows = present[i];
+                                if (shows === undefined)
+                                    push($3);
+                                else
+                                    $3.if(shows, push);
+                            });
+                            if (sub !== undefined)
+                                $3(out.append(sub));
+                        };
+                        if (member === undefined)
+                            emit($2);
+                        else
+                            $2.if(member(value, key), emit);
+                    });
+                    return out;
+                });
+            });
+        },
+        // One block of the entries' view rows — what a paged canvas pages (#823).
+        blocks(collection, at) {
+            return blockLists.get(collection, () => oneBlock(collection, spec.emitter(collection, at), false));
+        },
+        // An entry's view rows are its members' own (each at the entry's path,
+        // under its member's key), and the rows below them the views' (#880).
+        writer(collection, at) {
+            return writerLists.get(collection, () => {
+                const { entry, key: kt } = shapeOf(collection, at);
+                assertEntry(entry, rowType, where);
+                const owns = memberSpecs.flatMap((m) => {
+                    const own = m.ownFor?.(kt);
+                    return own === undefined ? [] : [{ key: m.key, own }];
+                });
+                const below = host.writer(collection, at);
+                if (owns.length === 0 && below === undefined)
+                    return undefined;
+                return East.function([rowType, kt, PathType, IntegerType, StringType, PlanGestureType, PlanCarriedType], OptionType(rowType), ($, value, key, path, depth, series, gesture, carried) => {
+                    const result = $.let(none, OptionType(rowType));
+                    $.if(depth.equal(path.size()), ($2) => {
+                        for (const o of owns) {
+                            const write = $2.const(o.own);
+                            $2.if(series.equal(o.key), ($3) => { $3.assign(result, write(value, key, path, gesture, carried)); });
+                        }
+                    }).else(($2) => {
+                        if (below === undefined)
+                            return;
+                        const write = $2.const(below);
+                        $2.assign(result, write(value, key, path, depth, series, gesture, carried));
+                    });
+                    return result;
+                });
+            });
+        },
+    };
+    return spec;
+}
+/** The build spec of a `section`. */
+function sectionSpec(cfg, members) {
+    const where = `Plan.series.section "${cfg.key}"`;
+    const memberSpecs = members.map((m, i) => nestedSpec(m, `${where}[${i}]`));
+    const summary = groupSummary(cfg.summary, cfg.summaryAggregate, where);
+    /** The header row — at `id`, nested under `parent`. */
+    const header = (id, parent) => planRow({
+        id, parent,
+        gutter: planGutter({
+            label: cfg.title,
+            ...(cfg.meta !== undefined ? { meta: some(cfg.meta) } : {}),
+            ...(cfg.value !== undefined ? { value: some(cfg.value) } : {}),
+        }),
+        kind: groupKind(summary),
+        collapsed: cfg.collapsed ?? false,
+        ...(cfg.status !== undefined ? { status: some(resolveTag(cfg.status, StatusValueType)) } : {}),
+    });
+    const emitters = new ByType();
+    const blockLists = new ByType();
+    const writerLists = new ByType();
+    return {
+        key: cfg.key,
+        title: cfg.title,
+        arm: "section",
+        nested: memberSpecs,
+        nests: false,
+        emitter(collection, at) {
+            return emitters.get(collection, () => {
+                const blocks = memberSpecs.map((m) => m.emitter(collection, `${at} › ${where}`));
+                return East.function([collection, PathType, IdOptType], PlanRowsCollectionType, ($, coll, prefix, parent) => {
+                    const id = $.let(East.value(variant("section", { series: cfg.key, path: prefix }), PlanRowIdType), PlanRowIdType);
+                    const under = $.let(East.value(some(id), IdOptType), IdOptType);
+                    const out = $.let(East.value([header(id, parent)], PlanRowsCollectionType), PlanRowsCollectionType);
+                    for (const block of blocks)
+                        $(out.append(block(coll, prefix, under)));
+                    return out;
+                });
+            });
+        },
+        // The header is a FIXED block — no entry produces it, so every window
+        // serves it alike and the canvas draws it once — and each member lays
+        // out as its own blocks under it, so the series in a section page on
+        // their own (#823).
+        blocks(collection, at) {
+            return blockLists.get(collection, () => {
+                const members = memberSpecs.map((m) => m.blocks(collection, `${at} › ${where}`));
+                return East.function([collection, PathType, IdOptType], PlanBlocksType, ($, coll, prefix, parent) => {
+                    const id = $.let(East.value(variant("section", { series: cfg.key, path: prefix }), PlanRowIdType), PlanRowIdType);
+                    const under = $.let(East.value(some(id), IdOptType), IdOptType);
+                    const head = $.let(East.value({ fixed: true, parent, rows: [header(id, parent)] }, PlanBlockType), PlanBlockType);
+                    const out = $.let(East.value([head], PlanBlocksType), PlanBlocksType);
+                    for (const member of members)
+                        $(out.append(member(coll, prefix, under)));
+                    return out;
+                });
+            });
+        },
+        // A section adds no path segment, so an entry's rows under it are its
+        // members' own: the first member that takes the gesture writes it
+        // (#880). The header is written by none.
+        writer(collection, at) {
+            return writerLists.get(collection, () => {
+                const writes = memberSpecs
+                    .map((m) => m.writer(collection, `${at} › ${where}`))
+                    .filter((w) => w !== undefined);
+                if (writes.length === 0)
+                    return undefined;
+                const { entry, key: kt } = shapeOf(collection, at);
+                return East.function([entry, kt, PathType, IntegerType, StringType, PlanGestureType, PlanCarriedType], OptionType(entry), ($, value, key, path, depth, series, gesture, carried) => {
+                    const result = $.let(none, OptionType(entry));
+                    for (const w of writes) {
+                        const write = $.const(w);
+                        $.if(result.hasTag("none"), ($2) => {
+                            $2.assign(result, write(value, key, path, depth, series, gesture, carried));
+                        });
+                    }
+                    return result;
+                });
+            });
+        },
+    };
+}
+/** The build spec of a `rows` series — hand-built rows, named and placed. */
+function rowsSpec(identity, rows) {
+    const emitters = new ByType();
+    const blockLists = new ByType();
+    const emitter = (collection) => emitters.get(collection, () => East.function([collection, PathType, IdOptType], PlanRowsCollectionType, (_$, _coll, prefix, parent) => REBASE_ROWS(rows, identity.key, prefix, parent)));
+    return {
+        key: identity.key,
+        title: identity.title,
+        arm: "rows",
+        nested: [],
+        nests: false,
+        emitter,
+        // A FIXED block: no entry produces hand-built rows, so every window
+        // serves them alike and the canvas draws them once (#823).
+        blocks(collection) {
+            return blockLists.get(collection, () => oneBlock(collection, emitter(collection), true));
+        },
+        // No entry produces them, so no gesture is written into one (#880).
+        writer() {
+            return undefined;
+        },
+    };
+}
+// ============================================================================
+// Keys — unique across the whole series tree
+// ============================================================================
+/**
+ * Refuse two series sharing a key anywhere in a series tree — a row's id is
+ * its series key and its path, so a repeated key would give two rows one id.
+ *
+ * @param specs - The series, in order
+ * @param where - Who is asking, for the message
+ * @throws {Error} Naming both series and where each sits
+ */
+function assertUniqueKeys(specs, where) {
+    const seen = new Map();
+    const walk = (list, trail) => {
+        list.forEach((spec, i) => {
+            const site = `${trail}[${i}] ${nameOf(spec)}`;
+            const prior = seen.get(spec.key);
+            if (prior !== undefined) {
+                throw new Error(`${where}: two series share the key "${spec.key}" — ${prior} and ${site}. A row's id is its ` +
+                    "series key and its path, so every series key must be unique across the whole series tree.");
+            }
+            seen.set(spec.key, site);
+            walk(spec.nested, `${site} ›`);
+        });
+    };
+    walk(specs, "series");
+}
+// ============================================================================
+// Series values — the East value, its spec beside it
+// ============================================================================
+/** Each spec's top-level writes, by collection type. */
+const topWrites = new WeakMap();
+/**
+ * A series' write at the top of a canvas over `collection` (#880) — what the
+ * series value carries as `write`: a gesture on a row of one entry, written
+ * into a DETACHED copy of the entry (a nested entry in place in its
+ * collection); `none` when the row is not the entry's, or no series in the
+ * tree takes the gesture on it. A move to another row carries its item
+ * between its two writes in `carried` (#825).
+ *
+ * @param spec - The series' build spec
+ * @param collection - The source's collection type
+ * @param where - Who is asking, for messages
+ * @returns `(entry, key, row, gesture, carried) → the entry written`
+ */
+function topWrite(spec, collection, where) {
+    let cache = topWrites.get(spec);
+    if (cache === undefined) {
+        cache = new ByType();
+        topWrites.set(spec, cache);
+    }
+    return cache.get(collection, () => {
+        const { entry: rowType, key: kt } = shapeOf(collection, where);
+        const writer = spec.writer(collection, where);
+        const seg = segmentOf(kt);
+        return East.function([rowType, kt, PlanRowIdType, PlanGestureType, PlanCarriedType], OptionType(rowType), ($, entry, key, row, gesture, carried) => {
+            const result = $.let(none, OptionType(rowType));
+            if (writer === undefined)
+                return result;
+            const write = $.const(writer);
+            $.match(row, {
+                entry: ($2, id) => {
+                    // A row's path starts with its entry's key.
+                    const mine = $2.let(id.path.size().greater(0n).and(() => id.path.get(0n).equal(seg(key))), BooleanType);
+                    $2.if(mine, ($3) => {
+                        const detached = $3.let(East.Blob.encodeBeast(entry, "v2").decodeBeast(rowType, "v2"), rowType);
+                        $3.assign(result, write(detached, key, id.path, 1n, id.series, gesture, carried));
+                    });
+                },
+            });
+            return result;
+        });
+    });
+}
+/** Pin a series value against the instantiated series type, recording its spec. */
+function seriesValue(rowType, keyType, spec, identity) {
+    assertUniqueKeys([spec], `Plan.series.${spec.arm} "${spec.key}"`);
+    const kt = keyType ?? StringType;
+    const source = DictType(kt, rowType);
+    const where = `Plan.series.${spec.arm} "${spec.key}"`;
+    const blocks = spec.blocks(source, where);
+    const derive = East.function([source], PlanBlocksType, ($, data) => {
+        const top = $.let(East.value([], PathType), PathType);
+        return blocks(data, top, East.value(none, IdOptType));
+    });
+    const value = East.value(variant(spec.arm, {
+        key: identity.key,
+        title: identity.title,
+        subtitle: identity.subtitle !== undefined ? some(identity.subtitle) : none,
+        icon: identity.icon !== undefined ? some(resolveIcon(identity.icon)) : none,
+        derive,
+        write: topWrite(spec, source, where),
+    }), PlanSeriesType(rowType, kt));
+    SPECS.set(value, spec);
+    return value;
+}
+/** Apply one series value to a source (the exhaustive-arm call) — its blocks. */
+export function applySeriesValue(s, data) {
+    const d = data;
     return s.match({
-        span: (_$, v) => v.derive(rows),
-        buckets: (_$, v) => v.derive(rows),
-        chart: (_$, v) => v.derive(rows),
-        heat: (_$, v) => v.derive(rows),
-        table: (_$, v) => v.derive(rows),
-        cards: (_$, v) => v.derive(rows),
-        events: (_$, v) => v.derive(rows),
-        group: (_$, v) => v.derive(rows),
-        rows: (_$, v) => v.rows,
+        span: (_$, v) => v.derive(d),
+        buckets: (_$, v) => v.derive(d),
+        chart: (_$, v) => v.derive(d),
+        heat: (_$, v) => v.derive(d),
+        table: (_$, v) => v.derive(d),
+        cards: (_$, v) => v.derive(d),
+        events: (_$, v) => v.derive(d),
+        group: (_$, v) => v.derive(d),
+        section: (_$, v) => v.derive(d),
+        views: (_$, v) => v.derive(d),
+        rows: (_$, v) => v.derive(d),
     });
 }
 /**
- * Apply the `series` input to the data expression — the inline arm's
- * application (Table's `rows_mapped`, per series). A TS array applies each
- * value in declared order; an East expression folds at evaluation, so
- * `$.const`-bound and computed series lists work identically.
+ * 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.
+ *
+ * @param series - The `series` input
+ * @param where - Who is asking, for the message
+ */
+export function checkSeries(series, where) {
+    if (!Array.isArray(series))
+        return;
+    const specs = series.map((s) => specOf(s)).filter((s) => s !== undefined);
+    assertUniqueKeys(specs, where);
+}
+/**
+ * Apply the `series` input to the source — the canvas's BLOCKS (#823): every
+ * series' blocks, in declared order.
  *
  * @remarks
- * Series are unioned, not concatenated: the canvas is one keyed collection,
- * and two series that emit the same key resolve last-wins instead of both
- * rows surviving to be walked twice.
+ * A TS array is built for the source's own collection type (so a source keyed
+ * by any type works with series whose accessors ignore the key); an East
+ * expression maps at evaluation, so a `$.const`-bound, picked or stored list
+ * works identically, its series built for their declared key type.
+ *
+ * The blocks stay apart so a paged canvas can page each data series on its
+ * own: applied to one window of a source, this is every block's share of that
+ * window, from one read of it.
+ *
+ * @param series - The `series` input
+ * @param data - The source collection (a whole `Dict`, or one paged window of it)
+ * @returns The blocks
  */
 export function applySeries(series, data) {
+    const collection = Expr.type(data);
     if (Array.isArray(series)) {
-        return series.reduce((acc, s) => acc.union(applySeriesValue(s, data), LAST_WINS), emptyRows());
+        const lists = series.map((s) => {
+            const spec = specOf(s);
+            return spec !== undefined
+                ? spec.blocks(collection, `Plan.series.${spec.arm} "${spec.key}"`)(data, East.value([], PathType), East.value(none, IdOptType))
+                : applySeriesValue(s, data);
+        });
+        return lists.reduce((acc, list) => acc.concat(list), East.value([], PlanBlocksType));
     }
-    const list = series;
-    return list.reduce(($, acc, s) => {
-        $(acc.unionInPlace(applySeriesValue(s, data), LAST_WINS));
-        return acc;
-    }, emptyRows());
+    return series.map((_$, s) => applySeriesValue(s, data)).flatMap((_$, list) => list);
+}
+/** One series value's `write` (the exhaustive-arm read). */
+function seriesValueWrite(s) {
+    return s.match({
+        span: (_$, v) => v.write,
+        buckets: (_$, v) => v.write,
+        chart: (_$, v) => v.write,
+        heat: (_$, v) => v.write,
+        table: (_$, v) => v.write,
+        cards: (_$, v) => v.write,
+        events: (_$, v) => v.write,
+        group: (_$, v) => v.write,
+        section: (_$, v) => v.write,
+        views: (_$, v) => v.write,
+        rows: (_$, v) => v.write,
+    });
+}
+/**
+ * The canvas's write (#880) — a gesture on a row of one entry, written into
+ * the entry by whichever series in the list made the row: `(entry, key, row,
+ * gesture, carried) → the entry written`, `none` when none takes it. A move
+ * to another row carries its item between its two writes in `carried`
+ * (#825).
+ *
+ * @remarks
+ * The `applySeries` rule: a TS array is built for the source's own collection
+ * type, and an East list (a `$.const` list, a pick's) writes through each
+ * series value's own `write`, built for its declared key type.
+ *
+ * @param series - The `series` input
+ * @param collection - The source's collection type (`Dict<K, R>`)
+ * @returns The write
+ */
+export function seriesWriteFn(series, collection) {
+    const { entry: rowType, key: kt } = shapeOf(collection, "Plan");
+    const inputs = [rowType, kt, PlanRowIdType, PlanGestureType, PlanCarriedType];
+    if (Array.isArray(series)) {
+        const built = series.map((s) => {
+            const spec = specOf(s);
+            return spec !== undefined ? topWrite(spec, collection, `Plan.series.${spec.arm} "${spec.key}"`) : undefined;
+        });
+        return East.function([...inputs], OptionType(rowType), ($, entry, key, row, gesture, carried) => {
+            const result = $.let(none, OptionType(rowType));
+            series.forEach((s, i) => {
+                const own = built[i];
+                const write = $.const(own !== undefined ? own : seriesValueWrite(s));
+                $.if(result.hasTag("none"), ($2) => { $2.assign(result, write(entry, key, row, gesture, carried)); });
+            });
+            return result;
+        });
+    }
+    return East.function([...inputs], OptionType(rowType), ($, entry, key, row, gesture, carried) => {
+        const result = $.let(none, OptionType(rowType));
+        $.for(series, ($2, s) => {
+            $2.if(result.hasTag("none"), ($3) => {
+                const write = $3.let(seriesValueWrite(s));
+                $3.assign(result, write(entry, key, row, gesture, carried));
+            });
+        });
+        return result;
+    });
 }
 // ============================================================================
 // Builders — Plan.series.*
 // ============================================================================
 /**
- * A data-driven span series — one span row per matched data row, grouped
- * to arbitrary depth with rollup parents (the span `.of` surface + `match`).
- *
- * @typeParam R - The data row type
- * @typeParam K - The axis kind the runs imply (inferred from the `runs` accessor; `never` when erased)
- * @param rowType - The data row type (every builder takes it first — the `Slice.config` shape)
- * @param config - The accessors + grouping ({@link PlanSpanSeriesConfig})
- * @returns A series value (`variant("span", { derive })`), branded with its kind
+ * 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
+ * runs' quantities unit by unit (#824).
+ *
+ * @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)
+ * @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
  */
 export function createSeriesSpan(rowType, config) {
     const cfg = config;
-    const derive = seriesScaffold(rowType, cfg.match, cfg.groupBy, () => groupParentFn(spanParentKind(cfg)), spanRowOf(cfg), cfg.keyPrefix);
-    return seriesValue(rowType, "span", { derive }, cfg);
+    const rollup = cfg.children !== undefined ? resolveTag(cfg.rollup ?? "union", PlanRollupType) : undefined;
+    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) } : {}),
+        }, 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,
+    });
+    return seriesValue(rowType, cfg.keyType, spec, cfg);
 }
 /**
- * A data-driven heat series — one heat row per matched data row, grouped
- * with per-bucket-aggregated parents (the heat `.of` surface + `match`).
- *
- * @typeParam R - The data row type
- * @typeParam K - The axis kind the cells imply (inferred from the `cells` accessor; `never` when erased)
- * @param rowType - The data row type
- * @param config - The accessors + grouping ({@link PlanHeatSeriesConfig})
- * @returns A series value (`variant("heat", { derive })`), branded with its kind
+ * A heat series — one per-bucket cell row per entry; a row with children and
+ * no cells of its own shows its children's per-bucket `aggregate`.
+ *
+ * @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
+ * @param rowType - The entry type
+ * @param config - The accessors and nesting ({@link PlanHeatSeriesConfig})
+ * @returns A series value, branded with its kind
  */
 export function createSeriesHeat(rowType, config) {
     const cfg = config;
-    const mode = cfg.aggregate ?? "mean";
-    const derive = seriesScaffold(rowType, cfg.match, cfg.groupBy, () => groupParentFn(heatParentKind(cfg), some(resolveTag(mode, PlanAggregateType).getTag())), heatRowOf(cfg), cfg.keyPrefix);
-    return seriesValue(rowType, "heat", { derive }, cfg);
+    const aggregate = cfg.children !== undefined
+        ? East.value(some(resolveTag(cfg.aggregate ?? "mean", PlanAggregateType)), OptionType(PlanAggregateType))
+        : East.value(none, OptionType(PlanAggregateType));
+    const spec = dataSpec(rowType, cfg, {
+        arm: "heat",
+        kind: (value, key) => heatKind({
+            cells: cfg.cells(value, key),
+            ...(cfg.scale !== undefined ? { scale: cfg.scale } : {}),
+        }, aggregate),
+    });
+    return seriesValue(rowType, cfg.keyType, spec, cfg);
 }
 /**
- * A data-driven table series — one table row per matched data row, grouped
- * with subtotal parents (the table `.of` surface + `match`).
- *
- * @typeParam R - The data row type
- * @typeParam K - The axis kind the cells imply (inferred from the `cells` / `series` accessors; `never` when erased)
- * @param rowType - The data row type
- * @param config - The accessors + grouping ({@link PlanTableSeriesOfConfig})
- * @returns A series value (`variant("table", { derive })`), branded with its kind
+ * A table series — one bucketed-numeral row per entry; a row with children and
+ * no values of its own shows per-position subtotals (`aggregate`, `format`).
+ *
+ * @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
+ * @param rowType - The entry type
+ * @param config - The accessors and nesting ({@link PlanTableSeriesOfConfig})
+ * @returns A series value, branded with its kind
  */
 export function createSeriesTable(rowType, config) {
     const cfg = config;
-    const mode = cfg.aggregate ?? "sum";
-    const derive = seriesScaffold(rowType, cfg.match, cfg.groupBy, () => groupParentFn(tableParentKind(cfg), some(resolveTag(mode, TableAggregateType).getTag())), tableRowOf(cfg), cfg.keyPrefix);
-    return seriesValue(rowType, "table", { derive }, cfg);
+    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`);
+    }
+    const aggregate = cfg.children !== undefined
+        ? East.value(some(resolveTag(cfg.aggregate ?? "sum", TableAggregateType)), OptionType(TableAggregateType))
+        : East.value(none, OptionType(TableAggregateType));
+    const spec = dataSpec(rowType, cfg, {
+        arm: "table",
+        kind: (value, key) => tableKind({
+            ...(cfg.cells !== undefined ? { cells: cfg.cells(value, key) } : {}),
+            ...(cfg.fold !== undefined ? { fold: cfg.fold } : {}),
+            ...(cfg.series !== undefined ? { series: cfg.series(value, key) } : {}),
+            ...(cfg.split !== undefined ? { split: cfg.split } : {}),
+            ...(cfg.format !== undefined ? { format: cfg.format } : {}),
+            ...(cfg.emphasis !== undefined ? { emphasis: cfg.emphasis } : {}),
+        }, aggregate),
+    });
+    return seriesValue(rowType, cfg.keyType, spec, cfg);
 }
 /**
- * A data-driven bucket series — one bucket row (the Planner surface) per
- * matched data row.
+ * A bucket series — one bucket row (the Planner surface) per entry.
  *
- * @typeParam R - The data row type
- * @typeParam K - The axis kind the tiles imply (inferred from the `events` / `markers` accessors; `never` when erased)
- * @param rowType - The data row type
+ * @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
+ * @param rowType - The entry type
  * @param config - The accessors ({@link PlanBucketsSeriesConfig})
- * @returns A series value (`variant("buckets", { derive })`), branded with its kind
+ * @returns A series value, branded with its kind
  */
 export function createSeriesBuckets(rowType, config) {
     const cfg = config;
-    const derive = seriesScaffold(rowType, cfg.match, undefined, undefined, (_$, r, k) => applyRowOverrides(createBuckets({
-        key: rowKey(cfg.keyPrefix, k, cfg.keySuffix),
-        label: cfg.label(r, k),
-        ...(cfg.id !== undefined ? { id: cfg.id } : {}),
-        ...(cfg.stacked !== undefined ? { stacked: cfg.stacked } : {}),
-        ...(cfg.lanes !== undefined ? { lanes: cfg.lanes(r, k) } : {}),
-        events: cfg.events(r, k),
-        ...(cfg.markers !== undefined ? { markers: cfg.markers(r, k) } : {}),
-    }), envelopeOverrides(cfg, r, k)), cfg.keyPrefix);
-    return seriesValue(rowType, "buckets", { derive }, cfg);
+    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) } : {}),
+        }),
+        edit: cfg.edit,
+    });
+    return seriesValue(rowType, cfg.keyType, spec, cfg);
 }
 /**
- * A data-driven cards series — one cards row (Roster chips) per matched
- * data row.
+ * A cards series — one cards row (Roster chips) per entry.
  *
- * @typeParam R - The data row type
- * @typeParam K - The axis kind the chips imply (inferred from the `chips` accessor; `never` when erased)
- * @param rowType - The data row type
+ * @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
+ * @param rowType - The entry type
  * @param config - The accessors ({@link PlanCardsSeriesConfig})
- * @returns A series value (`variant("cards", { derive })`), branded with its kind
+ * @returns A series value, branded with its kind
  */
 export function createSeriesCards(rowType, config) {
     const cfg = config;
-    const derive = seriesScaffold(rowType, cfg.match, undefined, undefined, (_$, r, k) => applyRowOverrides(createCards({
-        key: rowKey(cfg.keyPrefix, k, cfg.keySuffix),
-        label: cfg.label(r, k),
-        ...(cfg.id !== undefined ? { id: cfg.id } : {}),
-        ...(cfg.stacked !== undefined ? { stacked: cfg.stacked } : {}),
-        chips: cfg.chips(r, k),
-    }), envelopeOverrides(cfg, r, k)), cfg.keyPrefix);
-    return seriesValue(rowType, "cards", { derive }, cfg);
+    const spec = dataSpec(rowType, cfg, {
+        arm: "cards",
+        kind: (value, key) => cardsKind(cfg.chips(value, key)),
+        edit: cfg.edit,
+    });
+    return seriesValue(rowType, cfg.keyType, spec, cfg);
 }
 /**
- * A data-driven event series — one instant-mark row per matched data row.
+ * An events series — one instant-mark row per entry.
  *
- * @typeParam R - The data row type
- * @typeParam K - The axis kind the marks imply (inferred from the `marks` accessor; `never` when erased)
- * @param rowType - The data row type
+ * @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
+ * @param rowType - The entry type
  * @param config - The accessors ({@link PlanEventsSeriesConfig})
- * @returns A series value (`variant("events", { derive })`), branded with its kind
+ * @returns A series value, branded with its kind
  */
 export function createSeriesEvents(rowType, config) {
     const cfg = config;
-    const derive = seriesScaffold(rowType, cfg.match, undefined, undefined, (_$, r, k) => applyRowOverrides(createEvents({
-        key: rowKey(cfg.keyPrefix, k, cfg.keySuffix),
-        label: cfg.label(r, k),
-        ...(cfg.id !== undefined ? { id: cfg.id } : {}),
-        ...(cfg.stacked !== undefined ? { stacked: cfg.stacked } : {}),
-        marks: cfg.marks(r, k),
-    }), envelopeOverrides(cfg, r, k)), cfg.keyPrefix);
-    return seriesValue(rowType, "events", { derive }, cfg);
+    const spec = dataSpec(rowType, cfg, {
+        arm: "events",
+        kind: (value, key) => eventsKind(cfg.marks(value, key)),
+        edit: cfg.edit,
+    });
+    return seriesValue(rowType, cfg.keyType, spec, cfg);
 }
 /**
- * A data-driven chart series — one chart row per matched data row, layers
- * built from the row'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.
- *
- * @typeParam R - The data row type
- * @param rowType - The data row type
- * @param config - The accessors + shared axes ({@link PlanChartSeriesConfig})
- * @returns A series value (`variant("chart", { derive })`)
+ * 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.
+ *
+ * @typeParam R - The entry type
+ * @typeParam KT - The entries' key type
+ * @param rowType - The entry type
+ * @param config - The accessors and shared axes ({@link PlanChartSeriesConfig})
+ * @returns A series value
  */
 export function createSeriesChart(rowType, config) {
     const cfg = config;
-    const derive = seriesScaffold(rowType, cfg.match, undefined, undefined, (_$, r, k) => applyRowOverrides(createChart({
-        key: rowKey(cfg.keyPrefix, k, cfg.keySuffix),
-        label: cfg.label(r, k),
-        ...(cfg.id !== undefined ? { id: cfg.id } : {}),
-        ...(cfg.stacked !== undefined ? { stacked: cfg.stacked } : {}),
-        layers: cfg.layers(r, k),
-        ...(cfg.left !== undefined ? { left: cfg.left } : {}),
-        ...(cfg.right !== undefined ? { right: cfg.right } : {}),
-        ...(cfg.height !== undefined ? { height: cfg.height } : {}),
-        ...(cfg.expandedHeight !== undefined ? { expandedHeight: cfg.expandedHeight } : {}),
-        ...(cfg.expandable !== undefined ? { expandable: cfg.expandable } : {}),
+    const spec = dataSpec(rowType, cfg, {
+        arm: "chart",
+        kind: (value, key) => chartKind({
+            layers: cfg.layers(value, key),
+            ...(cfg.left !== undefined ? { left: cfg.left } : {}),
+            ...(cfg.right !== undefined ? { right: cfg.right } : {}),
+            ...(cfg.height !== undefined ? { height: cfg.height } : {}),
+            ...(cfg.expandedHeight !== undefined ? { expandedHeight: cfg.expandedHeight } : {}),
+            ...(cfg.expandable !== undefined ? { expandable: cfg.expandable } : {}),
+        }),
+        ...(cfg.pinned !== undefined
+            ? { pinned: (value, key) => East.value(cfg.pinned(value, key), BooleanType) }
+            : {}),
         ...(cfg.swatches !== undefined ? { swatches: cfg.swatches } : {}),
-    }), {
-        ...envelopeOverrides(cfg, r, k),
-        ...(cfg.pinned !== undefined ? { pinned: some(cfg.pinned(r, k)) } : {}),
-    }), cfg.keyPrefix);
-    return seriesValue(rowType, "chart", { derive }, cfg);
+    });
+    return seriesValue(rowType, cfg.keyType, spec, cfg);
 }
 /**
- * A group strip AROUND child series — the chrome is literal, the members
- * are the children applied to the same data and re-parented beneath it.
+ * A group series — one group strip PER ENTRY, its members the entry's
+ * children (#822). Collapsed, a strip rests as its summary heat strip —
+ * explicit `summary` cells, or the renderer-derived `summaryAggregate` — and
+ * its member count is derived.
  *
- * @typeParam R - The data row type
- * @param rowType - The data row type
  * @remarks
- * A group is the unit a person picks — "add Machines" — so the STATIC form's
- * series identity IS the strip's: `key` and `label` become the series' `key`
- * and `title`, and `meta` its subtitle. Nothing extra to write, and the two can
- * never disagree about what the section is called.
- *
- * The DISCOVERED (`by`) form cannot borrow that, because one series makes MANY
- * strips — it declares its own `key` / `title` ({@link PlanGroupSeriesByConfig}).
- *
- * @typeParam K - The union of the children's axis kinds (inferred; `never` when all are erased)
- * @param chrome - The group's literal chrome ({@link PlanGroupSeriesChrome})
- * @param children - The member series (applied in declared order; their rows sit in KEY order)
- * @returns A series value (`variant("group", { derive })`), branded with its children's kinds
+ * 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.
+ *
+ * @typeParam R - The entry type
+ * @typeParam K - The axis kind the summary cells imply
+ * @typeParam KT - The entries' key type
+ * @param rowType - The entry type
+ * @param config - The strip's accessors and its members ({@link PlanGroupSeriesConfig})
+ * @returns A series value, branded with its kind
+ * @throws {Error} When called with the removed `by` or static forms
  */
-export function createSeriesGroup(rowType, chromeOrBy, children) {
-    const applyChildren = (subset) => children.reduce((acc, c) => acc.union(applySeriesValue(c, subset), LAST_WINS), emptyRows());
-    if ("by" in chromeOrBy && typeof chromeOrBy.by === "function") {
-        // DISCOVERED strips — one group per distinct key, mirroring the
-        // grouped data form: the strip DECLARES its summary aggregation;
-        // children apply to each group's rows. The member count is NOT baked
-        // in here — a strip re-synthesized per paged window would carry that
-        // window's count — it is derived renderer-side like every other
-        // aggregate (#568).
-        const cfg = chromeOrBy;
-        const kind = East.value(variant("group", {
-            summary: none,
-            summaryAggregate: cfg.summaryAggregate !== undefined
-                ? some(resolveTag(cfg.summaryAggregate, PlanAggregateType))
-                : none,
-            collapsed: cfg.collapsed !== undefined ? some(cfg.collapsed) : none,
-        }), PlanRowKindType);
-        const parentFn = groupParentFn(kind);
-        const prefix = cfg.keyPrefix ?? "";
-        const rt = rowType;
-        const sourceType = DictType(StringType, rt);
-        const make = East.function([sourceType], PlanRowsCollectionType, ($, rows) => {
-            const matched = $.let(matchedRows(rows, rt, cfg.match), sourceType);
-            const levels = [{ by: reifyLevelKey(rt, cfg.by), parentFn }];
-            return groupRows(matched, levels, (subset, _prefix) => applyChildren(subset), prefix);
-        });
-        return seriesValue(rowType, "group", { derive: make }, cfg);
+export function createSeriesGroup(rowType, config) {
+    // The removed forms, named — a plain JS caller would otherwise meet an
+    // unhelpful "label is not a function".
+    if (arguments.length > 2 || "by" in config) {
+        throw new Error("Plan.series.group: the `by` and static `group(R, chrome, children)` forms are removed (#822) — a group " +
+            "strip is now one per ENTRY with its members nested in the entry (`children`); reshape a flat source " +
+            "with `groupToDicts` first, and use `Plan.series.section(R, { key, title }, [series…])` for a fixed block");
     }
-    // STATIC chrome — one literal strip around the children.
-    const chrome = chromeOrBy;
-    const make = East.function([DictType(StringType, rowType)], PlanRowsCollectionType, (_$, rows) => {
-        return createGroup({ ...chrome, rows: applyChildren(rows) });
-    });
-    // The strip's own identity, reused verbatim — see the remarks above.
-    return seriesValue(rowType, "group", { derive: make }, {
-        key: chrome.key,
-        title: chrome.label,
-        ...(chrome.meta !== undefined ? { subtitle: chrome.meta } : {}),
+    const cfg = config;
+    const where = `Plan.series.group "${cfg.key}"`;
+    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) {
+        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 spec = dataSpec(rowType, cfg, {
+        arm: "group",
+        kind: (value, key) => groupKind(declared ?? East.value(variant("cells", East.value(summary(value, key), PlanHeatCellsType)), PlanGroupSummaryType)),
     });
+    return seriesValue(rowType, cfg.keyType, spec, cfg);
+}
+/**
+ * A section — a fixed titled block over series: one header row, the member
+ * series' rows beneath it (#822). A section adds no path segment: its header's
+ * id is `section { series, path }` at its parent's path, and its members' rows
+ * keep their own.
+ *
+ * @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)
+ * @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
+ */
+export function createSeriesSection(rowType, config, members) {
+    const cfg = config;
+    const spec = sectionSpec(cfg, members);
+    return seriesValue(rowType, undefined, spec, cfg);
 }
 /**
- * Literal one-off chrome rows riding beside the data-driven series (a pinned
- * KPI chart, a hand-built section) — the finished rows carried directly, no
- * data dependence. They are placed by their own KEYS like every other row,
- * not by where this series sits in the list.
+ * A views series — each entry gets one row per member series, adjacent and in
+ * declared order; the entry's children follow its view rows, nested under the
+ * first of them (#822). How one entity is shown several ways: a machine's jobs,
+ * utilisation and tonnes as three rows side by side.
  *
  * @remarks
- * Unlike a group, a `rows` series has no single row to borrow identity from —
- * it may carry several — so it declares one. That is what lets a hand-built
- * section be switched off like anything else, instead of being the one thing on
- * the canvas a user cannot turn off.
+ * A member series' own `match` decides whether its row shows for an entry; a
+ * member may not declare `children` (the views own the entry's children). A
+ * 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.
  *
- * @typeParam R - The data row type (pins the series against its siblings)
- * @typeParam K - The union of the rows' axis kinds (inferred from the kind-factory results; `never` when erased)
- * @param rowType - The data row type
- * @param identity - How the library lists this section ({@link PlanSeriesIdentity})
- * @param rows - The literal rows (kind-factory results)
- * @returns A series value (`variant("rows", { rows })`), branded with the rows' kinds
+ * @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
+ * @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
  */
-export function createSeriesRows(rowType, identity, rows) {
-    return seriesValue(rowType, "rows", { rows: normalizeRows(rows) }, identity);
+export function createSeriesViews(rowType, config, members) {
+    const cfg = config;
+    const spec = viewsSpec(rowType, cfg, members);
+    return seriesValue(rowType, cfg.keyType, spec, cfg);
 }
 /**
- * Recover the row type of a data expression (the Table `Expr.type` idiom).
+ * Hand-built rows riding beside the data-driven series (a pinned KPI chart, a
+ * shutdown written out once) — the kind factories' streams, named by this
+ * series and placed as its block.
  *
  * @remarks
- * The paged arm no longer lives here: a Plan's rows channel is the shared
- * {@link RowSourceType} contract, and `contracts/source.ts`'s `buildRowSource`
- * wraps each window with this module's `applySeries` — the one place the
- * domain row type is erased to the canvas row type (#567).
+ * A hand-built row's id is this series' key and the factory `key`s that lead to
+ * it (`Plan.ref("works", "shutdown", "elec")`); keys must be unique among a
+ * row's siblings, or two rows share an id and the renderer draws the second as
+ * a diagnostic.
+ *
+ * @typeParam R - The entry type (pins the series against its siblings)
+ * @typeParam K - The union of the rows' axis kinds (inferred from the kind-factory results; `never` when erased)
+ * @param rowType - The entry type
+ * @param identity - How the library lists this block ({@link PlanSeriesIdentity})
+ * @param rows - The hand-built rows (kind-factory results)
+ * @returns A series value, branded with the rows' kinds
  */
-export function seriesRowType(data) {
-    return Expr.type(data).value;
+export function createSeriesRows(rowType, identity, rows) {
+    const spec = rowsSpec(identity, normalizeRows(rows));
+    return seriesValue(rowType, undefined, spec, identity);
 }
 //# sourceMappingURL=series.js.map