@elaraai/east-ui 1.0.80 → 1.0.82

package/dist/src/collections/plan/ir.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ir.d.ts","sourceRoot":"","sources":["../../../../src/collections/plan/ir.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;GAWG;AAEH,OAAO,EACH,SAAS,EACT,YAAY,EACZ,QAAQ,EACR,UAAU,EACV,UAAU,EACV,UAAU,EACb,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAErD,OAAO,EAAc,KAAK,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AAGhF,OAAO,EAMH,cAAc,EASjB,MAAM,YAAY,CAAC;AAMpB;;;GAGG;AACH,eAAO,MAAM,cAAc,EAAE,gBAAgB,CAAC,cAAc,EAAE,eAAe,CAA+C,CAAC;AAC7H,6CAA6C;AAC7C,MAAM,MAAM,cAAc,GAAG,OAAO,cAAc,CAAC;AAEnD;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsCvB,CAAC;AACH,2CAA2C;AAC3C,MAAM,MAAM,YAAY,GAAG,OAAO,YAAY,CAAC"}
+{"version":3,"file":"ir.d.ts","sourceRoot":"","sources":["../../../../src/collections/plan/ir.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;GAWG;AAEH,OAAO,EACH,SAAS,EACT,YAAY,EACZ,QAAQ,EACR,UAAU,EACV,UAAU,EACV,UAAU,EACb,MAAM,eAAe,CAAC;AAMvB,OAAO,EAWH,eAAe,EAClB,MAAM,YAAY,CAAC;AAMpB;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,cAAc;;;;;EAKzB,CAAC;AACH,6CAA6C;AAC7C,MAAM,MAAM,cAAc,GAAG,OAAO,cAAc,CAAC;AAEnD;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyCvB,CAAC;AACH,2CAA2C;AAC3C,MAAM,MAAM,YAAY,GAAG,OAAO,YAAY,CAAC"}

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

@@ -5,30 +5,48 @@
 /**
  * The Plan's resolved UIComponent-coupled IR — since the data-interface
  * redesign only the ROOT and the review config touch `UIComponentType`; the
- * whole row vocabulary (elements, kinds, rows, templates) is pure
- * data in `./types.ts`. These are the named twins of the `Plan` arm in
- * `component.ts` (which spells the SAME shapes inline with the recursion
- * `node`). Keep the two in lockstep: every factory builds values of these
- * types and `Plan.Root` constructs the variant against the arm, so any
- * drift fails the specs at build time.
+ * whole row vocabulary (elements, kinds, rows) is pure data in `./types.ts`.
+ * These are the named twins of the `Plan` arm in `component.ts`, which spells
+ * the SAME shapes inline with the recursion `node`. The renderer decodes the
+ * arm's values through {@link PlanRootType}, so the two must be one East
+ * type: `test/collections/plan.spec.ts` compares them as East type values,
+ * and a field (or a field type) on only one side fails it.
  *
  * @packageDocumentation
  */
 import { ArrayType, FunctionType, NullType, OptionType, StringType, StructType, } from "@elaraai/east";
 import { UIComponentType } from "../../component.js";
 import { PickBindType } from "../../contracts/pick.js";
-import { reviewType } from "../../contracts/approval.js";
-import { CanDropFnType, DragEventType } from "../../contracts/drag.js";
+import { CanDropFnType } from "../../contracts/drag.js";
 import { SliceChromeType } from "../../platform/slice/index.js";
-import { PlanAxisType, PlanGrainType, PlanLinkType, PlanRowsType, PlanElementRefType, PlanRowRefType, PlanRunClickEventType, PlanEventClickEventType, PlanMarkClickEventType, PlanChipClickEventType, PlanCellClickEventType, PlanGroupToggleEventType, PlanFooterItemType, PlanStyleType, } from "./types.js";
+import { PlanAxisType, PlanGrainType, PlanLinkType, PlanRowsType, PlanElementRefType, PlanRowIdType, PlanGroupToggleEventType, PlanFooterItemType, PlanStyleType, PlanUiBindType, PlanEditingType, } from "./types.js";
 // ============================================================================
 // Resolved types — the UIComponent-coupled shapes at `UIComponentType`
 // ============================================================================
 /**
- * The Plan review config — the shared review contract at the Plan's
- * keyed-row subject (`{ key }`).
+ * The Plan's review chrome (#880) — the decision column's header, the foot's
+ * summary and its Rerun.
+ *
+ * @remarks
+ * A verdict is a GESTURE of the root's editing session: the series whose rows
+ * are reviewed names the field it writes (`review.verdict`), Approve / Reject
+ * on a row and Approve all / Reject all over the canvas draft the entries,
+ * and Apply sends them as one checked batch. So the chrome carries no verdict
+ * callbacks — the shared contract's (`reviewType`) stay with Table, Roster
+ * and Board until they adopt a session. Rerun changes no data, so it stays a
+ * callback.
+ *
+ * @property columnLabel - The decision column's header (`"Decision"` by default)
+ * @property summary - The foot's eyebrow — a host-composed component
+ * @property onRerun - The Rerun verb (absent ⇒ no Rerun button)
+ * @property rerunLabel - The Rerun button's label (`"Rerun"` by default)
  */
-export const PlanReviewType = reviewType(PlanRowRefType, UIComponentType);
+export const PlanReviewType = StructType({
+    columnLabel: StringType,
+    summary: OptionType(UIComponentType),
+    onRerun: OptionType(FunctionType([], NullType)),
+    rerunLabel: StringType,
+});
 /**
  * The Plan root IR — the whole canvas.
  *
@@ -38,8 +56,11 @@ export const PlanReviewType = reviewType(PlanRowRefType, UIComponentType);
  * order is data (no sort callback), and element detail lives in the root
  * RESOLVERS: `popover` / `hover` over {@link PlanElementRefType} (a `none`
  * result opens nothing) and `expandRender` over the row ref (the R2
- * developer render for rows declaring `expand`) — one stored function per
- * surface instead of UI embedded per element.
+ * developer render for rows declaring `expand`, over the row's id) — one stored function per
+ * surface instead of UI embedded per element. A click on any element reports
+ * to ONE callback over the same ref (`onElementClick`, #824), and the
+ * interaction state a host wants to hold — selection, collapse, charts, a row
+ * to bring into view — rides a bound `ui` state.
  */
 export const PlanRootType = StructType({
     rows: PlanRowsType,
@@ -54,30 +75,33 @@ export const PlanRootType = StructType({
     // the action callbacks below).
     popover: OptionType(FunctionType([PlanElementRefType], OptionType(UIComponentType))),
     hover: OptionType(FunctionType([PlanElementRefType], OptionType(UIComponentType))),
-    expandRender: OptionType(FunctionType([PlanRowRefType], UIComponentType)),
+    expandRender: OptionType(FunctionType([PlanRowIdType], UIComponentType)),
     // The GUTTER half of R2. An expanded row's gutter cell grows with the row
     // (one tall cell, top-aligned), and the space that opens up is the
     // author's — identity that only earns its place when the row has the
-    // canvas. Same shape as `expandRender`, over the same row ref.
-    expandGutter: OptionType(FunctionType([PlanRowRefType], UIComponentType)),
+    // canvas. Same shape as `expandRender`, over the same row id.
+    expandGutter: OptionType(FunctionType([PlanRowIdType], UIComponentType)),
     review: OptionType(PlanReviewType),
+    // The editing session (#880) — every verdict, every dropped card and every
+    // moved or resized element (#825) is a draft, applied as one checked batch.
+    editing: OptionType(PlanEditingType),
     pick: OptionType(PickBindType),
     slice: OptionType(SliceChromeType),
     footer: ArrayType(PlanFooterItemType),
-    // DnD target role — the shared grammar verbatim (contracts/drag.ts).
-    id: StringType,
+    // DnD target role — the shared grammar (contracts/drag.ts); no id, no
+    // library card lands (#824 — it used to be `""`), though the canvas's own
+    // elements still move (#825). A drop or a move is a gesture of the editing
+    // session (#880); `canDrop` vets it first.
+    id: OptionType(StringType),
     sources: ArrayType(StringType),
-    onDrag: OptionType(FunctionType([DragEventType], NullType)),
     canDrop: OptionType(CanDropFnType),
-    // Selection + per-element clicks.
-    onSelect: OptionType(FunctionType([PlanRowRefType], NullType)),
-    onRunClick: OptionType(FunctionType([PlanRunClickEventType], NullType)),
-    onEventClick: OptionType(FunctionType([PlanEventClickEventType], NullType)),
-    onMarkClick: OptionType(FunctionType([PlanMarkClickEventType], NullType)),
-    onChipClick: OptionType(FunctionType([PlanChipClickEventType], NullType)),
-    onCellClick: OptionType(FunctionType([PlanCellClickEventType], NullType)),
+    // Selection + the one element click (#824).
+    onSelect: OptionType(FunctionType([PlanRowIdType], NullType)),
+    onElementClick: OptionType(FunctionType([PlanElementRefType], NullType)),
     onGroupToggle: OptionType(FunctionType([PlanGroupToggleEventType], NullType)),
     onGrainChange: OptionType(FunctionType([PlanGrainType], NullType)),
+    // The interaction state a host holds — a bound `State.bind` handle (#824).
+    ui: OptionType(PlanUiBindType),
     style: OptionType(PlanStyleType),
 });
 //# sourceMappingURL=ir.js.map

package/dist/src/collections/plan/ir.js.map

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

package/dist/src/collections/plan/pick.d.ts

@@ -6,31 +6,21 @@
  * `Plan.pick` — the Plan's façade over the shared pick contract (#590).
  *
  * The contract holds identified things and does not know what they are, so an
- * adopter supplies the two things it cannot: how to read identity off one item,
- * and what a useful count is. For a Plan that is a nine-arm match over the
- * series variant, plus the row count that series would contribute.
+ * adopter supplies what it cannot: how to read identity off one item. For a
+ * Plan that is an eleven-arm match over the series variant — every arm carries
+ * the same four identity fields, and the arm itself picks the kind's icon.
  *
- * Nothing here is Plan-specific machinery — it is ~40 lines of accessors. The
- * façade exists so an author writes `Plan.pick(key, all)` instead of restating
- * the match at every call site, not because the Plan needs its own contract.
+ * There are no per-series row counts (#822): a count means something only when
+ * every entry is in hand, and nothing on a Plan may behave differently because
+ * its data is inline or paged.
  *
  * @packageDocumentation
  */
-import { type ExprType, type SubtypeExprOrValue, ArrayType, DictType, StringType, StructType } from "@elaraai/east";
+import { type ExprType, ArrayType } from "@elaraai/east";
 import { type PickHandle, type PickItemType } from "../../contracts/pick.js";
 import { PlanSeriesType, type PlanSeriesInput } from "./series.js";
 /** Options for {@link createPlanPick}. */
 export interface PlanPickOptions {
-    /**
-     * The canvas data. Supplying it gives each library entry its row COUNT,
-     * derived by running that series' own pipeline — which is what turns "this
-     * series is on" into "this series contributes 18 rows", and what surfaces
-     * the `0 rs` case where a series is switched on to no visible effect.
-     *
-     * Omit it for a paged canvas: a window cannot know the total, and a wrong
-     * count is worse than none.
-     */
-    data?: SubtypeExprOrValue<DictType<StringType, StructType>>;
     /** Series switched off to begin with; omit ⇒ everything shows. */
     hidden?: readonly string[];
 }
@@ -38,27 +28,92 @@ export interface PlanPickOptions {
  * Bind a Plan's row series to a persisted pick.
  *
  * @remarks
- * A GROUP is the unit a person picks — "add Machines" — and hiding one takes
- * its whole subtree with it, because the members are built by the group's own
- * `derive`. That is why every arm carries identity (#590 §6.1): without it the
- * library could only offer top-level series, which on a grouped canvas is
- * almost nothing.
+ * The list is the layout (#822): the canvas shows the series still switched
+ * on, in the order they are listed, one block each — so the order written here
+ * is the order on screen. A section, a group or a views series is the unit a
+ * person picks — "add Machines" — and hiding one takes its whole subtree with
+ * it, because its members are built by its own `derive`.
  *
- * Identity is read through ONE nine-arm match rather than one match per
- * accessor — every arm carries the same four fields, so matching four times
- * would build four copies of the same traversal.
+ * Identity is read through ONE match rather than one match per accessor —
+ * every arm carries the same four fields, so matching four times would build
+ * four copies of the same traversal. A TS list is checked here for two series
+ * sharing a key (one switch would wear two labels).
+ *
+ * The handle is STATE (`State.bind` underneath), so it is built inside a
+ * `Reactive`. Pass it to the canvas as `pick`, in place of `series`: the Plan
+ * shows the picked series and mounts the library panel itself.
  *
  * @param key - The store key; also the persistence key
- * @param all - Every series that COULD show
- * @param options - Data for counts, and the initial hidden set ({@link PlanPickOptions})
- * @returns A pick handle over the series type
+ * @param all - Every series that COULD show, in layout order
+ * @param options - The initial hidden set ({@link PlanPickOptions})
+ * @returns A pick handle over the series type — the canvas's `pick` prop
  *
  * @example
  * ```tsx
- * const shown = $.let(Plan.pick("ops.series", all, { data: ops }));
- *
- * <Pick.Panel value={shown} title="Series" />
- * <Plan axis={axis} data={ops} series={Pick.active(shown)} />
+ * // .tsx file with the `@jsxImportSource @elaraai/east-ui` pragma
+ * import { ArrayType, DateTimeType, DictType, East, FloatType, IntegerType, StringType, StructType, none, some, variant } from "@elaraai/east";
+ * import { EventStateType, Plan, Reactive, UIComponentType } from "@elaraai/east-ui";
+ *
+ * const canvas = East.function([], UIComponentType, (_$) => (
+ *     <Reactive>{$ => {
+ *         // Monday of ISO week n, 2026 — window W27–W38 (half-open), now W31.
+ *         const week = $.const(East.function([IntegerType], DateTimeType, ($, n) => {
+ *             const w1 = $.const(new Date("2025-12-29T00:00:00Z"), DateTimeType);
+ *             return w1.addWeeks(n.subtract(1n));
+ *         }));
+ *         const JobRow = StructType({
+ *             batch: StringType, start: DateTimeType, end: DateTimeType, state: EventStateType,
+ *         });
+ *         const OpsRow = StructType({
+ *             series: StringType, jobs: ArrayType(JobRow), cells: ArrayType(Plan.Types.HeatCell),
+ *         });
+ *         const noJobs = $.const([], ArrayType(JobRow));
+ *         const noCells = $.const([], ArrayType(Plan.Types.HeatCell));
+ *         const pcts = $.const([46.0, 58.0, 66.0, 72.0, 84.0, 96.0], ArrayType(FloatType));
+ *         const cells = $.let(East.Array.generate(6n, Plan.Types.HeatCell, (_$, i) => ({
+ *             at: Plan.at.time(week(i.multiply(2n).add(27n))), value: some(pcts.get(i)), label: none,
+ *         })));
+ *         const ops = $.const(new Map([
+ *             ["L1-M03", { series: "machines", cells: noCells,
+ *                          jobs: [{ batch: "B-214", start: week(28n), end: week(31n), state: variant("in-progress", null) }] }],
+ *             ["L1-M04", { series: "machines", cells: noCells,
+ *                          jobs: [{ batch: "B-208", start: week(27n), end: week(30n), state: variant("actual", null) }] }],
+ *             ["L2-load", { series: "load", cells, jobs: noJobs }],
+ *         ]), DictType(StringType, OpsRow));
+ *         // Every series that COULD show — the library lists these, and the
+ *         // canvas shows the ones switched on in this order.
+ *         const all = $.const([
+ *             Plan.series.span(OpsRow, {
+ *                 key: "machines", title: "Machine jobs", subtitle: "one row per machine",
+ *                 match: r => r.series.equal("machines"),
+ *                 label: (_r, k) => k, id: true,
+ *                 runs: r => r.jobs.map((_$, j) => Plan.run({
+ *                     key: j.batch, start: j.start, end: j.end,
+ *                     label: East.str`RUN · ${j.batch}`, state: j.state,
+ *                 })),
+ *             }),
+ *             Plan.series.heat(OpsRow, {
+ *                 key: "load", title: "Line load", subtitle: "% per fortnight",
+ *                 match: r => r.series.equal("load"),
+ *                 label: (_r, k) => k,
+ *                 cells: r => Plan.heatCells(r.cells, { min: 0, max: 100 }),
+ *             }),
+ *         ], ArrayType(Plan.Types.Series(OpsRow)));
+ *         // The handle is STATE — which series are switched off, persisted
+ *         // under its key — so it lives inside the Reactive. "load" starts off.
+ *         const shown = $.let(Plan.pick("ex.plan.pick", all, { hidden: ["load"] }));
+ *         const axis = $.const(Plan.axis({ window: { min: week(27n), max: week(39n) }, resolution: "week", now: week(31n) }));
+ *         // `pick` REPLACES `series`: the canvas shows the picked series and
+ *         // mounts the library itself, so nothing else is wired.
+ *         return (
+ *             <Plan
+ *                 axis={axis}
+ *                 data={ops}
+ *                 pick={shown}
+ *             />
+ *         );
+ *     }}</Reactive>
+ * ));
  * ```
  */
 export declare function createPlanPick(key: string, all: PlanSeriesInput, options?: PlanPickOptions): PickHandle<ReturnType<typeof PlanSeriesType>>;
@@ -69,47 +124,10 @@ export declare function createPlanPick(key: string, all: PlanSeriesInput, option
  * {@link createPlanPick} builds its `items` from the same accessors, so proving
  * this proves the bound path too. Split out because `State.bind` is not
  * runnable in a `describeEast` spec (`TestImpl` carries no State runtime), and
- * identity / kind icons / counts are exactly the part worth asserting.
+ * identity and kind icons are exactly the part worth asserting.
  *
  * @param all - Every series that COULD show
- * @param options - Data for counts ({@link PlanPickOptions})
  * @returns One descriptor per series, in declaration order
  */
-/**
- * A stable signature of WHICH series a canvas is built from.
- *
- * @remarks
- * Exists for the paged arm. `PagedSourceType` requires that "two sources with
- * the same `id` must serve the same rows", and a derived source built from a
- * SUBSET of the series serves different rows than one built from all of them —
- * so its id has to say so.
- *
- * That requirement is not theoretical: the window cache invalidates on
- * `source.id` alone (`use-plan-paging.ts`), and resident windows are immutable
- * and served without re-calling `page`. Without a signature, toggling a series
- * off leaves the previous rows on screen indefinitely
- * (`use-plan-paging.dom.test.tsx` pins both halves of this).
- *
- * **This makes the key a load-bearing identity on a paged canvas.** The
- * signature is the joined keys, so it assumes a key NAMES a series: same keys ⇒
- * same rows. Two consequences worth knowing:
- *
- * - Two series sharing a key are safe HERE, because they share one entry in the
- *   hidden set and so toggle together — the active list is both-in or both-out,
- *   and the signature moves either way. They break the LIBRARY instead (one
- *   switch, two labels — `Pick.Panel` reports it).
- * - A key that stays put while the series it names CHANGES is the real hazard:
- *   the id does not move, the cache is not dropped, and resident windows keep
- *   serving rows built by the previous pipeline. Keys must be stable AND
- *   identifying, which is what they were for.
- *
- * Row keys are a separate layer with its own rule: two series emitting the same
- * ROW key resolve LAST_WINS inside `applySeries`, deterministically by series
- * order, and identically in every window (#568).
- *
- * @param all - The series the canvas is built from
- * @returns The series' keys, joined — stable for a given active set
- */
-export declare function seriesSignature(all: PlanSeriesInput): ExprType<StringType>;
-export declare function createPlanPickItems(all: PlanSeriesInput, options?: PlanPickOptions): ExprType<ArrayType<PickItemType>>;
+export declare function createPlanPickItems(all: PlanSeriesInput): ExprType<ArrayType<PickItemType>>;
 //# sourceMappingURL=pick.d.ts.map

package/dist/src/collections/plan/pick.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pick.d.ts","sourceRoot":"","sources":["../../../../src/collections/plan/pick.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAEH,KAAK,QAAQ,EACb,KAAK,kBAAkB,EACvB,SAAS,EACT,QAAQ,EAKR,UAAU,EACV,UAAU,EAGb,MAAM,eAAe,CAAC;AAGvB,OAAO,EAA6B,KAAK,UAAU,EAAE,KAAK,YAAY,EAAoB,MAAM,yBAAyB,CAAC;AAC1H,OAAO,EAAE,cAAc,EAAoB,KAAK,eAAe,EAAwB,MAAM,aAAa,CAAC;AAmC3G,0CAA0C;AAC1C,MAAM,WAAW,eAAe;IAC5B;;;;;;;;OAQG;IACH,IAAI,CAAC,EAAE,kBAAkB,CAAC,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC,CAAC,CAAC;IAC5D,kEAAkE;IAClE,MAAM,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC9B;AAyDD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,cAAc,CAC1B,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,eAAe,EACpB,OAAO,CAAC,EAAE,eAAe,GAC1B,UAAU,CAAC,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC,CAM/C;AAED;;;;;;;;;;;;GAYG;AACH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,eAAe,GAAG,QAAQ,CAAC,UAAU,CAAC,CAa1E;AAED,wBAAgB,mBAAmB,CAC/B,GAAG,EAAE,eAAe,EACpB,OAAO,CAAC,EAAE,eAAe,GAC1B,QAAQ,CAAC,SAAS,CAAC,YAAY,CAAC,CAAC,CAGnC"}
+{"version":3,"file":"pick.d.ts","sourceRoot":"","sources":["../../../../src/collections/plan/pick.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAEH,KAAK,QAAQ,EAEb,SAAS,EAQZ,MAAM,eAAe,CAAC;AAGvB,OAAO,EAA6B,KAAK,UAAU,EAAE,KAAK,YAAY,EAAoB,MAAM,yBAAyB,CAAC;AAC1H,OAAO,EAAE,cAAc,EAAmC,KAAK,eAAe,EAAwB,MAAM,aAAa,CAAC;AAkC1H,0CAA0C;AAC1C,MAAM,WAAW,eAAe;IAC5B,kEAAkE;IAClE,MAAM,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC9B;AAmDD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2FG;AACH,wBAAgB,cAAc,CAC1B,GAAG,EAAE,MAAM,EACX,GAAG,EAAE,eAAe,EACpB,OAAO,CAAC,EAAE,eAAe,GAC1B,UAAU,CAAC,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC,CAO/C;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,eAAe,GAAG,QAAQ,CAAC,SAAS,CAAC,YAAY,CAAC,CAAC,CAI3F"}

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

@@ -6,28 +6,25 @@
  * `Plan.pick` — the Plan's façade over the shared pick contract (#590).
  *
  * The contract holds identified things and does not know what they are, so an
- * adopter supplies the two things it cannot: how to read identity off one item,
- * and what a useful count is. For a Plan that is a nine-arm match over the
- * series variant, plus the row count that series would contribute.
+ * adopter supplies what it cannot: how to read identity off one item. For a
+ * Plan that is an eleven-arm match over the series variant — every arm carries
+ * the same four identity fields, and the arm itself picks the kind's icon.
  *
- * Nothing here is Plan-specific machinery — it is ~40 lines of accessors. The
- * façade exists so an author writes `Plan.pick(key, all)` instead of restating
- * the match at every call site, not because the Plan needs its own contract.
+ * There are no per-series row counts (#822): a count means something only when
+ * every entry is in hand, and nothing on a Plan may behave differently because
+ * its data is inline or paged.
  *
  * @packageDocumentation
  */
-import { ArrayType, DictType, East, Expr, IntegerType, OptionType, StringType, StructType, some, none, } from "@elaraai/east";
+import { ArrayType, East, Expr, OptionType, StringType, StructType, some, none, } from "@elaraai/east";
 import { IconType } from "../../display/icon/types.js";
 import { createPickBind, pickItems } from "../../contracts/pick.js";
-import { PlanSeriesType, applySeriesValue } from "./series.js";
+import { PlanSeriesType, checkSeries } from "./series.js";
 /**
- * The FA glyph each row kind declares.
- *
- * @remarks
- * `PlanTemplateKindType` has documented this set since the template model, and
- * nothing has ever rendered it — the library is the first surface that does.
- * `group` and `rows` are not template kinds and so are not in that set; they
- * take the marks that read as "a section" and "a hand-built list".
+ * The FA glyph the library shows for each series kind — the row kind's glyph
+ * for the seven row kinds; the four composites take the marks that read as
+ * "a group per entry", "a titled block", "one entry several ways" and "a
+ * hand-built list".
  */
 const KIND_ICONS = {
     span: "bars-staggered",
@@ -42,6 +39,8 @@ const KIND_ICONS = {
     cards: "user-group",
     events: "flag",
     group: "layer-group",
+    section: "heading",
+    views: "clone",
     rows: "list",
 };
 /** Identity read off ONE series — the whole of what the library needs. */
@@ -78,18 +77,15 @@ function planPickOptions(allExpr, options) {
         cards: (_$2, v) => ident(v, "cards"),
         events: (_$2, v) => ident(v, "events"),
         group: (_$2, v) => ident(v, "group"),
+        section: (_$2, v) => ident(v, "section"),
+        views: (_$2, v) => ident(v, "views"),
         rows: (_$2, v) => ident(v, "rows"),
     }));
-    // The row count this series contributes — its own pipeline, run over the
-    // canvas data. Absent for a paged canvas, which cannot know a total.
-    const data = options?.data;
-    const countOf = data === undefined ? undefined : East.function([itemType], IntegerType, (_$, s) => applySeriesValue(s, East.value(data)).size());
     return {
         id: (s) => identityOf(s).key,
         title: (s) => identityOf(s).title,
         subtitle: (s) => identityOf(s).subtitle,
         icon: (s) => identityOf(s).icon,
-        ...(countOf !== undefined ? { count: (s) => some(countOf(s)) } : {}),
         ...(options?.hidden !== undefined ? { hidden: options.hidden } : {}),
     };
 }
@@ -97,30 +93,96 @@ function planPickOptions(allExpr, options) {
  * Bind a Plan's row series to a persisted pick.
  *
  * @remarks
- * A GROUP is the unit a person picks — "add Machines" — and hiding one takes
- * its whole subtree with it, because the members are built by the group's own
- * `derive`. That is why every arm carries identity (#590 §6.1): without it the
- * library could only offer top-level series, which on a grouped canvas is
- * almost nothing.
+ * The list is the layout (#822): the canvas shows the series still switched
+ * on, in the order they are listed, one block each — so the order written here
+ * is the order on screen. A section, a group or a views series is the unit a
+ * person picks — "add Machines" — and hiding one takes its whole subtree with
+ * it, because its members are built by its own `derive`.
+ *
+ * Identity is read through ONE match rather than one match per accessor —
+ * every arm carries the same four fields, so matching four times would build
+ * four copies of the same traversal. A TS list is checked here for two series
+ * sharing a key (one switch would wear two labels).
  *
- * Identity is read through ONE nine-arm match rather than one match per
- * accessor — every arm carries the same four fields, so matching four times
- * would build four copies of the same traversal.
+ * The handle is STATE (`State.bind` underneath), so it is built inside a
+ * `Reactive`. Pass it to the canvas as `pick`, in place of `series`: the Plan
+ * shows the picked series and mounts the library panel itself.
  *
  * @param key - The store key; also the persistence key
- * @param all - Every series that COULD show
- * @param options - Data for counts, and the initial hidden set ({@link PlanPickOptions})
- * @returns A pick handle over the series type
+ * @param all - Every series that COULD show, in layout order
+ * @param options - The initial hidden set ({@link PlanPickOptions})
+ * @returns A pick handle over the series type — the canvas's `pick` prop
  *
  * @example
  * ```tsx
- * const shown = $.let(Plan.pick("ops.series", all, { data: ops }));
- *
- * <Pick.Panel value={shown} title="Series" />
- * <Plan axis={axis} data={ops} series={Pick.active(shown)} />
+ * // .tsx file with the `@jsxImportSource @elaraai/east-ui` pragma
+ * import { ArrayType, DateTimeType, DictType, East, FloatType, IntegerType, StringType, StructType, none, some, variant } from "@elaraai/east";
+ * import { EventStateType, Plan, Reactive, UIComponentType } from "@elaraai/east-ui";
+ *
+ * const canvas = East.function([], UIComponentType, (_$) => (
+ *     <Reactive>{$ => {
+ *         // Monday of ISO week n, 2026 — window W27–W38 (half-open), now W31.
+ *         const week = $.const(East.function([IntegerType], DateTimeType, ($, n) => {
+ *             const w1 = $.const(new Date("2025-12-29T00:00:00Z"), DateTimeType);
+ *             return w1.addWeeks(n.subtract(1n));
+ *         }));
+ *         const JobRow = StructType({
+ *             batch: StringType, start: DateTimeType, end: DateTimeType, state: EventStateType,
+ *         });
+ *         const OpsRow = StructType({
+ *             series: StringType, jobs: ArrayType(JobRow), cells: ArrayType(Plan.Types.HeatCell),
+ *         });
+ *         const noJobs = $.const([], ArrayType(JobRow));
+ *         const noCells = $.const([], ArrayType(Plan.Types.HeatCell));
+ *         const pcts = $.const([46.0, 58.0, 66.0, 72.0, 84.0, 96.0], ArrayType(FloatType));
+ *         const cells = $.let(East.Array.generate(6n, Plan.Types.HeatCell, (_$, i) => ({
+ *             at: Plan.at.time(week(i.multiply(2n).add(27n))), value: some(pcts.get(i)), label: none,
+ *         })));
+ *         const ops = $.const(new Map([
+ *             ["L1-M03", { series: "machines", cells: noCells,
+ *                          jobs: [{ batch: "B-214", start: week(28n), end: week(31n), state: variant("in-progress", null) }] }],
+ *             ["L1-M04", { series: "machines", cells: noCells,
+ *                          jobs: [{ batch: "B-208", start: week(27n), end: week(30n), state: variant("actual", null) }] }],
+ *             ["L2-load", { series: "load", cells, jobs: noJobs }],
+ *         ]), DictType(StringType, OpsRow));
+ *         // Every series that COULD show — the library lists these, and the
+ *         // canvas shows the ones switched on in this order.
+ *         const all = $.const([
+ *             Plan.series.span(OpsRow, {
+ *                 key: "machines", title: "Machine jobs", subtitle: "one row per machine",
+ *                 match: r => r.series.equal("machines"),
+ *                 label: (_r, k) => k, id: true,
+ *                 runs: r => r.jobs.map((_$, j) => Plan.run({
+ *                     key: j.batch, start: j.start, end: j.end,
+ *                     label: East.str`RUN · ${j.batch}`, state: j.state,
+ *                 })),
+ *             }),
+ *             Plan.series.heat(OpsRow, {
+ *                 key: "load", title: "Line load", subtitle: "% per fortnight",
+ *                 match: r => r.series.equal("load"),
+ *                 label: (_r, k) => k,
+ *                 cells: r => Plan.heatCells(r.cells, { min: 0, max: 100 }),
+ *             }),
+ *         ], ArrayType(Plan.Types.Series(OpsRow)));
+ *         // The handle is STATE — which series are switched off, persisted
+ *         // under its key — so it lives inside the Reactive. "load" starts off.
+ *         const shown = $.let(Plan.pick("ex.plan.pick", all, { hidden: ["load"] }));
+ *         const axis = $.const(Plan.axis({ window: { min: week(27n), max: week(39n) }, resolution: "week", now: week(31n) }));
+ *         // `pick` REPLACES `series`: the canvas shows the picked series and
+ *         // mounts the library itself, so nothing else is wired.
+ *         return (
+ *             <Plan
+ *                 axis={axis}
+ *                 data={ops}
+ *                 pick={shown}
+ *             />
+ *         );
+ *     }}</Reactive>
+ * ));
  * ```
  */
 export function createPlanPick(key, all, options) {
+    checkSeries(all, "Plan.pick");
     const allExpr = East.value(all);
     // Typed at the SERIES shape, not the erased element type: that is what
     // makes `Pick.active(shown)` assignable straight back to the `series` prop.
@@ -133,61 +195,14 @@ export function createPlanPick(key, all, options) {
  * {@link createPlanPick} builds its `items` from the same accessors, so proving
  * this proves the bound path too. Split out because `State.bind` is not
  * runnable in a `describeEast` spec (`TestImpl` carries no State runtime), and
- * identity / kind icons / counts are exactly the part worth asserting.
+ * identity and kind icons are exactly the part worth asserting.
  *
  * @param all - Every series that COULD show
- * @param options - Data for counts ({@link PlanPickOptions})
  * @returns One descriptor per series, in declaration order
  */
-/**
- * A stable signature of WHICH series a canvas is built from.
- *
- * @remarks
- * Exists for the paged arm. `PagedSourceType` requires that "two sources with
- * the same `id` must serve the same rows", and a derived source built from a
- * SUBSET of the series serves different rows than one built from all of them —
- * so its id has to say so.
- *
- * That requirement is not theoretical: the window cache invalidates on
- * `source.id` alone (`use-plan-paging.ts`), and resident windows are immutable
- * and served without re-calling `page`. Without a signature, toggling a series
- * off leaves the previous rows on screen indefinitely
- * (`use-plan-paging.dom.test.tsx` pins both halves of this).
- *
- * **This makes the key a load-bearing identity on a paged canvas.** The
- * signature is the joined keys, so it assumes a key NAMES a series: same keys ⇒
- * same rows. Two consequences worth knowing:
- *
- * - Two series sharing a key are safe HERE, because they share one entry in the
- *   hidden set and so toggle together — the active list is both-in or both-out,
- *   and the signature moves either way. They break the LIBRARY instead (one
- *   switch, two labels — `Pick.Panel` reports it).
- * - A key that stays put while the series it names CHANGES is the real hazard:
- *   the id does not move, the cache is not dropped, and resident windows keep
- *   serving rows built by the previous pipeline. Keys must be stable AND
- *   identifying, which is what they were for.
- *
- * Row keys are a separate layer with its own rule: two series emitting the same
- * ROW key resolve LAST_WINS inside `applySeries`, deterministically by series
- * order, and identically in every window (#568).
- *
- * @param all - The series the canvas is built from
- * @returns The series' keys, joined — stable for a given active set
- */
-export function seriesSignature(all) {
-    const allExpr = East.value(all);
-    const itemType = Expr.type(allExpr).value;
-    // An EMPTY series list has no element type (`Never`), so there is no
-    // variant to match on — and nothing to distinguish either. A canvas with no
-    // series is legal (`Plan.Root({ …, series: [] })`).
-    if (itemType.type !== "Variant")
-        return East.value("", StringType);
-    const keyOf = planPickOptions(allExpr).id;
-    const keyFn = East.function([itemType], StringType, (_$, s) => keyOf(s));
-    return allExpr.reduce((_$, acc, s) => East.str `${acc}/${keyFn(s)}`, East.value("", StringType));
-}
-export function createPlanPickItems(all, options) {
+export function createPlanPickItems(all) {
+    checkSeries(all, "Plan.pickItems");
     const allExpr = East.value(all);
-    return pickItems(allExpr, planPickOptions(allExpr, options));
+    return pickItems(allExpr, planPickOptions(allExpr));
 }
 //# sourceMappingURL=pick.js.map