@elaraai/e3-ui 1.0.98 → 1.0.99

package/dist/test/plan/plan.examples.js

@@ -4,7 +4,7 @@ import { jsx as _jsx, jsxs as _jsxs } from "@elaraai/e3-ui/jsx-runtime";
  * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
  */
 /** @jsxImportSource @elaraai/e3-ui */
-import { ArrayType, BooleanType, DateTimeType, DictType, East, FloatType, IntegerType, NullType, OptionType, RecursiveType, StringType, StructType, VariantType, example, none, some, variant, } from "@elaraai/east";
+import { ArrayType, BooleanType, DateTimeType, DictType, East, FloatType, IntegerType, NullType, OptionType, RecursiveType, SortedMap, StringType, StructType, VariantType, compareFor, example, none, some, variant, } from "@elaraai/east";
 import { DragEventType, Editing, EventStateType, State, StatusValueType, Style, UIComponentType } from "@elaraai/east-ui";
 import { Badge, Box, Button, Chart, Configurator, Format, HStack, Progress, Reactive, SegmentGroup, Select, Slice, Sparkline, Text, VStack } from "@elaraai/east-ui";
 import { Data, Plan, Record } from "@elaraai/e3-ui";
@@ -69,306 +69,309 @@ export const generateTargetHorizon = East.function([IntegerType], ArrayType(Targ
  * flagship's Deliveries tab lists, the rail's `deliveries` source narrowing
  * them by hall and risk, its range the canvas's window (#1344).
  */
-export const planTargetDeliveries = e3.record("plan_target_deliveries", DictType(StringType, TargetHorizonRow), East.compile(East.function([IntegerType], DictType(StringType, TargetHorizonRow), ($, count) => {
-    const generate = $.const(generateTargetHorizon);
-    return generate(count).toDict((_$2, delivery) => delivery.key, (_$2, delivery) => delivery);
-}), [])(36n));
-// The deliveries through their indexes, each ending at the delivery's instant, so every narrowing — a hall, a
-// risk, both — holds the window too.
-export const planTargetDeliveriesByAt = e3.recordIndex("plan_target_deliveries_by_at", planTargetDeliveries, { on: ["at"] });
-export const planTargetDeliveriesByRiskAt = e3.recordIndex("plan_target_deliveries_by_risk_at", planTargetDeliveries, { on: ["risk", "at"] });
-export const planTargetDeliveriesByHallAt = e3.recordIndex("plan_target_deliveries_by_hall_at", planTargetDeliveries, { on: ["hall", "at"] });
-export const planTargetDeliveriesByHallRiskAt = e3.recordIndex("plan_target_deliveries_by_hall_risk_at", planTargetDeliveries, { on: ["hall", "risk", "at"] });
-/** A job on a press — the RAW record an ops dataset stores: its phase and
- *  optional job ticket, its window, optional sheets, lifecycle state and alert. */
+export const planTargetDeliveries = e3.record("plan_target_deliveries", DictType(StringType, TargetHorizonRow), {
+    initial: () => East.compile(East.function([IntegerType], DictType(StringType, TargetHorizonRow), ($, count) => {
+        const generate = $.const(generateTargetHorizon);
+        return generate(count).toDict((_$2, delivery) => delivery.key, (_$2, delivery) => delivery);
+    }), [])(36n),
+    indexes: (index) => ({
+        // The deliveries through their indexes, each ending at the delivery's instant, so every narrowing — a hall, a
+        // risk, both — holds the window too.
+        plan_target_deliveries_by_at: index.on(["at"]),
+        plan_target_deliveries_by_risk_at: index.on(["risk", "at"]),
+        plan_target_deliveries_by_hall_at: index.on(["hall", "at"]),
+        plan_target_deliveries_by_hall_risk_at: index.on(["hall", "risk", "at"]),
+    }),
+});
+/** A job on a press, under its id — the RAW record an ops dataset stores: its
+ *  phase and optional job ticket, its window, optional sheets, lifecycle state
+ *  and alert. */
 export const TargetJob = StructType({
-    key: StringType, phase: StringType, ticket: OptionType(StringType),
+    phase: StringType, ticket: OptionType(StringType),
     start: DateTimeType, end: DateTimeType,
     sheets: OptionType(FloatType), state: EventStateType,
     alert: OptionType(StatusValueType),
 });
-/** A crew's shift — its window, its hours and its lifecycle state. */
-export const TargetShift = StructType({
-    key: StringType, from: DateTimeType, to: DateTimeType,
-    hours: FloatType, state: EventStateType,
+/** A crew's shift, under its id — its window, its hours and its lifecycle state. */
+export const TargetShift = StructType({ from: DateTimeType, to: DateTimeType, hours: FloatType, state: EventStateType });
+/** A van drop, under its id — its week and its lifecycle state. */
+export const TargetAlloc = StructType({ at: DateTimeType, state: EventStateType });
+/** A decision on a run's transition, under its id — when, and whether it is applied. */
+export const TargetDecision = StructType({ at: DateTimeType, applied: BooleanType });
+/** Sheets moving in or out of a press, at their instant — the caption. */
+export const TargetPort = StructType({ label: StringType });
+/** A van's capacity alert, at its week — how bad, and what it says. */
+export const TargetAlert = StructType({ status: StatusValueType, message: StringType });
+/** A tile's look channels, as a bucket row's tile holds them. */
+const TileLook = Plan.Types.BucketEvent.fields;
+/** A tile stored as it draws, under its id: its week, its lane and every channel of its look. */
+export const TargetTile = StructType({
+    at: DateTimeType, lane: TileLook.lane, label: TileLook.label, icon: TileLook.icon, state: TileLook.state,
+    tone: TileLook.tone, color: TileLook.color, colorPalette: TileLook.colorPalette, stretch: TileLook.stretch,
+    content: TileLook.content, animation: TileLook.animation,
 });
-/** A van drop — its week and its lifecycle state. */
-export const TargetAlloc = StructType({ key: StringType, at: DateTimeType, state: EventStateType });
+/** A chip stored as it draws, under its id: its window, its text, its state and its icon. */
+export const TargetChip = StructType({ from: DateTimeType, to: DateTimeType, label: StringType, state: EventStateType, icon: Plan.Types.Chip.fields.icon });
+/** A mark on a stream, under its id: its instant, its kind, its icon and its caption. */
+export const TargetMark = StructType({ at: DateTimeType, kind: Plan.Types.EventMarkKind, icon: Plan.Types.EventMark.fields.icon, label: OptionType(StringType) });
 /**
  * The ops row — every series' rows in ONE keyed source, discriminated by the
- * kind variant (the natural ops-dataset shape). The arms carry RAW fields: a
- * measure is its weekly readings from its first week, and presence — a
- * status, an expand declaration (`detail`) — is per-row Option data the
- * accessors pass through. A row that stands in a hall names it (`hall`), and a
- * data step groups those rows into their hall's entry (the `hall` arm, which
- * the dataset itself never stores). The row is recursive, so the hierarchy is
- * the data's own (#822): a hall holds its members, and a contract the presses
- * it books (`presses`), to whatever depth the data has. A press names the span
- * series that draws it (`series`): a hall's presses, the proposal flavours,
- * the detail line, a contract rolled up by union or by status, a delivery.
+ * kind variant (the natural ops-dataset shape). The kind carries a row's own
+ * facts; presence — a status, an expand declaration (`detail`) — is per-row
+ * Option data the accessors pass through. A row's COLLECTIONS sit at its top,
+ * each a Dict a series reads by name (#1436): the things people drag keyed by
+ * their ids (`jobs`, `decisions`, `drops`, `tiles`, `shifts`, `chips`,
+ * `marks`), a value a week keyed by the week (`ontime`, `load`, `util`,
+ * `delivered`, `sheets`), and the rows nested under it. A row that stands in a
+ * hall names it (`hall`), and a data step groups those rows into their hall's
+ * entry (the `hall` arm, which the dataset itself never stores), its rows its
+ * `members`. The row is recursive, so the hierarchy is the data's own (#822):
+ * a hall holds its members, and a contract the presses it books (`presses`),
+ * to whatever depth the data has. A press names the span series that draws it
+ * (`series`): a hall's presses, the proposal flavours, the detail line, a
+ * contract rolled up by union or by status, a delivery.
  */
 export const TargetOpsRow = RecursiveType((self) => StructType({
     hall: OptionType(StringType),
     kind: VariantType({
-        kpi: StructType({ name: StringType, headline: StringType, pinned: BooleanType,
-            from: DateTimeType, weekly: ArrayType(FloatType), detail: OptionType(Plan.Types.Expand) }),
+        kpi: StructType({ name: StringType, headline: StringType, pinned: BooleanType, detail: OptionType(Plan.Types.Expand) }),
         press: StructType({ series: StringType, rate: OptionType(FloatType), sub: OptionType(StringType),
-            status: OptionType(StatusValueType), detail: OptionType(Plan.Types.Expand),
-            jobs: ArrayType(TargetJob),
-            decisions: ArrayType(Plan.Types.DecisionMark),
-            ports: ArrayType(Plan.Types.Port),
-            presses: DictType(StringType, self) }),
-        load: StructType({ name: StringType, sub: StringType, from: DateTimeType,
-            weekly: ArrayType(OptionType(FloatType)), detail: OptionType(Plan.Types.Expand) }),
+            status: OptionType(StatusValueType), detail: OptionType(Plan.Types.Expand) }),
+        load: StructType({ name: StringType, sub: StringType, detail: OptionType(Plan.Types.Expand) }),
         van: StructType({ name: StringType, region: StringType, sub: OptionType(StringType), detail: OptionType(Plan.Types.Expand),
-            lanes: ArrayType(Plan.Types.Lane), drops: ArrayType(TargetAlloc),
-            tiles: ArrayType(Plan.Types.BucketEvent), markers: ArrayType(Plan.Types.CellMarker) }),
+            lanes: ArrayType(Plan.Types.Lane) }),
         crew: StructType({ name: StringType, pool: BooleanType, sub: OptionType(StringType), value: OptionType(StringType),
-            detail: OptionType(Plan.Types.Expand), shifts: ArrayType(TargetShift), chips: ArrayType(Plan.Types.Chip) }),
-        stream: StructType({ name: StringType, cadence: OptionType(StringType), detail: OptionType(Plan.Types.Expand),
-            marks: ArrayType(Plan.Types.EventMark) }),
-        tally: StructType({ name: StringType, detail: OptionType(Plan.Types.Expand), cells: ArrayType(Plan.Types.TableCell) }),
-        finisher: StructType({ name: StringType, jobs: ArrayType(TargetJob), util: ArrayType(FloatType),
-            sheets: ArrayType(Plan.Types.TableCell) }),
-        hall: StructType({ members: DictType(StringType, self) }),
+            detail: OptionType(Plan.Types.Expand) }),
+        stream: StructType({ name: StringType, cadence: OptionType(StringType), detail: OptionType(Plan.Types.Expand) }),
+        tally: StructType({ name: StringType, detail: OptionType(Plan.Types.Expand) }),
+        finisher: StructType({ name: StringType }),
+        hall: NullType,
     }),
+    jobs: DictType(StringType, TargetJob),
+    decisions: DictType(StringType, TargetDecision),
+    ports: DictType(DateTimeType, TargetPort),
+    drops: DictType(StringType, TargetAlloc),
+    tiles: DictType(StringType, TargetTile),
+    alerts: DictType(DateTimeType, TargetAlert),
+    shifts: DictType(StringType, TargetShift),
+    chips: DictType(StringType, TargetChip),
+    marks: DictType(StringType, TargetMark),
+    ontime: DictType(DateTimeType, FloatType),
+    load: DictType(DateTimeType, OptionType(FloatType)),
+    util: DictType(DateTimeType, FloatType),
+    delivered: DictType(DateTimeType, OptionType(FloatType)),
+    sheets: DictType(DateTimeType, FloatType),
+    presses: DictType(StringType, self),
+    members: DictType(StringType, self),
 }));
+/** Every collection an ops row holds, empty: a row names the few it fills. */
+const TARGET_EMPTY = {
+    jobs: new Map(), decisions: new Map(), ports: new Map(), drops: new Map(), tiles: new Map(), alerts: new Map(),
+    shifts: new Map(), chips: new Map(), marks: new Map(), ontime: new Map(), load: new Map(), util: new Map(),
+    delivered: new Map(), sheets: new Map(), presses: new Map(), members: new Map(),
+};
+/** Values keyed by their instants — East keeps a Dict keyed by DateTime as a `SortedMap` in its order. */
+const atInstants = (entries) => new SortedMap(entries, compareFor(DateTimeType));
+/** A value a week from W27 (Monday 29 June 2026), each keyed by its week's instant. */
+const fromW27 = (weekly) => atInstants(weekly.map((v, i) => [new Date(Date.UTC(2026, 5, 29 + 7 * i)), v]));
 /**
  * The ONE ops source — every series' rows in one KEYED collection, RAW: no
- * display strings the accessors can derive, no built elements; the instants an
- * element record stores ride the axis's `time` arm. A key is its entry's
- * identity, never its place: a row's id is the series that made it and the
- * path of keys to it (`Plan.ref("presses", "Hall 1", "H1-P03")`), which is
- * what `links`, `popover`, `ui` and `onSelect` speak — the layout is the
- * series list. Weeks W27–W38.
+ * display strings the accessors can derive, no built elements. A key is its
+ * entry's identity, never its place: a row's id is the series that made it
+ * and the path of keys to it (`Plan.ref("presses", "Hall 1", "H1-P03")`),
+ * which is what `links`, `popover`, `ui` and `onSelect` speak — the layout is
+ * the series list. Weeks W27–W38.
  */
 export const planTargetOps = e3.input("plan_target_ops", DictType(StringType, TargetOpsRow), variant("value", new Map([
     // ── The pinned KPI ──
-    ["ontime", { hall: none, kind: variant("kpi", { name: "On-time", headline: "94.2%", pinned: true,
-                from: new Date("2026-06-29T00:00:00Z"), weekly: [96.1, 96.4, 96.8, 97.0, 96.2, 95.1, 93.4, 91.0, 88.9, 91.4, 93.8, 94.2],
-                detail: some({ height: some("150px"), axis: variant("keep", null) }) }) }],
-    // ── Deliveries — Van 1's drops are raw, its tiles derived; Van 2's are
-    // stored tile records in its AM/PM lanes. Van 1's Aug 24 cell holds two
-    // drops, more than its room: a `+n` holds the rest. ──
-    ["van1", { hall: none, kind: variant("van", { name: "Van 1", region: "local", sub: some("drops/wk"), detail: none, lanes: [],
-                drops: [
-                    { key: "a0", at: new Date("2026-06-29T00:00:00Z"), state: variant("confirmed", null) },
-                    { key: "a1", at: new Date("2026-07-06T00:00:00Z"), state: variant("confirmed", null) },
-                    { key: "a2", at: new Date("2026-07-13T00:00:00Z"), state: variant("proposed", variant("recommended", null)) },
-                    { key: "a3", at: new Date("2026-07-20T00:00:00Z"), state: variant("confirmed", null) },
-                    { key: "a4", at: new Date("2026-07-27T00:00:00Z"), state: variant("confirmed", null) },
-                    { key: "a5", at: new Date("2026-08-03T00:00:00Z"), state: variant("proposed", variant("recommended", null)) },
-                    { key: "a6", at: new Date("2026-08-10T00:00:00Z"), state: variant("proposed", variant("recommended", null)) },
-                    { key: "a7", at: new Date("2026-08-24T00:00:00Z"), state: variant("confirmed", null) },
-                    { key: "a8", at: new Date("2026-08-24T00:00:00Z"), state: variant("proposed", variant("recommended", null)) },
-                ],
-                tiles: [],
-                markers: [
-                    { at: variant("time", new Date("2026-07-13T00:00:00Z")), lane: none, status: variant("warning", null), message: "capacity 90%" },
-                    { at: variant("time", new Date("2026-08-24T00:00:00Z")), lane: none, status: variant("warning", null), message: "capacity breach — 2 drops" },
-                ] }) }],
-    ["van2", { hall: none, kind: variant("van", { name: "Van 2", region: "regional", sub: some("day · am/pm"),
+    ["ontime", { ...TARGET_EMPTY, hall: none, kind: variant("kpi", { name: "On-time", headline: "94.2%", pinned: true,
+                detail: some({ height: some("150px"), axis: variant("keep", null) }) }),
+            ontime: fromW27([96.1, 96.4, 96.8, 97.0, 96.2, 95.1, 93.4, 91.0, 88.9, 91.4, 93.8, 94.2]) }],
+    // ── Deliveries — Van 1's drops are raw, drawn as resting tiles; Van 2's
+    // are tiles stored as they draw, in its AM/PM lanes. Van 1's Aug 24 cell
+    // holds two drops, more than its room: a `+n` holds the rest. ──
+    ["van1", { ...TARGET_EMPTY, hall: none, kind: variant("van", { name: "Van 1", region: "local", sub: some("drops/wk"), detail: none, lanes: [] }),
+            drops: new Map([
+                ["a0", { at: new Date("2026-06-29T00:00:00Z"), state: variant("confirmed", null) }],
+                ["a1", { at: new Date("2026-07-06T00:00:00Z"), state: variant("confirmed", null) }],
+                ["a2", { at: new Date("2026-07-13T00:00:00Z"), state: variant("proposed", variant("recommended", null)) }],
+                ["a3", { at: new Date("2026-07-20T00:00:00Z"), state: variant("confirmed", null) }],
+                ["a4", { at: new Date("2026-07-27T00:00:00Z"), state: variant("confirmed", null) }],
+                ["a5", { at: new Date("2026-08-03T00:00:00Z"), state: variant("proposed", variant("recommended", null)) }],
+                ["a6", { at: new Date("2026-08-10T00:00:00Z"), state: variant("proposed", variant("recommended", null)) }],
+                ["a7", { at: new Date("2026-08-24T00:00:00Z"), state: variant("confirmed", null) }],
+                ["a8", { at: new Date("2026-08-24T00:00:00Z"), state: variant("proposed", variant("recommended", null)) }],
+            ]),
+            alerts: atInstants([
+                [new Date("2026-07-13T00:00:00Z"), { status: variant("warning", null), message: "capacity 90%" }],
+                [new Date("2026-08-24T00:00:00Z"), { status: variant("warning", null), message: "capacity breach — 2 drops" }],
+            ]) }],
+    ["van2", { ...TARGET_EMPTY, hall: none, kind: variant("van", { name: "Van 2", region: "regional", sub: some("day · am/pm"),
                 detail: some({ height: some("112px"), axis: variant("keep", null) }),
-                lanes: [{ key: "am", label: some("AM") }, { key: "pm", label: some("PM") }],
-                drops: [],
-                tiles: [
-                    { key: "m1", at: variant("time", new Date("2026-06-29T00:00:00Z")), lane: some("am"), label: none, icon: none, state: variant("confirmed", null),
-                        tone: none, color: none, colorPalette: none, stretch: none, content: none, animation: none },
-                    { key: "m2", at: variant("time", new Date("2026-06-29T00:00:00Z")), lane: some("pm"), label: none, icon: none, state: variant("confirmed", null),
-                        tone: some(variant("warning", null)), color: none, colorPalette: none, stretch: none, content: none, animation: none },
-                    { key: "m3", at: variant("time", new Date("2026-07-06T00:00:00Z")), lane: some("am"), label: none, icon: none, state: variant("proposed", variant("recommended", null)),
-                        tone: none, color: none, colorPalette: none, stretch: none, content: none, animation: some(variant("pulse", null)) },
-                    { key: "m4", at: variant("time", new Date("2026-07-13T00:00:00Z")), lane: none, label: some("MIXED"), icon: none, state: variant("confirmed", null),
+                lanes: [{ key: "am", label: some("AM") }, { key: "pm", label: some("PM") }] }),
+            tiles: new Map([
+                ["m1", { at: new Date("2026-06-29T00:00:00Z"), lane: some("am"), label: none, icon: none, state: variant("confirmed", null),
+                        tone: none, color: none, colorPalette: none, stretch: none, content: none, animation: none }],
+                ["m2", { at: new Date("2026-06-29T00:00:00Z"), lane: some("pm"), label: none, icon: none, state: variant("confirmed", null),
+                        tone: some(variant("warning", null)), color: none, colorPalette: none, stretch: none, content: none, animation: none }],
+                ["m3", { at: new Date("2026-07-06T00:00:00Z"), lane: some("am"), label: none, icon: none, state: variant("proposed", variant("recommended", null)),
+                        tone: none, color: none, colorPalette: none, stretch: none, content: none, animation: some(variant("pulse", null)) }],
+                ["m4", { at: new Date("2026-07-13T00:00:00Z"), lane: none, label: some("MIXED"), icon: none, state: variant("confirmed", null),
                         tone: none, color: none, colorPalette: none, stretch: some(variant("horizontal", null)),
-                        content: some({ horizontal: some(variant("center", null)), vertical: none }), animation: none },
-                    { key: "m5", at: variant("time", new Date("2026-07-20T00:00:00Z")), lane: some("pm"), label: none,
+                        content: some({ horizontal: some(variant("center", null)), vertical: none }), animation: none }],
+                ["m5", { at: new Date("2026-07-20T00:00:00Z"), lane: some("pm"), label: none,
                         icon: some({ prefix: "fas", name: "truck", label: none, style: none }),
                         state: variant("proposed", variant("recommended", null)),
-                        tone: none, color: none, colorPalette: none, stretch: none, content: none, animation: none },
-                    { key: "m6", at: variant("time", new Date("2026-07-27T00:00:00Z")), lane: some("am"), label: some("PROOF"), icon: none, state: variant("estimated", null),
-                        tone: none, color: none, colorPalette: none, stretch: none, content: none, animation: none },
-                    // The colour channels: `color` is a raw token override,
-                    // `colorPalette` recolours the whole lifecycle treatment.
-                    { key: "m7", at: variant("time", new Date("2026-08-03T00:00:00Z")), lane: some("am"), label: some("S-A"), icon: none, state: variant("confirmed", null),
-                        tone: none, color: some("teal.solid"), colorPalette: none, stretch: none, content: none, animation: none },
-                    { key: "m8", at: variant("time", new Date("2026-08-03T00:00:00Z")), lane: some("pm"), label: some("S-B"), icon: none, state: variant("confirmed", null),
-                        tone: none, color: none, colorPalette: some(variant("brand", null)), stretch: none, content: none, animation: none },
-                ],
-                markers: [{ at: variant("time", new Date("2026-07-13T00:00:00Z")), lane: none, status: variant("danger", null), message: "capacity breach" }] }) }],
+                        tone: none, color: none, colorPalette: none, stretch: none, content: none, animation: none }],
+                ["m6", { at: new Date("2026-07-27T00:00:00Z"), lane: some("am"), label: some("PROOF"), icon: none, state: variant("estimated", null),
+                        tone: none, color: none, colorPalette: none, stretch: none, content: none, animation: none }],
+                // The colour channels: `color` is a raw token override,
+                // `colorPalette` recolours the whole lifecycle treatment.
+                ["m7", { at: new Date("2026-08-03T00:00:00Z"), lane: some("am"), label: some("S-A"), icon: none, state: variant("confirmed", null),
+                        tone: none, color: some("teal.solid"), colorPalette: none, stretch: none, content: none, animation: none }],
+                ["m8", { at: new Date("2026-08-03T00:00:00Z"), lane: some("pm"), label: some("S-B"), icon: none, state: variant("confirmed", null),
+                        tone: none, color: none, colorPalette: some(variant("brand", null)), stretch: none, content: none, animation: none }],
+            ]),
+            alerts: atInstants([[new Date("2026-07-13T00:00:00Z"), { status: variant("danger", null), message: "capacity breach" }]]) }],
     // ── The halls' presses and loads: each names its hall, and the data
     // step groups them under it. ──
-    ["H1-P03", { hall: some("Hall 1"), kind: variant("press", { series: "presses", rate: some(12.0), sub: none,
-                status: some(variant("success", null)), detail: none,
-                jobs: [
-                    { key: "mr", phase: "MAKEREADY", ticket: none, start: new Date("2026-06-29T00:00:00Z"), end: new Date("2026-07-06T00:00:00Z"), sheets: none, state: variant("actual", null), alert: none },
-                    { key: "j4642", phase: "RUN", ticket: some("J-4642"), start: new Date("2026-07-06T00:00:00Z"), end: new Date("2026-07-27T00:00:00Z"), sheets: some(96.0), state: variant("in-progress", null), alert: none },
-                    { key: "wash", phase: "WASH-UP", ticket: none, start: new Date("2026-07-27T00:00:00Z"), end: new Date("2026-08-03T00:00:00Z"), sheets: none, state: variant("confirmed", null), alert: none },
-                    { key: "j4663", phase: "RUN", ticket: some("J-4663"), start: new Date("2026-08-03T00:00:00Z"), end: new Date("2026-08-24T00:00:00Z"), sheets: some(88.0), state: variant("proposed", variant("recommended", null)), alert: none },
-                ],
-                decisions: [{ key: "d1", at: variant("time", new Date("2026-08-03T00:00:00Z")), applied: false }],
-                ports: [{ at: variant("time", new Date("2026-07-27T00:00:00Z")), label: some("−24 k sheets") }],
-                presses: new Map() }) }],
-    ["H1-P04", { hall: some("Hall 1"), kind: variant("press", { series: "presses", rate: some(12.0), sub: none, status: none,
+    ["H1-P03", { ...TARGET_EMPTY, hall: some("Hall 1"), kind: variant("press", { series: "presses", rate: some(12.0), sub: none,
+                status: some(variant("success", null)), detail: none }),
+            jobs: new Map([
+                ["mr", { phase: "MAKEREADY", ticket: none, start: new Date("2026-06-29T00:00:00Z"), end: new Date("2026-07-06T00:00:00Z"), sheets: none, state: variant("actual", null), alert: none }],
+                ["j4642", { phase: "RUN", ticket: some("J-4642"), start: new Date("2026-07-06T00:00:00Z"), end: new Date("2026-07-27T00:00:00Z"), sheets: some(96.0), state: variant("in-progress", null), alert: none }],
+                ["wash", { phase: "WASH-UP", ticket: none, start: new Date("2026-07-27T00:00:00Z"), end: new Date("2026-08-03T00:00:00Z"), sheets: none, state: variant("confirmed", null), alert: none }],
+                ["j4663", { phase: "RUN", ticket: some("J-4663"), start: new Date("2026-08-03T00:00:00Z"), end: new Date("2026-08-24T00:00:00Z"), sheets: some(88.0), state: variant("proposed", variant("recommended", null)), alert: none }],
+            ]),
+            decisions: new Map([["d1", { at: new Date("2026-08-03T00:00:00Z"), applied: false }]]),
+            ports: atInstants([[new Date("2026-07-27T00:00:00Z"), { label: "−24 k sheets" }]]) }],
+    ["H1-P04", { ...TARGET_EMPTY, hall: some("Hall 1"), kind: variant("press", { series: "presses", rate: some(12.0), sub: none, status: none,
                 // The expand declaration — a stored plain-data record; presence is a
                 // per-row fact, and the ROOT's expandRender mounts the body.
-                detail: some({ height: some("152px"), axis: variant("keep", null) }),
-                jobs: [
-                    { key: "j4624", phase: "RUN", ticket: some("J-4624"), start: new Date("2026-06-29T00:00:00Z"), end: new Date("2026-07-20T00:00:00Z"), sheets: some(112.0), state: variant("actual", null), alert: none },
-                    { key: "plates", phase: "PLATES", ticket: none, start: new Date("2026-07-20T00:00:00Z"), end: new Date("2026-07-27T00:00:00Z"), sheets: none, state: variant("confirmed", null), alert: none },
-                    { key: "proof", phase: "PROOF", ticket: none, start: new Date("2026-07-27T00:00:00Z"), end: new Date("2026-08-10T00:00:00Z"), sheets: none, state: variant("confirmed", null), alert: none },
-                    { key: "j4693", phase: "RUN", ticket: some("J-4693"), start: new Date("2026-08-10T00:00:00Z"), end: new Date("2026-10-05T00:00:00Z"), sheets: some(104.0), state: variant("proposed", variant("recommended", null)), alert: none },
-                ],
-                decisions: [], ports: [], presses: new Map() }) }],
-    ["H1-P05", { hall: some("Hall 1"), kind: variant("press", { series: "presses", rate: some(8.0), sub: none,
-                status: some(variant("warning", null)), detail: none,
-                jobs: [
-                    { key: "j4591", phase: "PLATES", ticket: some("J-4591"), start: new Date("2026-06-29T00:00:00Z"), end: new Date("2026-07-27T00:00:00Z"), sheets: none, state: variant("actual", null), alert: some(variant("warning", null)) },
-                    { key: "wash", phase: "WASH-UP", ticket: none, start: new Date("2026-08-17T00:00:00Z"), end: new Date("2026-08-31T00:00:00Z"), sheets: none, state: variant("proposed", variant("recommended", null)), alert: none },
-                ],
-                decisions: [], ports: [], presses: new Map() }) }],
+                detail: some({ height: some("152px"), axis: variant("keep", null) }) }),
+            jobs: new Map([
+                ["j4624", { phase: "RUN", ticket: some("J-4624"), start: new Date("2026-06-29T00:00:00Z"), end: new Date("2026-07-20T00:00:00Z"), sheets: some(112.0), state: variant("actual", null), alert: none }],
+                ["plates", { phase: "PLATES", ticket: none, start: new Date("2026-07-20T00:00:00Z"), end: new Date("2026-07-27T00:00:00Z"), sheets: none, state: variant("confirmed", null), alert: none }],
+                ["proof", { phase: "PROOF", ticket: none, start: new Date("2026-07-27T00:00:00Z"), end: new Date("2026-08-10T00:00:00Z"), sheets: none, state: variant("confirmed", null), alert: none }],
+                ["j4693", { phase: "RUN", ticket: some("J-4693"), start: new Date("2026-08-10T00:00:00Z"), end: new Date("2026-10-05T00:00:00Z"), sheets: some(104.0), state: variant("proposed", variant("recommended", null)), alert: none }],
+            ]) }],
+    ["H1-P05", { ...TARGET_EMPTY, hall: some("Hall 1"), kind: variant("press", { series: "presses", rate: some(8.0), sub: none,
+                status: some(variant("warning", null)), detail: none }),
+            jobs: new Map([
+                ["j4591", { phase: "PLATES", ticket: some("J-4591"), start: new Date("2026-06-29T00:00:00Z"), end: new Date("2026-07-27T00:00:00Z"), sheets: none, state: variant("actual", null), alert: some(variant("warning", null)) }],
+                ["wash", { phase: "WASH-UP", ticket: none, start: new Date("2026-08-17T00:00:00Z"), end: new Date("2026-08-31T00:00:00Z"), sheets: none, state: variant("proposed", variant("recommended", null)), alert: none }],
+            ]) }],
     // A load reading nothing in the week of 17 August: its cell is no data.
-    ["h1-load", { hall: some("Hall 1"), kind: variant("load", { name: "H1 load", sub: "%/wk", from: new Date("2026-06-29T00:00:00Z"),
-                weekly: [some(46.0), some(58.0), some(66.0), some(72.0), some(84.0), some(90.0), some(96.0), none, some(92.0), some(88.0), some(81.0), some(77.0)],
-                detail: some({ height: some("132px"), axis: variant("keep", null) }) }) }],
-    ["H2-P11", { hall: some("Hall 2"), kind: variant("press", { series: "presses", rate: some(10.0), sub: none, status: none, detail: none,
-                jobs: [{ key: "j4723", phase: "RUN", ticket: some("J-4723"), start: new Date("2026-07-13T00:00:00Z"), end: new Date("2026-08-10T00:00:00Z"), sheets: some(92.0), state: variant("confirmed", null), alert: none }],
-                decisions: [], ports: [], presses: new Map() }) }],
-    ["H2-P12", { hall: some("Hall 2"), kind: variant("press", { series: "presses", rate: some(10.0), sub: none, status: none, detail: none,
-                jobs: [{ key: "j4594", phase: "RUN", ticket: some("J-4594"), start: new Date("2026-07-20T00:00:00Z"), end: new Date("2026-08-17T00:00:00Z"), sheets: some(64.0), state: variant("proposed", variant("recommended", null)), alert: none }],
-                decisions: [], ports: [], presses: new Map() }) }],
-    ["h2-load", { hall: some("Hall 2"), kind: variant("load", { name: "H2 load", sub: "%/wk", from: new Date("2026-06-29T00:00:00Z"),
-                weekly: [some(46.0), some(52.0), some(58.0), some(61.0), some(66.0), some(72.0), some(78.0), some(84.0), some(90.0), some(96.0), some(98.0), some(92.0)],
-                detail: none }) }],
-    ["H3-P21", { hall: some("Hall 3"), kind: variant("press", { series: "presses", rate: some(6.0), sub: none, status: none, detail: none,
-                jobs: [{ key: "j4903", phase: "RUN", ticket: some("J-4903"), start: new Date("2026-07-27T00:00:00Z"), end: new Date("2026-08-24T00:00:00Z"), sheets: some(48.0), state: variant("confirmed", null), alert: none }],
-                decisions: [], ports: [], presses: new Map() }) }],
-    ["H3-P22", { hall: some("Hall 3"), kind: variant("press", { series: "presses", rate: some(6.0), sub: none, status: none, detail: none,
-                jobs: [{ key: "j4906", phase: "RUN", ticket: some("J-4906"), start: new Date("2026-08-10T00:00:00Z"), end: new Date("2026-09-07T00:00:00Z"), sheets: some(54.0), state: variant("proposed", variant("recommended", null)), alert: none }],
-                decisions: [], ports: [], presses: new Map() }) }],
-    ["h3-load", { hall: some("Hall 3"), kind: variant("load", { name: "H3 load", sub: "%/wk", from: new Date("2026-06-29T00:00:00Z"),
-                weekly: [some(38.0), some(42.0), some(47.0), some(51.0), some(55.0), some(61.0), some(66.0), some(70.0), some(75.0), some(80.0), some(83.0), some(78.0)],
-                detail: none }) }],
+    ["h1-load", { ...TARGET_EMPTY, hall: some("Hall 1"), kind: variant("load", { name: "H1 load", sub: "%/wk",
+                detail: some({ height: some("132px"), axis: variant("keep", null) }) }),
+            load: fromW27([some(46.0), some(58.0), some(66.0), some(72.0), some(84.0), some(90.0), some(96.0), none, some(92.0), some(88.0), some(81.0), some(77.0)]) }],
+    ["H2-P11", { ...TARGET_EMPTY, hall: some("Hall 2"), kind: variant("press", { series: "presses", rate: some(10.0), sub: none, status: none, detail: none }),
+            jobs: new Map([["j4723", { phase: "RUN", ticket: some("J-4723"), start: new Date("2026-07-13T00:00:00Z"), end: new Date("2026-08-10T00:00:00Z"), sheets: some(92.0), state: variant("confirmed", null), alert: none }]]) }],
+    ["H2-P12", { ...TARGET_EMPTY, hall: some("Hall 2"), kind: variant("press", { series: "presses", rate: some(10.0), sub: none, status: none, detail: none }),
+            jobs: new Map([["j4594", { phase: "RUN", ticket: some("J-4594"), start: new Date("2026-07-20T00:00:00Z"), end: new Date("2026-08-17T00:00:00Z"), sheets: some(64.0), state: variant("proposed", variant("recommended", null)), alert: none }]]) }],
+    ["h2-load", { ...TARGET_EMPTY, hall: some("Hall 2"), kind: variant("load", { name: "H2 load", sub: "%/wk", detail: none }),
+            load: fromW27([some(46.0), some(52.0), some(58.0), some(61.0), some(66.0), some(72.0), some(78.0), some(84.0), some(90.0), some(96.0), some(98.0), some(92.0)]) }],
+    ["H3-P21", { ...TARGET_EMPTY, hall: some("Hall 3"), kind: variant("press", { series: "presses", rate: some(6.0), sub: none, status: none, detail: none }),
+            jobs: new Map([["j4903", { phase: "RUN", ticket: some("J-4903"), start: new Date("2026-07-27T00:00:00Z"), end: new Date("2026-08-24T00:00:00Z"), sheets: some(48.0), state: variant("confirmed", null), alert: none }]]) }],
+    ["H3-P22", { ...TARGET_EMPTY, hall: some("Hall 3"), kind: variant("press", { series: "presses", rate: some(6.0), sub: none, status: none, detail: none }),
+            jobs: new Map([["j4906", { phase: "RUN", ticket: some("J-4906"), start: new Date("2026-08-10T00:00:00Z"), end: new Date("2026-09-07T00:00:00Z"), sheets: some(54.0), state: variant("proposed", variant("recommended", null)), alert: none }]]) }],
+    ["h3-load", { ...TARGET_EMPTY, hall: some("Hall 3"), kind: variant("load", { name: "H3 load", sub: "%/wk", detail: none }),
+            load: fromW27([some(38.0), some(42.0), some(47.0), some(51.0), some(55.0), some(61.0), some(66.0), some(70.0), some(75.0), some(80.0), some(83.0), some(78.0)]) }],
     // ── The span grammar: proposal flavours (a forecast ghost, a proposed
     // cut, a declined run) ──
-    ["H1-P07", { hall: none, kind: variant("press", { series: "flavours", rate: some(8.0), sub: none, status: none, detail: none,
-                jobs: [
-                    { key: "run", phase: "RUN", ticket: some("J-4580"), start: new Date("2026-06-29T00:00:00Z"), end: new Date("2026-07-20T00:00:00Z"), sheets: some(64.0), state: variant("in-progress", null), alert: none },
-                    { key: "gho", phase: "FORECAST", ticket: none, start: new Date("2026-07-20T00:00:00Z"), end: new Date("2026-08-03T00:00:00Z"), sheets: none, state: variant("estimated", null), alert: none },
-                    { key: "rem", phase: "CUT", ticket: none, start: new Date("2026-08-10T00:00:00Z"), end: new Date("2026-08-24T00:00:00Z"), sheets: none, state: variant("proposed", variant("removed", null)), alert: none },
-                    { key: "rej", phase: "DECLINED", ticket: none, start: new Date("2026-08-31T00:00:00Z"), end: new Date("2026-09-14T00:00:00Z"), sheets: none, state: variant("rejected", null), alert: none },
-                ],
-                decisions: [], ports: [], presses: new Map() }) }],
+    ["H1-P07", { ...TARGET_EMPTY, hall: none, kind: variant("press", { series: "flavours", rate: some(8.0), sub: none, status: none, detail: none }),
+            jobs: new Map([
+                ["run", { phase: "RUN", ticket: some("J-4580"), start: new Date("2026-06-29T00:00:00Z"), end: new Date("2026-07-20T00:00:00Z"), sheets: some(64.0), state: variant("in-progress", null), alert: none }],
+                ["gho", { phase: "FORECAST", ticket: none, start: new Date("2026-07-20T00:00:00Z"), end: new Date("2026-08-03T00:00:00Z"), sheets: none, state: variant("estimated", null), alert: none }],
+                ["rem", { phase: "CUT", ticket: none, start: new Date("2026-08-10T00:00:00Z"), end: new Date("2026-08-24T00:00:00Z"), sheets: none, state: variant("proposed", variant("removed", null)), alert: none }],
+                ["rej", { phase: "DECLINED", ticket: none, start: new Date("2026-08-31T00:00:00Z"), end: new Date("2026-09-14T00:00:00Z"), sheets: none, state: variant("rejected", null), alert: none }],
+            ]) }],
     // …sheets, an applied decision and a port on a two-line gutter, its
     // expand declaration dimming the axis behind the render…
-    ["H1-P09", { hall: none, kind: variant("press", { series: "detail", rate: none, sub: some("12k sheets/h"), status: none,
-                detail: some({ height: some("152px"), axis: variant("dim", null) }),
-                jobs: [
-                    { key: "a", phase: "RUN", ticket: some("J-4624"), start: new Date("2026-06-29T00:00:00Z"), end: new Date("2026-07-27T00:00:00Z"), sheets: some(112.0), state: variant("actual", null), alert: none },
-                    { key: "b", phase: "RUN", ticket: some("J-4693"), start: new Date("2026-07-27T00:00:00Z"), end: new Date("2026-08-17T00:00:00Z"), sheets: some(104.0), state: variant("proposed", variant("recommended", null)), alert: none },
-                ],
-                decisions: [{ key: "d1", at: variant("time", new Date("2026-07-27T00:00:00Z")), applied: true }],
-                ports: [{ at: variant("time", new Date("2026-07-27T00:00:00Z")), label: some("−24 k sheets") }],
-                presses: new Map() }) }],
+    ["H1-P09", { ...TARGET_EMPTY, hall: none, kind: variant("press", { series: "detail", rate: none, sub: some("12k sheets/h"), status: none,
+                detail: some({ height: some("152px"), axis: variant("dim", null) }) }),
+            jobs: new Map([
+                ["a", { phase: "RUN", ticket: some("J-4624"), start: new Date("2026-06-29T00:00:00Z"), end: new Date("2026-07-27T00:00:00Z"), sheets: some(112.0), state: variant("actual", null), alert: none }],
+                ["b", { phase: "RUN", ticket: some("J-4693"), start: new Date("2026-07-27T00:00:00Z"), end: new Date("2026-08-17T00:00:00Z"), sheets: some(104.0), state: variant("proposed", variant("recommended", null)), alert: none }],
+            ]),
+            decisions: new Map([["d1", { at: new Date("2026-07-27T00:00:00Z"), applied: true }]]),
+            ports: atInstants([[new Date("2026-07-27T00:00:00Z"), { label: "−24 k sheets" }]]) }],
     // …a contract and the presses it books — its row rolls their runs up
     // into union bands (renderer-derived)…
-    ["Contract A", { hall: none, kind: variant("press", { series: "rollup", rate: none, sub: none, status: none, detail: none,
-                jobs: [], decisions: [], ports: [],
-                presses: new Map([
-                    ["H1-P03", { hall: none, kind: variant("press", { series: "rollup", rate: none, sub: none, status: none, detail: none,
-                                jobs: [
-                                    { key: "j4642", phase: "RUN", ticket: some("J-4642"), start: new Date("2026-07-06T00:00:00Z"), end: new Date("2026-07-27T00:00:00Z"), sheets: some(96.0), state: variant("actual", null), alert: none },
-                                    { key: "j4663", phase: "RUN", ticket: some("J-4663"), start: new Date("2026-08-03T00:00:00Z"), end: new Date("2026-08-24T00:00:00Z"), sheets: some(88.0), state: variant("proposed", variant("recommended", null)), alert: none },
-                                ],
-                                decisions: [], ports: [], presses: new Map() }) }],
-                    ["H2-P11", { hall: none, kind: variant("press", { series: "rollup", rate: none, sub: none, status: none, detail: none,
-                                jobs: [{ key: "j4723", phase: "RUN", ticket: some("J-4723"), start: new Date("2026-07-13T00:00:00Z"), end: new Date("2026-08-10T00:00:00Z"), sheets: some(92.0), state: variant("confirmed", null), alert: none }],
-                                decisions: [], ports: [], presses: new Map() }) }],
-                ]) }) }],
+    ["Contract A", { ...TARGET_EMPTY, hall: none, kind: variant("press", { series: "rollup", rate: none, sub: none, status: none, detail: none }),
+            presses: new Map([
+                ["H1-P03", { ...TARGET_EMPTY, hall: none, kind: variant("press", { series: "rollup", rate: none, sub: none, status: none, detail: none }),
+                        jobs: new Map([
+                            ["j4642", { phase: "RUN", ticket: some("J-4642"), start: new Date("2026-07-06T00:00:00Z"), end: new Date("2026-07-27T00:00:00Z"), sheets: some(96.0), state: variant("actual", null), alert: none }],
+                            ["j4663", { phase: "RUN", ticket: some("J-4663"), start: new Date("2026-08-03T00:00:00Z"), end: new Date("2026-08-24T00:00:00Z"), sheets: some(88.0), state: variant("proposed", variant("recommended", null)), alert: none }],
+                        ]) }],
+                ["H2-P11", { ...TARGET_EMPTY, hall: none, kind: variant("press", { series: "rollup", rate: none, sub: none, status: none, detail: none }),
+                        jobs: new Map([["j4723", { phase: "RUN", ticket: some("J-4723"), start: new Date("2026-07-13T00:00:00Z"), end: new Date("2026-08-10T00:00:00Z"), sheets: some(92.0), state: variant("confirmed", null), alert: none }]]) }],
+            ]) }],
     // …a linked delivery whose run starts BEYOND the window — in links focus
     // its landing is a slot on the plot's edge…
-    ["dlv", { hall: none, kind: variant("press", { series: "delivery", rate: none, sub: none, status: none, detail: none,
-                jobs: [{ key: "d1", phase: "DELIVER", ticket: none, start: new Date("2026-09-21T00:00:00Z"), end: new Date("2026-10-12T00:00:00Z"), sheets: some(91.0), state: variant("proposed", variant("recommended", null)), alert: none }],
-                decisions: [], ports: [], presses: new Map() }) }],
+    ["dlv", { ...TARGET_EMPTY, hall: none, kind: variant("press", { series: "delivery", rate: none, sub: none, status: none, detail: none }),
+            jobs: new Map([["d1", { phase: "DELIVER", ticket: none, start: new Date("2026-09-21T00:00:00Z"), end: new Date("2026-10-12T00:00:00Z"), sheets: some(91.0), state: variant("proposed", variant("recommended", null)), alert: none }]]) }],
     // …and a contract rolled up by status.
-    ["Contract B", { hall: none, kind: variant("press", { series: "contracts", rate: none, sub: none, status: none, detail: none,
-                jobs: [], decisions: [], ports: [],
-                presses: new Map([
-                    ["H2-P12", { hall: none, kind: variant("press", { series: "contracts", rate: none, sub: none, status: none, detail: none,
-                                jobs: [
-                                    { key: "r1", phase: "RUN", ticket: some("J-4594"), start: new Date("2026-07-06T00:00:00Z"), end: new Date("2026-08-03T00:00:00Z"), sheets: some(64.0), state: variant("actual", null), alert: none },
-                                    { key: "r2", phase: "RUN", ticket: some("J-4606"), start: new Date("2026-07-20T00:00:00Z"), end: new Date("2026-08-17T00:00:00Z"), sheets: some(40.0), state: variant("proposed", variant("recommended", null)), alert: none },
-                                ],
-                                decisions: [], ports: [], presses: new Map() }) }],
-                ]) }) }],
+    ["Contract B", { ...TARGET_EMPTY, hall: none, kind: variant("press", { series: "contracts", rate: none, sub: none, status: none, detail: none }),
+            presses: new Map([
+                ["H2-P12", { ...TARGET_EMPTY, hall: none, kind: variant("press", { series: "contracts", rate: none, sub: none, status: none, detail: none }),
+                        jobs: new Map([
+                            ["r1", { phase: "RUN", ticket: some("J-4594"), start: new Date("2026-07-06T00:00:00Z"), end: new Date("2026-08-03T00:00:00Z"), sheets: some(64.0), state: variant("actual", null), alert: none }],
+                            ["r2", { phase: "RUN", ticket: some("J-4606"), start: new Date("2026-07-20T00:00:00Z"), end: new Date("2026-08-17T00:00:00Z"), sheets: some(40.0), state: variant("proposed", variant("recommended", null)), alert: none }],
+                        ]) }],
+            ]) }],
     // ── A second heat series of the same kind, its own entry ──
-    ["quality", { hall: none, kind: variant("load", { name: "Quality index", sub: "%", from: new Date("2026-06-29T00:00:00Z"),
-                weekly: [some(94.0), some(95.0), some(96.0), some(95.0), some(97.0), some(96.0), some(93.0), some(92.0), some(94.0), some(95.0), some(96.0), some(97.0)],
-                detail: none }) }],
+    ["quality", { ...TARGET_EMPTY, hall: none, kind: variant("load", { name: "Quality index", sub: "%", detail: none }),
+            load: fromW27([some(94.0), some(95.0), some(96.0), some(95.0), some(97.0), some(96.0), some(93.0), some(92.0), some(94.0), some(95.0), some(96.0), some(97.0)]) }],
     // ── Crews — Crew A's chips derive from raw shifts; the relief pool's are
-    // chip records stored as they draw. ──
-    ["crewA", { hall: none, kind: variant("crew", { name: "Crew A", pool: false, sub: some("152h → 168h"), value: none,
-                detail: some({ height: some("120px"), axis: variant("keep", null) }),
-                shifts: [
-                    { key: "s1", from: new Date("2026-06-29T00:00:00Z"), to: new Date("2026-07-13T00:00:00Z"), hours: 80.0, state: variant("confirmed", null) },
-                    { key: "s2", from: new Date("2026-07-13T00:00:00Z"), to: new Date("2026-07-27T00:00:00Z"), hours: 56.0, state: variant("proposed", variant("removed", null)) },
-                    { key: "s3", from: new Date("2026-07-27T00:00:00Z"), to: new Date("2026-08-10T00:00:00Z"), hours: 64.0, state: variant("proposed", variant("recommended", null)) },
-                    { key: "s4", from: new Date("2026-08-17T00:00:00Z"), to: new Date("2026-08-24T00:00:00Z"), hours: 48.0, state: variant("estimated", null) },
-                    { key: "s5", from: new Date("2026-08-31T00:00:00Z"), to: new Date("2026-09-14T00:00:00Z"), hours: 56.0, state: variant("proposed", variant("recommended", null)) },
-                ],
-                chips: [] }) }],
-    ["crewB", { hall: none, kind: variant("crew", { name: "Crew B", pool: true, sub: none, value: some("128h"), detail: none, shifts: [],
-                chips: [
-                    { key: "b1", from: variant("time", new Date("2026-07-06T00:00:00Z")), to: variant("time", new Date("2026-07-27T00:00:00Z")), label: "96h", state: variant("confirmed", null),
-                        icon: some({ prefix: "fas", name: "user-group", label: none, style: none }) },
-                    { key: "b2", from: variant("time", new Date("2026-08-10T00:00:00Z")), to: variant("time", new Date("2026-08-31T00:00:00Z")), label: "+32h", state: variant("proposed", variant("recommended", null)), icon: none },
-                ] }) }],
+    // chips stored as they draw. ──
+    ["crewA", { ...TARGET_EMPTY, hall: none, kind: variant("crew", { name: "Crew A", pool: false, sub: some("152h → 168h"), value: none,
+                detail: some({ height: some("120px"), axis: variant("keep", null) }) }),
+            shifts: new Map([
+                ["s1", { from: new Date("2026-06-29T00:00:00Z"), to: new Date("2026-07-13T00:00:00Z"), hours: 80.0, state: variant("confirmed", null) }],
+                ["s2", { from: new Date("2026-07-13T00:00:00Z"), to: new Date("2026-07-27T00:00:00Z"), hours: 56.0, state: variant("proposed", variant("removed", null)) }],
+                ["s3", { from: new Date("2026-07-27T00:00:00Z"), to: new Date("2026-08-10T00:00:00Z"), hours: 64.0, state: variant("proposed", variant("recommended", null)) }],
+                ["s4", { from: new Date("2026-08-17T00:00:00Z"), to: new Date("2026-08-24T00:00:00Z"), hours: 48.0, state: variant("estimated", null) }],
+                ["s5", { from: new Date("2026-08-31T00:00:00Z"), to: new Date("2026-09-14T00:00:00Z"), hours: 56.0, state: variant("proposed", variant("recommended", null)) }],
+            ]) }],
+    ["crewB", { ...TARGET_EMPTY, hall: none, kind: variant("crew", { name: "Crew B", pool: true, sub: none, value: some("128h"), detail: none }),
+            chips: new Map([
+                ["b1", { from: new Date("2026-07-06T00:00:00Z"), to: new Date("2026-07-27T00:00:00Z"), label: "96h", state: variant("confirmed", null),
+                        icon: some({ prefix: "fas", name: "user-group", label: none, style: none }) }],
+                ["b2", { from: new Date("2026-08-10T00:00:00Z"), to: new Date("2026-08-31T00:00:00Z"), label: "+32h", state: variant("proposed", variant("recommended", null)), icon: none }],
+            ]) }],
     // ── Instant marks — every kind: milestones, decisions applied and
     // pending, an exception, a custom icon; the releases on a cadence. ──
-    ["milestones", { hall: none, kind: variant("stream", { name: "Milestones", cadence: none,
-                detail: some({ height: some("112px"), axis: variant("dim", null) }),
-                marks: [
-                    { key: "kick", at: variant("time", new Date("2026-07-06T00:00:00Z")), kind: variant("milestone", null), icon: none, label: some("KICKOFF") },
-                    { key: "d1", at: variant("time", new Date("2026-07-27T00:00:00Z")), kind: variant("decision", { applied: true }), icon: none, label: none },
-                    { key: "rel", at: variant("time", new Date("2026-08-10T00:00:00Z")), kind: variant("milestone", null),
-                        icon: some({ prefix: "fas", name: "rocket", label: none, style: none }), label: some("REL 2.4") },
-                    { key: "audit", at: variant("time", new Date("2026-08-24T00:00:00Z")), kind: variant("exception", null), icon: none, label: some("AUDIT") },
-                    { key: "d2", at: variant("time", new Date("2026-09-07T00:00:00Z")), kind: variant("decision", { applied: false }), icon: none, label: some("×3") },
-                ] }) }],
-    ["releases", { hall: none, kind: variant("stream", { name: "Releases", cadence: some("6-wk cadence"), detail: none,
-                marks: [
-                    { key: "r1", at: variant("time", new Date("2026-07-13T00:00:00Z")), kind: variant("milestone", null), icon: none, label: some("2.3") },
-                    { key: "r2", at: variant("time", new Date("2026-08-31T00:00:00Z")), kind: variant("milestone", null), icon: none, label: some("2.4") },
-                ] }) }],
+    ["milestones", { ...TARGET_EMPTY, hall: none, kind: variant("stream", { name: "Milestones", cadence: none,
+                detail: some({ height: some("112px"), axis: variant("dim", null) }) }),
+            marks: new Map([
+                ["kick", { at: new Date("2026-07-06T00:00:00Z"), kind: variant("milestone", null), icon: none, label: some("KICKOFF") }],
+                ["d1", { at: new Date("2026-07-27T00:00:00Z"), kind: variant("decision", { applied: true }), icon: none, label: none }],
+                ["rel", { at: new Date("2026-08-10T00:00:00Z"), kind: variant("milestone", null),
+                        icon: some({ prefix: "fas", name: "rocket", label: none, style: none }), label: some("REL 2.4") }],
+                ["audit", { at: new Date("2026-08-24T00:00:00Z"), kind: variant("exception", null), icon: none, label: some("AUDIT") }],
+                ["d2", { at: new Date("2026-09-07T00:00:00Z"), kind: variant("decision", { applied: false }), icon: none, label: some("×3") }],
+            ]) }],
+    ["releases", { ...TARGET_EMPTY, hall: none, kind: variant("stream", { name: "Releases", cadence: some("6-wk cadence"), detail: none }),
+            marks: new Map([
+                ["r1", { at: new Date("2026-07-13T00:00:00Z"), kind: variant("milestone", null), icon: none, label: some("2.3") }],
+                ["r2", { at: new Date("2026-08-31T00:00:00Z"), kind: variant("milestone", null), icon: none, label: some("2.4") }],
+            ]) }],
     // ── Delivered sheets, a week apiece — negatives, and a week with none;
     // its render draws its own canvas, so the shared lines leave its row. ──
-    ["delivered", { hall: none, kind: variant("tally", { name: "Delivered · k",
-                detail: some({ height: some("120px"), axis: variant("off", null) }),
-                cells: [
-                    { at: variant("time", new Date("2026-06-29T00:00:00Z")), value: some(128.0), text: none, tone: none },
-                    { at: variant("time", new Date("2026-07-06T00:00:00Z")), value: some(134.0), text: none, tone: none },
-                    { at: variant("time", new Date("2026-07-13T00:00:00Z")), value: some(119.0), text: none, tone: none },
-                    { at: variant("time", new Date("2026-07-20T00:00:00Z")), value: some(-96.0), text: none, tone: none },
-                    { at: variant("time", new Date("2026-07-27T00:00:00Z")), value: some(-88.0), text: none, tone: none },
-                    { at: variant("time", new Date("2026-08-03T00:00:00Z")), value: none, text: none, tone: none },
-                    { at: variant("time", new Date("2026-08-10T00:00:00Z")), value: some(151.0), text: none, tone: none },
-                    { at: variant("time", new Date("2026-08-17T00:00:00Z")), value: some(162.0), text: none, tone: none },
-                    { at: variant("time", new Date("2026-08-24T00:00:00Z")), value: some(144.0), text: none, tone: none },
-                ] }) }],
+    ["delivered", { ...TARGET_EMPTY, hall: none, kind: variant("tally", { name: "Delivered · k",
+                detail: some({ height: some("120px"), axis: variant("off", null) }) }),
+            delivered: fromW27([some(128.0), some(134.0), some(119.0), some(-96.0), some(-88.0), none, some(151.0), some(162.0), some(144.0)]) }],
     // ── The finishing line's machines — each one shown three ways ──
-    ["FN-1", { hall: none, kind: variant("finisher", { name: "Folder FN-1",
-                jobs: [{ key: "f1", phase: "FOLD", ticket: some("J-4642"), start: new Date("2026-07-27T00:00:00Z"), end: new Date("2026-08-10T00:00:00Z"), sheets: some(96.0), state: variant("confirmed", null), alert: none }],
-                util: [46.0, 52.0, 58.0, 66.0, 72.0, 78.0, 84.0, 80.0, 74.0, 68.0, 62.0, 58.0],
-                sheets: [
-                    { at: variant("time", new Date("2026-07-27T00:00:00Z")), value: some(48.0), text: none, tone: none },
-                    { at: variant("time", new Date("2026-08-03T00:00:00Z")), value: some(-8.0), text: none, tone: none },
-                ] }) }],
-    ["FN-2", { hall: none, kind: variant("finisher", { name: "Cutter FN-2",
-                jobs: [{ key: "f2", phase: "CUT", ticket: some("J-4663"), start: new Date("2026-08-24T00:00:00Z"), end: new Date("2026-09-07T00:00:00Z"), sheets: some(88.0), state: variant("proposed", variant("recommended", null)), alert: none }],
-                util: [30.0, 34.0, 38.0, 42.0, 46.0, 50.0, 54.0, 58.0, 62.0, 66.0, 70.0, 74.0],
-                sheets: [
-                    { at: variant("time", new Date("2026-08-24T00:00:00Z")), value: some(44.0), text: none, tone: none },
-                    { at: variant("time", new Date("2026-08-31T00:00:00Z")), value: some(44.0), text: none, tone: none },
-                ] }) }],
+    ["FN-1", { ...TARGET_EMPTY, hall: none, kind: variant("finisher", { name: "Folder FN-1" }),
+            jobs: new Map([["f1", { phase: "FOLD", ticket: some("J-4642"), start: new Date("2026-07-27T00:00:00Z"), end: new Date("2026-08-10T00:00:00Z"), sheets: some(96.0), state: variant("confirmed", null), alert: none }]]),
+            util: fromW27([46.0, 52.0, 58.0, 66.0, 72.0, 78.0, 84.0, 80.0, 74.0, 68.0, 62.0, 58.0]),
+            sheets: atInstants([[new Date("2026-07-27T00:00:00Z"), 48.0], [new Date("2026-08-03T00:00:00Z"), -8.0]]) }],
+    ["FN-2", { ...TARGET_EMPTY, hall: none, kind: variant("finisher", { name: "Cutter FN-2" }),
+            jobs: new Map([["f2", { phase: "CUT", ticket: some("J-4663"), start: new Date("2026-08-24T00:00:00Z"), end: new Date("2026-09-07T00:00:00Z"), sheets: some(88.0), state: variant("proposed", variant("recommended", null)), alert: none }]]),
+            util: fromW27([30.0, 34.0, 38.0, 42.0, 46.0, 50.0, 54.0, 58.0, 62.0, 66.0, 70.0, 74.0]),
+            sheets: atInstants([[new Date("2026-08-24T00:00:00Z"), 44.0], [new Date("2026-08-31T00:00:00Z"), 44.0]]) }],
 ])));
 /**
  * The data flagship: every row kind on one axis, from ONE raw ops source bound
@@ -423,7 +426,7 @@ export const planTargetState = example({
         "span", "run", "group", "groups", "strip", "section", "heat", "buckets", "cards", "chip", "events", "mark", "chart",
         "table", "views", "rows", "layers", "rollup", "union", "byStatus", "bands", "footer", "milestone",
         "decision", "exception", "pinned", "port", "hovercard", "popover", "hover",
-        "slice", "Slice.bindRecords", "source", "Data.bindPaged", "recordIndex", "presets", "brush", "horizon", "toolbar", "affordances", "summary", "#1344",
+        "slice", "Slice.bindRecords", "source", "Data.bindPaged", "indexes", "presets", "brush", "horizon", "toolbar", "affordances", "summary", "#1344",
         "expand", "expandRender", "expandGutter", "keep", "dim", "off", "collapse", "context strip",
         "resolver", "data-driven", "accessor", "raw", "target state", "flagship",
         "layout", "row id", "Plan.ref", "Plan.sectionRef", "links", "link", "focus", "quantity", "Plan.quantity", "unit",
@@ -464,66 +467,57 @@ export const planTargetState = example({
                 }));
                 // ── The data step ──────────────────────────────────────────
                 // Hierarchy is the DATA's (#822): one `groupToDicts` makes each
-                // hall an entry holding the rows that stand in it, keyed as the
-                // source keys them, and the halls join the rest of the source.
+                // hall an entry holding the rows that stand in it — its
+                // `members`, keyed as the source keys them — and the halls join
+                // the rest of the source.
                 const raw = $.let(ops.read());
                 const halls = $.let(raw.filter((_$2, r) => r.unwrap().hall.hasTag("some"))
                     .groupToDicts((_$2, r) => r.unwrap().hall.unwrap("some"), (_$2, _r, k) => k));
                 const rows = $.let(raw.filter((_$2, r) => r.unwrap().hall.hasTag("none"))
-                    .union(halls.map((_$2, members) => East.value({ hall: none, kind: variant("hall", { members }) }, TargetOpsRow))));
-                // ── What the accessors share ───────────────────────────────
-                const MeasureRow = StructType({ week: DateTimeType, pct: FloatType });
-                // A measure's weekly readings, from its first week, as a chart's
-                // points, and as heat cells printing their values — a week with
-                // none read the no-data cell.
-                const weeklyPoints = $.const(East.function([DateTimeType, ArrayType(FloatType)], ArrayType(MeasureRow), (_$2, from, weekly) => East.Array.generate(weekly.size(), MeasureRow, (_$3, i) => ({ week: from.addWeeks(i), pct: weekly.get(i) }))));
-                const weeklyCells = $.const(East.function([DateTimeType, ArrayType(OptionType(FloatType))], ArrayType(Plan.Types.HeatCell), (_$2, from, weekly) => East.Array.generate(weekly.size(), Plan.Types.HeatCell, ($3, i) => {
-                    const value = $3.let(weekly.get(i), OptionType(FloatType));
-                    const label = $3.let(none, OptionType(StringType));
-                    $3.match(value, { some: ($4, v) => { $4.assign(label, some(East.Float.printFixed(v, 0n))); } });
-                    return { at: Plan.at.time(from.addWeeks(i)), value, label };
-                })));
+                    .union(halls.map((_$2, members) => East.value({ ...TARGET_EMPTY, hall: none, kind: variant("hall", null), members }, TargetOpsRow))));
+                // ── What the reads share ───────────────────────────────────
+                // Each series reads its row's collections BY NAME (#1436): the
+                // jobs as runs (`Plan.items`, an id and the times named), a week's
+                // values as cells and points (`Plan.values`, each at its week).
+                // `draw` builds only how an element looks.
                 // A press's rate, a thousand sheets an hour, as its gutter value.
                 const rateText = $.const(East.function([OptionType(FloatType)], OptionType(StringType), (_$2, rate) => rate.match({
                     some: (_$3, k) => East.value(some(East.str `${East.Float.printFixed(k, 0n)}k/h`), OptionType(StringType)),
                     none: (_$3) => East.value(none, OptionType(StringType)),
                 })));
-                // Raw jobs → runs: ONE bound mapping function — the bar label and
-                // the quantity derive CLIENT-SIDE from the raw phase/ticket/sheets
-                // fields. A quantity is ONE value — the number, its unit and how it
-                // prints (#824) — so the bar's caption and a rollup's sum can never
-                // disagree. The run is written as a RECORD, so its instants are
-                // spelled with `Plan.at.time` — the `Plan.run` builder would wrap a
-                // DateTime field by itself.
+                // A job's look: the bar label and the quantity derive CLIENT-SIDE
+                // from its raw phase, ticket and sheets. A quantity is ONE value —
+                // the number, its unit and how it prints (#824) — so the bar's
+                // caption and a rollup's sum can never disagree.
                 const sheetsFormat = $.const(Format.Number({ maximumFractionDigits: 0n }));
-                const jobRuns = $.const(East.function([ArrayType(TargetJob)], ArrayType(Plan.Types.Run), (_$2, jobs) => jobs.map(($3, j) => {
-                    const noQuantity = $3.const(none, OptionType(Plan.Types.Quantity));
-                    const quantity = $3.let(j.sheets.match({
-                        some: (_$4, t) => East.value(some(Plan.quantity(t, { unit: "k sheets", format: sheetsFormat })), OptionType(Plan.Types.Quantity)),
-                        none: (_$4) => noQuantity,
-                    }), OptionType(Plan.Types.Quantity));
-                    const label = $3.let(j.ticket.match({
-                        some: (_$4, b) => East.str `${j.phase} · ${b}`,
-                        none: (_$4) => j.phase,
-                    }), StringType);
-                    const run = $3.let({
-                        key: j.key, start: Plan.at.time(j.start), end: Plan.at.time(j.end), label,
-                        quantity, state: j.state, status: j.alert,
-                        moved: none, icon: none,
-                    }, Plan.Types.Run);
-                    return run;
-                })));
-                // Raw shifts → chips: hours print as the chip label, an ADDED
+                const jobLook = (job) => ({
+                    label: job.ticket.match({ some: (_$2, t) => East.str `${job.phase} · ${t}`, none: () => job.phase }),
+                    state: job.state,
+                    quantity: job.sheets.match({
+                        some: (_$2, t) => East.value(some(Plan.quantity(t, { unit: "k sheets", format: sheetsFormat })), OptionType(Plan.Types.Quantity)),
+                        none: () => East.value(none, OptionType(Plan.Types.Quantity)),
+                    }),
+                    status: job.alert,
+                });
+                // A shift's look: its hours print as the chip label, an ADDED
                 // proposal wearing the `+` prefix — display derives from the
                 // lifecycle, down to the proposal's flavour (a `removed` shift is
                 // a proposal too, and `+` would read as its opposite).
-                const shiftChips = $.const(East.function([ArrayType(TargetShift)], ArrayType(Plan.Types.Chip), (_$2, shifts) => shifts.map(($3, s) => {
-                    const hrs = $3.let(East.Float.printFixed(s.hours, 0n), StringType);
-                    const label = $3.let(s.state.match({
-                        proposed: (_$4, p) => p.hasTag("removed").ifElse(() => East.str `${hrs}h`, () => East.str `+${hrs}h`),
-                    }, _$4 => East.str `${hrs}h`), StringType);
-                    return Plan.chip({ key: s.key, from: s.from, to: s.to, label, state: s.state });
-                })));
+                const shiftLook = (shift) => ({
+                    label: shift.state.match({
+                        proposed: (_$2, p) => p.hasTag("removed").ifElse(() => East.str `${East.Float.printFixed(shift.hours, 0n)}h`, () => East.str `+${East.Float.printFixed(shift.hours, 0n)}h`),
+                    }, () => East.str `${East.Float.printFixed(shift.hours, 0n)}h`),
+                    state: shift.state,
+                });
+                // A week's load: its value, printed as the cell's label — a week
+                // reading none is the no-data cell.
+                const loadLook = (pct) => ({
+                    value: pct,
+                    label: pct.match({
+                        some: (_$2, v) => East.value(some(East.Float.printFixed(v, 0n)), OptionType(StringType)),
+                        none: () => East.value(none, OptionType(StringType)),
+                    }),
+                });
                 const whole = $.const(Format.Number({ maximumFractionDigits: 0n }));
                 // ── The series — the list IS the layout (#822): one block per
                 // series, top to bottom, a section titling the blocks beneath
@@ -543,24 +537,24 @@ export const planTargetState = example({
                         expand: r => r.kind.unwrap("kpi").detail,
                         height: "spark", expandable: true,
                         left: { domain: [80, 110], tickValues: [80, 100] },
-                        layers: r => [
-                            Plan.layer(Chart.Line(weeklyPoints(r.kind.unwrap("kpi").from, r.kind.unwrap("kpi").weekly), { x: p => p.week, y: p => p.pct }), { breach: { below: 92 } }),
+                        layers: [
+                            Plan.line(Plan.values("ontime", (pct) => ({ y: pct })), { breach: { below: 92 } }),
                             Chart.refLine({ y: 100, label: "TARGET 100" }),
                         ],
                     }),
                     Plan.series.section(TargetOpsRow, { key: "vans-local", title: "Deliveries · Local", meta: "1 row", value: "9 drops", status: "warning" }, [
-                        // Raw drops → resting tiles, in the accessor.
+                        // Raw drops, each a resting tile at its week.
                         Plan.series.buckets(TargetOpsRow, {
                             key: "vans", title: "Vans",
                             match: r => r.kind.hasTag("van").and(() => r.kind.unwrap("van").region.equal("local")),
                             label: r => r.kind.unwrap("van").name,
                             sub: r => r.kind.unwrap("van").sub,
-                            events: r => r.kind.unwrap("van").drops.map((_$2, a) => Plan.event({ key: a.key, at: a.at, state: a.state })),
-                            markers: r => r.kind.unwrap("van").markers,
+                            events: Plan.items("drops", { at: "at" }, (drop) => ({ state: drop.state })),
+                            markers: Plan.values("alerts", (alert) => ({ message: alert.message, status: alert.status })),
                         }),
                     ]),
                     Plan.series.section(TargetOpsRow, { key: "vans-regional", title: "Deliveries · Regional", meta: "1 row" }, [
-                        // Stored tile records pass straight through, in their lanes.
+                        // Tiles stored as they draw pass straight through, in their lanes.
                         Plan.series.buckets(TargetOpsRow, {
                             key: "regional", title: "Regional",
                             match: r => r.kind.hasTag("van").and(() => r.kind.unwrap("van").region.equal("regional")),
@@ -568,13 +562,16 @@ export const planTargetState = example({
                             sub: r => r.kind.unwrap("van").sub,
                             expand: r => r.kind.unwrap("van").detail,
                             lanes: r => r.kind.unwrap("van").lanes,
-                            events: r => r.kind.unwrap("van").tiles,
-                            markers: r => r.kind.unwrap("van").markers,
+                            events: Plan.items("tiles", { at: "at" }, (tile) => ({
+                                state: tile.state, lane: tile.lane, label: tile.label, icon: tile.icon, tone: tile.tone, color: tile.color,
+                                colorPalette: tile.colorPalette, stretch: tile.stretch, content: tile.content, animation: tile.animation,
+                            })),
+                            markers: Plan.values("alerts", (alert) => ({ message: alert.message, status: alert.status })),
                         }),
                     ]),
                     // One strip PER HALL — the data step's entries — its members
-                    // stepped down into (`Plan.children`) and laid out like a
-                    // top-level list: the hall's presses, then its load. Hall 2
+                    // stepped down into by field (`Plan.children`) and laid out like
+                    // a top-level list: the hall's presses, then its load. Hall 2
                     // rests folded, as its DECLARED mean strip with its member
                     // count; the host's state folds Hall 3.
                     Plan.series.group(TargetOpsRow, {
@@ -583,7 +580,7 @@ export const planTargetState = example({
                         label: (_r, hall) => hall,
                         collapsed: (_r, hall) => hall.equal("Hall 2"),
                         summaryAggregate: "mean",
-                        children: Plan.children(r => r.kind.unwrap("hall").members, [
+                        children: Plan.children("members", [
                             Plan.series.span(TargetOpsRow, {
                                 key: "presses", title: "Presses",
                                 match: r => r.kind.hasTag("press"),
@@ -591,9 +588,9 @@ export const planTargetState = example({
                                 value: r => rateText(r.kind.unwrap("press").rate),
                                 status: r => r.kind.unwrap("press").status,
                                 expand: r => r.kind.unwrap("press").detail,
-                                runs: r => jobRuns(r.kind.unwrap("press").jobs),
-                                decisions: r => r.kind.unwrap("press").decisions,
-                                ports: r => r.kind.unwrap("press").ports,
+                                runs: Plan.items("jobs", { from: "start", to: "end" }, jobLook),
+                                decisions: Plan.items("decisions", { at: "at" }, (decision) => ({ applied: decision.applied })),
+                                ports: Plan.values("ports", (port) => ({ label: some(port.label) })),
                             }),
                             Plan.series.heat(TargetOpsRow, {
                                 key: "hall-load", title: "Hall load",
@@ -601,7 +598,7 @@ export const planTargetState = example({
                                 label: r => r.kind.unwrap("load").name,
                                 sub: r => some(r.kind.unwrap("load").sub),
                                 expand: r => r.kind.unwrap("load").detail,
-                                cells: r => Plan.heatCells(weeklyCells(r.kind.unwrap("load").from, r.kind.unwrap("load").weekly), { min: 0, max: 100, warnAt: 95 }),
+                                cells: Plan.heatCells(Plan.values("load", loadLook), { min: 0, max: 100, warnAt: 95 }),
                             }),
                         ]),
                     }),
@@ -612,7 +609,7 @@ export const planTargetState = example({
                         match: r => r.kind.hasTag("press").and(() => r.kind.unwrap("press").series.equal("flavours")),
                         label: (_r, k) => k, id: true,
                         value: r => rateText(r.kind.unwrap("press").rate),
-                        runs: r => jobRuns(r.kind.unwrap("press").jobs),
+                        runs: Plan.items("jobs", { from: "start", to: "end" }, jobLook),
                     }),
                     // …sheets, an applied decision and a port on a stacked two-line gutter…
                     Plan.series.span(TargetOpsRow, {
@@ -621,25 +618,26 @@ export const planTargetState = example({
                         label: (_r, k) => k, id: true, stacked: true,
                         sub: r => r.kind.unwrap("press").sub,
                         expand: r => r.kind.unwrap("press").detail,
-                        runs: r => jobRuns(r.kind.unwrap("press").jobs),
-                        decisions: r => r.kind.unwrap("press").decisions,
-                        ports: r => r.kind.unwrap("press").ports,
+                        runs: Plan.items("jobs", { from: "start", to: "end" }, jobLook),
+                        decisions: Plan.items("decisions", { at: "at" }, (decision) => ({ applied: decision.applied })),
+                        ports: Plan.values("ports", (port) => ({ label: some(port.label) })),
                     }),
-                    // …a contract's presses nest under it (`children` — more of
-                    // this series, to any depth), and its row rolls their runs up…
+                    // …a contract's presses nest under it (`children: "presses"` —
+                    // more of this series, to any depth), and its row rolls their
+                    // runs up…
                     Plan.series.span(TargetOpsRow, {
                         key: "rollup", title: "Rollup",
                         match: r => r.kind.hasTag("press").and(() => r.kind.unwrap("press").series.equal("rollup")),
                         label: (_r, k) => k, id: true,
-                        runs: r => jobRuns(r.kind.unwrap("press").jobs),
-                        children: r => r.kind.unwrap("press").presses, rollup: "union",
+                        runs: Plan.items("jobs", { from: "start", to: "end" }, jobLook),
+                        children: "presses", rollup: "union",
                     }),
                     // …a delivery whose run lands past the window…
                     Plan.series.span(TargetOpsRow, {
                         key: "delivery", title: "Deliveries",
                         match: r => r.kind.hasTag("press").and(() => r.kind.unwrap("press").series.equal("delivery")),
                         label: (_r, k) => k, id: true,
-                        runs: r => jobRuns(r.kind.unwrap("press").jobs),
+                        runs: Plan.items("jobs", { from: "start", to: "end" }, jobLook),
                     }),
                     // …and a contract rolled up by status, under a section.
                     Plan.series.section(TargetOpsRow, { key: "contract-block", title: "Contracts", meta: "1 row" }, [
@@ -647,8 +645,8 @@ export const planTargetState = example({
                             key: "contracts", title: "Contracts",
                             match: r => r.kind.hasTag("press").and(() => r.kind.unwrap("press").series.equal("contracts")),
                             label: (_r, k) => k, id: true,
-                            runs: r => jobRuns(r.kind.unwrap("press").jobs),
-                            children: r => r.kind.unwrap("press").presses, rollup: "byStatus",
+                            runs: Plan.items("jobs", { from: "start", to: "end" }, jobLook),
+                            children: "presses", rollup: "byStatus",
                         }),
                     ]),
                     // A section folded to start, resting as its strip — its
@@ -660,7 +658,7 @@ export const planTargetState = example({
                             match: r => r.kind.hasTag("load"),
                             label: r => r.kind.unwrap("load").name,
                             sub: r => some(r.kind.unwrap("load").sub),
-                            cells: r => Plan.heatCells(weeklyCells(r.kind.unwrap("load").from, r.kind.unwrap("load").weekly), { min: 0, max: 100 }),
+                            cells: Plan.heatCells(Plan.values("load", loadLook), { min: 0, max: 100 }),
                         }),
                     ]),
                     // Chips derived from raw shifts on a two-line gutter…
@@ -670,25 +668,25 @@ export const planTargetState = example({
                         label: r => r.kind.unwrap("crew").name, stacked: true,
                         sub: r => r.kind.unwrap("crew").sub,
                         expand: r => r.kind.unwrap("crew").detail,
-                        chips: r => shiftChips(r.kind.unwrap("crew").shifts),
+                        chips: Plan.items("shifts", { from: "from", to: "to" }, shiftLook),
                     }),
-                    // …and chip records stored as they draw, one with an icon.
+                    // …and chips stored as they draw, one with an icon.
                     Plan.series.section(TargetOpsRow, { key: "relief", title: "Relief pool", meta: "1 row" }, [
                         Plan.series.cards(TargetOpsRow, {
                             key: "pool", title: "Pool",
                             match: r => r.kind.hasTag("crew").and(() => r.kind.unwrap("crew").pool),
                             label: r => r.kind.unwrap("crew").name,
                             value: r => r.kind.unwrap("crew").value,
-                            chips: r => r.kind.unwrap("crew").chips,
+                            chips: Plan.items("chips", { from: "from", to: "to" }, (chip) => ({ label: chip.label, state: chip.state, icon: chip.icon })),
                         }),
                     ]),
                     Plan.series.events(TargetOpsRow, {
                         key: "milestones", title: "Milestones",
                         match: r => r.kind.hasTag("stream").and(() => r.kind.unwrap("stream").cadence.hasTag("none")),
                         label: r => r.kind.unwrap("stream").name, id: true,
-                        value: r => some(East.print(r.kind.unwrap("stream").marks.length())),
+                        value: r => some(East.print(r.marks.size())),
                         expand: r => r.kind.unwrap("stream").detail,
-                        marks: r => r.kind.unwrap("stream").marks,
+                        marks: Plan.items("marks", { at: "at" }, (mark) => ({ kind: mark.kind, icon: mark.icon, label: mark.label })),
                     }),
                     Plan.series.section(TargetOpsRow, { key: "programs", title: "Programs", meta: "1 row" }, [
                         Plan.series.events(TargetOpsRow, {
@@ -696,7 +694,7 @@ export const planTargetState = example({
                             match: r => r.kind.hasTag("stream").and(() => r.kind.unwrap("stream").cadence.hasTag("some")),
                             label: r => r.kind.unwrap("stream").name, id: true, stacked: true,
                             sub: r => r.kind.unwrap("stream").cadence,
-                            marks: r => r.kind.unwrap("stream").marks,
+                            marks: Plan.items("marks", { at: "at" }, (mark) => ({ kind: mark.kind, icon: mark.icon, label: mark.label })),
                         }),
                     ]),
                     Plan.series.table(TargetOpsRow, {
@@ -704,7 +702,7 @@ export const planTargetState = example({
                         match: r => r.kind.hasTag("tally"),
                         label: r => r.kind.unwrap("tally").name,
                         expand: r => r.kind.unwrap("tally").detail,
-                        cells: r => r.kind.unwrap("tally").cells,
+                        cells: Plan.tableCells(Plan.values("delivered", (sheets) => ({ value: sheets }))),
                         format: whole,
                     }),
                     // ONE machine, THREE views — a `views` series gives each
@@ -718,17 +716,17 @@ export const planTargetState = example({
                         Plan.series.span(TargetOpsRow, {
                             key: "finisher-jobs", title: "Finisher jobs",
                             label: r => r.kind.unwrap("finisher").name, id: true,
-                            runs: r => jobRuns(r.kind.unwrap("finisher").jobs),
+                            runs: Plan.items("jobs", { from: "start", to: "end" }, jobLook),
                         }),
                         Plan.series.chart(TargetOpsRow, {
                             key: "finisher-util", title: "Finisher · utilisation",
                             label: r => r.kind.unwrap("finisher").name, stacked: true, sub: _r => some("utilisation %"), height: "spark",
-                            layers: r => [Chart.Line(weeklyPoints(week(27n), r.kind.unwrap("finisher").util), { x: p => p.week, y: p => p.pct })],
+                            layers: [Plan.line(Plan.values("util", (pct) => ({ y: pct })))],
                         }),
                         Plan.series.table(TargetOpsRow, {
                             key: "finisher-sheets", title: "Finisher · sheets",
                             label: r => r.kind.unwrap("finisher").name, stacked: true, sub: _r => some("sheets · plan Δ"),
-                            cells: r => r.kind.unwrap("finisher").sheets,
+                            cells: Plan.tableCells(Plan.values("sheets", (sheets) => ({ value: some(sheets) }))),
                             format: whole,
                         }),
                     ]),
@@ -764,7 +762,7 @@ export const planTargetState = example({
                 // presets narrow the deliveries and keep the window.
                 const slice = $.let(Slice.bindRecords("ex.plan.target", {
                     deliveries: {
-                        source: Data.bindPaged(planTargetDeliveries, { indexes: [planTargetDeliveriesByAt, planTargetDeliveriesByRiskAt, planTargetDeliveriesByHallAt, planTargetDeliveriesByHallRiskAt] }),
+                        source: Data.bindPaged(planTargetDeliveries, { indexes: ["plan_target_deliveries_by_at", "plan_target_deliveries_by_risk_at", "plan_target_deliveries_by_hall_at", "plan_target_deliveries_by_hall_risk_at"] }),
                         label: "Deliveries", icon: { prefix: "fas", name: "truck" },
                         fields: {
                             hall: { label: "Hall", hints: ["Hall 1", "Hall 2"] },
@@ -938,37 +936,43 @@ export const planTargetState = example({
 // ============================================================================
 // planVariants — THE Plan configurator (#571): axis presets × style sweeps
 // ============================================================================
-/** A press job, its label already composed. */
+/** A press job, under its id — its label already composed. */
 export const VariantsJob = StructType({
-    key: StringType, label: StringType,
+    label: StringType,
     start: DateTimeType, end: DateTimeType, state: EventStateType,
 });
-/** One fortnightly reading of a measure. */
-export const VariantsMeasure = StructType({ week: DateTimeType, pct: FloatType });
-/** A van drop. */
-export const VariantsAlloc = StructType({ key: StringType, at: DateTimeType, state: EventStateType });
-/** A crew shift, its label already composed. */
+/** A van drop, under its id. */
+export const VariantsAlloc = StructType({ at: DateTimeType, state: EventStateType });
+/** A crew shift, under its id — its label already composed. */
 export const VariantsShift = StructType({
-    key: StringType, from: DateTimeType, to: DateTimeType, label: StringType, state: EventStateType,
+    from: DateTimeType, to: DateTimeType, label: StringType, state: EventStateType,
 });
-/** One table reading — a bucket's instant and its value, if it has one. */
-export const VariantsReading = StructType({ at: DateTimeType, value: OptionType(FloatType) });
+/** A milestone or an exception on a stream, under its id. */
+export const VariantsMark = StructType({ at: DateTimeType, kind: Plan.Types.EventMarkKind, label: OptionType(StringType) });
 /**
  * ONE flat source: `series` names the series that claims the row, and every
- * channel a row's kind does not read stays empty.
+ * collection a row's kind does not read stays empty. The collections are Dicts
+ * each series reads by name (#1436): the things people drag by their ids, and
+ * a reading a fortnight keyed by its week.
  */
 export const VariantsOpsRow = StructType({
     series: StringType, label: StringType,
     sub: OptionType(StringType),
-    jobs: ArrayType(VariantsJob),
-    points: ArrayType(VariantsMeasure),
-    cells: ArrayType(Plan.Types.HeatCell),
-    allocs: ArrayType(VariantsAlloc),
-    act: ArrayType(VariantsReading),
-    plan: ArrayType(VariantsReading),
-    shifts: ArrayType(VariantsShift),
-    marks: ArrayType(Plan.Types.EventMark),
+    jobs: DictType(StringType, VariantsJob),
+    util: DictType(DateTimeType, FloatType),
+    load: DictType(DateTimeType, FloatType),
+    allocs: DictType(StringType, VariantsAlloc),
+    act: DictType(DateTimeType, FloatType),
+    plan: DictType(DateTimeType, FloatType),
+    shifts: DictType(StringType, VariantsShift),
+    marks: DictType(StringType, VariantsMark),
 });
+/** Every collection a row holds, empty: a row names the few it fills. */
+const VARIANTS_EMPTY = {
+    jobs: new Map(), util: new Map(), load: new Map(), allocs: new Map(), act: new Map(), plan: new Map(), shifts: new Map(), marks: new Map(),
+};
+/** A reading a fortnight from W27 (Monday 29 June 2026), each keyed by its week's instant. */
+const fortnightsFromW27 = (readings) => atInstants(readings.map((v, i) => [new Date(Date.UTC(2026, 5, 29 + 14 * i)), v]));
 /**
  * Every row kind on purpose: the density sweep re-rhythms them all at once —
  * compact tightens the shared row and the bars in it, while a two-line gutter
@@ -976,71 +980,42 @@ export const VariantsOpsRow = StructType({
  * sweep re-widths every label. The readings are fortnightly from W27.
  */
 export const planVariantsOps = e3.input("plan_variants_ops", DictType(StringType, VariantsOpsRow), variant("value", new Map([
-    ["util", { series: "util", label: "Util %", sub: none, jobs: [],
-            points: [
-                { week: new Date("2026-06-29T00:00:00Z"), pct: 46.0 }, { week: new Date("2026-07-13T00:00:00Z"), pct: 58.0 },
-                { week: new Date("2026-07-27T00:00:00Z"), pct: 66.0 }, { week: new Date("2026-08-10T00:00:00Z"), pct: 72.0 },
-                { week: new Date("2026-08-24T00:00:00Z"), pct: 84.0 }, { week: new Date("2026-09-07T00:00:00Z"), pct: 96.0 },
-            ],
-            cells: [], allocs: [], act: [], plan: [], shifts: [], marks: [] }],
-    ["p03", { series: "press", label: "H1-P03", sub: some("12k sheets/h"),
-            jobs: [
-                { key: "j4642", label: "RUN · J-4642", start: new Date("2026-07-06T00:00:00Z"), end: new Date("2026-07-27T00:00:00Z"), state: variant("in-progress", null) },
-                { key: "j4663", label: "RUN · J-4663", start: new Date("2026-08-03T00:00:00Z"), end: new Date("2026-08-24T00:00:00Z"), state: variant("proposed", variant("recommended", null)) },
-            ],
-            points: [], cells: [], allocs: [], act: [], plan: [], shifts: [], marks: [] }],
-    ["p04", { series: "press", label: "H1-P04", sub: none,
-            jobs: [
-                { key: "j4624", label: "RUN · J-4624", start: new Date("2026-06-29T00:00:00Z"), end: new Date("2026-07-20T00:00:00Z"), state: variant("actual", null) },
-            ],
-            points: [], cells: [], allocs: [], act: [], plan: [], shifts: [], marks: [] }],
-    ["load", { series: "load", label: "H2 load", sub: some("%/wk"), jobs: [], points: [],
-            cells: [
-                { at: variant("time", new Date("2026-06-29T00:00:00Z")), value: some(46.0), label: some("46") },
-                { at: variant("time", new Date("2026-07-13T00:00:00Z")), value: some(58.0), label: some("58") },
-                { at: variant("time", new Date("2026-07-27T00:00:00Z")), value: some(66.0), label: some("66") },
-                { at: variant("time", new Date("2026-08-10T00:00:00Z")), value: some(72.0), label: some("72") },
-                { at: variant("time", new Date("2026-08-24T00:00:00Z")), value: some(84.0), label: some("84") },
-                { at: variant("time", new Date("2026-09-07T00:00:00Z")), value: some(96.0), label: some("96") },
-            ],
-            allocs: [], act: [], plan: [], shifts: [], marks: [] }],
-    ["van1", { series: "van", label: "Van 1", sub: none, jobs: [], points: [], cells: [],
-            allocs: [
-                { key: "a1", at: new Date("2026-07-06T00:00:00Z"), state: variant("confirmed", null) },
-                { key: "a2", at: new Date("2026-07-27T00:00:00Z"), state: variant("proposed", variant("recommended", null)) },
-                { key: "a3", at: new Date("2026-08-10T00:00:00Z"), state: variant("confirmed", null) },
-            ],
-            act: [], plan: [], shifts: [], marks: [] }],
+    ["util", { ...VARIANTS_EMPTY, series: "util", label: "Util %", sub: none, util: fortnightsFromW27([46.0, 58.0, 66.0, 72.0, 84.0, 96.0]) }],
+    ["p03", { ...VARIANTS_EMPTY, series: "press", label: "H1-P03", sub: some("12k sheets/h"),
+            jobs: new Map([
+                ["j4642", { label: "RUN · J-4642", start: new Date("2026-07-06T00:00:00Z"), end: new Date("2026-07-27T00:00:00Z"), state: variant("in-progress", null) }],
+                ["j4663", { label: "RUN · J-4663", start: new Date("2026-08-03T00:00:00Z"), end: new Date("2026-08-24T00:00:00Z"), state: variant("proposed", variant("recommended", null)) }],
+            ]) }],
+    ["p04", { ...VARIANTS_EMPTY, series: "press", label: "H1-P04", sub: none,
+            jobs: new Map([
+                ["j4624", { label: "RUN · J-4624", start: new Date("2026-06-29T00:00:00Z"), end: new Date("2026-07-20T00:00:00Z"), state: variant("actual", null) }],
+            ]) }],
+    ["load", { ...VARIANTS_EMPTY, series: "load", label: "H2 load", sub: some("%/wk"), load: fortnightsFromW27([46.0, 58.0, 66.0, 72.0, 84.0, 96.0]) }],
+    ["van1", { ...VARIANTS_EMPTY, series: "van", label: "Van 1", sub: none,
+            allocs: new Map([
+                ["a1", { at: new Date("2026-07-06T00:00:00Z"), state: variant("confirmed", null) }],
+                ["a2", { at: new Date("2026-07-27T00:00:00Z"), state: variant("proposed", variant("recommended", null)) }],
+                ["a3", { at: new Date("2026-08-10T00:00:00Z"), state: variant("confirmed", null) }],
+            ]) }],
     // Delivered sheets and their signed Δ against plan — the table row's
     // two positions.
-    ["desp", { series: "desp", label: "Delivered · k", sub: none, jobs: [], points: [], cells: [], allocs: [],
-            act: [
-                { at: new Date("2026-06-29T00:00:00Z"), value: some(69.0) }, { at: new Date("2026-07-13T00:00:00Z"), value: some(87.0) },
-                { at: new Date("2026-07-27T00:00:00Z"), value: some(99.0) }, { at: new Date("2026-08-10T00:00:00Z"), value: some(108.0) },
-                { at: new Date("2026-08-24T00:00:00Z"), value: some(126.0) }, { at: new Date("2026-09-07T00:00:00Z"), value: some(144.0) },
-            ],
-            plan: [
-                { at: new Date("2026-06-29T00:00:00Z"), value: some(-24.0) }, { at: new Date("2026-07-13T00:00:00Z"), value: some(-12.0) },
-                { at: new Date("2026-07-27T00:00:00Z"), value: some(-4.0) }, { at: new Date("2026-08-10T00:00:00Z"), value: some(2.0) },
-                { at: new Date("2026-08-24T00:00:00Z"), value: some(14.0) }, { at: new Date("2026-09-07T00:00:00Z"), value: some(26.0) },
-            ],
-            shifts: [], marks: [] }],
-    ["crewA", { series: "crew", label: "Crew A", sub: none, jobs: [], points: [], cells: [], allocs: [], act: [], plan: [],
-            shifts: [
-                { key: "s1", from: new Date("2026-06-29T00:00:00Z"), to: new Date("2026-07-13T00:00:00Z"), label: "80h", state: variant("confirmed", null) },
-                { key: "s2", from: new Date("2026-07-27T00:00:00Z"), to: new Date("2026-08-10T00:00:00Z"), label: "+64h", state: variant("proposed", variant("recommended", null)) },
-            ],
-            marks: [] }],
-    ["ms", { series: "ms", label: "Milestones", sub: none, jobs: [], points: [], cells: [], allocs: [], act: [], plan: [], shifts: [],
-            marks: [
-                { key: "k", at: variant("time", new Date("2026-07-13T00:00:00Z")), kind: variant("milestone", null), icon: none, label: some("KICKOFF") },
-                { key: "a", at: variant("time", new Date("2026-08-17T00:00:00Z")), kind: variant("exception", null), icon: none, label: some("AUDIT") },
-            ] }],
-    ["p11", { series: "gpress", label: "H3-P11", sub: none,
-            jobs: [
-                { key: "j4903", label: "RUN · J-4903", start: new Date("2026-07-13T00:00:00Z"), end: new Date("2026-08-10T00:00:00Z"), state: variant("confirmed", null) },
-            ],
-            points: [], cells: [], allocs: [], act: [], plan: [], shifts: [], marks: [] }],
+    ["desp", { ...VARIANTS_EMPTY, series: "desp", label: "Delivered · k", sub: none,
+            act: fortnightsFromW27([69.0, 87.0, 99.0, 108.0, 126.0, 144.0]),
+            plan: fortnightsFromW27([-24.0, -12.0, -4.0, 2.0, 14.0, 26.0]) }],
+    ["crewA", { ...VARIANTS_EMPTY, series: "crew", label: "Crew A", sub: none,
+            shifts: new Map([
+                ["s1", { from: new Date("2026-06-29T00:00:00Z"), to: new Date("2026-07-13T00:00:00Z"), label: "80h", state: variant("confirmed", null) }],
+                ["s2", { from: new Date("2026-07-27T00:00:00Z"), to: new Date("2026-08-10T00:00:00Z"), label: "+64h", state: variant("proposed", variant("recommended", null)) }],
+            ]) }],
+    ["ms", { ...VARIANTS_EMPTY, series: "ms", label: "Milestones", sub: none,
+            marks: new Map([
+                ["k", { at: new Date("2026-07-13T00:00:00Z"), kind: variant("milestone", null), label: some("KICKOFF") }],
+                ["a", { at: new Date("2026-08-17T00:00:00Z"), kind: variant("exception", null), label: some("AUDIT") }],
+            ]) }],
+    ["p11", { ...VARIANTS_EMPTY, series: "gpress", label: "H3-P11", sub: none,
+            jobs: new Map([
+                ["j4903", { label: "RUN · J-4903", start: new Date("2026-07-13T00:00:00Z"), end: new Date("2026-08-10T00:00:00Z"), state: variant("confirmed", null) }],
+            ]) }],
 ])));
 /**
  * THE Plan configurator — the slot-2 variant-space surface the retired Gantt /
@@ -1085,39 +1060,37 @@ export const planVariants = example({
                     key: "util", title: "Utilisation",
                     match: r => r.series.equal("util"),
                     label: r => r.label, id: true, height: "spark", expandable: true,
-                    layers: r => [Chart.Line(r.points, { x: p => p.week, y: p => p.pct })],
+                    layers: [Plan.line(Plan.values("util", (pct) => ({ y: pct })))],
                 }),
                 Plan.series.span(VariantsOpsRow, {
                     key: "press", title: "Press jobs",
                     match: r => r.series.equal("press"),
                     label: r => r.label, id: true, sub: r => r.sub,
-                    runs: r => r.jobs.map((_$, j) => Plan.run({
-                        key: j.key, start: j.start, end: j.end, label: j.label, state: j.state,
-                    })),
+                    runs: Plan.items("jobs", { from: "start", to: "end" }, (job) => ({ label: job.label, state: job.state })),
                 }),
                 Plan.series.heat(VariantsOpsRow, {
                     key: "load", title: "Hall load",
                     match: r => r.series.equal("load"),
                     label: r => r.label, sub: r => r.sub,
-                    cells: r => Plan.heatCells(r.cells, { min: 0, max: 100 }),
+                    cells: Plan.heatCells(Plan.values("load", (pct) => ({ value: pct, label: some(East.Float.printFixed(pct, 0n)) })), { min: 0, max: 100 }),
                 }),
                 Plan.series.buckets(VariantsOpsRow, {
                     key: "van", title: "Van drops",
                     match: r => r.series.equal("van"),
                     label: r => r.label,
-                    events: r => r.allocs.map((_$, a) => Plan.event({ key: a.key, at: a.at, state: a.state })),
+                    events: Plan.items("allocs", { at: "at" }, (alloc) => ({ state: alloc.state })),
                 }),
                 // The positions STACKED — the row grows a line per position.
                 Plan.series.table(VariantsOpsRow, {
                     key: "desp", title: "Deliveries",
                     match: r => r.series.equal("desp"),
                     label: r => r.label, split: "vertical",
-                    series: r => [
-                        Plan.tableSeries({ strong: true, cells: Plan.tableCells(r.act) }),
+                    series: [
+                        Plan.tableSeries({ strong: true, cells: Plan.tableCells(Plan.values("act", (n) => ({ value: n }))) }),
                         Plan.tableSeries({
                             tone: "muted",
                             format: Format.Number({ maximumFractionDigits: 0n, signDisplay: "always" }),
-                            cells: Plan.tableCells(r.plan),
+                            cells: Plan.tableCells(Plan.values("plan", (n) => ({ value: n }))),
                         }),
                     ],
                     format: Format.Number({ maximumFractionDigits: 0n }),
@@ -1126,13 +1099,13 @@ export const planVariants = example({
                     key: "crew", title: "Crew shifts",
                     match: r => r.series.equal("crew"),
                     label: r => r.label,
-                    chips: r => r.shifts.map((_$, s) => Plan.chip({ key: s.key, from: s.from, to: s.to, label: s.label, state: s.state })),
+                    chips: Plan.items("shifts", { from: "from", to: "to" }, (shift) => ({ label: shift.label, state: shift.state })),
                 }),
                 Plan.series.events(VariantsOpsRow, {
                     key: "ms", title: "Milestones",
                     match: r => r.series.equal("ms"),
                     label: r => r.label, id: true,
-                    marks: r => r.marks,
+                    marks: Plan.items("marks", { at: "at" }, (mark) => ({ kind: mark.kind, label: mark.label })),
                 }),
                 // A section header, so the group-toggle callback has something to fire on.
                 Plan.series.section(VariantsOpsRow, { key: "hall3", title: "Hall 3", meta: "1 row" }, [
@@ -1140,9 +1113,7 @@ export const planVariants = example({
                         key: "gpress", title: "Grouped jobs",
                         match: r => r.series.equal("gpress"),
                         label: r => r.label, id: true,
-                        runs: r => r.jobs.map((_$, j) => Plan.run({
-                            key: j.key, start: j.start, end: j.end, label: j.label, state: j.state,
-                        })),
+                        runs: Plan.items("jobs", { from: "start", to: "end" }, (job) => ({ label: job.label, state: job.state })),
                     }),
                 ]),
             ], ArrayType(Plan.Types.Series(VariantsOpsRow)));
@@ -1217,36 +1188,51 @@ export const planVariants = example({
 // planMeasures — measure rows over weekly readings, folded to the resolution
 // the slice states (#824)
 // ============================================================================
+/** A band's bounds at a week: its low and high edges. */
+export const MeasureBand = StructType({ lo: FloatType, hi: FloatType });
 /**
- * A measure — its readings a week apiece from W23, the window's first week, a
- * week with none read nothing: `readings` the series its row draws, and
- * `second` the set a row pairs with it — the stacked columns' second hall, the
- * dual chart's on-time line, a table's Δ against plan; `lo` / `hi` a band's
- * bounds; and a finishing line's capacity, stored in the element vocabulary
- * itself (`segments`). A measure nests (`children`): a hall holds its presses,
- * a top its contracts, a contract its orders — the hierarchy is the data's own
- * (#822), to whatever depth it has.
+ * A measure — its values a week apiece, each keyed by its week's instant (#1436),
+ * each collection read by name: `readings`, the cells a heat or table row
+ * draws, a week reading none its no-data cell; `second`, the position a table
+ * row pairs with them (a Δ against plan, what left); `points`, the readings a
+ * chart row draws, and `paired`, the series it pairs with them (the stacked
+ * columns' second hall, the dual chart's on-time line); `band`, a band's
+ * bounds; and `segments`, a finishing line's capacity compositions. A measure
+ * nests (`children`): a hall holds its presses, a top its contracts, a contract
+ * its orders — the hierarchy is the data's own (#822), to whatever depth it has.
  */
 export const Measure = RecursiveType((self) => StructType({
     series: StringType, label: StringType,
     sub: OptionType(StringType), value: OptionType(StringType),
-    readings: ArrayType(OptionType(FloatType)),
-    second: ArrayType(OptionType(FloatType)),
-    lo: ArrayType(FloatType), hi: ArrayType(FloatType),
-    segments: ArrayType(Plan.Types.SegmentCell),
+    readings: DictType(DateTimeType, OptionType(FloatType)),
+    second: DictType(DateTimeType, OptionType(FloatType)),
+    points: DictType(DateTimeType, FloatType),
+    paired: DictType(DateTimeType, FloatType),
+    band: DictType(DateTimeType, MeasureBand),
+    segments: DictType(DateTimeType, ArrayType(Plan.Types.Segment)),
     children: DictType(StringType, self),
 }));
+/** Every collection a measure holds, empty: a measure names the few it fills. */
+const MEASURE_EMPTY = {
+    readings: new Map(), second: new Map(), points: new Map(), paired: new Map(), band: new Map(), segments: new Map(), children: new Map(),
+};
+/** A value a week from W23 (Monday 1 June 2026), each keyed by its week's instant. */
+const fromW23 = (weekly) => atInstants(weekly.map((v, i) => [new Date(Date.UTC(2026, 5, 1 + 7 * i)), v]));
 /** On-time %, a week apiece from W23: July's weeks run under the 92 breach. */
-const MEASURE_ON_TIME = [some(96.1), some(96.4), some(96.8), some(97.0), some(96.2), some(91.0), some(89.4), some(88.9), some(90.6), some(93.8), some(94.0), some(94.2)];
+const MEASURE_ON_TIME = [96.1, 96.4, 96.8, 97.0, 96.2, 91.0, 89.4, 88.9, 90.6, 93.8, 94.0, 94.2];
 /** Sheets printed, thousands a week — Hall 1's, then Hall 2's. */
-const MEASURE_PRINTED_H1 = [some(28.0), some(34.0), some(40.0), some(29.0), some(35.0), some(41.0), some(30.0), some(36.0), some(42.0), some(31.0), some(37.0), some(43.0)];
-const MEASURE_PRINTED_H2 = [some(14.0), some(19.0), some(24.0), some(16.0), some(21.0), some(26.0), some(18.0), some(23.0), some(15.0), some(20.0), some(25.0), some(17.0)];
+const MEASURE_PRINTED_H1 = [28.0, 34.0, 40.0, 29.0, 35.0, 41.0, 30.0, 36.0, 42.0, 31.0, 37.0, 43.0];
+const MEASURE_PRINTED_H2 = [14.0, 19.0, 24.0, 16.0, 21.0, 26.0, 18.0, 23.0, 15.0, 20.0, 25.0, 17.0];
 /** An order's delivered sheets, thousands a week — the week of 3 August none. */
 const MEASURE_ACT = [some(40.0), some(47.0), some(54.0), some(61.0), some(68.0), some(75.0), some(82.0), some(89.0), some(96.0), none, some(110.0), some(117.0)];
 /** The Δ against plan beside them — some weeks none. */
 const MEASURE_DELTA = [some(-8.0), some(-6.5), some(-5.0), none, some(-2.0), some(-0.5), some(1.0), none, some(4.0), some(5.5), some(7.0), none];
 /** What left as the sheets came in. */
 const MEASURE_OUT = [some(-12.0), some(-15.0), some(-18.0), some(-21.0), some(-24.0), some(-27.0), some(-30.0), some(-33.0), some(-36.0), some(-39.0), some(-42.0), some(-45.0)];
+/** An order: its delivered sheets, and the position beside them. */
+const order = (series, label, second = []) => ({ ...MEASURE_EMPTY, series, label, sub: none, value: none, readings: fromW23(MEASURE_ACT), second: fromW23(second) });
+/** A parent measure: no readings of its own, its children's subtotal. */
+const parent = (series, label, children) => ({ ...MEASURE_EMPTY, series, label, sub: none, value: none, children: new Map(children) });
 /**
  * Twelve weeks of every measure, W23–W34 — from the first Monday of June, so
  * the first month's column starts with the first week; the weeks after now
@@ -1254,128 +1240,96 @@ const MEASURE_OUT = [some(-12.0), some(-15.0), some(-18.0), some(-21.0), some(-2
  */
 export const planMeasureReadings = e3.input("plan_measure_readings", DictType(StringType, Measure), variant("value", new Map([
     // ── Output ──
-    ["spark", { series: "spark", label: "On-time", sub: none, value: some("94.2%"),
-            readings: MEASURE_ON_TIME, second: [], lo: [], hi: [], segments: [], children: new Map() }],
+    ["spark", { ...MEASURE_EMPTY, series: "spark", label: "On-time", sub: none, value: some("94.2%"), points: fromW23(MEASURE_ON_TIME) }],
     // A running total: each week the sheets printed so far.
-    ["cum", { series: "cum", label: "Cumulative · k", sub: none, value: some("194 k sheets"),
-            readings: [some(40.0), some(54.0), some(68.0), some(82.0), some(96.0), some(110.0), some(124.0), some(138.0), some(152.0), some(166.0), some(180.0), some(194.0)],
-            second: [], lo: [], hi: [], segments: [], children: new Map() }],
-    ["stacked", { series: "stacked", label: "Printed · k", sub: some("k/wk"), value: none,
-            readings: MEASURE_PRINTED_H1, second: MEASURE_PRINTED_H2, lo: [], hi: [], segments: [], children: new Map() }],
-    ["ppm", { series: "ppm", label: "Defects · ppm", sub: none, value: some("161"),
-            readings: [some(120.0), some(157.0), some(134.0), some(171.0), some(148.0), some(125.0), some(162.0), some(139.0), some(176.0), some(153.0), some(130.0), some(167.0)],
-            second: [], lo: [], hi: [], segments: [], children: new Map() }],
-    ["refs", { series: "refs", label: "On-time + refs", sub: none, value: none,
-            readings: MEASURE_ON_TIME, second: [], lo: [], hi: [], segments: [], children: new Map() }],
+    ["cum", { ...MEASURE_EMPTY, series: "cum", label: "Cumulative · k", sub: none, value: some("194 k sheets"),
+            points: fromW23([40.0, 54.0, 68.0, 82.0, 96.0, 110.0, 124.0, 138.0, 152.0, 166.0, 180.0, 194.0]) }],
+    ["stacked", { ...MEASURE_EMPTY, series: "stacked", label: "Printed · k", sub: some("k/wk"), value: none,
+            points: fromW23(MEASURE_PRINTED_H1), paired: fromW23(MEASURE_PRINTED_H2) }],
+    ["ppm", { ...MEASURE_EMPTY, series: "ppm", label: "Defects · ppm", sub: none, value: some("161"),
+            points: fromW23([120.0, 157.0, 134.0, 171.0, 148.0, 125.0, 162.0, 139.0, 176.0, 153.0, 130.0, 167.0]) }],
+    ["refs", { ...MEASURE_EMPTY, series: "refs", label: "On-time + refs", sub: none, value: none, points: fromW23(MEASURE_ON_TIME) }],
     // Output columns on the left axis; the on-time line and its ±3 band on the right.
-    ["dual", { series: "dual", label: "Out + on-time", sub: none, value: none,
-            readings: MEASURE_PRINTED_H1, second: MEASURE_ON_TIME,
-            lo: [93.1, 93.4, 93.8, 94.0, 93.2, 88.0, 86.4, 85.9, 87.6, 90.8, 91.0, 91.2],
-            hi: [99.1, 99.4, 99.8, 100.0, 99.2, 94.0, 92.4, 91.9, 93.6, 96.8, 97.0, 97.2],
-            segments: [], children: new Map() }],
+    ["dual", { ...MEASURE_EMPTY, series: "dual", label: "Out + on-time", sub: none, value: none,
+            points: fromW23(MEASURE_PRINTED_H1), paired: fromW23(MEASURE_ON_TIME),
+            band: fromW23([
+                { lo: 93.1, hi: 99.1 }, { lo: 93.4, hi: 99.4 }, { lo: 93.8, hi: 99.8 }, { lo: 94.0, hi: 100.0 }, { lo: 93.2, hi: 99.2 }, { lo: 88.0, hi: 94.0 },
+                { lo: 86.4, hi: 92.4 }, { lo: 85.9, hi: 91.9 }, { lo: 87.6, hi: 93.6 }, { lo: 90.8, hi: 96.8 }, { lo: 91.0, hi: 97.0 }, { lo: 91.2, hi: 97.2 },
+            ]) }],
     // ── Load ──
     // A hall with no readings of its own: its row is its presses' per-bucket
     // mean. H1-P03 read nothing in the week of 29 June; H1-P04 nothing in
     // August, which folds to a month with no data.
-    ["hall1", { series: "depth", label: "Hall 1", sub: none, value: none, readings: [], second: [], lo: [], hi: [], segments: [],
-            children: new Map([
-                ["p03h", { series: "depth", label: "H1-P03", sub: none, value: none, second: [], lo: [], hi: [], segments: [], children: new Map(),
-                        readings: [some(46.0), some(52.0), some(58.0), some(61.0), none, some(72.0), some(78.0), some(84.0), some(90.0), some(96.0), some(98.0), some(92.0)] }],
-                ["p04h", { series: "depth", label: "H1-P04", sub: none, value: none, second: [], lo: [], hi: [], segments: [], children: new Map(),
-                        readings: [some(44.0), some(50.0), some(55.0), some(60.0), some(63.0), some(70.0), some(74.0), some(80.0), some(86.0), none, none, none] }],
-            ]) }],
-    ["peak", { series: "peak", label: "Hall 2 peak %", sub: none, value: none,
-            readings: [some(45.0), some(62.0), some(79.0), some(46.0), some(63.0), some(80.0), some(47.0), some(64.0), some(81.0), some(48.0), some(65.0), some(82.0)],
-            second: [], lo: [], hi: [], segments: [], children: new Map() }],
+    ["hall1", parent("depth", "Hall 1", [
+            ["p03h", { ...MEASURE_EMPTY, series: "depth", label: "H1-P03", sub: none, value: none,
+                    readings: fromW23([some(46.0), some(52.0), some(58.0), some(61.0), none, some(72.0), some(78.0), some(84.0), some(90.0), some(96.0), some(98.0), some(92.0)]) }],
+            ["p04h", { ...MEASURE_EMPTY, series: "depth", label: "H1-P04", sub: none, value: none,
+                    readings: fromW23([some(44.0), some(50.0), some(55.0), some(60.0), some(63.0), some(70.0), some(74.0), some(80.0), some(86.0), none, none, none]) }],
+        ])],
+    ["peak", { ...MEASURE_EMPTY, series: "peak", label: "Hall 2 peak %", sub: none, value: none,
+            readings: fromW23([some(45.0), some(62.0), some(79.0), some(46.0), some(63.0), some(80.0), some(47.0), some(64.0), some(81.0), some(48.0), some(65.0), some(82.0)]) }],
     // Crew A's booked fraction of its hours, a week apiece.
-    ["booked", { series: "booked", label: "Crew A", sub: some("booked h"), value: none,
-            readings: [some(0.9), some(0.84), some(0.79), some(0.74), some(0.68), some(0.62), some(0.57), some(0.52), some(0.46), some(0.41), some(0.35), some(0.3)],
-            second: [], lo: [], hi: [], segments: [], children: new Map() }],
+    ["booked", { ...MEASURE_EMPTY, series: "booked", label: "Crew A", sub: some("booked h"), value: none,
+            points: fromW23([0.9, 0.84, 0.79, 0.74, 0.68, 0.62, 0.57, 0.52, 0.46, 0.41, 0.35, 0.3]) }],
     // ── Finishing ──
-    // Capacity compositions — plain `{ fill, weight, label }` records. June's
-    // and August's are their month's only one, so they keep their labels.
-    ["finishing", { series: "segments", label: "Finishing line", sub: some("capacity"), value: none,
-            readings: [], second: [], lo: [], hi: [], children: new Map(),
-            segments: [
-                { at: variant("time", new Date("2026-06-29T00:00:00Z")), segments: [
+    // Capacity compositions — plain `{ fill, weight, label }` records, a
+    // week's at its week. June's and August's are their month's only one, so
+    // they keep their labels.
+    ["finishing", { ...MEASURE_EMPTY, series: "segments", label: "Finishing line", sub: some("capacity"), value: none,
+            segments: atInstants([
+                [new Date("2026-06-29T00:00:00Z"), [
                         { fill: variant("success", null), weight: 60.0, label: some("60%") },
                         { fill: variant("warning", null), weight: 25.0, label: some("25%") },
                         { fill: variant("slack", null), weight: 15.0, label: none },
-                    ] },
-                { at: variant("time", new Date("2026-07-06T00:00:00Z")), segments: [
+                    ]],
+                [new Date("2026-07-06T00:00:00Z"), [
                         { fill: variant("success", null), weight: 70.0, label: some("70%") },
                         { fill: variant("slack", null), weight: 30.0, label: none },
-                    ] },
-                { at: variant("time", new Date("2026-07-13T00:00:00Z")), segments: [
+                    ]],
+                [new Date("2026-07-13T00:00:00Z"), [
                         { fill: variant("danger", null), weight: 40.0, label: some("40%") },
                         { fill: variant("free", null), weight: 60.0, label: none },
-                    ] },
-                { at: variant("time", new Date("2026-08-10T00:00:00Z")), segments: [
+                    ]],
+                [new Date("2026-08-10T00:00:00Z"), [
                         { fill: variant("success", null), weight: 55.0, label: some("55%") },
                         { fill: variant("warning", null), weight: 30.0, label: some("30%") },
                         { fill: variant("slack", null), weight: 15.0, label: none },
-                    ] },
-            ] }],
+                    ]],
+            ]) }],
     // ── Deliveries ──
     // Two levels of nesting — a top holds its contracts, a contract its
     // orders; every level with no readings of its own is a subtotal.
-    ["deliveries", { series: "orders", label: "Deliveries", sub: none, value: none, readings: [], second: [], lo: [], hi: [], segments: [],
-            children: new Map([
-                ["contract-a", { series: "orders", label: "Contract A", sub: none, value: none, readings: [], second: [], lo: [], hi: [], segments: [],
-                        children: new Map([
-                            ["j6188", { series: "orders", label: "J-6188", sub: none, value: none, readings: MEASURE_ACT, second: [], lo: [], hi: [], segments: [], children: new Map() }],
-                            ["j6204", { series: "orders", label: "J-6204", sub: none, value: none, readings: MEASURE_ACT, second: [], lo: [], hi: [], segments: [], children: new Map() }],
-                        ]) }],
-                ["contract-b", { series: "orders", label: "Contract B", sub: none, value: none, readings: [], second: [], lo: [], hi: [], segments: [],
-                        children: new Map([
-                            ["j6219", { series: "orders", label: "J-6219", sub: none, value: none, readings: MEASURE_ACT, second: [], lo: [], hi: [], segments: [], children: new Map() }],
-                        ]) }],
-            ]) }],
-    ["reprints", { series: "orders", label: "Reprints", sub: none, value: none, readings: [], second: [], lo: [], hi: [], segments: [],
-            children: new Map([
-                ["contract-b", { series: "orders", label: "Contract B", sub: none, value: none, readings: [], second: [], lo: [], hi: [], segments: [],
-                        children: new Map([
-                            ["rp-0031", { series: "orders", label: "RP-0031", sub: none, value: none, readings: MEASURE_ACT, second: [], lo: [], hi: [], segments: [], children: new Map() }],
-                        ]) }],
-            ]) }],
+    ["deliveries", parent("orders", "Deliveries", [
+            ["contract-a", parent("orders", "Contract A", [["j6188", order("orders", "J-6188")], ["j6204", order("orders", "J-6204")]])],
+            ["contract-b", parent("orders", "Contract B", [["j6219", order("orders", "J-6219")]])],
+        ])],
+    ["reprints", parent("orders", "Reprints", [
+            ["contract-b", parent("orders", "Contract B", [["rp-0031", order("orders", "RP-0031")]])],
+        ])],
     // Footer emphasis, a negative and the em-dash: July read nothing at all.
-    ["net", { series: "net", label: "Net flow", sub: none, value: none,
-            readings: [some(22.0), some(-26.0), some(8.0), some(-4.0), some(12.0), none, none, none, none, some(-30.0), some(12.0), some(6.0)],
-            second: [], lo: [], hi: [], segments: [], children: new Map() }],
+    ["net", { ...MEASURE_EMPTY, series: "net", label: "Net flow", sub: none, value: none,
+            readings: fromW23([some(22.0), some(-26.0), some(8.0), some(-4.0), some(12.0), none, none, none, none, some(-30.0), some(12.0), some(6.0)]) }],
     // Multi-value rows — the actuals and the Δ per row. The SPLIT (how the
     // positions sit against each other) and the GUTTER (one line or two) are
     // independent choices, so all four combinations are here: the pair that
     // reads well depends on the numbers, not on the split.
-    ["actplan", { series: "actplan", label: "Act · Δ plan", sub: some("k/wk"), value: none,
-            readings: MEASURE_ACT, second: MEASURE_DELTA, lo: [], hi: [], segments: [], children: new Map() }],
-    ["inout", { series: "inout", label: "In / out", sub: none, value: none,
-            readings: MEASURE_ACT, second: MEASURE_OUT, lo: [], hi: [], segments: [], children: new Map() }],
+    ["actplan", { ...order("actplan", "Act · Δ plan", MEASURE_DELTA), sub: some("k/wk") }],
+    ["inout", order("inout", "In / out", MEASURE_OUT)],
     // Horizontal, on a ONE-line gutter — the pair reads as a single fact
     // ("booked beside free"), so a sub label would only repeat it.
-    ["sidebyside", { series: "sidebyside", label: "Booked · free", sub: none, value: none,
-            readings: MEASURE_ACT, second: MEASURE_OUT, lo: [], hi: [], segments: [], children: new Map() }],
+    ["sidebyside", order("sidebyside", "Booked · free", MEASURE_OUT)],
     // Vertical, on a TWO-line gutter — the stack needs the unit spelled out,
     // because the positions are the same measure at two times.
-    ["overunder", { series: "overunder", label: "Act / plan", sub: some("k/wk"), value: none,
-            readings: MEASURE_ACT, second: MEASURE_DELTA, lo: [], hi: [], segments: [], children: new Map() }],
+    ["overunder", { ...order("overunder", "Act / plan", MEASURE_DELTA), sub: some("k/wk") }],
     // NESTED and multi-value: the subtotal parent mirrors its members, an act
     // subtotal beside a Δ subtotal.
-    ["lots", { series: "lot", label: "Lots", sub: none, value: none, readings: [], second: [], lo: [], hi: [], segments: [],
-            children: new Map([
-                ["lt-1", { series: "lot", label: "LT-2201", sub: none, value: none, readings: MEASURE_ACT, second: MEASURE_DELTA, lo: [], hi: [], segments: [], children: new Map() }],
-                ["lt-2", { series: "lot", label: "LT-2202", sub: none, value: none, readings: MEASURE_ACT, second: MEASURE_DELTA, lo: [], hi: [], segments: [], children: new Map() }],
-            ]) }],
+    ["lots", parent("lot", "Lots", [["lt-1", order("lot", "LT-2201", MEASURE_DELTA)], ["lt-2", order("lot", "LT-2202", MEASURE_DELTA)]])],
     // The same, STACKED: members and their subtotal both put the two positions
     // on their own lines, so the parent has to grow too.
-    ["stacks", { series: "stack", label: "Stacks", sub: none, value: none, readings: [], second: [], lo: [], hi: [], segments: [],
-            children: new Map([
-                ["st-1", { series: "stack", label: "ST-3301", sub: none, value: none, readings: MEASURE_ACT, second: MEASURE_OUT, lo: [], hi: [], segments: [], children: new Map() }],
-                ["st-2", { series: "stack", label: "ST-3302", sub: none, value: none, readings: MEASURE_ACT, second: MEASURE_OUT, lo: [], hi: [], segments: [], children: new Map() }],
-            ]) }],
+    ["stacks", parent("stack", "Stacks", [["st-1", order("stack", "ST-3301", MEASURE_OUT)], ["st-2", order("stack", "ST-3302", MEASURE_OUT)]])],
     // A balance: the paper in stock, thousands of sheets, each week's close.
-    ["stock", { series: "stock", label: "Paper stock · k", sub: none, value: none,
-            readings: [some(420.0), some(398.0), some(376.0), some(354.0), some(332.0), some(310.0), some(288.0), some(266.0), some(244.0), some(222.0), some(200.0), some(178.0)],
-            second: [], lo: [], hi: [], segments: [], children: new Map() }],
+    ["stock", { ...MEASURE_EMPTY, series: "stock", label: "Paper stock · k", sub: none, value: none,
+            readings: fromW23([some(420.0), some(398.0), some(376.0), some(354.0), some(332.0), some(310.0), some(288.0), some(266.0), some(244.0), some(222.0), some(200.0), some(178.0)]) }],
 ])));
 /** A week the readings cover: its first instant, and its name. */
 export const MeasureWeek = StructType({ week: DateTimeType, label: StringType });
@@ -1384,22 +1338,26 @@ export const MeasureWeek = StructType({ week: DateTimeType, label: StringType })
  * the library's Weeks tab lists, the rail's `weeks` source holding the
  * canvas's window in its range (#1344).
  */
-export const planMeasureWeeks = e3.record("plan_measure_weeks", DictType(StringType, MeasureWeek), new Map([
-    ["W23", { week: new Date("2026-06-01T00:00:00Z"), label: "W23 · 1 Jun" }],
-    ["W24", { week: new Date("2026-06-08T00:00:00Z"), label: "W24 · 8 Jun" }],
-    ["W25", { week: new Date("2026-06-15T00:00:00Z"), label: "W25 · 15 Jun" }],
-    ["W26", { week: new Date("2026-06-22T00:00:00Z"), label: "W26 · 22 Jun" }],
-    ["W27", { week: new Date("2026-06-29T00:00:00Z"), label: "W27 · 29 Jun" }],
-    ["W28", { week: new Date("2026-07-06T00:00:00Z"), label: "W28 · 6 Jul" }],
-    ["W29", { week: new Date("2026-07-13T00:00:00Z"), label: "W29 · 13 Jul" }],
-    ["W30", { week: new Date("2026-07-20T00:00:00Z"), label: "W30 · 20 Jul" }],
-    ["W31", { week: new Date("2026-07-27T00:00:00Z"), label: "W31 · 27 Jul" }],
-    ["W32", { week: new Date("2026-08-03T00:00:00Z"), label: "W32 · 3 Aug" }],
-    ["W33", { week: new Date("2026-08-10T00:00:00Z"), label: "W33 · 10 Aug" }],
-    ["W34", { week: new Date("2026-08-17T00:00:00Z"), label: "W34 · 17 Aug" }],
-]));
-/** The weeks by their first instant: what the window narrows them through. */
-export const planMeasureWeeksByWeek = e3.recordIndex("plan_measure_weeks_by_week", planMeasureWeeks, { on: ["week"] });
+export const planMeasureWeeks = e3.record("plan_measure_weeks", DictType(StringType, MeasureWeek), {
+    initial: new Map([
+        ["W23", { week: new Date("2026-06-01T00:00:00Z"), label: "W23 · 1 Jun" }],
+        ["W24", { week: new Date("2026-06-08T00:00:00Z"), label: "W24 · 8 Jun" }],
+        ["W25", { week: new Date("2026-06-15T00:00:00Z"), label: "W25 · 15 Jun" }],
+        ["W26", { week: new Date("2026-06-22T00:00:00Z"), label: "W26 · 22 Jun" }],
+        ["W27", { week: new Date("2026-06-29T00:00:00Z"), label: "W27 · 29 Jun" }],
+        ["W28", { week: new Date("2026-07-06T00:00:00Z"), label: "W28 · 6 Jul" }],
+        ["W29", { week: new Date("2026-07-13T00:00:00Z"), label: "W29 · 13 Jul" }],
+        ["W30", { week: new Date("2026-07-20T00:00:00Z"), label: "W30 · 20 Jul" }],
+        ["W31", { week: new Date("2026-07-27T00:00:00Z"), label: "W31 · 27 Jul" }],
+        ["W32", { week: new Date("2026-08-03T00:00:00Z"), label: "W32 · 3 Aug" }],
+        ["W33", { week: new Date("2026-08-10T00:00:00Z"), label: "W33 · 10 Aug" }],
+        ["W34", { week: new Date("2026-08-17T00:00:00Z"), label: "W34 · 17 Aug" }],
+    ]),
+    indexes: (index) => ({
+        // The weeks by their first instant: what the window narrows them through.
+        plan_measure_weeks_by_week: index.on(["week"]),
+    }),
+});
 /**
  * Measure rows — the chart, heat and table grammars over weekly readings, and
  * the temporal fold (#824) that shows them at whatever resolution the slice
@@ -1442,7 +1400,7 @@ export const planMeasures = example({
         "em-dash", "neg", "tableSeries", "split", "horizontal", "vertical", "multi-value", "multi-cell", "two-line",
         "strong", "muted", "rollup", "mirror", "position", "fold", "temporal fold", "resolution", "week", "month",
         "rebucket", "bucket", "max", "last", "count", "default", "override", "layer", "Plan.layer", "column",
-        "line", "Slice", "Slice.bindRecords", "source", "Data.bindPaged", "recordIndex", "toolbar", "range", "brush", "section", "match", "gutter",
+        "line", "Slice", "Slice.bindRecords", "source", "Data.bindPaged", "indexes", "toolbar", "range", "brush", "section", "match", "gutter",
         "raw", "readings", "Reactive", "Data.bind", "bound", "e3.input", "e3.record", "library", "Plan.library.tab", "#824", "#1258", "#1344",
     ],
     description: "Measure rows over weekly readings bound from e3, at MONTH to start — chart rows (a line with its breach, an area, stacked columns, a scatter, every annotation, and a fixed dual-axis composition with its band and swatches), heat rows (colour depth under a hall averaging its presses on its scale with the no-data hatch, weight bars with a planned tail, status segments) and table rows (subtotals at every depth, footer emphasis with a negative and the em-dash, multi-value positions in every split × gutter combination); each row folds a month's weeks by what its values mean, or by its override (peak load by max, a running total and the paper stock by last, the dual chart's columns by mean), the toolbar's resolution segment switches MONTH and WEEK, and one Slice.bindRecords rail's weeks source, which the Weeks tab lists, holds the window the horizon brush moves",
@@ -1456,31 +1414,18 @@ export const planMeasures = example({
                     const w1 = $.const(new Date("2025-12-29T00:00:00Z"), DateTimeType);
                     return w1.addWeeks(n.subtract(1n));
                 }));
-                const Point = StructType({ week: DateTimeType, v: FloatType });
-                const BandPoint = StructType({ week: DateTimeType, lo: FloatType, hi: FloatType });
-                const Weekly = StructType({ at: DateTimeType, value: OptionType(FloatType) });
-                // A measure's readings from W23, as each row kind reads them: a
-                // chart's points (a week with no reading draws none), heat cells
-                // printing their values (a week with none the no-data hatch),
-                // booked fractions (the weeks after now the planned, pale tail),
-                // and table cells (a week with none the em-dash).
-                const points = $.const(East.function([ArrayType(OptionType(FloatType))], ArrayType(Point), ($, readings) => readings.filterMap((_$2, r, i) => r.match({
-                    some: (_$3, v) => East.value(some({ week: week(i.add(23n)), v }), OptionType(Point)),
-                    none: (_$3) => East.value(none, OptionType(Point)),
-                }))));
-                const band = $.const(East.function([ArrayType(FloatType), ArrayType(FloatType)], ArrayType(BandPoint), ($, lo, hi) => East.Array.generate(lo.size(), BandPoint, (_$2, i) => ({ week: week(i.add(23n)), lo: lo.get(i), hi: hi.get(i) }))));
-                const heat = $.const(East.function([ArrayType(OptionType(FloatType))], ArrayType(Plan.Types.HeatCell), ($, readings) => East.Array.generate(readings.size(), Plan.Types.HeatCell, ($2, i) => {
-                    const value = $2.let(readings.get(i), OptionType(FloatType));
-                    const label = $2.let(none, OptionType(StringType));
-                    $2.match(value, { some: ($3, v) => { $3.assign(label, some(East.Float.printFixed(v, 0n))); } });
-                    return { at: Plan.at.time(week(i.add(23n))), value, label };
-                })));
-                const booked = $.const(East.function([ArrayType(OptionType(FloatType))], ArrayType(Plan.Types.WeightCell), ($, readings) => readings.filterMap((_$2, r, i) => r.match({
-                    some: (_$3, f) => East.value(some({ at: Plan.at.time(week(i.add(23n))), fraction: f, planned: i.add(23n).greater(27n) }), OptionType(Plan.Types.WeightCell)),
-                    none: (_$3) => East.value(none, OptionType(Plan.Types.WeightCell)),
-                }))));
-                const weekly = $.const(East.function([ArrayType(OptionType(FloatType))], ArrayType(Weekly), ($, readings) => East.Array.generate(readings.size(), Weekly, (_$2, i) => ({ at: week(i.add(23n)), value: readings.get(i) }))));
+                // Each row reads its measure's values BY NAME, each at its week
+                // (#1436): a chart's points, heat cells printing their values (a
+                // week with none the no-data hatch), booked fractions (the weeks
+                // after now the planned, pale tail), and table cells (a week with
+                // none the em-dash).
+                const printed = (v) => v.match({
+                    some: (_$2, x) => East.value(some(East.Float.printFixed(x, 0n)), OptionType(StringType)),
+                    none: () => East.value(none, OptionType(StringType)),
+                });
+                const now = $.const(week(27n));
                 const whole = $.const(Format.Number({ maximumFractionDigits: 0n }));
+                const signed = $.const(Format.Number({ maximumFractionDigits: 0n, signDisplay: "always" }));
                 const series = $.const([
                     Plan.series.section(Measure, { key: "output", title: "Output", meta: "5 rows" }, [
                         // A level: the on-time line folds a month's weeks by their
@@ -1493,14 +1438,14 @@ export const planMeasures = example({
                             label: r => r.label, id: true,
                             value: r => r.value, status: _r => some(variant("warning", null)),
                             height: "spark", expandable: true, expandedHeight: "120px",
-                            layers: r => [Plan.layer(Chart.Line(points(r.readings), { x: p => p.week, y: p => p.v }), { breach: { below: 92 } })],
+                            layers: [Plan.line(Plan.values("points", (v) => ({ y: v })), { breach: { below: 92 } })],
                         }),
                         // A running total — a month shows where it CLOSED.
                         Plan.series.chart(Measure, {
                             key: "cum", title: "Cumulative",
                             match: r => r.series.equal("cum"),
                             label: r => r.label, id: true, value: r => r.value,
-                            layers: r => [Plan.layer(Chart.Area(points(r.readings), { x: p => p.week, y: p => p.v }), { fold: "last" })],
+                            layers: [Plan.area(Plan.values("points", (v) => ({ y: v })), { fold: "last" })],
                         }),
                         // Amounts — the two halls' columns stacked by one series id,
                         // each month their weeks' SUM, on a two-line gutter (label
@@ -1509,9 +1454,9 @@ export const planMeasures = example({
                             key: "stacked", title: "Stacked",
                             match: r => r.series.equal("stacked"),
                             label: r => r.label, id: true, stacked: true, sub: r => r.sub,
-                            layers: r => [
-                                Plan.layer(Chart.Column(points(r.readings), { x: p => p.week, y: p => p.v }), { series: "H1" }),
-                                Plan.layer(Chart.Column(points(r.second), { x: p => p.week, y: p => p.v }), { series: "H2" }),
+                            layers: [
+                                Plan.column(Plan.values("points", (v) => ({ y: v })), { series: "H1" }),
+                                Plan.column(Plan.values("paired", (v) => ({ y: v })), { series: "H2" }),
                             ],
                         }),
                         // A scatter draws every reading, folded or not.
@@ -1519,7 +1464,7 @@ export const planMeasures = example({
                             key: "ppm", title: "Ppm",
                             match: r => r.series.equal("ppm"),
                             label: r => r.label, id: true, value: r => r.value,
-                            layers: r => [Chart.Scatter(points(r.readings), { x: p => p.week, y: p => p.v })],
+                            layers: [Plan.scatter(Plan.values("points", (v) => ({ y: v })))],
                         }),
                         // A line and every annotation kind, at expanded density.
                         Plan.series.chart(Measure, {
@@ -1527,8 +1472,8 @@ export const planMeasures = example({
                             match: r => r.series.equal("refs"),
                             label: r => r.label, id: true,
                             height: "expanded",
-                            layers: r => [
-                                Plan.layer(Chart.Line(points(r.readings), { x: p => p.week, y: p => p.v }), { breach: { below: 92 } }),
+                            layers: [
+                                Plan.line(Plan.values("points", (v) => ({ y: v })), { breach: { below: 92 } }),
                                 Chart.refLine({ y: 100, label: "TARGET 100" }),
                                 Chart.refBand({ x: [week(29n), week(31n)], label: "CRUNCH" }),
                                 Chart.refDot({ x: week(30n), y: 88.9, label: "LOW" }),
@@ -1549,10 +1494,10 @@ export const planMeasures = example({
                             left: { domain: [0, 60], tickValues: [0, 25, 50] },
                             right: { domain: [80, 105], tickValues: [85, 95, 105] },
                             swatches: [{ color: "ink.3", label: "out" }, { color: "brand.d", label: "on-time · rh" }],
-                            layers: r => [
-                                Plan.layer(Chart.Column(points(r.readings), { x: p => p.week, y: p => p.v }), { fold: "mean" }),
-                                Plan.layer(Chart.Line(points(r.second), { x: p => p.week, y: p => p.v }), { axis: "right" }),
-                                Plan.layer(Chart.Band(band(r.lo, r.hi), { x: p => p.week, low: p => p.lo, high: p => p.hi }), { axis: "right" }),
+                            layers: [
+                                Plan.column(Plan.values("points", (v) => ({ y: v })), { fold: "mean" }),
+                                Plan.line(Plan.values("paired", (v) => ({ y: v })), { axis: "right" }),
+                                Plan.band(Plan.values("band", (b) => ({ lo: b.lo, hi: b.hi })), { axis: "right" }),
                             ],
                         }),
                     ]),
@@ -1564,8 +1509,8 @@ export const planMeasures = example({
                             key: "depth", title: "Depth",
                             match: r => r.series.equal("depth"),
                             label: r => r.label, id: true,
-                            cells: r => Plan.heatCells(heat(r.readings), { min: 0, max: 100, warnAt: 95 }),
-                            children: r => r.children, aggregate: "mean",
+                            cells: Plan.heatCells(Plan.values("readings", (v) => ({ value: v, label: printed(v) })), { min: 0, max: 100, warnAt: 95 }),
+                            children: "children", aggregate: "mean",
                             scale: { min: 0, max: 100, warnAt: 95 },
                         }),
                         // The same kind of reading, folded by its MAX — the peak a
@@ -1574,7 +1519,7 @@ export const planMeasures = example({
                             key: "peak", title: "Peak load",
                             match: r => r.series.equal("peak"),
                             label: r => r.label,
-                            cells: r => Plan.heatCells(heat(r.readings), { min: 0, max: 100, fold: "max", format: whole }),
+                            cells: Plan.heatCells(Plan.values("readings", (v) => ({ value: v, label: printed(v) })), { min: 0, max: 100, fold: "max", format: whole }),
                         }),
                         // A fraction of each week booked — a month's is its weeks'
                         // mean, pale only when every one of them is planned.
@@ -1582,7 +1527,7 @@ export const planMeasures = example({
                             key: "booked", title: "Booked",
                             match: r => r.series.equal("booked"),
                             label: r => r.label, sub: r => r.sub,
-                            cells: r => Plan.weightCells(booked(r.readings)),
+                            cells: Plan.weightCells(Plan.values("points", (fraction, at) => ({ fraction, planned: at.greater(now) }))),
                         }),
                     ]),
                     Plan.series.section(Measure, { key: "finishing", title: "Finishing", meta: "1 row" }, [
@@ -1592,7 +1537,7 @@ export const planMeasures = example({
                             key: "segments", title: "Segments",
                             match: r => r.series.equal("segments"),
                             label: r => r.label, sub: r => r.sub,
-                            cells: r => Plan.segmentCells(r.segments),
+                            cells: Plan.segmentCells(Plan.values("segments", (segments) => ({ segments }))),
                         }),
                     ]),
                     Plan.series.section(Measure, { key: "deliveries", title: "Deliveries", meta: "21 rows" }, [
@@ -1603,15 +1548,15 @@ export const planMeasures = example({
                             key: "orders", title: "Orders",
                             match: r => r.series.equal("orders"),
                             label: r => r.label,
-                            cells: r => Plan.tableCells(weekly(r.readings)),
-                            children: r => r.children, aggregate: "sum",
+                            cells: Plan.tableCells(Plan.values("readings", (v) => ({ value: v }))),
+                            children: "children", aggregate: "sum",
                             format: whole,
                         }),
                         Plan.series.table(Measure, {
                             key: "net", title: "Net",
                             match: r => r.series.equal("net"),
                             label: r => r.label, emphasis: "footer",
-                            cells: r => Plan.tableCells(weekly(r.readings)),
+                            cells: Plan.tableCells(Plan.values("readings", (v) => ({ value: v }))),
                             format: whole,
                         }),
                         // Per-POSITION style declared ONCE, in the CONFIG — a strong
@@ -1620,13 +1565,9 @@ export const planMeasures = example({
                             key: "actplan", title: "Actual vs plan",
                             match: r => r.series.equal("actplan"),
                             label: r => r.label, stacked: true, sub: r => r.sub,
-                            series: r => [
-                                Plan.tableSeries({ strong: true, rollup: true, cells: Plan.tableCells(weekly(r.readings)) }),
-                                Plan.tableSeries({
-                                    tone: "muted",
-                                    format: Format.Number({ maximumFractionDigits: 0n, signDisplay: "always" }),
-                                    cells: Plan.tableCells(weekly(r.second)),
-                                }),
+                            series: [
+                                Plan.tableSeries({ strong: true, rollup: true, cells: Plan.tableCells(Plan.values("readings", (v) => ({ value: v }))) }),
+                                Plan.tableSeries({ tone: "muted", format: signed, cells: Plan.tableCells(Plan.values("second", (v) => ({ value: v }))) }),
                             ],
                             format: whole,
                         }),
@@ -1635,9 +1576,9 @@ export const planMeasures = example({
                             key: "inout", title: "Inout",
                             match: r => r.series.equal("inout"),
                             label: r => r.label, split: "vertical",
-                            series: r => [
-                                Plan.tableSeries({ cells: Plan.tableCells(weekly(r.readings)) }),
-                                Plan.tableSeries({ tone: "muted", cells: Plan.tableCells(weekly(r.second)) }),
+                            series: [
+                                Plan.tableSeries({ cells: Plan.tableCells(Plan.values("readings", (v) => ({ value: v }))) }),
+                                Plan.tableSeries({ tone: "muted", cells: Plan.tableCells(Plan.values("second", (v) => ({ value: v }))) }),
                             ],
                             format: whole,
                         }),
@@ -1648,9 +1589,9 @@ export const planMeasures = example({
                             key: "sidebyside", title: "Side by side",
                             match: r => r.series.equal("sidebyside"),
                             label: r => r.label, split: "horizontal",
-                            series: r => [
-                                Plan.tableSeries({ strong: true, cells: Plan.tableCells(weekly(r.readings)) }),
-                                Plan.tableSeries({ tone: "muted", cells: Plan.tableCells(weekly(r.second)) }),
+                            series: [
+                                Plan.tableSeries({ strong: true, cells: Plan.tableCells(Plan.values("readings", (v) => ({ value: v }))) }),
+                                Plan.tableSeries({ tone: "muted", cells: Plan.tableCells(Plan.values("second", (v) => ({ value: v }))) }),
                             ],
                             format: whole,
                         }),
@@ -1663,15 +1604,11 @@ export const planMeasures = example({
                             key: "lot", title: "Lot",
                             match: r => r.series.equal("lot"),
                             label: r => r.label,
-                            series: r => [
-                                Plan.tableSeries({ strong: true, cells: Plan.tableCells(weekly(r.readings)) }),
-                                Plan.tableSeries({
-                                    tone: "muted",
-                                    format: Format.Number({ maximumFractionDigits: 0n, signDisplay: "always" }),
-                                    cells: Plan.tableCells(weekly(r.second)),
-                                }),
+                            series: [
+                                Plan.tableSeries({ strong: true, cells: Plan.tableCells(Plan.values("readings", (v) => ({ value: v }))) }),
+                                Plan.tableSeries({ tone: "muted", format: signed, cells: Plan.tableCells(Plan.values("second", (v) => ({ value: v }))) }),
                             ],
-                            children: r => r.children, aggregate: "sum",
+                            children: "children", aggregate: "sum",
                             format: whole,
                         }),
                         // NESTED and VERTICAL — the subtotal stacks its positions the
@@ -1683,11 +1620,11 @@ export const planMeasures = example({
                             key: "stack", title: "Stack",
                             match: r => r.series.equal("stack"),
                             label: r => r.label, split: "vertical",
-                            series: r => [
-                                Plan.tableSeries({ strong: true, cells: Plan.tableCells(weekly(r.readings)) }),
-                                Plan.tableSeries({ tone: "muted", cells: Plan.tableCells(weekly(r.second)) }),
+                            series: [
+                                Plan.tableSeries({ strong: true, cells: Plan.tableCells(Plan.values("readings", (v) => ({ value: v }))) }),
+                                Plan.tableSeries({ tone: "muted", cells: Plan.tableCells(Plan.values("second", (v) => ({ value: v }))) }),
                             ],
-                            children: r => r.children, aggregate: "sum",
+                            children: "children", aggregate: "sum",
                             format: whole,
                         }),
                         // VERTICAL on a TWO-line gutter — the remaining combination,
@@ -1696,13 +1633,9 @@ export const planMeasures = example({
                             key: "overunder", title: "Over / under",
                             match: r => r.series.equal("overunder"),
                             label: r => r.label, split: "vertical", stacked: true, sub: r => r.sub,
-                            series: r => [
-                                Plan.tableSeries({ strong: true, rollup: true, cells: Plan.tableCells(weekly(r.readings)) }),
-                                Plan.tableSeries({
-                                    tone: "muted",
-                                    format: Format.Number({ maximumFractionDigits: 0n, signDisplay: "always" }),
-                                    cells: Plan.tableCells(weekly(r.second)),
-                                }),
+                            series: [
+                                Plan.tableSeries({ strong: true, rollup: true, cells: Plan.tableCells(Plan.values("readings", (v) => ({ value: v }))) }),
+                                Plan.tableSeries({ tone: "muted", format: signed, cells: Plan.tableCells(Plan.values("second", (v) => ({ value: v }))) }),
                             ],
                             format: whole,
                         }),
@@ -1711,7 +1644,7 @@ export const planMeasures = example({
                             key: "stock", title: "Paper stock",
                             match: r => r.series.equal("stock"),
                             label: r => r.label,
-                            cells: r => Plan.tableCells(weekly(r.readings)), fold: "last",
+                            cells: Plan.tableCells(Plan.values("readings", (v) => ({ value: v }))), fold: "last",
                             format: whole,
                         }),
                     ]),
@@ -1721,7 +1654,7 @@ export const planMeasures = example({
                 // resolution, MONTH to start; the Weeks tab lists the weeks in it.
                 const slice = $.let(Slice.bindRecords("ex.plan.measures", {
                     weeks: {
-                        source: Data.bindPaged(planMeasureWeeks, { indexes: [planMeasureWeeksByWeek] }),
+                        source: Data.bindPaged(planMeasureWeeks, { indexes: ["plan_measure_weeks_by_week"] }),
                         label: "Weeks", fields: { week: { label: "Week", format: { date: "MMM D" } } }, range: "week",
                     },
                 }));
@@ -1738,75 +1671,83 @@ export const planMeasures = example({
 // planRowDrop — `data`'s rows edited in place: cards dropped from the Plan's
 // library panel, runs moved and resized, one checked Save (#880, #825, #1259)
 // ============================================================================
-/** A job, its label already composed. */
+/** A job, under its id — its label already composed. */
 export const DropJob = StructType({
-    key: StringType, label: StringType,
+    label: StringType,
     start: DateTimeType, end: DateTimeType, state: EventStateType,
 });
-/** A van drop. */
-export const DropAlloc = StructType({ key: StringType, at: DateTimeType, state: EventStateType });
-/** A crew shift, its label already composed. */
+/** A van drop, under its id. */
+export const DropAlloc = StructType({ at: DateTimeType, state: EventStateType });
+/** A crew shift, under its id — its label already composed. */
 export const DropShift = StructType({
-    key: StringType, from: DateTimeType, to: DateTimeType, label: StringType, state: EventStateType,
+    from: DateTimeType, to: DateTimeType, label: StringType, state: EventStateType,
 });
+/** A milestone on a stream, under its id. */
+export const DropMark = StructType({ at: DateTimeType, kind: Plan.Types.EventMarkKind, label: OptionType(StringType) });
 /** A press a hall holds — its jobs; its name is its key. */
-export const DropPress = StructType({ jobs: ArrayType(DropJob) });
-/** One row of the ops record — `series` names the series that claims it;
- *  `readings` are fortnightly from W27; a hall holds its presses
- *  (`presses`), the hierarchy the data's own. */
+export const DropPress = StructType({ jobs: DictType(StringType, DropJob) });
+/** One row of the ops record — `series` names the series that claims it; its
+ *  collections are Dicts a series reads by name (#1436): the things people
+ *  drag by their ids, `readings` and `nums` a value a fortnight keyed by its
+ *  week; a hall holds its presses (`presses`), the hierarchy the data's own. */
 export const DropOpsRow = StructType({
     series: StringType, label: StringType,
-    jobs: ArrayType(DropJob),
-    readings: ArrayType(FloatType),
-    allocs: ArrayType(DropAlloc),
-    nums: ArrayType(Plan.Types.TableCell),
-    shifts: ArrayType(DropShift),
-    marks: ArrayType(Plan.Types.EventMark),
+    jobs: DictType(StringType, DropJob),
+    readings: DictType(DateTimeType, FloatType),
+    allocs: DictType(StringType, DropAlloc),
+    nums: DictType(DateTimeType, FloatType),
+    shifts: DictType(StringType, DropShift),
+    marks: DictType(StringType, DropMark),
     presses: DictType(StringType, DropPress),
 });
+/** Every collection an ops row holds, empty: a row names the few it fills. */
+const DROP_EMPTY = {
+    jobs: new Map(), readings: new Map(), allocs: new Map(), nums: new Map(), shifts: new Map(), marks: new Map(), presses: new Map(),
+};
+/** A value a fortnight from W27 (Monday 29 June 2026), each keyed by its week's instant. */
+const fortnightly = (readings) => atInstants(readings.map((v, i) => [new Date(Date.UTC(2026, 5, 29 + 14 * i)), v]));
 /**
  * The ops RECORD every gesture drafts and Save commits to — its initial state
  * the genesis commit. The droppable and inert kinds interleave, and Hall 3 is
  * an entry holding its two presses, H3-P11 already running four jobs, so one
  * more is refused.
  */
-export const planDropOps = e3.record("plan_drop_ops", DictType(StringType, DropOpsRow), new Map([
-    ["util", { series: "util", label: "Util %", jobs: [], readings: [46.0, 58.0, 66.0, 72.0, 84.0, 96.0],
-            allocs: [], nums: [], shifts: [], marks: [], presses: new Map() }],
-    ["p03", { series: "press", label: "H1-P03", readings: [], allocs: [], nums: [], shifts: [], marks: [], presses: new Map(),
-            jobs: [{ key: "j4642", label: "RUN · J-4642", start: new Date("2026-07-06T00:00:00Z"), end: new Date("2026-07-27T00:00:00Z"), state: variant("in-progress", null) }] }],
-    ["p04", { series: "press", label: "H1-P04", readings: [], allocs: [], nums: [], shifts: [], marks: [], presses: new Map(),
-            jobs: [{ key: "j4624", label: "RUN · J-4624", start: new Date("2026-06-29T00:00:00Z"), end: new Date("2026-07-20T00:00:00Z"), state: variant("confirmed", null) }] }],
-    ["load", { series: "load", label: "H2 load", jobs: [], readings: [46.0, 58.0, 66.0, 72.0, 84.0, 96.0],
-            allocs: [], nums: [], shifts: [], marks: [], presses: new Map() }],
-    ["van1", { series: "van", label: "Van 1", jobs: [], readings: [], nums: [], shifts: [], marks: [], presses: new Map(),
-            allocs: [{ key: "a1", at: new Date("2026-07-13T00:00:00Z"), state: variant("confirmed", null) }] }],
-    ["desp", { series: "table", label: "Delivered · k", jobs: [], readings: [], allocs: [], shifts: [], marks: [], presses: new Map(),
-            nums: [
-                { at: variant("time", new Date("2026-07-06T00:00:00Z")), value: some(128.0), text: none, tone: none },
-                { at: variant("time", new Date("2026-07-27T00:00:00Z")), value: some(-96.0), text: none, tone: none },
-            ] }],
-    ["crewA", { series: "crew", label: "Crew A", jobs: [], readings: [], allocs: [], nums: [], marks: [], presses: new Map(),
-            shifts: [{ key: "s1", from: new Date("2026-06-29T00:00:00Z"), to: new Date("2026-07-13T00:00:00Z"), label: "80h", state: variant("confirmed", null) }] }],
-    ["ms", { series: "strm", label: "Milestones", jobs: [], readings: [], allocs: [], nums: [], shifts: [], presses: new Map(),
-            marks: [{ key: "k", at: variant("time", new Date("2026-07-13T00:00:00Z")), kind: variant("milestone", null), icon: none, label: some("KICKOFF") }] }],
-    // A HALL, holding its presses: a gesture on one of them drafts the hall,
-    // the entry they ride in. H3-P11 already runs four jobs.
-    ["hall3", { series: "hall", label: "Hall 3", jobs: [], readings: [], allocs: [], nums: [], shifts: [], marks: [],
-            presses: new Map([
-                ["H3-P11", { jobs: [
-                            { key: "j4897", label: "RUN · J-4897", start: new Date("2026-06-29T00:00:00Z"), end: new Date("2026-07-13T00:00:00Z"), state: variant("confirmed", null) },
-                            { key: "j4903", label: "RUN · J-4903", start: new Date("2026-07-20T00:00:00Z"), end: new Date("2026-08-17T00:00:00Z"), state: variant("confirmed", null) },
-                            { key: "j4911", label: "RUN · J-4911", start: new Date("2026-08-17T00:00:00Z"), end: new Date("2026-08-31T00:00:00Z"), state: variant("proposed", variant("recommended", null)) },
-                            { key: "j4918", label: "RUN · J-4918", start: new Date("2026-08-31T00:00:00Z"), end: new Date("2026-09-14T00:00:00Z"), state: variant("proposed", variant("recommended", null)) },
-                        ] }],
-                ["H3-P12", { jobs: [
-                            { key: "j4925", label: "RUN · J-4925", start: new Date("2026-07-06T00:00:00Z"), end: new Date("2026-07-27T00:00:00Z"), state: variant("confirmed", null) },
-                        ] }],
-            ]) }],
-]));
-/** The ops record's patch door — every Save commits through it. */
-export const planDropOpsPatch = e3.mutation.patch(planDropOps);
+export const planDropOps = e3.record("plan_drop_ops", DictType(StringType, DropOpsRow), {
+    initial: new Map([
+        ["util", { ...DROP_EMPTY, series: "util", label: "Util %", readings: fortnightly([46.0, 58.0, 66.0, 72.0, 84.0, 96.0]) }],
+        ["p03", { ...DROP_EMPTY, series: "press", label: "H1-P03",
+                jobs: new Map([["j4642", { label: "RUN · J-4642", start: new Date("2026-07-06T00:00:00Z"), end: new Date("2026-07-27T00:00:00Z"), state: variant("in-progress", null) }]]) }],
+        ["p04", { ...DROP_EMPTY, series: "press", label: "H1-P04",
+                jobs: new Map([["j4624", { label: "RUN · J-4624", start: new Date("2026-06-29T00:00:00Z"), end: new Date("2026-07-20T00:00:00Z"), state: variant("confirmed", null) }]]) }],
+        ["load", { ...DROP_EMPTY, series: "load", label: "H2 load", readings: fortnightly([46.0, 58.0, 66.0, 72.0, 84.0, 96.0]) }],
+        ["van1", { ...DROP_EMPTY, series: "van", label: "Van 1",
+                allocs: new Map([["a1", { at: new Date("2026-07-13T00:00:00Z"), state: variant("confirmed", null) }]]) }],
+        ["desp", { ...DROP_EMPTY, series: "table", label: "Delivered · k",
+                nums: atInstants([[new Date("2026-07-06T00:00:00Z"), 128.0], [new Date("2026-07-27T00:00:00Z"), -96.0]]) }],
+        ["crewA", { ...DROP_EMPTY, series: "crew", label: "Crew A",
+                shifts: new Map([["s1", { from: new Date("2026-06-29T00:00:00Z"), to: new Date("2026-07-13T00:00:00Z"), label: "80h", state: variant("confirmed", null) }]]) }],
+        ["ms", { ...DROP_EMPTY, series: "strm", label: "Milestones",
+                marks: new Map([["k", { at: new Date("2026-07-13T00:00:00Z"), kind: variant("milestone", null), label: some("KICKOFF") }]]) }],
+        // A HALL, holding its presses: a gesture on one of them drafts the hall,
+        // the entry they ride in. H3-P11 already runs four jobs.
+        ["hall3", { ...DROP_EMPTY, series: "hall", label: "Hall 3",
+                presses: new Map([
+                    ["H3-P11", { jobs: new Map([
+                                ["j4897", { label: "RUN · J-4897", start: new Date("2026-06-29T00:00:00Z"), end: new Date("2026-07-13T00:00:00Z"), state: variant("confirmed", null) }],
+                                ["j4903", { label: "RUN · J-4903", start: new Date("2026-07-20T00:00:00Z"), end: new Date("2026-08-17T00:00:00Z"), state: variant("confirmed", null) }],
+                                ["j4911", { label: "RUN · J-4911", start: new Date("2026-08-17T00:00:00Z"), end: new Date("2026-08-31T00:00:00Z"), state: variant("proposed", variant("recommended", null)) }],
+                                ["j4918", { label: "RUN · J-4918", start: new Date("2026-08-31T00:00:00Z"), end: new Date("2026-09-14T00:00:00Z"), state: variant("proposed", variant("recommended", null)) }],
+                            ]) }],
+                    ["H3-P12", { jobs: new Map([
+                                ["j4925", { label: "RUN · J-4925", start: new Date("2026-07-06T00:00:00Z"), end: new Date("2026-07-27T00:00:00Z"), state: variant("confirmed", null) }],
+                            ]) }],
+                ]) }],
+    ]),
+    mutations: (mutation) => ({
+        // The ops record's patch door — every Save commits through it.
+        patch: mutation.patch(),
+    }),
+});
 /** A card in the palette — a thing a row of its family takes. */
 export const DropCard = StructType({ name: StringType, family: StringType, note: StringType });
 /** The palette's cards, by key — a card's key is what a drop names it by. */
@@ -1837,13 +1778,14 @@ export const planDropCards = e3.input("plan_drop_cards", DictType(StringType, Dr
  * so the question is answered at three levels:
  *
  *  1. **Structurally, by series.** A card lands only on a row whose series
- *     declares `edit` — WHERE it lands (`items`, the entry's list the row's
- *     elements come from) and HOW it becomes one (`create`, from the drop: the
- *     card, the row and the bucket's instant). Only the kinds holding discrete
- *     scheduled objects can — `span` (runs), `buckets` (tiles), `events`
- *     (marks), `cards` (chips). A `chart` / `heat` / `table` row renders
- *     DERIVED values, and section headers and group strips are wayfinding:
- *     they register no cell and never light up during a drag.
+ *     declares `edit: { create }` — it lands in the collection the row's
+ *     elements read (`Plan.items`, #1436), under an id the Plan mints, and
+ *     `create` says what it becomes, from the drop: the card, the row and the
+ *     bucket's instant. Only the kinds holding discrete scheduled objects can
+ *     — `span` (runs), `buckets` (tiles), `events` (marks), `cards` (chips). A
+ *     `chart` / `heat` / `table` row renders DERIVED values, and section
+ *     headers and group strips are wayfinding: they register no cell and never
+ *     light up during a drag.
  *  2. **By policy, with `canDrop`.** Of the rows that can receive, this canvas
  *     admits only the matching FAMILY: a job goes on a press, a delivery on
  *     a van, a shift on a crew, a milestone on a stream. The `PALLET` card
@@ -1857,13 +1799,14 @@ export const planDropCards = e3.input("plan_drop_cards", DictType(StringType, Dr
  *     door (`Record.onApply`).
  *
  * A press's run moves along its press or onto another press and resizes by
- * either end: its series names the job's key and the instant fields a move
- * writes (`key`, `start`, `end`). It moves in whole weeks, or in days with
+ * either end: its runs' read names the jobs and the times a move writes
+ * (`Plan.items("jobs", { from: "start", to: "end" }, …)`), and the job keeps
+ * its id wherever it goes. It moves in whole weeks, or in days with
  * Shift held; from the keyboard, Space on a focused run picks it up: ←/→ move
  * it a week, Shift+←/→ its end, Alt+←/→ its start, ↑/↓ carry it to another
  * press, and Space drops it.
  *
- * Hall 3 is an entry of its own, holding its presses (`Plan.children`): its
+ * Hall 3 is an entry of its own, holding its presses (`Plan.children("presses", …)`): its
  * row rolls their runs up and takes no drop, and every gesture on one of its
  * presses lands on the press row, one level down, yet drafts the HALL — the
  * source's top-level entry, which the whole subtree rides in. A job moved
@@ -1882,7 +1825,7 @@ export const planDropCards = e3.input("plan_drop_cards", DictType(StringType, Dr
 export const planRowDrop = example({
     keywords: [
         "Plan", "library", "panel", "Plan.library.tab", "palette", "DnD", "drag", "drop", "canDrop",
-        "edit", "items", "create", "add", "target", "surface", "cell", "slot", "row kind", "selective", "veto",
+        "edit", "items", "Plan.items", "Plan.values", "create", "minted id", "add", "target", "surface", "cell", "slot", "row kind", "selective", "veto",
         "invalid", "span", "buckets", "events", "cards", "chart", "heat", "table", "section", "row id", "row text",
         "droppable", "inert", "bucket instant", "editing", "session", "onApply", "onPatch", "ready",
         "Readiness", "Editing.Types.Readiness", "draft", "drafts", "transaction", "Save", "undo", "redo",
@@ -1897,7 +1840,7 @@ export const planRowDrop = example({
             // The source is a RECORD: the canvas pages it, and each Save is
             // one commit through its patch door.
             const ops = $.let(Data.bindPaged(planDropOps));
-            const record = $.let(Record.bind(planDropOps, [planDropOpsPatch]));
+            const record = $.let(Record.bind(planDropOps));
             // The palette the cards come from, by key.
             const cards = $.let(Data.bind(planDropCards));
             const palette = $.let(cards.read());
@@ -1906,15 +1849,6 @@ export const planRowDrop = example({
                 const w1 = $.const(new Date("2025-12-29T00:00:00Z"), DateTimeType);
                 return w1.addWeeks(n.subtract(1n));
             }));
-            const MeasureRow = StructType({ week: DateTimeType, pct: FloatType });
-            // A row's fortnightly readings from W27, as a chart's points and as
-            // heat cells printing their values.
-            const points = $.const(East.function([ArrayType(FloatType)], ArrayType(MeasureRow), ($, readings) => East.Array.generate(readings.size(), MeasureRow, (_$, i) => ({ week: week(i.multiply(2n).add(27n)), pct: readings.get(i) }))));
-            const cells = $.const(East.function([ArrayType(FloatType)], ArrayType(Plan.Types.HeatCell), ($, readings) => East.Array.generate(readings.size(), Plan.Types.HeatCell, (_$, i) => ({
-                at: Plan.at.time(week(i.multiply(2n).add(27n))),
-                value: some(readings.get(i)),
-                label: some(East.Float.printFixed(readings.get(i), 0n)),
-            }))));
             // Everything a drop creates is a PROPOSAL — it is a suggestion the
             // host has not committed, and the lifecycle is how the canvas says so.
             const ADDED = variant("proposed", variant("added", null));
@@ -1998,28 +1932,23 @@ export const planRowDrop = example({
                         key: "util", title: "Utilisation",
                         match: r => r.series.equal("util"),
                         label: r => r.label, id: true, height: "spark",
-                        layers: r => [Chart.Line(points(r.readings), { x: p => p.week, y: p => p.pct })],
+                        layers: [Plan.line(Plan.values("readings", (pct) => ({ y: pct })))],
                     }),
                     // RECEIVES and MOVES — runs are discrete scheduled
-                    // objects. A dropped job joins the press's `jobs`, a
-                    // fortnight long from the bucket the pointer named;
-                    // a run moves and resizes — the job found by `key`,
-                    // the run's own key, and a move writing `start` and
-                    // `end`. Keys stay unique on a press: a drop or a move
-                    // that would repeat one is refused, so a new job's key
-                    // names its card and place.
+                    // objects, read by name (#1436). A dropped job joins
+                    // the press's `jobs` under the id the Plan mints, a
+                    // fortnight long from the bucket the pointer named; a
+                    // run moves and resizes — the job found by its id, the
+                    // run's own key, and a move writing the `start` and
+                    // `end` the read names. A job keeps its id wherever it
+                    // goes: a move onto a press already holding it is refused.
                     Plan.series.span(DropOpsRow, {
                         key: "press", title: "Press jobs",
                         match: r => r.series.equal("press"),
                         label: r => r.label, id: true,
-                        runs: r => r.jobs.map((_$, j) => Plan.run({
-                            key: j.key, start: j.start, end: j.end, label: j.label, state: j.state,
-                        })),
+                        runs: Plan.items("jobs", { from: "start", to: "end" }, (job) => ({ label: job.label, state: job.state })),
                         edit: {
-                            items: "jobs",
-                            key: "key", start: "start", end: "end",
-                            create: (drop, r) => ({
-                                key: East.str `drop-${drop.from.key}-${East.print(r.jobs.size())}`,
+                            create: (drop) => ({
                                 label: palette.get(drop.from.key).name,
                                 start: drop.at.unwrap("time"), end: drop.at.unwrap("time").addWeeks(2n),
                                 state: ADDED,
@@ -2031,7 +1960,7 @@ export const planRowDrop = example({
                         key: "load", title: "Hall load",
                         match: r => r.series.equal("load"),
                         label: r => r.label,
-                        cells: r => Plan.heatCells(cells(r.readings), { min: 0, max: 100 }),
+                        cells: Plan.heatCells(Plan.values("readings", (pct) => ({ value: some(pct), label: some(East.Float.printFixed(pct, 0n)) })), { min: 0, max: 100 }),
                     }),
                     // RECEIVES — a dropped delivery becomes a tile in
                     // the bucket under the pointer.
@@ -2039,21 +1968,15 @@ export const planRowDrop = example({
                         key: "van", title: "Van drops",
                         match: r => r.series.equal("van"),
                         label: r => r.label,
-                        events: r => r.allocs.map((_$, a) => Plan.event({ key: a.key, at: a.at, state: a.state })),
-                        edit: {
-                            items: "allocs",
-                            create: (drop, r) => ({
-                                key: East.str `drop-${drop.from.key}-${East.print(r.allocs.size())}`,
-                                at: drop.at.unwrap("time"), state: ADDED,
-                            }),
-                        },
+                        events: Plan.items("allocs", { at: "at" }, (alloc) => ({ state: alloc.state })),
+                        edit: { create: (drop) => ({ at: drop.at.unwrap("time"), state: ADDED }) },
                     }),
                     // INERT — the cells are computed numbers.
                     Plan.series.table(DropOpsRow, {
                         key: "table", title: "Delivered sheets",
                         match: r => r.series.equal("table"),
                         label: r => r.label,
-                        cells: r => r.nums,
+                        cells: Plan.tableCells(Plan.values("nums", (n) => ({ value: some(n) }))),
                         format: Format.Number({ maximumFractionDigits: 0n }),
                     }),
                     // RECEIVES — a dropped shift becomes a chip.
@@ -2061,13 +1984,9 @@ export const planRowDrop = example({
                         key: "crew", title: "Crew shifts",
                         match: r => r.series.equal("crew"),
                         label: r => r.label,
-                        chips: r => r.shifts.map((_$, s) => Plan.chip({
-                            key: s.key, from: s.from, to: s.to, label: s.label, state: s.state,
-                        })),
+                        chips: Plan.items("shifts", { from: "from", to: "to" }, (shift) => ({ label: shift.label, state: shift.state })),
                         edit: {
-                            items: "shifts",
-                            create: (drop, r) => ({
-                                key: East.str `drop-${drop.from.key}-${East.print(r.shifts.size())}`,
+                            create: (drop) => ({
                                 from: drop.at.unwrap("time"), to: drop.at.unwrap("time").addWeeks(2n),
                                 label: palette.get(drop.from.key).name, state: ADDED,
                             }),
@@ -2079,20 +1998,18 @@ export const planRowDrop = example({
                         key: "strm", title: "Milestones",
                         match: r => r.series.equal("strm"),
                         label: r => r.label, id: true,
-                        marks: r => r.marks,
+                        marks: Plan.items("marks", { at: "at" }, (mark) => ({ kind: mark.kind, label: mark.label })),
                         edit: {
-                            items: "marks",
-                            create: (drop, r) => ({
-                                key: East.str `drop-${drop.from.key}-${East.print(r.marks.size())}`,
-                                at: drop.at, kind: variant("milestone", null), icon: none,
+                            create: (drop) => ({
+                                at: drop.at.unwrap("time"), kind: variant("milestone", null),
                                 label: some(palette.get(drop.from.key).name),
                             }),
                         },
                     }),
                     // A SECTION's header is inert. Under it, a HALL: an
-                    // entry holding its presses, stepped down into
-                    // through a plain field — which is what lets a
-                    // gesture on a press write back into its hall. The
+                    // entry holding its presses, stepped down into by
+                    // field — which is what lets a gesture on a press
+                    // write back into its hall. The
                     // hall's row rolls their runs up and takes no drop; a
                     // press of it receives, and its runs move — onto the
                     // Hall 1 presses too.
@@ -2102,18 +2019,13 @@ export const planRowDrop = example({
                             match: r => r.series.equal("hall"),
                             label: r => r.label,
                             runs: _r => [], rollup: "union",
-                            children: Plan.children(r => r.presses, [
+                            children: Plan.children("presses", [
                                 Plan.series.span(DropPress, {
                                     key: "gpress", title: "Hall presses",
                                     label: (_p, k) => k, id: true,
-                                    runs: p => p.jobs.map((_$, j) => Plan.run({
-                                        key: j.key, start: j.start, end: j.end, label: j.label, state: j.state,
-                                    })),
+                                    runs: Plan.items("jobs", { from: "start", to: "end" }, (job) => ({ label: job.label, state: job.state })),
                                     edit: {
-                                        items: "jobs",
-                                        key: "key", start: "start", end: "end",
-                                        create: (drop, p) => ({
-                                            key: East.str `drop-${drop.from.key}-${East.print(p.jobs.size())}`,
+                                        create: (drop) => ({
                                             label: palette.get(drop.from.key).name,
                                             start: drop.at.unwrap("time"), end: drop.at.unwrap("time").addWeeks(2n),
                                             state: ADDED,
@@ -2147,114 +2059,94 @@ export const generateNumberHorizon = East.function([IntegerType], ArrayType(Numb
  * number axis's Orders tab lists, the rail's `orders` source narrowing them by
  * hall, its integer range the canvas's window (#1344).
  */
-export const planNumberOrders = e3.record("plan_number_orders", DictType(StringType, NumberHorizonRow), East.compile(East.function([IntegerType], DictType(StringType, NumberHorizonRow), ($, count) => {
-    const generate = $.const(generateNumberHorizon);
-    return generate(count).toDict((_$2, order) => order.key, (_$2, order) => order);
-}), [])(24n));
-// The orders by their day, alone and after their hall: a hall's narrowing holds the window too.
-export const planNumberOrdersByDay = e3.recordIndex("plan_number_orders_by_day", planNumberOrders, { on: ["day"] });
-export const planNumberOrdersByHallDay = e3.recordIndex("plan_number_orders_by_hall_day", planNumberOrders, { on: ["hall", "day"] });
-/** A van drop — its day (a plain number), lane and lifecycle state. */
-export const NumberAlloc = StructType({ key: StringType, day: FloatType, lane: StringType, state: EventStateType });
-/** A job — its days. */
-export const NumberJob = StructType({ key: StringType, label: StringType, start: FloatType, end: FloatType, state: EventStateType });
-/** A crew shift — its days and hours. */
-export const NumberShift = StructType({ key: StringType, from: FloatType, to: FloatType, hours: FloatType, state: EventStateType });
-/** A milestone — its day. */
-export const NumberMark = StructType({ key: StringType, day: FloatType, label: StringType });
-/** A chart point — a day and a value. */
-export const NumberPoint = StructType({ day: FloatType, sheets: FloatType });
-/** A table reading — a day and its value. */
-export const NumberReading = StructType({ at: FloatType, value: OptionType(FloatType) });
-/** RAW rows — every instant is a plain number (a day index). */
+export const planNumberOrders = e3.record("plan_number_orders", DictType(StringType, NumberHorizonRow), {
+    initial: () => East.compile(East.function([IntegerType], DictType(StringType, NumberHorizonRow), ($, count) => {
+        const generate = $.const(generateNumberHorizon);
+        return generate(count).toDict((_$2, order) => order.key, (_$2, order) => order);
+    }), [])(24n),
+    indexes: (index) => ({
+        // The orders by their day, alone and after their hall: a hall's narrowing holds the window too.
+        plan_number_orders_by_day: index.on(["day"]),
+        plan_number_orders_by_hall_day: index.on(["hall", "day"]),
+    }),
+});
+/** A van drop, under its id — its day (a plain number), lane and lifecycle state. */
+export const NumberAlloc = StructType({ day: FloatType, lane: StringType, state: EventStateType });
+/** A job, under its id — its days. */
+export const NumberJob = StructType({ label: StringType, start: FloatType, end: FloatType, state: EventStateType });
+/** A crew shift, under its id — its days and hours. */
+export const NumberShift = StructType({ from: FloatType, to: FloatType, hours: FloatType, state: EventStateType });
+/** A milestone, under its id — its day. */
+export const NumberMark = StructType({ day: FloatType, label: StringType });
+/** RAW rows — every instant is a plain number (a day index): the things people drag by their ids, their days fields
+ *  of them, and a value a day keyed by its day, each a Dict a series reads by name (#1436). */
 export const NumberOpsRow = StructType({
     series: StringType, label: StringType, value: OptionType(StringType), sub: OptionType(StringType),
-    allocations: ArrayType(NumberAlloc), jobs: ArrayType(NumberJob), shifts: ArrayType(NumberShift),
-    marks: ArrayType(NumberMark), points: ArrayType(NumberPoint), sheets: ArrayType(NumberReading),
-    cells: ArrayType(Plan.Types.HeatCell),
+    allocations: DictType(StringType, NumberAlloc), jobs: DictType(StringType, NumberJob), shifts: DictType(StringType, NumberShift),
+    marks: DictType(StringType, NumberMark), output: DictType(FloatType, FloatType), delivered: DictType(FloatType, FloatType),
+    load: DictType(FloatType, FloatType),
 });
+/** Every collection a row holds, empty: a row names the few it fills. */
+const NUMBER_EMPTY = {
+    allocations: new Map(), jobs: new Map(), shifts: new Map(), marks: new Map(), output: new Map(), delivered: new Map(), load: new Map(),
+};
+/** A value a day from day 1, each keyed by its day. */
+const daily = (values) => new Map(values.map((v, i) => [i + 1, v]));
 /** The rows — the keys are the entries' identities; the series list is the layout. */
 export const planNumberOps = e3.input("plan_number_ops", DictType(StringType, NumberOpsRow), variant("value", new Map([
-    ["van1", { series: "van", label: "Van 1", value: none, sub: some("drops/day"),
-            jobs: [], shifts: [], marks: [], points: [], sheets: [], cells: [],
-            allocations: [
-                { key: "a1", day: 1.0, lane: "am", state: variant("confirmed", null) },
-                { key: "a2", day: 1.0, lane: "pm", state: variant("confirmed", null) },
-                { key: "a3", day: 2.0, lane: "am", state: variant("confirmed", null) },
-                { key: "a4", day: 3.0, lane: "pm", state: variant("proposed", variant("recommended", null)) },
-                { key: "a5", day: 5.0, lane: "am", state: variant("proposed", variant("recommended", null)) },
-                { key: "a6", day: 6.0, lane: "pm", state: variant("confirmed", null) },
-                { key: "a7", day: 8.0, lane: "am", state: variant("proposed", variant("recommended", null)) },
-            ] }],
-    ["van2", { series: "van", label: "Van 2", value: none, sub: some("drops/day"),
-            jobs: [], shifts: [], marks: [], points: [], sheets: [], cells: [],
-            allocations: [
-                { key: "b1", day: 2.0, lane: "pm", state: variant("confirmed", null) },
-                { key: "b2", day: 4.0, lane: "am", state: variant("confirmed", null) },
-                { key: "b3", day: 4.0, lane: "pm", state: variant("proposed", variant("recommended", null)) },
-                { key: "b4", day: 7.0, lane: "am", state: variant("proposed", variant("recommended", null)) },
-            ] }],
-    ["p03", { series: "press", label: "H1-P03", value: some("12k/h"), sub: none,
-            allocations: [], shifts: [], marks: [], points: [], sheets: [], cells: [],
-            jobs: [
-                { key: "mr", label: "MAKEREADY", start: 1.0, end: 2.0, state: variant("actual", null) },
-                { key: "j4642", label: "RUN · J-4642", start: 2.0, end: 5.0, state: variant("in-progress", null) },
-                { key: "j4663", label: "RUN · J-4663", start: 6.0, end: 8.0, state: variant("proposed", variant("recommended", null)) },
-            ] }],
-    ["p04", { series: "press", label: "H1-P04", value: some("8k/h"), sub: none,
-            allocations: [], shifts: [], marks: [], points: [], sheets: [], cells: [],
-            jobs: [
-                { key: "j4624", label: "RUN · J-4624", start: 1.0, end: 4.0, state: variant("actual", null) },
-                { key: "proof", label: "PROOF", start: 4.0, end: 5.0, state: variant("confirmed", null) },
-                { key: "j4693", label: "RUN · J-4693", start: 5.0, end: 9.0, state: variant("proposed", variant("recommended", null)) },
-            ] }],
-    // Heat cells as STORED records — the instant spelled explicitly.
-    ["load", { series: "load", label: "Hall load", value: none, sub: none,
-            allocations: [], jobs: [], shifts: [], marks: [], points: [], sheets: [],
-            cells: [
-                { at: variant("number", 1.0), value: some(40.0), label: some("40") },
-                { at: variant("number", 2.0), value: some(69.0), label: some("69") },
-                { at: variant("number", 3.0), value: some(43.0), label: some("43") },
-                { at: variant("number", 4.0), value: some(72.0), label: some("72") },
-                { at: variant("number", 5.0), value: some(46.0), label: some("46") },
-                { at: variant("number", 6.0), value: some(75.0), label: some("75") },
-                { at: variant("number", 7.0), value: some(49.0), label: some("49") },
-                { at: variant("number", 8.0), value: some(78.0), label: some("78") },
-            ] }],
-    ["out", { series: "out", label: "Printed · k", value: some("612 k sheets"), sub: none,
-            allocations: [], jobs: [], shifts: [], marks: [], sheets: [], cells: [],
-            points: [
-                { day: 1.0, sheets: 60.0 }, { day: 2.0, sheets: 77.0 }, { day: 3.0, sheets: 94.0 }, { day: 4.0, sheets: 71.0 },
-                { day: 5.0, sheets: 88.0 }, { day: 6.0, sheets: 65.0 }, { day: 7.0, sheets: 82.0 }, { day: 8.0, sheets: 99.0 },
-            ] }],
-    ["desp", { series: "table", label: "Delivered · k", value: none, sub: none,
-            allocations: [], jobs: [], shifts: [], marks: [], points: [], cells: [],
-            sheets: [
-                { at: 1.0, value: some(80.0) }, { at: 2.0, value: some(103.0) }, { at: 3.0, value: some(126.0) }, { at: 4.0, value: some(149.0) },
-                { at: 5.0, value: some(102.0) }, { at: 6.0, value: some(125.0) }, { at: 7.0, value: some(148.0) }, { at: 8.0, value: some(101.0) },
-            ] }],
-    ["crewA", { series: "crew", label: "Crew A", value: none, sub: none,
-            allocations: [], jobs: [], marks: [], points: [], sheets: [], cells: [],
-            shifts: [
-                { key: "s1", from: 1.0, to: 3.0, hours: 24.0, state: variant("confirmed", null) },
-                { key: "s2", from: 3.0, to: 6.0, hours: 36.0, state: variant("confirmed", null) },
-                { key: "s3", from: 6.0, to: 8.0, hours: 24.0, state: variant("proposed", variant("recommended", null)) },
-            ] }],
-    ["ms", { series: "ms", label: "Milestones", value: none, sub: none,
-            allocations: [], jobs: [], shifts: [], points: [], sheets: [], cells: [],
-            marks: [
-                { key: "kick", day: 2.0, label: "KICKOFF" },
-                { key: "rel", day: 6.0, label: "REL" },
-            ] }],
+    ["van1", { ...NUMBER_EMPTY, series: "van", label: "Van 1", value: none, sub: some("drops/day"),
+            allocations: new Map([
+                ["a1", { day: 1.0, lane: "am", state: variant("confirmed", null) }],
+                ["a2", { day: 1.0, lane: "pm", state: variant("confirmed", null) }],
+                ["a3", { day: 2.0, lane: "am", state: variant("confirmed", null) }],
+                ["a4", { day: 3.0, lane: "pm", state: variant("proposed", variant("recommended", null)) }],
+                ["a5", { day: 5.0, lane: "am", state: variant("proposed", variant("recommended", null)) }],
+                ["a6", { day: 6.0, lane: "pm", state: variant("confirmed", null) }],
+                ["a7", { day: 8.0, lane: "am", state: variant("proposed", variant("recommended", null)) }],
+            ]) }],
+    ["van2", { ...NUMBER_EMPTY, series: "van", label: "Van 2", value: none, sub: some("drops/day"),
+            allocations: new Map([
+                ["b1", { day: 2.0, lane: "pm", state: variant("confirmed", null) }],
+                ["b2", { day: 4.0, lane: "am", state: variant("confirmed", null) }],
+                ["b3", { day: 4.0, lane: "pm", state: variant("proposed", variant("recommended", null)) }],
+                ["b4", { day: 7.0, lane: "am", state: variant("proposed", variant("recommended", null)) }],
+            ]) }],
+    ["p03", { ...NUMBER_EMPTY, series: "press", label: "H1-P03", value: some("12k/h"), sub: none,
+            jobs: new Map([
+                ["mr", { label: "MAKEREADY", start: 1.0, end: 2.0, state: variant("actual", null) }],
+                ["j4642", { label: "RUN · J-4642", start: 2.0, end: 5.0, state: variant("in-progress", null) }],
+                ["j4663", { label: "RUN · J-4663", start: 6.0, end: 8.0, state: variant("proposed", variant("recommended", null)) }],
+            ]) }],
+    ["p04", { ...NUMBER_EMPTY, series: "press", label: "H1-P04", value: some("8k/h"), sub: none,
+            jobs: new Map([
+                ["j4624", { label: "RUN · J-4624", start: 1.0, end: 4.0, state: variant("actual", null) }],
+                ["proof", { label: "PROOF", start: 4.0, end: 5.0, state: variant("confirmed", null) }],
+                ["j4693", { label: "RUN · J-4693", start: 5.0, end: 9.0, state: variant("proposed", variant("recommended", null)) }],
+            ]) }],
+    ["load", { ...NUMBER_EMPTY, series: "load", label: "Hall load", value: none, sub: none, load: daily([40.0, 69.0, 43.0, 72.0, 46.0, 75.0, 49.0, 78.0]) }],
+    ["out", { ...NUMBER_EMPTY, series: "out", label: "Printed · k", value: some("612 k sheets"), sub: none,
+            output: daily([60.0, 77.0, 94.0, 71.0, 88.0, 65.0, 82.0, 99.0]) }],
+    ["desp", { ...NUMBER_EMPTY, series: "table", label: "Delivered · k", value: none, sub: none,
+            delivered: daily([80.0, 103.0, 126.0, 149.0, 102.0, 125.0, 148.0, 101.0]) }],
+    ["crewA", { ...NUMBER_EMPTY, series: "crew", label: "Crew A", value: none, sub: none,
+            shifts: new Map([
+                ["s1", { from: 1.0, to: 3.0, hours: 24.0, state: variant("confirmed", null) }],
+                ["s2", { from: 3.0, to: 6.0, hours: 36.0, state: variant("confirmed", null) }],
+                ["s3", { from: 6.0, to: 8.0, hours: 24.0, state: variant("proposed", variant("recommended", null)) }],
+            ]) }],
+    ["ms", { ...NUMBER_EMPTY, series: "ms", label: "Milestones", value: none, sub: none,
+            marks: new Map([
+                ["kick", { day: 2.0, label: "KICKOFF" }],
+                ["rel", { day: 6.0, label: "REL" }],
+            ]) }],
 ])));
 /**
  * The `number` axis — the retired Planner's `plannerPoint` canvas on the
  * Plan: eight days at step 1, AM/PM lanes in the bucket rows, `now` at day
  * 5. Every kind positions on the one numeric scale, and every instant in the
- * raw data is a plain number: a `FloatType` field wraps to the `number` arm
- * through the element builders (`Plan.run({ start: j.start })`), a chart
- * layer's numeric x accessor lands its columns on the same arm, `Plan.tableCells`
- * reads a numeric `at`, and the heat cells stored as RECORDS spell it out with
+ * raw data is a plain number, read by name (#1436): a Float time field of the
+ * things people drag (`Plan.items("jobs", { from: "start", to: "end" }, …)`),
+ * and the Float key of a value a day (`Plan.values("load", …)`), each lands on
  * the `number` arm. One rail (`Slice.bindRecords`, #1344): its `orders`
  * source — twelve days of orders behind the eight-day window, a record of
  * their own — narrows the library's Orders tab by hall, and its range field is
@@ -2265,10 +2157,10 @@ export const planNumberOps = e3.input("plan_number_ops", DictType(StringType, Nu
  */
 export const planNumberAxis = example({
     keywords: [
-        "Plan", "axis", "number", "numeric", "step", "Plan.axis.number", "Plan.at", "instant",
+        "Plan", "axis", "number", "numeric", "step", "Plan.axis.number", "Plan.items", "Plan.values", "instant",
         "day", "AM", "PM", "lanes", "buckets", "Planner", "plannerPoint", "brush", "integer", "range", "half-open",
         "format", "now", "typed axis", "#631", "raw", "Data.bind", "bound", "e3.input", "e3.record",
-        "Slice.bindRecords", "source", "Data.bindPaged", "recordIndex", "library", "Plan.library.tab", "#1344",
+        "Slice.bindRecords", "source", "Data.bindPaged", "indexes", "library", "Plan.library.tab", "#1344",
     ],
     description: "The number axis over rows bound from e3 — day 1..8 at step 1 with AM/PM lanes (the retired Planner's plannerPoint), every row kind on the numeric scale; one Slice.bindRecords rail whose orders source narrows the Orders tab by hall and holds the window, the horizon brush over its integer range",
     fn: East.function([], UIComponentType, (_$) => {
@@ -2285,51 +2177,49 @@ export const planNumberAxis = example({
                             label: r => r.label, sub: r => r.sub,
                             // The Planner's AM/PM lanes — sub-slots of each day column.
                             lanes: _r => [Plan.lane({ key: "am", label: "AM" }), Plan.lane({ key: "pm", label: "PM" })],
-                            // `a.day` is a FloatType field — the builder wraps it to the number arm.
-                            events: r => r.allocations.map((_$, a) => Plan.event({ key: a.key, at: a.day, lane: a.lane, state: a.state })),
+                            // `day` is a Float field of each drop — the read places it on the number arm.
+                            events: Plan.items("allocations", { at: "day" }, (alloc) => ({ lane: alloc.lane, state: alloc.state })),
                         }),
                     ]),
                     Plan.series.span(NumberOpsRow, {
                         key: "press", title: "Presses",
                         match: r => r.series.equal("press"),
                         label: r => r.label, id: true, value: r => r.value,
-                        runs: r => r.jobs.map((_$, j) => Plan.run({ key: j.key, start: j.start, end: j.end, label: j.label, state: j.state })),
+                        runs: Plan.items("jobs", { from: "start", to: "end" }, (job) => ({ label: job.label, state: job.state })),
                     }),
                     Plan.series.heat(NumberOpsRow, {
                         key: "load", title: "Hall load",
                         match: r => r.series.equal("load"),
                         label: r => r.label,
-                        cells: r => Plan.heatCells(r.cells, { min: 0, max: 100, warnAt: 90 }),
+                        // A value a day, keyed by its Float day — each cell on the number arm.
+                        cells: Plan.heatCells(Plan.values("load", (pct) => ({ value: pct, label: some(East.Float.printFixed(pct, 0n)) })), { min: 0, max: 100, warnAt: 90 }),
                     }),
                     Plan.series.chart(NumberOpsRow, {
                         key: "out", title: "Output",
                         match: r => r.series.equal("out"),
                         label: r => r.label, id: true, value: r => r.value, height: "expanded",
-                        // A numeric x accessor lands the columns on the number arm.
-                        layers: r => [Chart.Column(r.points, { x: p => p.day, y: p => p.sheets })],
+                        layers: [Plan.column(Plan.values("output", (sheets) => ({ y: sheets })))],
                     }),
                     Plan.series.table(NumberOpsRow, {
                         key: "table", title: "Deliveries",
                         match: r => r.series.equal("table"),
                         label: r => r.label,
-                        // A `{ at: FloatType, value }` record wraps by its field type.
-                        cells: r => Plan.tableCells(r.sheets),
+                        cells: Plan.tableCells(Plan.values("delivered", (sheets) => ({ value: sheets }))),
                         format: Format.Number({ maximumFractionDigits: 0n }),
                     }),
                     Plan.series.cards(NumberOpsRow, {
                         key: "crew", title: "Crews",
                         match: r => r.series.equal("crew"),
                         label: r => r.label,
-                        chips: r => r.shifts.map((_$, s) => Plan.chip({
-                            key: s.key, from: s.from, to: s.to,
-                            label: East.str `${East.Float.printFixed(s.hours, 0n)}h`, state: s.state,
+                        chips: Plan.items("shifts", { from: "from", to: "to" }, (shift) => ({
+                            label: East.str `${East.Float.printFixed(shift.hours, 0n)}h`, state: shift.state,
                         })),
                     }),
                     Plan.series.events(NumberOpsRow, {
                         key: "ms", title: "Milestones",
                         match: r => r.series.equal("ms"),
                         label: r => r.label, id: true,
-                        marks: r => r.marks.map((_$, m) => Plan.mark({ key: m.key, at: m.day, kind: "milestone", label: m.label })),
+                        marks: Plan.items("marks", { at: "day" }, (mark) => ({ kind: "milestone", label: mark.label })),
                     }),
                 ], ArrayType(Plan.Types.Series(NumberOpsRow)));
                 // The orders' range field is an INTEGER day, so the brush, the
@@ -2337,7 +2227,7 @@ export const planNumberAxis = example({
                 // half-open range — the eight days `[1, 9)`.
                 const slice = $.let(Slice.bindRecords("ex.plan.number", {
                     orders: {
-                        source: Data.bindPaged(planNumberOrders, { indexes: [planNumberOrdersByDay, planNumberOrdersByHallDay] }),
+                        source: Data.bindPaged(planNumberOrders, { indexes: ["plan_number_orders_by_day", "plan_number_orders_by_hall_day"] }),
                         label: "Orders", icon: { prefix: "fas", name: "box" },
                         fields: { hall: { label: "Hall", hints: ["Hall 1", "Hall 2"] }, day: { label: "Day" } },
                         range: "day", search: [],
@@ -2363,100 +2253,78 @@ export const planNumberAxis = example({
 // ============================================================================
 // planOrdinalAxis — the `ordinal` axis (#631): workflow phases
 // ============================================================================
-/** A job — the phases it spans, by name. */
-export const OrdinalJob = StructType({ key: StringType, label: StringType, start: StringType, end: StringType, state: EventStateType });
-/** A bindery slot — the phase it sits in. */
-export const OrdinalAlloc = StructType({ key: StringType, phase: StringType, state: EventStateType });
-/** A crew shift — the phases it covers. */
-export const OrdinalShift = StructType({ key: StringType, from: StringType, to: StringType, label: StringType, state: EventStateType });
-/** A gate — its phase, and whether it holds the work. */
-export const OrdinalMark = StructType({ key: StringType, phase: StringType, label: StringType, exception: BooleanType });
-/** A chart point — a phase and a count. */
-export const OrdinalPoint = StructType({ phase: StringType, n: FloatType });
-/** A table reading — a phase and its value. */
-export const OrdinalReading = StructType({ at: StringType, value: OptionType(FloatType) });
-/** RAW rows — every instant is a phase NAME. */
+/** A job, under its id — the phases it spans, by name. */
+export const OrdinalJob = StructType({ label: StringType, start: StringType, end: StringType, state: EventStateType });
+/** A bindery slot, under its id — the phase it sits in. */
+export const OrdinalAlloc = StructType({ phase: StringType, state: EventStateType });
+/** A crew shift, under its id — the phases it covers. */
+export const OrdinalShift = StructType({ from: StringType, to: StringType, label: StringType, state: EventStateType });
+/** A gate, under its id — its phase, and whether it holds the work. */
+export const OrdinalMark = StructType({ phase: StringType, label: StringType, exception: BooleanType });
+/** RAW rows — every instant is a phase NAME: the things people drag by their ids, their phases fields of them, and a
+ *  value a phase keyed by the phase, each a Dict a series reads by name (#1436). */
 export const OrdinalOrderRow = StructType({
     series: StringType, label: StringType, value: OptionType(StringType), sub: OptionType(StringType),
-    jobs: ArrayType(OrdinalJob), allocations: ArrayType(OrdinalAlloc), shifts: ArrayType(OrdinalShift),
-    marks: ArrayType(OrdinalMark), points: ArrayType(OrdinalPoint), counts: ArrayType(OrdinalReading),
-    cells: ArrayType(Plan.Types.HeatCell),
+    jobs: DictType(StringType, OrdinalJob), allocations: DictType(StringType, OrdinalAlloc), shifts: DictType(StringType, OrdinalShift),
+    marks: DictType(StringType, OrdinalMark), wip: DictType(StringType, FloatType), counts: DictType(StringType, OptionType(FloatType)),
+    load: DictType(StringType, FloatType),
 });
+/** Every collection a row holds, empty: a row names the few it fills. */
+const ORDINAL_EMPTY = {
+    jobs: new Map(), allocations: new Map(), shifts: new Map(), marks: new Map(), wip: new Map(), counts: new Map(), load: new Map(),
+};
 /** The jobs, bindery slots, loads and gates of a six-phase workflow. */
 export const planOrdinalOrders = e3.input("plan_ordinal_orders", DictType(StringType, OrdinalOrderRow), variant("value", new Map([
-    ["j6188", { series: "job", label: "J-6188", value: some("96 k sheets"), sub: none,
-            allocations: [], shifts: [], marks: [], points: [], counts: [], cells: [],
-            jobs: [
-                { key: "plates", label: "PLATES", start: "PREPRESS", end: "PLATES", state: variant("actual", null) },
-                { key: "print", label: "PRINT · J-4642", start: "PRINT", end: "FINISH", state: variant("in-progress", null) },
-                { key: "deliver", label: "BIND + DELIVER", start: "BIND", end: "DELIVER", state: variant("proposed", variant("recommended", null)) },
-            ] }],
-    ["j6204", { series: "job", label: "J-6204", value: some("54 k sheets"), sub: none,
-            allocations: [], shifts: [], marks: [], points: [], counts: [], cells: [],
-            jobs: [
-                { key: "prepress", label: "PREPRESS", start: "PREPRESS", end: "PREPRESS", state: variant("actual", null) },
-                { key: "print", label: "PRINT · J-4663", start: "PLATES", end: "BIND", state: variant("proposed", variant("recommended", null)) },
-            ] }],
-    ["bindery", { series: "bindery", label: "Bindery 2", value: none, sub: some("slots"),
-            jobs: [], shifts: [], marks: [], points: [], counts: [], cells: [],
-            allocations: [
-                { key: "a1", phase: "PLATES", state: variant("confirmed", null) }, { key: "a2", phase: "PRINT", state: variant("confirmed", null) },
-                { key: "a3", phase: "PRINT", state: variant("proposed", variant("recommended", null)) }, { key: "a4", phase: "BIND", state: variant("proposed", variant("recommended", null)) },
-            ] }],
-    // Heat cells as STORED records — the phase spelled on the `ordinal` arm.
-    ["load", { series: "load", label: "Phase load", value: none, sub: none,
-            jobs: [], allocations: [], shifts: [], marks: [], points: [], counts: [],
-            cells: [
-                { at: variant("ordinal", "PREPRESS"), value: some(35.0), label: some("35") },
-                { at: variant("ordinal", "PLATES"), value: some(66.0), label: some("66") },
-                { at: variant("ordinal", "PRINT"), value: some(37.0), label: some("37") },
-                { at: variant("ordinal", "FINISH"), value: some(68.0), label: some("68") },
-                { at: variant("ordinal", "BIND"), value: some(39.0), label: some("39") },
-                { at: variant("ordinal", "DELIVER"), value: some(70.0), label: some("70") },
-            ] }],
-    ["wip", { series: "wip", label: "WIP · jobs", value: some("31"), sub: none,
-            jobs: [], allocations: [], shifts: [], marks: [], counts: [], cells: [],
-            points: [
-                { phase: "PREPRESS", n: 4.0 }, { phase: "PLATES", n: 11.0 }, { phase: "PRINT", n: 18.0 },
-                { phase: "FINISH", n: 5.0 }, { phase: "BIND", n: 12.0 }, { phase: "DELIVER", n: 19.0 },
-            ] }],
-    ["count", { series: "count", label: "Jobs in phase", value: none, sub: none,
-            jobs: [], allocations: [], shifts: [], marks: [], points: [], cells: [],
-            counts: [
-                { at: "PREPRESS", value: some(12.0) }, { at: "PLATES", value: some(23.0) }, { at: "PRINT", value: some(34.0) },
-                { at: "FINISH", value: some(15.0) }, { at: "BIND", value: none }, { at: "DELIVER", value: some(37.0) },
-            ] }],
-    ["crew", { series: "crew", label: "Crew B", value: none, sub: none,
-            jobs: [], allocations: [], marks: [], points: [], counts: [], cells: [],
-            shifts: [
-                { key: "s1", from: "PREPRESS", to: "PLATES", label: "prepress crew", state: variant("confirmed", null) },
-                { key: "s2", from: "PRINT", to: "DELIVER", label: "+ bindery crew", state: variant("proposed", variant("recommended", null)) },
-            ] }],
-    ["gates", { series: "gates", label: "Gates", value: none, sub: none,
-            jobs: [], allocations: [], shifts: [], points: [], counts: [], cells: [],
-            marks: [
-                { key: "g1", phase: "FINISH", label: "HOLD", exception: true },
-                { key: "g2", phase: "DELIVER", label: "RELEASE", exception: false },
-            ] }],
+    ["j6188", { ...ORDINAL_EMPTY, series: "job", label: "J-6188", value: some("96 k sheets"), sub: none,
+            jobs: new Map([
+                ["plates", { label: "PLATES", start: "PREPRESS", end: "PLATES", state: variant("actual", null) }],
+                ["print", { label: "PRINT · J-4642", start: "PRINT", end: "FINISH", state: variant("in-progress", null) }],
+                ["deliver", { label: "BIND + DELIVER", start: "BIND", end: "DELIVER", state: variant("proposed", variant("recommended", null)) }],
+            ]) }],
+    ["j6204", { ...ORDINAL_EMPTY, series: "job", label: "J-6204", value: some("54 k sheets"), sub: none,
+            jobs: new Map([
+                ["prepress", { label: "PREPRESS", start: "PREPRESS", end: "PREPRESS", state: variant("actual", null) }],
+                ["print", { label: "PRINT · J-4663", start: "PLATES", end: "BIND", state: variant("proposed", variant("recommended", null)) }],
+            ]) }],
+    ["bindery", { ...ORDINAL_EMPTY, series: "bindery", label: "Bindery 2", value: none, sub: some("slots"),
+            allocations: new Map([
+                ["a1", { phase: "PLATES", state: variant("confirmed", null) }], ["a2", { phase: "PRINT", state: variant("confirmed", null) }],
+                ["a3", { phase: "PRINT", state: variant("proposed", variant("recommended", null)) }], ["a4", { phase: "BIND", state: variant("proposed", variant("recommended", null)) }],
+            ]) }],
+    ["load", { ...ORDINAL_EMPTY, series: "load", label: "Phase load", value: none, sub: none,
+            load: new Map([["PREPRESS", 35.0], ["PLATES", 66.0], ["PRINT", 37.0], ["FINISH", 68.0], ["BIND", 39.0], ["DELIVER", 70.0]]) }],
+    ["wip", { ...ORDINAL_EMPTY, series: "wip", label: "WIP · jobs", value: some("31"), sub: none,
+            wip: new Map([["PREPRESS", 4.0], ["PLATES", 11.0], ["PRINT", 18.0], ["FINISH", 5.0], ["BIND", 12.0], ["DELIVER", 19.0]]) }],
+    ["count", { ...ORDINAL_EMPTY, series: "count", label: "Jobs in phase", value: none, sub: none,
+            counts: new Map([["PREPRESS", some(12.0)], ["PLATES", some(23.0)], ["PRINT", some(34.0)], ["FINISH", some(15.0)], ["BIND", none], ["DELIVER", some(37.0)]]) }],
+    ["crew", { ...ORDINAL_EMPTY, series: "crew", label: "Crew B", value: none, sub: none,
+            shifts: new Map([
+                ["s1", { from: "PREPRESS", to: "PLATES", label: "prepress crew", state: variant("confirmed", null) }],
+                ["s2", { from: "PRINT", to: "DELIVER", label: "+ bindery crew", state: variant("proposed", variant("recommended", null)) }],
+            ]) }],
+    ["gates", { ...ORDINAL_EMPTY, series: "gates", label: "Gates", value: none, sub: none,
+            marks: new Map([
+                ["g1", { phase: "FINISH", label: "HOLD", exception: true }],
+                ["g2", { phase: "DELIVER", label: "RELEASE", exception: false }],
+            ]) }],
 ])));
 /**
  * The `ordinal` axis — a workflow of six phases, each a bucket, in declared
- * order. Instants are the phase VALUES: a run's `start` / `end` are phase
- * names (an interval covers `[start, end]` in phase order — on an ordinal
- * axis the end names the LAST bucket covered, since values are buckets, not
- * edges), a tile sits in a phase, a chart's string x accessor lands its
- * columns on the phase arm, `Plan.tableCells` reads a string `at`, and a
- * record written as data spells its phase on the `ordinal` arm. There is no
+ * order. Instants are the phase VALUES, read by name (#1436): a run's `start`
+ * / `end` are phase names (an interval covers `[start, end]` in phase order —
+ * on an ordinal axis the end names the LAST bucket covered, since values are
+ * buckets, not edges), a tile and a gate sit in a phase, and a value a phase is
+ * keyed by the phase's name — a load cell, a column, a count. There is no
  * slice range for an ordinal axis — the list IS the window, so the horizon
  * brush does not mount and the window keys idle; `now` names a phase.
  */
 export const planOrdinalAxis = example({
     keywords: [
         "Plan", "axis", "ordinal", "phase", "phases", "workflow", "stage", "Plan.axis.ordinal",
-        "Plan.at", "instant", "values", "list", "span", "buckets", "heat", "chart", "table",
+        "Plan.items", "Plan.values", "instant", "values", "list", "span", "buckets", "heat", "chart", "table",
         "cards", "events", "Planner", "typed axis", "#631", "raw", "Data.bind", "bound", "e3.input",
     ],
-    description: "The ordinal axis over rows bound from e3 — six workflow phases as the buckets, in declared order; jobs span phases, tiles and cells sit in them, a string x accessor lands a chart on them",
+    description: "The ordinal axis over rows bound from e3 — six workflow phases as the buckets, in declared order; jobs span phases, tiles and gates sit in them, and a value a phase, keyed by the phase, lands a heat cell, a column and a count in each",
     fn: East.function([], UIComponentType, (_$) => (_jsx(Reactive, { children: $ => {
             const orders = $.let(Data.bind(planOrdinalOrders));
             const PHASES = $.const(["PREPRESS", "PLATES", "PRINT", "FINISH", "BIND", "DELIVER"], ArrayType(StringType));
@@ -2468,49 +2336,48 @@ export const planOrdinalAxis = example({
                         key: "job", title: "Jobs",
                         match: r => r.series.equal("job"),
                         label: r => r.label, id: true, value: r => r.value,
-                        // `j.start` / `j.end` are StringType fields — the builder wraps them to the ordinal arm.
-                        runs: r => r.jobs.map((_$, j) => Plan.run({ key: j.key, start: j.start, end: j.end, label: j.label, state: j.state })),
+                        // `start` / `end` are String fields of each job — the read places them on the ordinal arm.
+                        runs: Plan.items("jobs", { from: "start", to: "end" }, (job) => ({ label: job.label, state: job.state })),
                     }),
                 ]),
                 Plan.series.buckets(OrdinalOrderRow, {
                     key: "bindery", title: "Bindery",
                     match: r => r.series.equal("bindery"),
                     label: r => r.label, sub: r => r.sub,
-                    events: r => r.allocations.map((_$, a) => Plan.event({ key: a.key, at: a.phase, state: a.state })),
+                    events: Plan.items("allocations", { at: "phase" }, (alloc) => ({ state: alloc.state })),
                 }),
                 Plan.series.heat(OrdinalOrderRow, {
                     key: "load", title: "Phase load",
                     match: r => r.series.equal("load"),
                     label: r => r.label,
-                    cells: r => Plan.heatCells(r.cells, { min: 0, max: 100, warnAt: 90 }),
+                    // A value a phase, keyed by the phase's name — each cell in its phase.
+                    cells: Plan.heatCells(Plan.values("load", (pct) => ({ value: pct, label: some(East.Float.printFixed(pct, 0n)) })), { min: 0, max: 100, warnAt: 90 }),
                 }),
                 Plan.series.chart(OrdinalOrderRow, {
                     key: "wip", title: "WIP",
                     match: r => r.series.equal("wip"),
                     label: r => r.label, id: true, value: r => r.value, height: "expanded",
-                    // A string x accessor lands the columns on the ordinal arm.
-                    layers: r => [Chart.Column(r.points, { x: p => p.phase, y: p => p.n })],
+                    layers: [Plan.column(Plan.values("wip", (n) => ({ y: n })))],
                 }),
                 Plan.series.table(OrdinalOrderRow, {
                     key: "count", title: "Counts",
                     match: r => r.series.equal("count"),
                     label: r => r.label,
-                    cells: r => Plan.tableCells(r.counts),
+                    cells: Plan.tableCells(Plan.values("counts", (n) => ({ value: n }))),
                     format: Format.Number({ maximumFractionDigits: 0n }),
                 }),
                 Plan.series.cards(OrdinalOrderRow, {
                     key: "crew", title: "Crews",
                     match: r => r.series.equal("crew"),
                     label: r => r.label,
-                    chips: r => r.shifts.map((_$, s) => Plan.chip({ key: s.key, from: s.from, to: s.to, label: s.label, state: s.state })),
+                    chips: Plan.items("shifts", { from: "from", to: "to" }, (shift) => ({ label: shift.label, state: shift.state })),
                 }),
                 Plan.series.events(OrdinalOrderRow, {
                     key: "gates", title: "Gates",
                     match: r => r.series.equal("gates"),
                     label: r => r.label, id: true,
-                    marks: r => r.marks.map((_$, m) => Plan.mark({
-                        key: m.key, at: m.phase, label: m.label,
-                        kind: m.exception.ifElse(() => EXCEPTION, () => MILESTONE),
+                    marks: Plan.items("marks", { at: "phase" }, (gate) => ({
+                        label: gate.label, kind: gate.exception.ifElse(() => EXCEPTION, () => MILESTONE),
                     })),
                 }),
             ], ArrayType(Plan.Types.Series(OrdinalOrderRow)));
@@ -2530,18 +2397,22 @@ export const planOrdinalAxis = example({
 /** A task on the plan — its owner and its window. */
 export const SliceJob = StructType({ task: StringType, owner: StringType, start: DateTimeType, end: DateTimeType });
 /** The plan's tasks, by name — a record of their own, the rows the slice's `rows` source narrows (#1344). */
-export const planSliceJobs = e3.record("plan_slice_jobs", DictType(StringType, SliceJob), new Map([
-    ["Planning", { task: "Planning", owner: "Team A", start: new Date("2024-01-01T00:00:00Z"), end: new Date("2024-01-15T00:00:00Z") }],
-    ["Design", { task: "Design", owner: "Team B", start: new Date("2024-01-10T00:00:00Z"), end: new Date("2024-02-01T00:00:00Z") }],
-    ["Development", { task: "Development", owner: "Team C", start: new Date("2024-01-20T00:00:00Z"), end: new Date("2024-03-15T00:00:00Z") }],
-    ["Testing", { task: "Testing", owner: "Team A", start: new Date("2024-03-01T00:00:00Z"), end: new Date("2024-03-30T00:00:00Z") }],
-]));
-// The tasks over the interval each runs, alone and after its owner: a range of dates the rail chooses reads every task
-// overlapping it once, an owner's beside it too.
-export const planSliceJobsByTime = e3.recordIndex.interval("plan_slice_jobs_by_time", planSliceJobs, { from: "start", to: "end" });
-export const planSliceJobsByOwnerTime = e3.recordIndex.interval("plan_slice_jobs_by_owner_time", planSliceJobs, { on: ["owner"], from: "start", to: "end" });
+export const planSliceJobs = e3.record("plan_slice_jobs", DictType(StringType, SliceJob), {
+    initial: new Map([
+        ["Planning", { task: "Planning", owner: "Team A", start: new Date("2024-01-01T00:00:00Z"), end: new Date("2024-01-15T00:00:00Z") }],
+        ["Design", { task: "Design", owner: "Team B", start: new Date("2024-01-10T00:00:00Z"), end: new Date("2024-02-01T00:00:00Z") }],
+        ["Development", { task: "Development", owner: "Team C", start: new Date("2024-01-20T00:00:00Z"), end: new Date("2024-03-15T00:00:00Z") }],
+        ["Testing", { task: "Testing", owner: "Team A", start: new Date("2024-03-01T00:00:00Z"), end: new Date("2024-03-30T00:00:00Z") }],
+    ]),
+    indexes: (index) => ({
+        // The tasks over the interval each runs, alone and after its owner: a range of dates the rail chooses reads every task
+        // overlapping it once, an owner's beside it too.
+        plan_slice_jobs_by_time: index.interval({ from: "start", to: "end" }),
+        plan_slice_jobs_by_owner_time: index.interval({ on: ["owner"], from: "start", to: "end" }),
+    }),
+});
 export const slicePlanChrome = example({
-    keywords: ["Slice", "Slice.bindRecords", "rows", "Plan", "slice", "rail", "filter", "range", "brush", "timeline", "Data.bindPaged", "recordIndex", "interval", "e3.record", "#1344"],
+    keywords: ["Slice", "Slice.bindRecords", "rows", "Plan", "slice", "rail", "filter", "range", "brush", "timeline", "Data.bindPaged", "indexes", "interval", "e3.record", "#1344"],
     description: "Ops plan — a Plan narrowed through one Slice.bindRecords rail over tasks bound from e3: its `rows` source gives the canvas its rows, paged through the tasks' interval index and narrowed by owner and by their dates — fields of the rail the viewer sets — while the window is the canvas's own: the toolbar's dates and the horizon brush move it, and never decide which tasks are listed",
     fn: East.function([], UIComponentType, (_$) => {
         return (_jsx(Reactive, { children: $ => {
@@ -2549,7 +2420,7 @@ export const slicePlanChrome = example({
                 // the rail, the viewer's to set: the dates on screen never narrow the tasks.
                 const slice = $.let(Slice.bindRecords("ex.slice.plan.chrome", {
                     rows: {
-                        source: Data.bindPaged(planSliceJobs, { indexes: [planSliceJobsByTime, planSliceJobsByOwnerTime] }),
+                        source: Data.bindPaged(planSliceJobs, { indexes: ["plan_slice_jobs_by_time", "plan_slice_jobs_by_owner_time"] }),
                         label: "Tasks",
                         fields: { owner: { label: "Owner", hints: ["Team A", "Team B", "Team C"] }, start: { label: "Start" } },
                         search: [],