@elaraai/east-ui 1.0.86 → 1.0.87

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

@@ -1,1710 +0,0 @@
-/**
- * Copyright (c) 2025 Elara AI Pty Ltd
- * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
- */
-/**
- * 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, 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 { TableAggregateType } from "../table/types.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 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 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, k = StringType) => {
-    const arm = StructType({
-        key: StringType,
-        title: StringType,
-        subtitle: OptionType(StringType),
-        icon: OptionType(IconType),
-        derive: FunctionType([DictType(k, r)], PlanBlocksType),
-        write: FunctionType([r, k, PlanRowIdType, PlanGestureType, PlanCarriedType], OptionType(r)),
-    });
-    return VariantType({
-        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;
-/** 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),
-    };
-}
-/** The instant fields a kind's elements have (#825): two ends (a run, a chip) or one instant (a tile, a mark). */
-function editShapeOf(arm) {
-    return arm === "span" || arm === "cards" ? "span" : "point";
-}
-/** The item field types a move can write an instant into (#825). */
-const INSTANT_FIELD_TYPES = [DateTimeType, FloatType, IntegerType, StringType, PlanInstantType];
-/** 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 {
-        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 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 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");
-        }
-        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;
-}
-/** 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(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),
-    });
-}
-/**
- * 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
- * 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)) {
-        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));
-    }
-    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 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 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 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 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 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;
-    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 bucket series — one bucket row (the Planner surface) per entry.
- *
- * @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, branded with its kind
- */
-export function createSeriesBuckets(rowType, config) {
-    const cfg = config;
-    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 cards series — one cards row (Roster chips) per entry.
- *
- * @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, branded with its kind
- */
-export function createSeriesCards(rowType, config) {
-    const cfg = config;
-    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);
-}
-/**
- * An events series — one instant-mark row per entry.
- *
- * @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, branded with its kind
- */
-export function createSeriesEvents(rowType, config) {
-    const cfg = config;
-    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 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 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 } : {}),
-    });
-    return seriesValue(rowType, cfg.keyType, spec, cfg);
-}
-/**
- * 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.
- *
- * @remarks
- * Hierarchy comes from the data's nesting: to group a flat source, reshape it
- * first — inline, one East `groupToDicts` in the canvas function (the entries
- * are then `Dict<String, Row>` and a group's label is its key); a paged source
- * is grouped in the dataflow. The `by` form and the static
- * `group(R, chrome, children)` form are gone — see `Plan.series.section` for a
- * fixed titled block.
- *
- * @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, 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");
-    }
-    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);
-}
-/**
- * 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
- * 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 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 createSeriesViews(rowType, config, members) {
-    const cfg = config;
-    const spec = viewsSpec(rowType, cfg, members);
-    return seriesValue(rowType, cfg.keyType, spec, cfg);
-}
-/**
- * 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
- * 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 createSeriesRows(rowType, identity, rows) {
-    const spec = rowsSpec(identity, normalizeRows(rows));
-    return seriesValue(rowType, undefined, spec, identity);
-}
-//# sourceMappingURL=series.js.map