@elaraai/east-codex-plugin 0.0.0-stage → 1.0.90

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,1529 @@
1
+ ---
2
+ name: east-ui
3
+ description: "Type-safe UI component library for the East language, authored as JSX tags. Use when writing East programs that define user interfaces. Triggers for: (1) Authoring `.tsx` component trees with `@elaraai/east-ui` tags, (2) Layout with (Box), (Flex), (Stack)/(VStack)/(HStack), (Grid), (SnapGrid) (a page of tiles held as data on the 12-column grid, and its wireframe thumbnail), (Splitter), (ScrollArea), (Sticky), (Expandable), (Dock), (Configurator) (control table + live preview + spec readout), (3) Forms with (Input), (Textarea), (Select), (Combobox), (Checkbox), (Switch), (Slider), (RadioGroup), (RadioCardGroup), (TagsInput), (FileUpload), (Field), (DateRangeInput), (TimeRangeInput), (4) Data display with (Table), (TreeView), (ValueTree), (DataList), (Deck), (Matrix), (Schematic), (Map), (Library) (a drag palette, or a gallery of large cards whose media is any component), (Blend), (Slice.Rail), (Pagination), (ChipRail),… See the detailed scope below."
4
+ ---
5
+
6
+ ## Detailed skill scope
7
+
8
+ Type-safe UI component library for the East language, authored as JSX tags. Use when writing East programs that define user interfaces. Triggers for: (1) Authoring `.tsx` component trees with `@elaraai/east-ui` tags, (2) Layout with <Box>, <Flex>, <Stack>/<VStack>/<HStack>, <Grid>, <SnapGrid> (a page of tiles held as data on the 12-column grid, and its wireframe thumbnail), <Splitter>, <ScrollArea>, <Sticky>, <Expandable>, <Dock>, <Configurator> (control table + live preview + spec readout), (3) Forms with <Input>, <Textarea>, <Select>, <Combobox>, <Checkbox>, <Switch>, <Slider>, <RadioGroup>, <RadioCardGroup>, <TagsInput>, <FileUpload>, <Field>, <DateRangeInput>, <TimeRangeInput>, (4) Data display with <Table>, <TreeView>, <ValueTree>, <DataList>, <Deck>, <Matrix>, <Schematic>, <Map>, <Library> (a drag palette, or a gallery of large cards whose media is any component), <Blend>, <Slice.Rail>, <Pagination>, <ChipRail>, <Trace>, (5) Charts with <Chart layers={Chart.Line/Column/Bar/Area/Scatter/Band(...)}/> (Column = vertical, Bar = horizontal) plus Chart.refLine/refBand/refDot, <Sparkline>, (6) Overlays with <Dialog>, <Drawer>, <Popover>, <Menu>, <Tooltip>, <HoverCard>, <ToggleTip>, <ActionBar>, <CommandPalette>, <Hotkey>, (7) Feedback with <Banner>, <Status>, <Progress>, <Skeleton>, <EmptyState>, (8) Disclosure with <Tabs>, <Accordion>, <Carousel>, <Collapsible>, <SegmentGroup>, <OptionList>, <Story>, (9) Navigation within a page with <Breadcrumb> and <NavList> (an app's own navigation is its host's), (10) Reactive UI via <Reactive>{$ => …}</Reactive> + State.bind, and conditional hosting of stateful components via <Match on cases> (remounts the active variant case on tag change), (11) Value formatting — Chart.format.* specs (chart axes, Slice fields, Deck metrics, e3-ui's Plan) and Format.* specs (<Numeric>, <Stat>, Table columns) through one interpreter, in the viewer's locale (react-aria's I18nProvider) with every date in UTC, (12) Status colour vocabulary — the five status tokens, the Deck.statuses registry, Library.status, rowStatus tints and tone props.
9
+
10
+ # East UI
11
+
12
+ A type-safe UI component library for the East language. The public surface is
13
+ **JSX tags** — capitalized, React-style components that desugar to East IR. No
14
+ React at runtime: a `<Button>` evaluates to the identical
15
+ `ExprType<UIComponentType>` value, which serializes and renders anywhere.
16
+
17
+ ## Before writing code — search the example index
18
+
19
+ Every East API has a tested example in the plugin's index — the index IS the
20
+ API reference, printed from each example's IR in TypeScript or python. Before
21
+ writing or changing East code:
22
+
23
+ 1. Call `search_east_examples` for each capability you
24
+ are about to use — `language: "python"` for east-py, `"typescript"`
25
+ otherwise. Summaries come back first: id, signature, the inputs and the
26
+ expected result, a few hundred bytes each.
27
+ 2. Fetch the one or two that match with `get_east_example`
28
+ and pattern your code on them.
29
+ 3. Do not read `node_modules/@elaraai/**` or `*.examples.ts` files wholesale,
30
+ and do not reason from `.d.ts` signatures: the index holds the same
31
+ programs, exact and far cheaper, and the signatures omit the runtime rules
32
+ that make East code correct.
33
+
34
+ Nothing is injected for you; the search is the step.
35
+
36
+ ## Quick Start
37
+
38
+ ```tsx
39
+ /** @jsxImportSource @elaraai/east-ui */
40
+ import { East, IntegerType, NullType, example } from "@elaraai/east";
41
+ import { VStack, HStack, Text, Button, UIComponentType } from "@elaraai/east-ui";
42
+
43
+ const MyComponent = East.function([], UIComponentType, (_$) => (
44
+ <VStack gap="4" padding="6">
45
+ <Text textStyle="heading-md" fontWeight="bold">Hello, World!</Text>
46
+ <HStack gap="2">
47
+ <Button variant="outline">Cancel</Button>
48
+ <Button variant="solid" colorPalette="blue">Save</Button>
49
+ </HStack>
50
+ </VStack>
51
+ ));
52
+
53
+ const ir = MyComponent.toIR();
54
+ ```
55
+
56
+ Three things make a file JSX-capable:
57
+ 1. The per-file pragma `/** @jsxImportSource @elaraai/east-ui */` (first line).
58
+ 2. One tag import line from `@elaraai/east-ui`.
59
+ 3. A `.tsx` extension.
60
+
61
+ **Tags vs factories.** Each tag desugars 1:1 to a factory call —
62
+ `<Button variant="solid">Save</Button>` builds the same IR as
63
+ `Button.Root("Save", { variant: "solid" })`. The factories are an implementation
64
+ detail under `@elaraai/east-ui/internal` (used by renderers/tests). **Author with
65
+ tags**; props are exactly the factory's flat options bag.
66
+
67
+ ## Decision Tree: Which Tag to Use
68
+
69
+ Every public tag is listed with its purpose, its **Props** (each marked
70
+ required / optional) and its **Factories** — the `Component.xyz(…)` builders
71
+ that construct that component's config values. Props are the factory's flat
72
+ option bag — no nested `style` object. Children are always UI components;
73
+ non-UI sub-structures (columns, layers, cells, header fields) are **config
74
+ props or typed callbacks**, never child sub-tags.
75
+
76
+ Two shared prop bags recur; a Props list references them by name instead of
77
+ re-listing each member's description:
78
+
79
+ - **BOX bag** (all optional) — `width`, `height`, `minWidth`, `minHeight`,
80
+ `maxWidth`, `maxHeight`, `padding`, `margin`, `overflow`, `overflowX`,
81
+ `overflowY`, `opacity`. CSS sizing/box-model pass-throughs (see the Sizing
82
+ pattern below for the string spellings).
83
+ - **COLOR overrides** (all optional) — `color`, `background`, `borderColor`.
84
+ Explicit escape hatches over the palette / variant defaults; take semantic
85
+ tokens (`fg.muted`, `bg.subtle`) or CSS colours.
86
+
87
+ Every icon is a Font Awesome **solid** icon (#1263): an icon prop takes
88
+ `{ prefix: "fas", name: "…" }`, or the bare solid name where it says so. East
89
+ UI draws no other set — a factory refuses another prefix at build, naming the
90
+ icon.
91
+
92
+ ```
93
+ Task → Which tag?
94
+ │
95
+ ├─ Layout (arrange content)
96
+ │ ├─ <Box> — generic block container
97
+ │ │ └─ Props:
98
+ │ │ ├─ children (required) — the boxed content
99
+ │ │ ├─ display (optional) — CSS display (block / flex / grid / …)
100
+ │ │ ├─ flexDirection / justifyContent / alignItems / gap (optional) — flex props when display is flex
101
+ │ │ ├─ flex / flexGrow / flexShrink (optional) — behaviour as a flex CHILD
102
+ │ │ ├─ fill (optional) — boolean shorthand for "fill remaining space" (flex:1 + min-height:0)
103
+ │ │ ├─ scroll / scrollX / scrollY (optional) — boolean shorthands for a styled scroll region
104
+ │ │ ├─ position / top / right / bottom / left / zIndex (optional) — positioning; zIndex is a token
105
+ │ │ ├─ borderRadius / border / borderColor / borderWidth (optional) — border styling
106
+ │ │ ├─ boxShadow / transform / transition / cursor / animation (optional) — presentation extras
107
+ │ │ ├─ fontFamily / fontVariantNumeric (optional) — inherited text styling for the subtree
108
+ │ │ ├─ density (optional) — provides "condensed"|"compact"|"comfortable" to densified descendants
109
+ │ │ └─ …plus BOX bag + COLOR overrides
110
+ │ ├─ <Flex> — flexbox container
111
+ │ │ └─ Props:
112
+ │ │ ├─ children (required) — flex items
113
+ │ │ ├─ direction (optional) — row | column (+reverse)
114
+ │ │ ├─ wrap (optional) — nowrap | wrap | wrap-reverse
115
+ │ │ ├─ justifyContent / alignItems / gap (optional) — main/cross alignment + spacing
116
+ │ │ ├─ density (optional) — density provider (as Box)
117
+ │ │ └─ …plus the same flex-child / position / border / presentation props as <Box>, BOX bag, COLOR overrides
118
+ │ ├─ <Stack> / <VStack> / <HStack> — flex with stacking defaults (VStack = column, HStack = row)
119
+ │ │ └─ Props:
120
+ │ │ ├─ children (required) — stacked items
121
+ │ │ ├─ direction (optional, <Stack> only) — stacking axis
122
+ │ │ ├─ gap (optional) — spacing token between items
123
+ │ │ ├─ align / justify (optional) — cross/main-axis alignment
124
+ │ │ ├─ wrap (optional) — allow wrapping
125
+ │ │ ├─ density (optional) — density provider (as Box)
126
+ │ │ └─ …plus fill/scroll shorthands, flex-child, position, border, presentation props, BOX bag, COLOR overrides
127
+ │ ├─ <Grid> — CSS grid container
128
+ │ │ ├─ Props:
129
+ │ │ │ ├─ children (required) — grid items (wrap one in Grid.Item to place it)
130
+ │ │ │ ├─ templateColumns / templateRows / templateAreas (optional) — grid templates ("repeat(auto-fit, minmax(240px, 1fr))" reflows to 1 column on phones)
131
+ │ │ │ ├─ gap / columnGap / rowGap (optional) — grid spacing
132
+ │ │ │ ├─ justifyItems / alignItems / justifyContent / alignContent (optional) — item + track alignment
133
+ │ │ │ ├─ autoColumns / autoRows / autoFlow (optional) — implicit-track sizing + placement
134
+ │ │ │ ├─ density (optional) — density provider
135
+ │ │ │ └─ …plus BOX bag (width/height/min*/max*/padding)
136
+ │ │ └─ Factories:
137
+ │ │ └─ Grid.Item(children, { colSpan?, rowSpan?, colStart?, colEnd?, rowStart?, rowEnd?, area? }) — explicit cell placement for one child
138
+ │ ├─ <SnapGrid data={rows} cell={r => SnapGrid.cell({ key, row, span, content })} /> — a page of tiles on the 12-column grid, HELD AS DATA: each row of `data` is one tile. Rows stack in the order their keys first appear; a row's tiles sit left to right, continue on a line below once their spans pass 12 (never overlapping), and the row is as tall as its tallest tile. The spans answer to the SnapGrid's own width, not the viewport: under 480px every tile takes the full width, from 480px a span under 6 takes 6 and any other 12, from 960px the span declared. A framed tile has no header strip, and the SnapGrid draws no border of its own — the host draws the panel around it
139
+ │ │ ├─ Props:
140
+ │ │ │ ├─ data (required) — the rows: an `Array`, or a `Dict` (tiles in key order), inline or a `$.let`-bound whole-value handle (`State.bind` / `Data.bind`); a paged source is refused — a page's tiles are held whole
141
+ │ │ │ ├─ cell (required) — r => SnapGrid.cell({…}): one row's tile, reified once and called per row; pick its `content` per row with a `match` on the row's kind
142
+ │ │ │ ├─ variant (optional) — "tiles" (default) | "wireframe": each tile an outline at its size with its content left out, its spans kept at any width and its declared height exact — a page's thumbnail. It draws no frame of its own: its host frames it (a Library gallery card's media) and it fills the host's height. With no rows it is the blank page — a band over the body, each dashed
143
+ │ │ │ ├─ width (optional) — the design width ("1440px"): a page's grid is that wide, scrolls inside a narrower host, and its spans answer to it; on the editing canvas it is the most the grid lays out at — a narrower column lays it out at the column's width, a wider one centres it — and the toolbar reads it out
144
+ │ │ │ ├─ height / maxHeight (optional) — pin or cap the SnapGrid; the grid scrolls within
145
+ │ │ │ ├─ edit + editing (optional, given together) — the builder's canvas: every tile keeps its declared span at any width, and each gesture is a DRAFT of the shared editing session — e3-ui's Sheet's and Plan's — each ONE undoable transaction (origin drop / move / resize / remove); the history item (Undo · Redo · Discard · Save) sits in the canvas's toolbar (see The frame), and ⌘Z / Ctrl+Z undo, ⌘⇧Z / Ctrl+Y redo. Editing takes an `Array` source — its order is the tiles' order, so a move is a new order and a new row key; a `Dict` is refused. `edit` names the row fields a gesture writes: { key: "id" (the String identity field), row: "row" (String), span: "span" (Integer), height?: "height" (Option<Integer>; omitted, heights are not edited), align?: "align" (SnapGrid.Types.Align; the field an align request writes — omitted, one is refused), create?: ($, card, at) => R — a dropped library card's new row: `card` the drag grammar's { library, key }, `at` { key (a fresh identity), row (the row it lands in) }; the canvas then writes `at.row` and fits the span }. `editing` is { onApply? | onUpdate?, onPatch?, onDrafted?, mode?, ready? } as on e3-ui's Plan: `onUpdate={handle.write}` with `data={handle}` is the inline adapter; `onPatch` hears SnapGrid.Types.PatchEvent(R); `onDrafted` fn(Array<R>) => Null hears the rows the canvas draws — the source with its drafts, exactly as Save would leave them — as it mounts and whenever they change (a gesture, an undo or redo, a Discard, a source that moved), so a pane beside it reads what it shows; `ready` fn(R) => Editing.Types.Readiness marks the tile it refuses and holds Save. Save leaves exactly the order the canvas shows
146
+ │ │ │ ├─ ui (optional) — the bound selection: `State.bind([SnapGrid.Types.UiState], key, SnapGrid.uiState())` — the canvas draws the tile it holds and writes the one the user picks, so an inspector beside it reads and sets it; omitted, the canvas keeps its own. Its `request` asks the editing canvas for a change, as e3-ui's Plan's `focus` asks for a row: `ui.write(SnapGrid.uiState({ selected: key, request: { key, change: variant("span", 8n) } }))` — `span` (held to the row's room), `row` (counting from 1; a row already holding 6 tiles, or one past the last, is a new row after it), `height` (`none` for its content's), `align` (written to `edit.align`) — taken as ONE gesture of the session by the rules the handles and drags keep, undoable with the rest, and written back `none`
147
+ │ │ │ ├─ view (optional) — the bound design width and zoom: `State.bind([SnapGrid.Types.ViewState], key, SnapGrid.viewState())` under a key of its own, apart from `ui` — the editing canvas draws at them and writes the width the user presses and the zoom step they take; omitted, the canvas keeps them, starting from `width` and `zoom`
148
+ │ │ │ ├─ apply (optional) — the bound Apply request: `State.bind([SnapGrid.Types.ApplyState], key, variant("idle", null))` under a key of its own — a screen that must not leave drafts behind (a publish) writes `variant("asked", id)` with an id of its own, and the editing canvas saves its drafts as its history item does — waiting out a Save already running, retrying one of unknown outcome — and answers under the same id: `applied(id)` once the source confirms them, or at once with none; `refused({ id, reason })` when they cannot land, `reason` in the canvas's words (the conflict's, the rejection's, a check's or the stale source's). The canvas stays the only writer of its drafts; omitted, only the history item saves
149
+ │ │ │ ├─ widths (optional) — [{ label, icon?, width }] the design widths the editing canvas's toolbar offers, a device each (`{ label: "Desktop", icon: "desktop", width: "1440px" }`, `{ label: "Tablet", icon: "tablet-screen-button", width: "1024px" }`): the one the canvas draws at is pressed, and pressing another draws it at that width
150
+ │ │ │ ├─ toolbar (optional) — { start?, end? } the host's items in the editing canvas's toolbar, each an array of UIComponents: `start` leads the row (a `<Status>`), `end` closes it (Preview, Publish buttons); they never fold
151
+ │ │ │ ├─ panes (optional) — { start?, end? } the panes beside the editing canvas, under its toolbar — a palette, an inspector: a `<Dock surface="shell">` pane collapses to its rail and the canvas column takes the room
152
+ │ │ │ ├─ surface (optional) — "card" (default; the editing canvas's own bordered panel) | "shell" (no frame — a canvas inside a host's frame). `view`, `apply`, `widths`, `toolbar`, `panes` and `surface` dress the editing canvas: given without `edit` and `editing`, the build refuses them
153
+ │ │ │ ├─ sources (optional) — the Library ids whose cards land on the canvas (`edit.create` builds the row); id (optional) — the drag surface's name in a drop's cell refs; canDrop (optional) — fn(DragEventType) => Boolean, the veto over a card's `add` or a tile's `move` where the drag rests (⊘; a throwing predicate fails open). A drop's cell ref: `row` is the row key, or "" for a new row between rows; `slot` the pointed column "1"–"12", or the gap's index ("0" above the first row, n below the last)
154
+ │ │ │ ├─ guides (optional) — draw the column ruler above the rows (the selected tile's columns in brand) and the column bands behind them
155
+ │ │ │ └─ zoom (optional) — the scale the canvas draws at (1.0 actual size); the canvas scrolls inside its host
156
+ │ │ ├─ The frame (editing): one toolbar across the canvas's width, then the `panes` beside a column holding the selection bar over the grid panel. The toolbar leads with `toolbar.start`, the grid chip ("12 col · snap on") and — once the source confirms a Save — the time it was saved ("Saved · 14:32", UTC); it closes with the width readout ("1440 px"), the zoom (− 100% +, 10% steps from 50% to 150%), the history item, the `widths` and `toolbar.end`. A narrower frame folds it by one ladder: the grid chip first, then the width readout, the saved time, the widths to their icons, and the history item last. The selection bar names the selected tile — its `icon` in a tile, its `label` (else its key) and its `meta` — or says "No selection · Click a component on the grid to arrange it". The history shortcuts work anywhere in the frame, a pane's controls too; a key typed into a field stays the field's
157
+ │ │ ├─ The canvas: a click selects a tile (brand border and focus shadow, four corner handles, a span handle on the right edge, a height handle on the bottom edge, the bottom-right corner drags both, and a remove button); Esc or a click on empty canvas clears it. A span drag snaps per column — at least 2, at most 12 less the row's other spans. A height drag snaps to 40px steps, or to a neighbour's bottom edge within 16px while a dashed guide runs across the row; a tile with a `minHeight` shrinks to it, any other stops at its content's height; at most 960; released near its content's height it is auto again. A tile or a card drops beside a tile (a brand line with a "+" badge), between rows, or on the end zone under the last row, each a new row; a tile that takes a row past 12 shrinks to the free columns when that leaves it 3 or more, and otherwise every tile in the row takes ⌊12 / n⌋; a row holds at most 6 tiles (⊘), and a row left empty is gone. Keys: the arrows move the selection; [ and ] change the span by 1; Delete / Backspace remove; tiles drag by keyboard too. A tile's content takes the tile's height — a `<Chart height="fill" …/>` takes the tile's once given one, and its natural height in an auto tile
158
+ │ │ └─ Factories:
159
+ │ │ ├─ SnapGrid.cell({ key, row, span, height?, minHeight?, align?, frame?, label?, icon?, meta?, content }) — one tile: key (its identity) · row (the key of the row it sits in) · span (columns of 12, held to 1–12) · height (Option<Integer> px; none = its content's height) · minHeight (Option<Integer> px; the least height a height drag leaves it — a chart's plot; none = its content's height) · align ("top" default | "center" | "stretch" — where a shorter tile sits in its row) · frame (default true; false = bare) · label (Option<String>; its name for the drag ghost, the announcements, the history and the selection bar; none = its key) · icon (Option<String>; a Font Awesome solid icon name, the selection bar's tile) · meta (Option<String>; the selection bar's line after its name — what it is, what it reads) · content (the UIComponent it shows)
160
+ │ │ ├─ SnapGrid.uiState({ selected?, request? }) — the seed of a bound `ui`, or what a host writes to it: a selection, and a change it asks of the editing canvas (SnapGrid.Types.Request { key, change: span | row | height | align })
161
+ │ │ ├─ SnapGrid.viewState({ width?, zoom? }) — the seed of a bound `view`; omitted fields follow the SnapGrid's own `width` and `zoom`
162
+ │ │ └─ SnapGrid.Types.{ Root, Cell, Align, Variant, UiState, Request, ViewState, ApplyState, Width, Surface, Place, PatchEvent(R), Editing } — the East types
163
+ │ ├─ <Splitter> — resizable panel group
164
+ │ │ ├─ Props:
165
+ │ │ │ ├─ panels (required) — array of Splitter.Panel(…) values
166
+ │ │ │ ├─ defaultSize (required) — initial size percentages, one per panel
167
+ │ │ │ ├─ children (required) — one body per panel, in order
168
+ │ │ │ ├─ orientation (optional) — horizontal | vertical
169
+ │ │ │ ├─ collapseBelow (optional) — container px width below which the panels stack vertically
170
+ │ │ │ └─ onResize / onResizeStart / onResizeEnd (optional) — drag lifecycle callbacks (sizes payload)
171
+ │ │ └─ Factories:
172
+ │ │ └─ Splitter.Panel({ id, minSize?, maxSize?, collapsible?, defaultCollapsed? }) — one panel: id (required), min/max size as percentages, collapsibility
173
+ │ ├─ <Configurator> — labelled control table + live preview + derived spec readout
174
+ │ │ ├─ Props:
175
+ │ │ │ ├─ controls (required) — array of Configurator.Control(…) / .Slot(…) rows, in display order
176
+ │ │ │ ├─ preview (required) — the component being configured
177
+ │ │ │ ├─ live (optional) — render the LIVE pip in the preview header (default true)
178
+ │ │ │ ├─ aside (optional) — { label, body } secondary panel under the preview
179
+ │ │ │ ├─ spec (optional) — extra Configurator.Spec(…) rows for state with no control row of its own
180
+ │ │ │ └─ labelWidth / sidebarWidth / previewMinHeight (optional) — sizing overrides
181
+ │ │ └─ Factories:
182
+ │ │ ├─ Configurator.Control(label, value, control, hint?) — a row that ALSO reports `value` in the spec column
183
+ │ │ ├─ Configurator.Slot(label, control, hint?) — a row that reports nothing (use `spec` instead)
184
+ │ │ └─ Configurator.Spec(label, value) — one extra spec row
185
+ │ ├─ <Separator> — 1px rule
186
+ │ │ └─ Props:
187
+ │ │ ├─ orientation (optional) — horizontal | vertical
188
+ │ │ ├─ variant (optional) — subtle | brand | dashed | strong
189
+ │ │ ├─ label (optional) — inline label on the rule (string or UIComponent)
190
+ │ │ └─ align (optional) — label placement along the rule
191
+ │ ├─ <ScrollArea> — styled-scrollbar scroll container
192
+ │ │ └─ Props:
193
+ │ │ ├─ children (required) — scrollable content
194
+ │ │ ├─ orientation (optional) — vertical (default) | horizontal
195
+ │ │ ├─ scrollbarStyle (optional) — overlay (default) | classic
196
+ │ │ └─ thumbColor / trackColor / background (optional) — scrollbar + viewport colours
197
+ │ ├─ <Sticky> — position-sticky wrapper
198
+ │ │ └─ Props:
199
+ │ │ ├─ children (required) — the stuck content
200
+ │ │ ├─ offset (optional) — CSS length sticky offset (default "0")
201
+ │ │ ├─ boundary (optional) — stick to the parent scroll ancestor (default) or the viewport
202
+ │ │ └─ background / borderColor / shadowColor (optional) — styling applied while stuck
203
+ │ ├─ <Expandable> — region expands in place to fill the app container (CSS takeover, no remount); Esc collapses
204
+ │ │ └─ Props:
205
+ │ │ ├─ children (required) — the expandable region
206
+ │ │ ├─ expanded (optional) — controlled expanded state
207
+ │ │ ├─ onExpandedChange (optional) — fn(Boolean) => Null on user toggle
208
+ │ │ ├─ label (optional) — accessible toggle name ("Expand ‹label›")
209
+ │ │ ├─ zIndex (optional) — stacking level of the expanded surface (default 900, below Chakra floating tiers)
210
+ │ │ └─ background (optional) — expanded-surface background (default bg.canvas)
211
+ │ └─ <Dock> — inline pane that collapses along an axis to an icon rail, staying in flow (siblings reflow; never overlays) — a source panel beside a drop target (Library beside a Plan); Esc does NOT collapse. Expanded, it has no header strip: its one row is a tab row with the collapse control at its end. Collapsed, it is a rail: the expand control, then the icon in its tile, the badge, the label and the detail running down it
212
+ │ └─ Props:
213
+ │ ├─ children (required unless `tabs`) — the pane's body, under the `label` as its only tab; not shown when `tabs` are given
214
+ │ ├─ tabs (optional) — [{ key, label, body }] the tab row, each tab with its own body: the first open to begin with, the one opened kept under the storage key, every body kept mounted so each keeps its state; ← / → / Home / End move along the row
215
+ │ ├─ orientation (optional) — collapse axis: horizontal (default) | vertical
216
+ │ ├─ side (optional) — edge the rail pins to: start (default) | end
217
+ │ ├─ expandedSize / railSize (optional) — size along the axis expanded (px or %) / collapsed (default 44px)
218
+ │ ├─ icon / label / badge (optional) — the rail's icon tile (FA name) / the pane's name: its only tab without `tabs`, the rail's label, and the controls' accessible names ("Collapse ‹label›" / "Expand ‹label›") / the rail's count chip (an empty one draws none, so a computed badge can come and go)
219
+ │ ├─ active / detail (optional) — `active` draws the rail's icon tile and badge in the brand, as when the pane shows something (an inspector's selected tile); `detail` is a second line down the rail after the label — what the pane shows now (the tile's name), muted unless `active`
220
+ │ ├─ surface (optional) — "card" (default; its own bordered panel) | "shell" (only the rule along its inner edge — a pane inside a host's frame, beside what it serves)
221
+ │ ├─ collapsed (optional) — controlled collapsed state
222
+ │ ├─ defaultCollapsed (optional) — uncontrolled initial state (default false)
223
+ │ ├─ onCollapsedChange (optional) — fn(Boolean) => Null on user toggle
224
+ │ ├─ persist (optional) — where the uncontrolled state persists (default none)
225
+ │ ├─ keepMounted (optional) — keep the body mounted while collapsed (default true)
226
+ │ ├─ lazy (optional) — mount the body only on first expand (default false)
227
+ │ └─ animated (optional) — animate the rail↔expanded size change (default false)
228
+ │
229
+ ├─ Typography (display text)
230
+ │ ├─ <Text> — inline/block text
231
+ │ │ ├─ Props:
232
+ │ │ │ ├─ children (required) — the text (an East string — see the Text pattern below)
233
+ │ │ │ ├─ textStyle (optional) — typographic preset token (body-md, heading-sm, …)
234
+ │ │ │ ├─ fontWeight / fontStyle / fontFamily (optional) — face overrides (fontFamily: sans | serif | mono)
235
+ │ │ │ ├─ fontVariantNumeric (optional) — e.g. tabular-nums for aligned digits
236
+ │ │ │ ├─ textAlign / textDecoration / textTransform (optional) — alignment + decoration + casing
237
+ │ │ │ ├─ textOverflow / whiteSpace (optional) — ellipsis / wrapping control
238
+ │ │ │ ├─ lineHeight / letterSpacing (optional) — rhythm overrides
239
+ │ │ │ ├─ borderWidth / borderStyle (optional) — text-block border (with borderColor)
240
+ │ │ │ └─ …plus BOX bag + COLOR overrides
241
+ │ │ └─ Factories:
242
+ │ │ ├─ Text.Presets.Eyebrow(text, style?) — mono uppercase eyebrow (section labels, status words)
243
+ │ │ ├─ Text.Presets.EyebrowSm(text, style?) — smaller eyebrow tier
244
+ │ │ ├─ Text.Presets.MonoLabel(text, style?) — mono label (sidebar items, dense frame headers)
245
+ │ │ ├─ Text.Presets.MonoSm(text, style?) — small mono annotation
246
+ │ │ ├─ Text.Presets.MetaSm(text, style?) — small muted meta line
247
+ │ │ └─ Text.Presets.MonoKpi(text, style?) — 24px mono tabular-nums KPI number
248
+ │ ├─ <Heading> — display heading
249
+ │ │ └─ Props:
250
+ │ │ ├─ children (required) — the heading text
251
+ │ │ ├─ as (optional) — rendered element h1…h6
252
+ │ │ ├─ textStyle (optional) — heading preset token
253
+ │ │ ├─ fontWeight / fontStyle / fontFamily (optional) — face overrides
254
+ │ │ ├─ textAlign / textDecoration / lineHeight / letterSpacing (optional) — alignment + rhythm
255
+ │ │ └─ …plus BOX bag + COLOR overrides
256
+ │ ├─ <Link> — hyperlink
257
+ │ │ └─ Props:
258
+ │ │ ├─ href (required) — target URL
259
+ │ │ ├─ children (required) — link text
260
+ │ │ ├─ external (optional) — open in a new tab
261
+ │ │ ├─ variant (optional) — underline-on-hover presets
262
+ │ │ ├─ colorPalette (optional) — hue theming
263
+ │ │ ├─ hoverColor / visitedColor (optional) — state colours
264
+ │ │ └─ …plus textDecoration / lineHeight / letterSpacing, BOX bag, COLOR overrides
265
+ │ ├─ <Code> — inline code token
266
+ │ │ └─ Props:
267
+ │ │ ├─ children (required) — the code text
268
+ │ │ ├─ variant (optional) — visual preset
269
+ │ │ ├─ colorPalette / size (optional) — hue + size
270
+ │ │ └─ …plus textDecoration / lineHeight / letterSpacing, BOX bag, COLOR overrides
271
+ │ ├─ <CodeBlock> — multi-line code block
272
+ │ │ └─ Props:
273
+ │ │ ├─ children (required) — the source text
274
+ │ │ ├─ language (optional) — syntax-highlight language
275
+ │ │ ├─ showLineNumbers / highlightLines (optional) — gutter numbers + highlighted line list
276
+ │ │ ├─ showCopyButton (optional) — corner copy affordance
277
+ │ │ ├─ wordWrap (optional) — soft-wrap long lines
278
+ │ │ ├─ title (optional) — header caption
279
+ │ │ ├─ headerBackground / lineNumberColor / highlightBackground (optional) — chrome colours
280
+ │ │ └─ …plus BOX bag + COLOR overrides
281
+ │ ├─ <List items={…}> — bulleted / numbered list
282
+ │ │ └─ Props:
283
+ │ │ ├─ items (required) — the entries (strings or nested components — a config prop, not JSX children)
284
+ │ │ ├─ variant (optional) — ordered | unordered | dot
285
+ │ │ ├─ marker / markerIcon / markerColor (optional) — marker glyph styling
286
+ │ │ ├─ colorPalette / gap (optional) — hue + item spacing
287
+ │ │ └─ …plus BOX bag + COLOR overrides
288
+ │ ├─ <Highlight> — tints query substrings inside its text
289
+ │ │ └─ Props:
290
+ │ │ ├─ children (required) — the full text
291
+ │ │ ├─ query (required) — substrings to highlight
292
+ │ │ └─ color / background (optional) — highlight ink + wash, plus BOX bag
293
+ │ ├─ <Mark> — semantic <mark> span
294
+ │ │ └─ Props:
295
+ │ │ ├─ children (required) — the marked text
296
+ │ │ ├─ variant (optional) — severity preset
297
+ │ │ └─ colorPalette + COLOR overrides + BOX bag (all optional)
298
+ │ ├─ <Note> — inset callout / quote
299
+ │ │ └─ Props:
300
+ │ │ ├─ children (required) — note content
301
+ │ │ ├─ variant (optional) — visual preset
302
+ │ │ ├─ emphasis (optional) — brand | warn | danger
303
+ │ │ ├─ accentColor (optional) — the callout stripe colour
304
+ │ │ └─ width / maxWidth / padding / margin / opacity + COLOR overrides (all optional)
305
+ │ └─ <Numeric> — tabular-num number with sentiment (shares the Formats vocabulary)
306
+ │ └─ Props:
307
+ │ ├─ value (required) — the raw number
308
+ │ ├─ format (optional) — a Format.* spec: Format.Currency({ currency: "EUR" }), Format.Percent(…), Format.Compact(), … (see the Formats branch)
309
+ │ ├─ sentiment (optional) — positive | negative | neutral colouring
310
+ │ ├─ showSign (optional) — always render the +/− sign
311
+ │ ├─ textStyle (optional) — typographic preset
312
+ │ └─ signColor / color / background / opacity (optional) — ink overrides
313
+ │
314
+ ├─ Buttons (user actions)
315
+ │ ├─ <Button> — the standard action button
316
+ │ │ └─ Props:
317
+ │ │ ├─ children (required) — label text
318
+ │ │ ├─ variant (optional) — solid | subtle | outline | ghost | plain
319
+ │ │ ├─ colorPalette / size (optional) — hue + size token
320
+ │ │ ├─ onClick (optional) — East.function([], NullType) handler
321
+ │ │ ├─ startIcon / endIcon (optional) — leading / trailing icon ({ prefix: "fas", name })
322
+ │ │ ├─ loading / loadingText / loadingIcon (optional) — spinner state + swapped label/icon
323
+ │ │ ├─ disabled (optional) — blocks interaction
324
+ │ │ └─ hoverBackground + COLOR overrides (optional) — palette escape hatches
325
+ │ ├─ <IconButton> — icon-only button
326
+ │ │ └─ Props:
327
+ │ │ ├─ prefix / name (required) — Font Awesome solid icon ("fas", "chevron-right")
328
+ │ │ ├─ label (required) — accessible aria-label
329
+ │ │ ├─ variant / colorPalette / size (optional) — as Button
330
+ │ │ ├─ onClick / loading / loadingIcon / disabled (optional) — as Button
331
+ │ │ ├─ badge (optional) — superscript count text ("99+", "" = dot-only)
332
+ │ │ ├─ badgeColorPalette (optional) — badge hue (default red)
333
+ │ │ ├─ attention (optional) — "pulse" blinks the badge, "ring" rings the button
334
+ │ │ └─ hoverBackground + COLOR overrides (optional)
335
+ │ ├─ <CloseButton> — × dismiss button
336
+ │ │ └─ Props: variant / size / label (aria, default "Close") / disabled / onClick / hoverBackground + COLOR overrides (all optional)
337
+ │ ├─ <CopyButton> — copies to clipboard with ✓ feedback
338
+ │ │ └─ Props:
339
+ │ │ ├─ value (required) — the text copied
340
+ │ │ ├─ label (optional) — text next to the copy icon
341
+ │ │ ├─ timeout (optional) — "Copied!" duration ms
342
+ │ │ ├─ successColor (optional) — confirmation glyph tint
343
+ │ │ └─ variant / colorPalette / size / disabled / hoverBackground + COLOR overrides (optional)
344
+ │ ├─ <Toggle> — pressable on/off button (NOT a form toggle — see <Switch>)
345
+ │ │ └─ Props:
346
+ │ │ ├─ pressed (required) — current state (Toggle has no internal state)
347
+ │ │ ├─ children (required) — label
348
+ │ │ ├─ onChange (optional) — fn(Boolean) => Null
349
+ │ │ ├─ icon (optional) — leading icon
350
+ │ │ ├─ pressedBackground / pressedColor (optional) — pressed-state colours
351
+ │ │ └─ variant / size / disabled + COLOR overrides (optional)
352
+ │ └─ <ButtonGroup> — row/col cluster of buttons
353
+ │ └─ Props:
354
+ │ ├─ children (required) — the buttons
355
+ │ ├─ attached (optional) — join into one control with shared borders
356
+ │ └─ gap / borderColor (optional) — spacing when not attached; shared border colour when attached
357
+ │
358
+ ├─ Forms (user input)
359
+ │ ├─ <Input> — typed text inputs (namespace tag)
360
+ │ │ ├─ Nested tags: <Input.String> <Input.Integer> <Input.Float> <Input.DateTime> — value-typed variants
361
+ │ │ └─ Props (shared unless noted):
362
+ │ │ ├─ value (required) — current value (String / Integer / Float / DateTime respectively)
363
+ │ │ ├─ onChange (optional) — fn(newValue) => Null (typed per variant)
364
+ │ │ ├─ onBlur / onFocus (optional) — focus lifecycle
365
+ │ │ ├─ variant (optional) — outline | subtle | flushed
366
+ │ │ ├─ size (optional) — xs | sm | md | lg
367
+ │ │ ├─ disabled (optional) — blocks input
368
+ │ │ ├─ autoFocus (optional) — focus on first mount
369
+ │ │ ├─ String: placeholder / maxLength / pattern (optional) — text constraints
370
+ │ │ ├─ Integer & Float: min / max / step (optional); Float: precision (decimal places)
371
+ │ │ ├─ DateTime: min / max / precision (date|time|datetime) / format (token list) (optional)
372
+ │ │ └─ focusBorderColor / placeholderColor + COLOR overrides (optional)
373
+ │ ├─ <Textarea> — multi-line input
374
+ │ │ └─ Props:
375
+ │ │ ├─ value (required) — current text
376
+ │ │ ├─ onChange / onBlur / onFocus / onValidate (optional) — edit + focus callbacks
377
+ │ │ ├─ placeholder / rows / maxLength / autoresize (optional) — sizing + constraints
378
+ │ │ ├─ resize (optional) — none | vertical | horizontal | both
379
+ │ │ ├─ disabled / readOnly / required / invalid (optional) — form state
380
+ │ │ └─ variant / size / focusBorderColor + COLOR overrides (optional)
381
+ │ ├─ <Select> — single/multi-select dropdown
382
+ │ │ ├─ Props:
383
+ │ │ │ ├─ value (required) — selected value ("" = none)
384
+ │ │ │ ├─ items (required) — array of Select.Item(…)
385
+ │ │ │ ├─ onChange (optional) — fn(String) => Null (single)
386
+ │ │ │ ├─ onChangeMultiple (optional) — fn(Array<String>) => Null (multi)
387
+ │ │ │ ├─ multiple / placeholder / disabled / size (optional) — behaviour + chrome
388
+ │ │ │ ├─ onOpenChange (optional) — dropdown open/close callback
389
+ │ │ │ └─ COLOR overrides (optional) — trigger colours
390
+ │ │ └─ Factories:
391
+ │ │ └─ Select.Item(value, label, { disabled? }) — one option
392
+ │ ├─ <Combobox> — typeahead / filter select
393
+ │ │ ├─ Props:
394
+ │ │ │ ├─ value (required) — current input / selected value
395
+ │ │ │ ├─ items (required) — array of Combobox.Item(…)
396
+ │ │ │ ├─ onChange / onChangeMultiple (optional) — selection callbacks (single / multi)
397
+ │ │ │ ├─ onInputValueChange (optional) — fires as the user types
398
+ │ │ │ ├─ allowCustomValue (optional) — accept values not in the list
399
+ │ │ │ ├─ multiple / placeholder / disabled / size / onOpenChange (optional) — as Select
400
+ │ │ │ └─ COLOR overrides (optional)
401
+ │ │ └─ Factories:
402
+ │ │ └─ Combobox.Item(value, label, { disabled? }) — one option
403
+ │ ├─ <Checkbox> — boolean checkbox
404
+ │ │ └─ Props:
405
+ │ │ ├─ checked (required) — current state
406
+ │ │ ├─ onChange (optional) — fn(Boolean) => Null
407
+ │ │ ├─ label (optional) — trailing text
408
+ │ │ ├─ indeterminate (optional) — partial-selection dash
409
+ │ │ ├─ disabled / colorPalette / size (optional)
410
+ │ │ └─ fillColor / checkColor / borderColor (optional) — slot colours
411
+ │ ├─ <Switch> — form on/off toggle (binds a boolean)
412
+ │ │ └─ Props:
413
+ │ │ ├─ checked (required) — current state
414
+ │ │ ├─ onChange (optional) — fn(Boolean) => Null
415
+ │ │ ├─ label / disabled / colorPalette / size (optional)
416
+ │ │ └─ onColor / offColor / thumbColor (optional) — track + knob colours
417
+ │ ├─ <Slider> — range slider
418
+ │ │ └─ Props:
419
+ │ │ ├─ value (required) — current value
420
+ │ │ ├─ onChange (optional) — fires during drag; onChangeEnd (optional) — fires on release
421
+ │ │ ├─ min / max / step (optional) — range (defaults 0–100)
422
+ │ │ ├─ orientation / variant / colorPalette / size / disabled (optional)
423
+ │ │ └─ trackColor / fillColor / thumbColor / markColor (optional) — slot colours
424
+ │ ├─ <RadioGroup> — single-select radio list
425
+ │ │ └─ Props:
426
+ │ │ ├─ value (required) — selected value ("" = none)
427
+ │ │ ├─ items (required) — [{ value, label?, disabled? }]
428
+ │ │ ├─ onChange (optional) — fn(String) => Null
429
+ │ │ ├─ orientation / name / disabled / required / colorPalette / size (optional)
430
+ │ │ └─ color / fillColor / borderColor (optional) — ink + radio colours
431
+ │ ├─ <RadioCardGroup> — radios rendered as picker cards
432
+ │ │ └─ Props:
433
+ │ │ ├─ value (required) — selected card value
434
+ │ │ ├─ items (required) — [{ value, label, description?, disabled? }]
435
+ │ │ ├─ onChange (optional) — fn(String) => Null
436
+ │ │ ├─ orientation / name / disabled / required / colorPalette / size (optional)
437
+ │ │ └─ color / descriptionColor / cardBackground / selectedCardBackground / selectedBorderColor (optional)
438
+ │ ├─ <TagsInput> — typeahead chip input
439
+ │ │ └─ Props:
440
+ │ │ ├─ defaultValue (optional) — initial tags
441
+ │ │ ├─ onChange (optional) — fn(Array<String>) => Null with the new tag set
442
+ │ │ ├─ suggestions (optional) — autocomplete list (free entry still allowed)
443
+ │ │ ├─ max / maxLength / allowOverflow (optional) — tag-count / length constraints
444
+ │ │ ├─ editable / delimiter / addOnPaste / blurBehavior (optional) — editing behaviours
445
+ │ │ ├─ onInputChange / onHighlightChange (optional) — typing + highlight callbacks
446
+ │ │ ├─ label / placeholder / disabled / readOnly / invalid (optional) — chrome + state
447
+ │ │ ├─ variant / size / colorPalette (optional)
448
+ │ │ └─ tagBackground / tagColor / tagBorderColor + COLOR overrides (optional) — per-chip colours
449
+ │ ├─ <FileUpload> — drop-zone file picker
450
+ │ │ └─ Props:
451
+ │ │ ├─ onFileAccept (optional) — fn(files) => Null; onFileReject (optional) — fn(rejections) => Null
452
+ │ │ ├─ accept / maxFiles / maxFileSize / minFileSize (optional) — acceptance constraints
453
+ │ │ ├─ directory / allowDrop / capture (optional) — folder upload, drag-drop, mobile camera
454
+ │ │ ├─ label / dropzoneText / triggerText / orientation (optional) — copy + layout
455
+ │ │ ├─ disabled / required / name (optional) — form state
456
+ │ │ └─ variant / size / dropzoneBackground / dropzoneBorderColor / activeBackground + COLOR overrides (optional)
457
+ │ ├─ <Field> — form-field wrapper (label + control + helper/error)
458
+ │ │ └─ Props:
459
+ │ │ ├─ label (required) — the field caption; children (required) — the control
460
+ │ │ ├─ helperText / errorText (optional) — descriptive + validation lines
461
+ │ │ ├─ required / disabled / invalid / readOnly (optional) — form state
462
+ │ │ ├─ orientation (optional) — label/control layout
463
+ │ │ └─ labelColor / helperTextColor / errorColor / warningColor / infoColor / requiredIndicatorColor (optional)
464
+ │ ├─ <DateRangeInput> — start–end date pair with preset chips
465
+ │ │ └─ Props:
466
+ │ │ ├─ startValue / endValue (required) — the range (UTC DateTime pair)
467
+ │ │ ├─ onChange (optional) — fn(start, end) => Null
468
+ │ │ ├─ min / max / precision (optional) — bounds + picker precision (date|minute|second)
469
+ │ │ ├─ presets (optional) — [{ label, start, end }] preset rows above the inputs
470
+ │ │ ├─ disabled (optional)
471
+ │ │ └─ variant / size / focusBorderColor + COLOR overrides (optional)
472
+ │ └─ <TimeRangeInput> — start–end time pair (minutes since midnight)
473
+ │ └─ Props:
474
+ │ ├─ startValue / endValue (required) — minutes 0–1439
475
+ │ ├─ onChange (optional) — fn(startMin, endMin) => Null
476
+ │ ├─ min / max / step (optional) — bounds + picker step (default 15)
477
+ │ ├─ presets (optional) — [{ label, start, end }]
478
+ │ ├─ disabled (optional)
479
+ │ └─ variant / size / focusBorderColor + COLOR overrides (optional)
480
+ │
481
+ ├─ Collections (display data sets) — structured data on `data=` / `columns=` / `items=` props
482
+ │ ├─ <Table data={rows} columns={…} /> — sortable / pinnable / virtualized data grid; generic pass-through (column/cell inference preserved)
483
+ │ │ ├─ Props:
484
+ │ │ │ ├─ data (required) — array of row structs, or of RecursiveType rows whose node is a struct (nested with `tree`); or a paged source of either (#576)
485
+ │ │ │ ├─ columns (required) — keyed config: ["a","b"] or { a: { header, width, value?, render?, format?, aggregate?, … } }; with no `render` a cell PRINTS ITSELF in the viewer's language (#874): a number keeps every digit, never grouped, with the viewer's decimal separator (1234.5 — German 1234,5; a year or an id prints as stored), a string as it is, anything else as East prints it; `format` — a Format.* spec (Format.Number() groups thousands, Format.Currency({ currency: "EUR" }), Format.Percent(…)) — prints the column's number cells AND a parent's subtotals through it (a `count` prints as a count); column `render` is an East fn ({rowIndex, path, columnKey, cellValue} → UIComponent) called per VISIBLE cell, drawing it instead — full-row access = capture the data array + index it (($, ctx) => { const row = $.let(rows.get(ctx.rowIndex)); … }; a flat table's rowIndex IS the data index, a nested row is reached by its `path`); render/on* fns may capture only data + bind-handles — never a UIComponentType value (beast2 can't serialize it)
486
+ │ │ │ ├─ tree (optional) — { children: r => r.lines, collapsed?: true | r => Boolean } rows nest to ANY depth from the data's own tree (#954): `children` returns more of the SAME row type (a RecursiveType row's own field, or a lookup among the rows) — a recursive row reaches every accessor as its node — and a different type is refused at build; a parent IS its group row: its own cells, and in an `aggregate` column ("sum"|"mean"|"min"|"max"|"count") its children's subtotal, composed bottom-up (sum of sums, a mean of means — always a Float — min / max of theirs, `count` the leaf rows beneath), drawn through the column's `render` (its `cellValue` the subtotal) or `format` (a `count` prints itself through neither); a caret before a parent's first cell folds its subtree (persisted by path under the storageKey; `collapsed` is where it starts); a sort orders siblings among themselves, each parent carrying its subtree; rows arrive in PRE-ORDER, and a row's position in it is its `rowIndex`. There is no `groupBy`: group flat rows as a data step before the table; grand totals stay in footerRows
487
+ │ │ │ ├─ columnGroups (optional) — column-group heading row (type-checked columnKeys)
488
+ │ │ │ ├─ footer / footerRows (optional) — one / many footer rows, keys narrowed to the table's columns
489
+ │ │ │ ├─ expandedContent (optional) — fn(rowIndex) => UIComponent expandable row detail (the row's pre-order index — a flat table's data index — stable under sorting AND pagination)
490
+ │ │ │ ├─ frozen (optional) — column keys pinned left (visible during horizontal scroll)
491
+ │ │ │ ├─ height / maxHeight (optional) — uniform sizing (#320): pin or cap the table; chrome-inclusive, rows scroll within
492
+ │ │ │ ├─ variant / size / striped / interactive / stickyHeader / showColumnBorder (optional) — grid chrome
493
+ │ │ │ ├─ density (optional) — row rhythm preset; rowHeight (optional) — explicit px override (fed to the virtualizer)
494
+ │ │ │ ├─ virtualization / columnResize (optional) — row virtualization + header drag-resize
495
+ │ │ │ ├─ selection (optional) — { mode, selected, onChange } embedded row-selection state over pre-order indices (a shift-click range spans the rows as displayed; select-all takes every row in the data)
496
+ │ │ │ ├─ pagination (optional) — { pageSize, page, onPageChange } embedded pager over TOP-LEVEL rows, each page holding its rows' whole subtrees
497
+ │ │ │ ├─ onCellClick / onCellDoubleClick / onRowClick / onRowDoubleClick / onRowSelectionChange / onSortChange (optional) — interaction callbacks; row events carry `rowIndex` (the pre-order index) and `path` ([i] the i-th top-level row, [i, j] its j-th child)
498
+ │ │ │ ├─ rowStatus (optional) — fn(rowIndex) => StatusToken row tint over the pre-order index (see the Statuses branch)
499
+ │ │ │ ├─ review / reviewStatus / reviewApproval (optional) — pinned-right Decision column + commitBar foot BELOW the pager; rowIndex is the row's pre-order index
500
+ │ │ │ ├─ slice + affordances (optional) — bound slice chrome (default ["filter","search"]); filtering flows through the slice interface
501
+ │ │ │ ├─ plotGutter (optional) — shared plot gutter (#147); frozen columns fill `left`
502
+ │ │ │ └─ colorPalette + headerBackground / headerColor / zebraBackground / hoverBackground / selectedBackground / selectedBorderColor / footerBackground / borderColor (optional) — chrome colours
503
+ │ │ └─ Factories: (columns/footers are plain config objects; no builders)
504
+ │ ├─ <DataList items={…} /> — label/value pairs
505
+ │ │ └─ Props:
506
+ │ │ ├─ items (required) — [{ label: String, value: UIComponent }] (plain structs — no builder needed)
507
+ │ │ ├─ orientation / size / variant (optional) — pair layout + chrome
508
+ │ │ └─ labelColor / valueColor / background / borderColor (optional)
509
+ │ ├─ <TreeView nodes={…} /> — expandable hierarchical tree with selection
510
+ │ │ ├─ Props:
511
+ │ │ │ ├─ nodes (required) — array of TreeView.Item / TreeView.Branch values
512
+ │ │ │ ├─ selectionMode (optional) — selection cardinality
513
+ │ │ │ ├─ defaultExpandedValue / defaultSelectedValue (optional) — initial expansion / selection
514
+ │ │ │ ├─ onExpandedChange / onSelectionChange / onFocusChange (optional) — interaction callbacks
515
+ │ │ │ ├─ size / variant / animateContent / label (optional) — chrome
516
+ │ │ │ └─ itemColor / itemHoverBackground / selectedBackground / selectedColor / caretColor / connectorColor (optional)
517
+ │ │ └─ Factories:
518
+ │ │ ├─ TreeView.Item(value, label, indicator?) — leaf node (indicator = a Font Awesome solid icon + style)
519
+ │ │ └─ TreeView.Branch(value, label, children, indicator?, disabled?) — expandable node
520
+ │ ├─ <Plan> — the planning canvas (ONE shared time | number | ordinal axis over heterogeneous rows: event kinds over records, rows laid out by a series list over data, and read-only rows) is e3-ui's (#1177, #1191): `import { Plan } from "@elaraai/e3-ui"` — its props, factories and patterns are in the e3-ui skill
521
+ │ ├─ <Sheet> — the planning spreadsheet, always in its builder frame (typed columns over an e3 record's rows or the host's, a blank tail that invites the next row, typed grammars, an East-function copilot, a slice lens, an editing session, and a library and an inspector pane, each an optional prop) is e3-ui's (#1179, #1216): `import { Sheet } from "@elaraai/e3-ui"` — its props, factories and patterns are in the e3-ui skill
522
+ │ ├─ <Matrix data={…} columns={…} cell={(r, col) => Matrix.cell({…})} /> — rows × columns of status-coloured segment bars
523
+ │ │ ├─ Props:
524
+ │ │ │ ├─ data (required) — row structs, or RecursiveType rows whose node is a struct (nested with `tree`); columns (required) — array of Matrix.column(…) (data-drivable with .map)
525
+ │ │ │ ├─ cell (required) — (row, column) => Matrix.cell(…) builder
526
+ │ │ │ ├─ rowKey (required) — the row's key, its address in every event (keep keys unique across a nested tree); rowValue / rowSublabel (optional) — the row header's text
527
+ │ │ │ ├─ tree (optional) — { children: r => r.members, collapsed?: true | r => Boolean } rows nest to ANY depth from the data's own tree (#955), as on the Table: `children` returns more of the SAME row type (a RecursiveType row's own field, or a lookup among flat rows — `r => people.filter((_$, p) => p.team.equal(r.name))`); a parent is a FULL row — its header indented with a fold caret, and its own cells from the same `cell` builder (no aggregates: a parent's bars are whatever its row builds); the caret folds its subtree (persisted by path under the storageKey). There is no `groupBy`: group flat rows as a data step
528
+ │ │ │ ├─ rowHeader (optional) — header label for the left identity column
529
+ │ │ │ ├─ orientation (optional) — default segment orientation
530
+ │ │ │ └─ legend (optional) — explicit legend entries [{ fill, label }] (omitted ⇒ auto-derived)
531
+ │ │ └─ Factories:
532
+ │ │ ├─ Matrix.column({ key, label? }) — one x-axis column
533
+ │ │ ├─ Matrix.cell({ segments?, markers?, orientation?, slot?, popover? }) — one cell (slot = arbitrary UIComponent; popover = click body)
534
+ │ │ ├─ Matrix.segment({ fill?, weight, label?, color?, min?, max?, step? }) — one segment of the cell bar
535
+ │ │ └─ Matrix.marker({ status?, message, at?, label? }) — corner status marker
536
+ │ ├─ <Schematic items={rows} extent={{width,height}} item={r => ({…})} /> — 2D world-coord canvas: items / zones / links / nets from flat tables
537
+ │ │ ├─ Props:
538
+ │ │ │ ├─ items + extent (required) — item rows + world bounds (canvas scales to fit)
539
+ │ │ │ ├─ item (optional) — row mapper to { key, x, y, label, sublabel?, icon?, status?, meter?{value,max}, metric?, width?, footprint?, tone?, color?, bg?, fillOpacity?, weight?, excluded?, layer? } (omit when already Schematic.Types.Item)
540
+ │ │ │ ├─ zones + zone (optional) — zone rows + mapper to { key, label, x, y, width, height, pattern?, geometry?, tone?, color?, bg?, fillOpacity?, weight?, layer? }
541
+ │ │ │ ├─ links + link (optional) — link rows + mapper to { key, from, to, label?, metric?, style?, route?, via?, layer? }
542
+ │ │ │ ├─ nets + net (optional) — manifold/bus rows (ONE row = many sources → many destinations) + mapper to { key, sources, destinations, label?, metric?, style?, route?, via?, layer? }; drawn P&ID-style — a header BAR spans each multi-endpoint side with a stub per endpoint, the trunk runs bar → via… → bar (junction dots ONLY where a tap 3-way joins a bar)
543
+ │ │ │ ├─ selectionMode (optional) — "single" (default) | "multiple" | "range"; multiple ⇒ marquee tool (drag-box multi-select w/ live preview + count; plain box/tap replaces, Shift extends)
544
+ │ │ │ ├─ onSelect / onSelectionChange (optional) — item click (key) / full selection-set events ({key?, selected, selectedKeys, additive, region?}); works in every tool (grab/zoom/marquee)
545
+ │ │ │ ├─ onSelectZone / onZoneSelectionChange (optional) — zone click-select (items win hit-test; innermost zone wins; Shift extends) reporting the zones AND their childItemKeys
546
+ │ │ │ ├─ selectZoomFocus (optional) — a canvas selection also moves the camera (tap flies, marquee fits)
547
+ │ │ │ ├─ onItemOpen (optional) — double-click drill-in (background double-click keeps Fit/reset)
548
+ │ │ │ ├─ onViewportChange (optional) — debounced viewport-settled reporting ({zoom, minX, minY, maxX, maxY}) for sync / lazy-load / persist
549
+ │ │ │ ├─ linkMode (optional) — connect-gesture mode: "draw" (adds locally, form-input style) | "connect" (event-only, repeatable: plan operations); Shift+drag ADDS to the session
550
+ │ │ │ ├─ onCreateLink / onSelectLink / onEditLink / onDeleteLink (optional) — link lifecycle ({link, links, additive, existing} on create; click-select key; endpoint re-target; Del delete)
551
+ │ │ │ ├─ canConnect (optional) — fn(from, to) => Bool vetoes pairs BEFORE they resolve (the draft never snaps; one rule covers links, Shift-session/net extensions, and re-targets; a throwing validator fails OPEN)
552
+ │ │ │ ├─ onEditNet (optional) — net membership edits: trunk/bar click selects the WHOLE net, a STUB click selects ONE leg (Del removes just that endpoint; onEditNet reports membership AFTER; a side emptying deletes the whole net via onDeleteLink). Shift-session gestures keep ONE bus (a member never flips sides); with a LINK selected, Shift-drag from its endpoint SEEDS the session with that link (onCreateLink.absorbed lists absorbed keys — delete those rows when upserting); with a NET selected, Shift-drag out of a member adds the target as a leg; a Shift connect-session commits as a net (onCreateLink.net = {key, sources, destinations}, stable session key — upsert by net.key)
553
+ │ │ │ ├─ readOnly / readOnlyLinks / readOnlyItems (optional) — flattened per-domain edit gates
554
+ │ │ │ ├─ onMoveItem (optional) — move tool (readOnlyItems off): drags items to new positions; a selected item moves the WHOLE selection rigidly, local-first; fires once per gesture ({key, x, y, keys, dx, dy})
555
+ │ │ │ ├─ itemHover / zoneHover / linkHover (optional) — East fn key => UIComponent lazy hover cards (charts in a card over a tank / pipe); any camera or edit gesture closes them; hover ignores readOnly + locked layers
556
+ │ │ │ ├─ slice + affordances (optional) — bound slice chrome (default ["search"]); flat effect props sliceHidden / sliceOpacity / sliceDesaturate / sliceDot / sliceEmphasis:"halo"|"pulse" / sliceFrame / sliceFrameFit keep filtered-OUT items as ghost/desaturate/dot context + emphasise the remainder instead of hiding — feed the FULL set (Slice.partition) and mark item.excluded (e.g. t.matched.not())
557
+ │ │ │ ├─ sliceSelectField (optional) — bound-slice fieldId a marquee/tap selection writes an `in` filter of selected item keys into (one-directional selection→slice) — pair with the ghost effect (not a Slice.rows feed on the same slice)
558
+ │ │ │ ├─ layers (optional) — [{ key, label, tone?, visible?, locked?, opacity? }] + tag items/zones/links with layer:"key"; a canvas layer button opens a show/hide/solo/lock panel (persists per panel); lock ⇒ non-selectable (click-through), opacity dims
559
+ │ │ │ ├─ scaleUnit / grid / navigator / minimap (optional) — scale bar unit, metric grid (default on), zones→items TOC (default when zones exist), minimap (default 25+ items)
560
+ │ │ │ └─ height / maxHeight (optional) — uniform sizing (#320); default aspect-driven, capped 75vh
561
+ │ │ └─ Factories:
562
+ │ │ ├─ Schematic.circle(r) / .polyline(verts, {width}) / .polygon(verts) / .rect() — item footprints + zone geometry
563
+ │ │ ├─ Schematic.outline() / .hatch() — zone boundary patterns
564
+ │ │ └─ Schematic.solid() / .dashed() — link / net stroke styles
565
+ │ ├─ <Flowchart> — the state-transition flowchart (states in ORDERED phase lanes, its layout derived — no coordinates; H/V-routed transitions; per-link decision triggers and evidence) is e3-ui's (#1243): `import { Flowchart } from "@elaraai/e3-ui"` — its props, factories and patterns are in the e3-ui skill
566
+ │ ├─ <Map markers={…} center={Map.at(lat,lng)} zoom={n} /> — interactive geographic basemap; read-only / selection-only
567
+ │ │ ├─ Props:
568
+ │ │ │ ├─ markers + center + zoom (required) — marker rows + initial camera
569
+ │ │ │ ├─ marker / area / line / label (optional) — row mappers for each table (omit when rows are already Map.Types.* values)
570
+ │ │ │ ├─ areas / lines / labels (optional) — the additional overlay tables
571
+ │ │ │ ├─ hexes (optional) — H3 lattice + per-cell detail (Map.hex(…))
572
+ │ │ │ ├─ overlays (optional) — positioned East children (Map.overlay(child, { align }))
573
+ │ │ │ ├─ tiles (optional) — basemap (default Map.carto("positron"))
574
+ │ │ │ ├─ minZoom / maxZoom / lodZoom / fitBounds (optional) — zoom clamps, detail-LOD threshold, camera framing
575
+ │ │ │ ├─ onAreaClick / onMarkerClick / onZoom / onSelect (optional) — interaction callbacks
576
+ │ │ │ └─ scrollWheelZoom / attributionPrefix / height (optional) — chrome
577
+ │ │ └─ Factories:
578
+ │ │ ├─ Map.at(lat, lng) — a coordinate; Map.point(…) / Map.bounds(…) — flyTo targets
579
+ │ │ ├─ Map.carto(style) / Map.osm() / Map.tile(url, …) — basemaps
580
+ │ │ ├─ Map.hexDisk(…) / Map.cells(…) / Map.polygon(…) — H3 shapes; Map.hex(…) — the hex layer
581
+ │ │ ├─ Map.marker(…) / Map.area(…) / Map.line(…) / Map.label(…) — overlay values
582
+ │ │ ├─ Map.solid() / Map.dashed() — line styles
583
+ │ │ └─ Map.overlay(child, { align }) — a positioned East child
584
+ │ ├─ <Library id="people" data={rows} item={r => ({…})} /> — draggable palette (DnD source; targets list its id in their `sources`) under ONE toolbar row; a card drags by pointer or by KEYBOARD, announced — see the Drag and drop pattern. `variant="gallery"` draws the same cards LARGE, each with its `media` — any UI component — the library a person browses: a page library (each page's `<SnapGrid variant="wireframe">`), a report catalog (a `<Sparkline>` each)
585
+ │ │ ├─ Props:
586
+ │ │ │ ├─ id (required) — DnD source identity
587
+ │ │ │ ├─ data (required) — item rows
588
+ │ │ │ ├─ item (required) — row mapper to { key, label, sublabel?, icon?, status?, trailing?, draggable?, filtered?, placed?, media?, avatar?, byline?, action? } — `trailing` a glyph at the card's right edge (`some(Library.glyph(…))`: a lock on something fixed, a dot for a status); `placed` draws the card in its placed state, the brand border and tint (the item already on the target — say how often in its sublabel). A gallery card's own: `media` (any UIComponent, drawn inert — the card is the click target), `avatar` (the name whose initials the foot's avatar shows), `byline` (the foot's line after it), `action` (a label in the link voice at the foot's end, "Open in builder →", which a click on the card follows — `onCardClick`); a gallery card's `trailing` sits at its foot's end
589
+ │ │ │ ├─ variant (optional) — "compact" (default; a line per card — the palette a surface drags from) | "gallery" (a large card per item: its `media` above the face or at its start, the name with its status as a dot and the word, the meta line, and a foot holding the `avatar`, `byline` and `action`). A compact Library refuses the gallery's fields at build, naming each
590
+ │ │ │ ├─ layout (optional, gallery) — the layout a gallery starts in: "grid" (default; the style's `columns` across, fewer as the Library narrows, one on a phone) | "list" (a card per row, its media at the start). The toolbar's Grid · List switch changes it, and the viewer's pick is kept with the toolbar under the storage key; an expression that moves moves it
591
+ │ │ │ ├─ toolbar (optional) — true (default) | false: no toolbar row, the cards sitting in their host's frame — for a host whose ONE toolbar serves several Libraries (a page library's Templates and Pages): the host narrows `data` itself and gives a gallery its `layout`, which the Library then follows. The options whose controls live in the toolbar — `search`, `groupBy`, `filters`, `dimensions`, `hint` and `slice` — are refused with it at build, naming each
592
+ │ │ │ ├─ hint (optional) — a caption at the toolbar row's end (the first thing a narrow row folds away)
593
+ │ │ │ ├─ dimensions + defaultDimensions (optional) — toolbar-toggleable card facts ({ kind: "meter" | "chips" | "text", … }); initially-visible keys (default first two)
594
+ │ │ │ ├─ groupBy (optional) — [{ key, label, value, summary? }] GROUP BY options (omit for flat)
595
+ │ │ │ ├─ filters (optional) — [{ key, label, values: r => Array<String> }] the toolbar's Filter menu: each facet's distinct values, in the order the cards first hold them (one value for a single-valued facet like a category, several for its tags); checked values keep the cards holding one of them (OR within a facet, AND across facets), the rest hide as the search's do and the group counts follow; the trigger counts the checked values ("Filter · 2"), and the footer's Show all clears them with the search
596
+ │ │ │ ├─ search (optional) — filter-text accessor; unmatched cards hide (footer shows hidden count + Show all)
597
+ │ │ │ ├─ noun (optional) — { singular, plural } what the items are called — the search box counts them ("Search 47 components…"; default item / items)
598
+ │ │ │ ├─ onCardClick (optional) — fn(key) => Null when a card is clicked (a drag never clicks); a card that cannot be dragged is then a button, so Enter / Space click it too
599
+ │ │ │ ├─ addLabel + onAdd (optional) — footer action; a gallery's dashed last card
600
+ │ │ │ ├─ slice + affordances (optional) — bound slice chrome (default ["filter","search"])
601
+ │ │ │ └─ style (optional) — { height, maxHeight, virtualization, columns?, mediaPlacement?, mediaSize? } — the last three a gallery's (refused on a compact Library): `columns` its cards across in the grid (Integer, default 3), `mediaPlacement` "top" (default, above the face) | "start" (at its start), `mediaSize` a CSS length — the media's height on top, its width at the start ("156px"). A gallery mounts every card (no virtualization)
602
+ │ │ ├─ The toolbar: ONE row, the shared toolbar every toolbar host lays its chrome in — the search box (⌘ / focuses it) and GROUP · …, then at its end the `hint`, SECONDARY, FILTER and a gallery's Grid · List switch (a radio group: one tab stop, ← / → move and pick); with `slice` chrome the rail's affordances lead the same row, a `search` among them in place of the built-in one. A narrower row folds on one ladder: the rail first, then the hint goes, SECONDARY and FILTER fold to their icons, then GROUP does, and last the search box narrows and drops its key cap; the switch never folds. `toolbar: false` draws no row
603
+ │ │ └─ Factories:
604
+ │ │ ├─ Library.status(label, tone, ring?) — a card status: a compact card's chip, a gallery card's dot and word (tone = a status token; see the Statuses branch); `ring` draws the dot open, a state not reached yet (a Draft beside a Live)
605
+ │ │ └─ Library.glyph(icon, label, tone?) — a card's trailing glyph: an FA icon, the words it says (its accessible name and tooltip), and an optional status tone (else the card's quiet ink, the brand ink while placed)
606
+ │ ├─ <Deck data={rows} statuses={Deck.statuses({…})} card={r => ({ key, title, status, metrics, fill })} /> — grouped mini-card board (display, NOT a drag source — that's Library); every card carries an EXPLICIT status colour from the deck's STATUS REGISTRY (solid tag + dot, faint face wash, fill-bar colour); two card states: the LIST face + a VIEW state in an anchored POPOVER CARD whose head is inherited from the face
607
+ │ │ ├─ Props:
608
+ │ │ │ ├─ data (required) — array of rows to project into cards
609
+ │ │ │ ├─ card (required) — accessor r => face fields: key (required; identity reported by onCardClick/onOpen) · title (required; identity line) · sublabel (muted mono-uppercase second line) · icon (FA solid name) · status (a KEY into `statuses` — paints the tag/wash/fill) · metrics ([Deck.metric(…)] raw-value strip) · fill ({ value, max, format? } status-coloured bar; format = shared spec over value OR (value, max) => String accessor; omitted → percentage) · facts ([Deck.meter/chips/text(…)]) · filtered (render dimmed — the Slice.partition "keep the excluded" feed)
610
+ │ │ │ ├─ statuses (optional) — the status registry, Deck.statuses({…}); card `status` fields reference entries by key
611
+ │ │ │ ├─ groupBy (optional) — [{ key, label, value, summary? }] named GROUP BY toolbar + None; grouping by the status accessor decorates group heads with the registry swatch + hint
612
+ │ │ │ ├─ layout (optional) — "grid" (default; wrap auto-fill minmax(minCardWidth,1fr) → one phone column) | "list" (full-width rows)
613
+ │ │ │ ├─ onClick (optional) — r => <…/> the STICKY popover's BODY (tap opens; Esc / outside / × close); the head — title, sublabel, icon, status tag + wash — is INHERITED from the card face
614
+ │ │ │ ├─ onHover (optional) — r => <…/> the transient hover peek's body (hover-capable pointers only, intent-delayed)
615
+ │ │ │ ├─ onOpen (optional) — fn(key) => Null; fires when a card's popover opens
616
+ │ │ │ ├─ onClose (optional) — fn() => Null; fires once per popover close (Esc / outside / ×)
617
+ │ │ │ ├─ onCardClick (optional) — fn(key) => Null; cards are tap targets even without popover content
618
+ │ │ │ ├─ render (optional) — r => <…/> fully custom card body beneath the structured face
619
+ │ │ │ ├─ footer (optional) — [{ label, value }] board-foot key/value stats
620
+ │ │ │ ├─ legend (optional) — boolean; renders the registry legend (swatch + label + hint)
621
+ │ │ │ ├─ slice + affordances (optional) — slice={handle} + affordances (default ["filter","search"] — brush/legend/breakdown rejected) mounts the rail + count footer; feed data via Slice.rows (remove) or Slice.partition → filtered (dim); filtering/search flow through the slice interface like Table — no bespoke search
622
+ │ │ │ └─ style (optional) — { height, maxHeight, minCardWidth, virtualization }; height/maxHeight make the board its own (virtualized) scroll region, flat AND grouped
623
+ │ │ └─ Factories:
624
+ │ │ ├─ Deck.statuses({ key: { label, color, pulse?, hint? } }) — build the status registry; color is a standard status token "success"|"warning"|"danger"|"info"|"neutral" OR any custom CSS colour (the faint face tint is derived); pulse animates the tag dot (active states); hint feeds the legend + group heads
625
+ │ │ ├─ Deck.metric(label, value, { format?, warn? }) — one metric cell: the RAW Float (or Option Float) value plus a shared format — a Chart.format.* spec or a v => String accessor (same vocabulary as chart axes); a none value renders "—"; warn paints the value in the danger tone
626
+ │ │ ├─ Deck.Readout([{ label, value, format?, unit?, warn? }]) — popover readout rail: a bordered grid of big mono values with unit suffixes (raw values + shared format, like Deck.metric)
627
+ │ │ ├─ Deck.Rows([{ label, value }]) — popover key/value detail rows (mono-uppercase keys, body-voice values)
628
+ │ │ ├─ Deck.Note(text) — popover dashed-top mono footnote
629
+ │ │ ├─ Deck.meter(label, value, max, text) — card-face meter fact (utilisation bar + right-aligned reading)
630
+ │ │ ├─ Deck.chips(label, values) — card-face chip-set fact
631
+ │ │ └─ Deck.text(label, text) — card-face dim text fact
632
+ │ ├─ <ValueTree value={anyEastValue} /> — editable tree of ANY East value, materialized from its STATIC type at authoring time (structs/arrays/dicts/options/variants → branches; primitives → typed editable leaves; sets/blobs/vectors/matrices/refs/fns → read-only summaries; non-string-keyed dict entries label as field summaries and edit their VALUES — entry add/remove stays string-keyed)
633
+ │ │ ├─ Props:
634
+ │ │ │ ├─ value (required) — the East value to render; omit every callback for a read-only inspector
635
+ │ │ │ ├─ onUpdate (optional) — fn([T], Null) whole-value handler: receives the WHOLE value with the edit applied (the factory rebuilds it for you); sync or async
636
+ │ │ │ ├─ at (optional) — [ValueTree.at(T, probe, fn)] scoped subtree handlers; deepest matching scope wins, unmatched edits bubble to onUpdate
637
+ │ │ │ ├─ onEdit (optional) — RAW path callback (escape hatch; overrides per event): fn(path, leaf) => Null leaf edit
638
+ │ │ │ ├─ onInsert (optional) — RAW append/insert: array append paths end with an `append` step, dict adds carry the new `key`
639
+ │ │ │ ├─ onRemove (optional) — RAW remove with the element/entry path
640
+ │ │ │ ├─ onTag (optional) — RAW variant switch + option set/clear ("some"/"none")
641
+ │ │ │ └─ style (optional) — { height, maxHeight, openDepth, toolbar }; bounded trees virtualize rows; openDepth = how many levels start expanded (default 1; 0 = all collapsed), toolbar adds a Collapse all / Expand all header row; Alt-click any twist collapses that whole subtree
642
+ │ │ └─ Factories:
643
+ │ │ ├─ ValueTree.at(T, p => p.machines.entry("m1"), fn([SubT], Null)) — a typed scope: struct fields as properties, .item(i), .entry(k), .some()
644
+ │ │ ├─ ValueTree.zero(T) — the default element for inserts (delegates to East defaultValue)
645
+ │ │ └─ ValueTree.Types.{Root, Node, Path, Step, Leaf, Style} — the East types for RAW callbacks
646
+ │ ├─ <Roster> — the weekly staffing builder is in e3-ui: `import { Roster } from "@elaraai/e3-ui"`. Shifts day/week and People week, bound weeks/staff/configuration, shared Slice and editing; the former east-ui Roster and Board are removed.
647
+ │ ├─ <Blend targets={…} config={{…}} /> — blend / batch assembly surface; pairs with a Library; target count picks the mode: 1 single | 2 compare (derived diff / Δ table) | 3+ portfolio
648
+ │ │ ├─ Props:
649
+ │ │ │ ├─ targets + id (required) — target rows + DnD target identity
650
+ │ │ │ ├─ target (optional) — row mapper to Blend target fields (omit when already Blend.Types.Target)
651
+ │ │ │ ├─ sources (optional) — Library ids accepted for add-drops
652
+ │ │ │ ├─ diff (optional) — compare mode: metric keys for the foot table (default all); verdict (optional) — compare verdict line
653
+ │ │ │ ├─ onDrag + canDrop (optional) — add/remove drag funnel + IR drop veto (⊘)
654
+ │ │ │ ├─ onAmountChange (optional) — allocation amount edits
655
+ │ │ │ └─ onAction (optional) — panel actions; the action foot rides the shared commitBar (Apply = approve-primary, Discard = reject-danger, Reset plain — apply/discard are the panel-scope review verbs)
656
+ │ │ └─ Factories:
657
+ │ │ ├─ Blend.allocation({ source, amount, pinned?, state? }) — one allocation line
658
+ │ │ └─ Blend.metric({ key, label, value, numeric?, model?, band? }) — one target metric
659
+ │ ├─ <Slice.Rail slice={slice} affordances={[…]} /> — shared narrowing chrome over one bound dataset; feed consumers via Slice.rows
660
+ │ │ ├─ Props:
661
+ │ │ │ ├─ slice (required) — the bound handle from Slice.bind
662
+ │ │ │ ├─ affordances (optional) — ["filter","search","range","breakdown","cohort","presets","brush","legend"]; legends are explicit-only (list "legend" or compose <Slice.Legend>)
663
+ │ │ │ ├─ persist (optional) — "local" | "session" | "url" opts the state into reload-surviving / shareable-link storage
664
+ │ │ │ └─ brush (optional) — the brush strip is rich by default (the range field's format drives the axis labels; a self-excluding count histogram shows the row distribution); brush={{ axis?, count?, buckets? }} opts down to the bare track. The applied window is a full brush selection: drag its body to slide (width preserved), an edge to resize, empty track to draw (also the Plan's horizon-brush gesture)
665
+ │ │ ├─ Nested tags: <Slice.Filter/Search/Range/Breakdown/Legend/Cohort/Presets/Summary slice={slice} /> — per-affordance chrome; <Slice.Cohort mode="toggle"|"manage" allowCreate? group?> (cohorts toggle on chip click; cohorts sharing a `group` render as one captioned run — a FAMILY of alternatives: active members OR within a family, families AND with each other and with standalone cohorts; an empty family member hides on the preset bar unless on; `group="…"` shows one family alone; <Slice.Presets> = toggle-only preset bar); <Slice.Legend> = facet bar (click = in-set multi-select over self-excluding slice.facetGroups(); mode="visibility" = eye rail); Summary/Filter footers read "N of M"
666
+ │ │ └─ Factories:
667
+ │ │ ├─ Slice.bind(key, rows, options?) — local Array rows; infers the row type. Options: fields (label/hints/format), range, search, initial, presets, breakdown and match. Initial/preset clauses name typed fields; local operators include gte/contains. The positional form is removed.
668
+ │ │ ├─ Slice.bindRecord(key, indexed, options?) — Data.bindPaged(record, { indexes }) from e3-ui; fields/range/search/initial/presets come from declared field indexes. No browser predicate, local operators, match or breakdown. Several exact values then one range/prefix must follow one index; a Set field takes one exact member.
669
+ │ │ ├─ Slice.config(Row, { fields, rangeFieldId?, searchFieldIds?, breakdownFieldIds? }) / Slice.state({…}) — low-level config/state for pure Slice.apply and state operations; bind options infer and seed these automatically.
670
+ │ │ ├─ Slice.rows(slice) — the narrowed Array for local rows, or a pinned ordered source for records; record entries retain original key beside tagged ik, covering value and optional joined row.
671
+ │ │ ├─ Slice.partition([Row], slice) — the FULL set tagged [{value, matched}] (the "keep the excluded" feed — drive a de-emphasis effect from `matched`)
672
+ │ │ ├─ Slice.apply.where / .matches / .breakdown — the pure filter engine (string ops eq/neq/in/notIn/contains/matches/startsWith/endsWith/isEmpty/isNotEmpty; integer in; datetime between)
673
+ │ │ └─ slice.toggleFilter(pred) — idempotent single-predicate toggle for custom wiring; Range picker presets anchor to the DATA's date extent (clamped to now for live data) and pin concrete windows; an All chip clears the range; programmatic datetimePreset seeds stay rolling/wall-clock
674
+ │ └─ <Pagination> — page-number control
675
+ │ └─ Props:
676
+ │ ├─ page / pageSize / count (required) — current page, rows per page, total rows
677
+ │ ├─ onPageChange (required) — fn(newPage) => Null
678
+ │ ├─ siblings / boundaries (optional) — ellipsis control
679
+ │ └─ size / variant / activeBackground / activeColor + COLOR overrides (optional)
680
+ │
681
+ ├─ Charts (visualize data) — layers are a config array of factory values, never child tags
682
+ │ ├─ <Chart layers={…} /> — assemble mark + annotation layers; x-scale inferred from the x accessor type (String → band, number → linear, DateTime → time)
683
+ │ │ ├─ Props:
684
+ │ │ │ ├─ layers (required) — array of Chart.Line/Column/Bar/Area/Scatter/Band/refLine/refBand/refDot/Series values
685
+ │ │ │ ├─ x / y / y2 (optional) — axis options: { label?, format? (shared spec — see the Formats branch), domain?, scale?, numTicks?, tickValues?, hideTicks?, hideLine?, tickStyle?, titleStyle?, titleGap? }
686
+ │ │ │ │ tickValues (#318): floats on a linear axis ([0,1,2,…]) or DateTime[] on a time axis (pin ticks to exact instants, rendered through the date format); Date ticks on y/y2 are a build-time error
687
+ │ │ │ │ tickStyle/titleStyle (#315): { fontSize?, fontFamily?: "sans"|"serif"|"mono", fontWeight?, color?, letterSpacing? } — restyle ticks/captions over the spec chrome
688
+ │ │ │ │ titleGap (#327): px between ticks and caption — widens that axis's OWN margin band, never the shared plot gutter, so nudging a title can't shift a gutter-aligned plot lane
689
+ │ │ │ ├─ height (optional) — px, or "fill": the parent's height, never less than the chart's natural height — what a parent sized by its content (an auto SnapGrid tile) shows it at; width (optional) — px (omit for responsive)
690
+ │ │ │ ├─ grid / legend / tooltip (optional) — background gridlines (default on) / colour-matched legend / hover tooltip
691
+ │ │ │ ├─ stackOffset (optional) — "none" | "expand" (percent stacking)
692
+ │ │ │ └─ slice + affordances (optional) — bound slice chrome (default ["breakdown","range"]; the brush sets the slice's range)
693
+ │ │ └─ Factories:
694
+ │ │ ├─ Chart.Line / Chart.Column / Chart.Area / Chart.Scatter(rows, encoding, style?) — marks; encoding: { x, y } · { x, y, by } (split) · { x, columns: { Name: r => r.field } } (wide)
695
+ │ │ ├─ Chart.Bar(rows, { x: numeric, y: category }, style?) — HORIZONTAL bars (band y-axis, linear x; flips the whole frame; same { x, y, by } / { y, columns } splits; can't mix with vertical marks); the left margin grows to hold the widest category label, so a parent that clips never cuts one
696
+ │ │ ├─ Chart.Band(rows, { x, low, high }, style?) — filled range (e.g. confidence band)
697
+ │ │ ├─ mark style (all optional) — { key (legend label), color, curve, width, dash, dots, fillOpacity, opacity, legend, tooltip, stack (group id — layers sharing one stack accumulate), axis: "left"|"right", order (draw order) }; Scatter adds size (uniform px radius; a per-point size accessor overrides)
698
+ │ │ ├─ Chart.refLine({ y }|{ x }, label?, dash?) — reference line
699
+ │ │ ├─ Chart.refBand({ y: [lo, hi] }|{ x: [lo, hi] }, label?) — reference band
700
+ │ │ ├─ Chart.refDot({ x, y, label? }) — reference marker
701
+ │ │ ├─ Chart.format.{ number, currency, percent, compact, date, time, datetime } — the SHARED format specs (see the Formats branch)
702
+ │ │ └─ Chart.Series(slice, { x, value, mark? }) — a slice-bound layer (x/value are slice field ids; mark: "line"|"bar"|"area"|"scatter", default line)
703
+ │ └─ <Sparkline> — inline trend beside a <Stat>
704
+ │ └─ Props:
705
+ │ ├─ data (required) — the values
706
+ │ ├─ type (optional) — line | area
707
+ │ └─ color / height / width (optional)
708
+ │
709
+ ├─ Display (show information)
710
+ │ ├─ <Badge> — mono uppercase micro-label (status / taxonomy); stays a tier smaller than tags
711
+ │ │ └─ Props: variant (solid|subtle|outline) / colorPalette / size / density / borderRadius / borderWidth / borderStyle / justifyContent / alignItems + BOX bag + COLOR overrides (all optional; children required)
712
+ │ ├─ <Tag> — operator-set keyword / filter pill (body font)
713
+ │ │ └─ Props:
714
+ │ │ ├─ children (required) — the tag text
715
+ │ │ ├─ closable + onClose (optional) — × affordance + callback
716
+ │ │ └─ variant / colorPalette / size / density / borderRadius / borderWidth / borderStyle + BOX bag + COLOR overrides (optional)
717
+ │ ├─ <Avatar> / <AvatarGroup> — user avatar / overlapping cluster with "+N more"
718
+ │ │ └─ Props:
719
+ │ │ ├─ Avatar: src (image URL) / name (initials fallback) / variant / colorPalette / size / density / borderRadius + BOX bag + COLOR overrides (all optional)
720
+ │ │ └─ AvatarGroup: children (required) — the avatars; max (optional) — overflow threshold (+N after); size / density / borderColor (optional)
721
+ │ ├─ <Image> — raster/vector image or logo
722
+ │ │ ├─ Props:
723
+ │ │ │ ├─ source (required) — Image.url(u) | Image.dataUri(s) | Image.blob(bytes, "png"|"svg"|…)
724
+ │ │ │ ├─ fit (optional) — object-fit: contain | cover | fill | none | scaleDown
725
+ │ │ │ ├─ aspectRatio / alt / borderRadius / background (optional) — framing + accessibility
726
+ │ │ │ └─ …plus BOX bag
727
+ │ │ └─ Factories:
728
+ │ │ ├─ Image.url(u) — hosted image
729
+ │ │ ├─ Image.dataUri(s) — self-contained base64
730
+ │ │ └─ Image.blob(bytes, format) — raw BlobType bytes → revocable object URL
731
+ │ ├─ <Icon> — a Font Awesome solid icon (East UI draws no other set, #1263)
732
+ │ │ └─ Props:
733
+ │ │ ├─ prefix / name (required) — the icon: "fas", the solid set, and its name; another prefix is refused at build, naming the icon
734
+ │ │ ├─ variant (optional) — solid, the one set
735
+ │ │ ├─ size (optional) — xs…2xl; label (optional) — accessible name
736
+ │ │ └─ colorPalette / borderRadius + BOX bag + COLOR overrides (optional)
737
+ │ ├─ <Kbd> — keyboard-shortcut chip (⌘ K)
738
+ │ │ └─ Props: children (required); variant / size / density / colorPalette / shadowColor + COLOR overrides (optional)
739
+ │ ├─ <Stat> — metric tile with label / value / change indicator
740
+ │ │ └─ Props:
741
+ │ │ ├─ label (required) — metric caption; value (required) — the raw value (Float / Integer / String)
742
+ │ │ ├─ format (optional) — a Format.* spec over a numeric value: Format.Currency({ currency: "USD", maximumFractionDigits: 0n }), Format.Compact(), … (see the Formats branch)
743
+ │ │ ├─ helpText (optional) — caption beneath the value
744
+ │ │ ├─ baseline / delta / info (optional) — secondary line / change pill / ⓘ ToggleTip trigger (UIComponents)
745
+ │ │ ├─ indicator (optional) — "up"|"down"|"flat" or { direction, sentiment?: positive|negative|neutral, icon? }
746
+ │ │ ├─ density / size (optional) — rhythm + size preset
747
+ │ │ └─ valueColor / labelColor / helpTextColor / indicatorColor (optional)
748
+ │ ├─ <MetricChip> — compact mono delta chip
749
+ │ │ └─ Props:
750
+ │ │ ├─ children (required) — the value text; tone (required) — positive | negative | neutral | info (drives the palette)
751
+ │ │ ├─ unit (optional) — suffix ("%", "ms"); icon (optional) — leading icon
752
+ │ │ ├─ emphasis (optional) — subtle | solid | outline
753
+ │ │ └─ density / size / borderRadius / iconColor + COLOR overrides (optional)
754
+ │ ├─ <Meter> — horizontal capacity bar with sentiment colour (never a bare bar — value text on by default)
755
+ │ │ └─ Props:
756
+ │ │ ├─ value (required) — current value; max (optional) — full-bar value (default 100)
757
+ │ │ ├─ tone (optional) — a status token driving the fill (see the Statuses branch)
758
+ │ │ ├─ label (optional) — UIComponent beside the bar; showValue (optional) — trailing mono percent (default true)
759
+ │ │ └─ density / thickness / borderRadius / fillColor / trackColor / labelColor (optional)
760
+ │ ├─ <SegmentedMeter> — multi-segment meter (e.g. decomposed confidence)
761
+ │ │ └─ Props:
762
+ │ │ ├─ segments (required) — [{ value, tone?, color?, label? }]
763
+ │ │ ├─ caption (optional) — UIComponent beside the bar; max (optional) — total reference (default sum)
764
+ │ │ ├─ labels (optional) — inside | outside | none
765
+ │ │ └─ density / thickness / borderRadius / trackColor / captionColor / labelColor (optional)
766
+ │ ├─ <BarStrip items={[…]} /> or <BarStrip data={rows} item={r => ({ label, value, tone? })} /> — ranked horizontal-bar list (axis-free; fits inside a <Stat>)
767
+ │ │ └─ Props:
768
+ │ │ ├─ items (required, the written form) — [{ label (UIComponent), value, tone?, color?, trailing? }]
769
+ │ │ ├─ data + item (required, the data form — instead of items) — an East array of the host's rows + a row mapper to the same bar fields, reified ONCE into an East function every row maps through: bars computed in East (a groupSum's totals, `.toArray`'d), which a written array cannot hold
770
+ │ │ ├─ showValues (optional) — trailing value text (default true)
771
+ │ │ ├─ sort / maxItems (optional) — sort + row cap, applied by the renderer to written and mapped bars alike
772
+ │ │ └─ density / orientation / thickness / borderRadius / trackColor / labelColor / valueColor (optional)
773
+ │ ├─ <EditableChip> — chip whose text becomes inline input on click
774
+ │ │ └─ Props:
775
+ │ │ ├─ children (required) — chip text
776
+ │ │ ├─ onClick (optional) — activation callback; trigger (optional) — trailing icon (default chevron)
777
+ │ │ └─ disabled / density / size / borderRadius / triggerIconColor + COLOR overrides (optional)
778
+ │ ├─ <ChipRail> — horizontal rail of mixed chip-shaped children (<Tag>/<Badge>/<MetricChip>/<Avatar>/…); provides its density to the children
779
+ │ │ └─ Props:
780
+ │ │ ├─ children (required) — the chips
781
+ │ │ ├─ separator (optional) — dot | line; labels (optional) — per-chip labels
782
+ │ │ ├─ overflow (optional) — behaviour when the rail can't fit every chip (⋯ menu)
783
+ │ │ └─ density / separatorColor / overflowTriggerColor / background (optional)
784
+ │ └─ <Trace> — read-only inline heatmap (tracks × steps) with a now-line; sits flush beside a <ChipRail> at the same density in table cells
785
+ │ └─ Props:
786
+ │ ├─ tracks (required) — [{ name, values }] (heat normalises per track's own min/max)
787
+ │ ├─ now (optional) — step index of the now-line; [0, now) measured, [now, end) predicted; omit for measured-only
788
+ │ ├─ scale (optional) — heat colour encoding; future (optional) — how predicted steps are distinguished
789
+ │ ├─ axis (optional) — per-step labels (ruler at comfortable density, tooltips always)
790
+ │ ├─ density / brandColor / nowLineColor / labelWidth (optional) — rhythm + colour + name-gutter width
791
+ │ └─ plotGutter (optional) — shared gutter (#147): pins the step lane so a Trace stacked under a Chart lines up (left supersedes labelWidth)
792
+ │
793
+ ├─ Feedback (status & async signals)
794
+ │ ├─ <Banner> — page-spanning notice
795
+ │ │ └─ Props:
796
+ │ │ ├─ status (required) — info | warning | success | error | neutral | change | guard | stale
797
+ │ │ ├─ title (required) — string or UIComponent
798
+ │ │ ├─ description / actions (optional) — body + trailing actions
799
+ │ │ ├─ icon / showIcon (optional) — explicit icon override / hide the paired icon
800
+ │ │ ├─ dismissible + onDismiss (optional) — close affordance
801
+ │ │ └─ variant / size / iconColor / accentColor + COLOR overrides (optional)
802
+ │ ├─ <Status> — dot + uppercase label (no fill)
803
+ │ │ └─ Props:
804
+ │ │ ├─ label (required) — string or UIComponent
805
+ │ │ ├─ value (optional) — success | warning | danger | info | neutral (default neutral; see the Statuses branch)
806
+ │ │ ├─ pulsing (optional) — animate the dot
807
+ │ │ ├─ ring (optional) — an open ring in place of the filled dot: a state that is not live yet (a Draft beside a Live)
808
+ │ │ ├─ icon / showIcon (optional) — icon override / hide
809
+ │ │ └─ size / dotColor + COLOR overrides (optional)
810
+ │ ├─ <Progress> — linear progress bar
811
+ │ │ └─ Props:
812
+ │ │ ├─ value (required) — current value
813
+ │ │ ├─ min / max (optional) — range (defaults 0–100)
814
+ │ │ ├─ indeterminate (optional) — unknown-% mode
815
+ │ │ ├─ label / valueText / showValue (optional) — captions
816
+ │ │ ├─ estimatedDuration / startedAt (optional) — drive an ETA display
817
+ │ │ ├─ tone (optional) — brand | pos | neg (bsys-restricted fill tone)
818
+ │ │ └─ variant / size / striped / animated / trackColor / fillColor / labelColor (optional)
819
+ │ ├─ <Skeleton> — shimmer placeholder
820
+ │ │ └─ Props:
821
+ │ │ ├─ shape (required) — text | rect | circle
822
+ │ │ ├─ lines (optional) — line count (text shape); count (optional) — repeat in a VStack
823
+ │ │ └─ width / height / fontSize / background / shimmerColor (optional)
824
+ │ └─ <EmptyState> — zero-data state
825
+ │ └─ Props:
826
+ │ ├─ title (required) — string or UIComponent
827
+ │ ├─ icon (optional) — its one mark, a Font Awesome solid icon ({ prefix: "fas", name: "inbox" }); a text `glyph` is removed (#1263) and refused at build
828
+ │ ├─ description / actions (optional) — body + action row
829
+ │ └─ size / iconColor + COLOR overrides (optional)
830
+ │
831
+ ├─ Disclosure (reveal / switch content) — item metadata is config, not child tags
832
+ │ ├─ <Tabs items={…}> — content-panel switcher
833
+ │ │ ├─ Props:
834
+ │ │ │ ├─ items (required) — array of Tabs.Item(…)
835
+ │ │ │ ├─ value / defaultValue (optional) — controlled / initial selected tab
836
+ │ │ │ ├─ onValueChange (optional) — fn(String) => Null
837
+ │ │ │ ├─ variant (optional) — line | plain; size — sm | md | lg
838
+ │ │ │ ├─ orientation / activationMode / fitted / justify (optional) — layout + keyboard behaviour
839
+ │ │ │ ├─ lazyMount / unmountOnExit (optional) — panel mount policy
840
+ │ │ │ └─ colorPalette / listBackground / indicatorColor / activeTriggerColor / inactiveTriggerColor / contentBackground (optional)
841
+ │ │ └─ Factories:
842
+ │ │ └─ Tabs.Item(value, title, body, { disabled? }) — one tab
843
+ │ ├─ <Accordion items={…}> — single/multi-open sections
844
+ │ │ ├─ Props:
845
+ │ │ │ ├─ items (required) — array of Accordion.Item(…)
846
+ │ │ │ ├─ multiple / collapsible (optional) — allow multiple open / allow all closed
847
+ │ │ │ ├─ value / defaultValue / onValueChange (optional) — controlled expansion
848
+ │ │ │ └─ variant / size / triggerBackground / triggerHoverBackground / contentBackground + COLOR overrides (optional)
849
+ │ │ └─ Factories:
850
+ │ │ └─ Accordion.Item(value, trigger, children, { meta?, disabled? }) — one section (meta = right-aligned header caption)
851
+ │ ├─ <Carousel> — paginated slide carousel
852
+ │ │ └─ Props:
853
+ │ │ ├─ children (required) — the slides
854
+ │ │ ├─ index / defaultIndex / onIndexChange (optional) — controlled slide position
855
+ │ │ ├─ slidesPerView / slidesPerMove / spacing (optional) — layout
856
+ │ │ ├─ loop / autoplay / allowMouseDrag (optional) — behaviour
857
+ │ │ ├─ showIndicators / showControls (optional) — dots + prev/next chrome
858
+ │ │ └─ orientation / padding / indicatorColor / activeIndicatorColor / controlColor / controlBackground (optional)
859
+ │ ├─ <Collapsible> — single show/hide section
860
+ │ │ └─ Props:
861
+ │ │ ├─ trigger (required) — always-visible header (string or UIComponent); children (required) — the body
862
+ │ │ ├─ defaultOpen / onOpenChange (optional) — initial state + toggle callback
863
+ │ │ └─ triggerColor / contentColor + COLOR overrides (optional)
864
+ │ ├─ <SegmentGroup items={…}> — compact single-select mode switcher (no panels)
865
+ │ │ ├─ Props:
866
+ │ │ │ ├─ value (required) — selected segment; items (required) — array of SegmentGroup.Item(…)
867
+ │ │ │ ├─ onChange (optional) — fn(String) => Null
868
+ │ │ │ └─ size / colorPalette / orientation / activeBackground / activeColor / inactiveColor + COLOR overrides (optional)
869
+ │ │ └─ Factories:
870
+ │ │ └─ SegmentGroup.Item(value, label, { disabled? }) — one segment
871
+ │ ├─ <OptionList> — keyboard-navigable single-select list (rows + description)
872
+ │ │ ├─ Props:
873
+ │ │ │ ├─ options (required) — array of OptionList.Option(…)
874
+ │ │ │ ├─ selectedId (optional) — currently-selected row; onSelect (optional) — fn(id) => Null
875
+ │ │ │ └─ itemColor / itemHoverBackground / selectedBackground / borderColor / impactColor (optional)
876
+ │ │ └─ Factories:
877
+ │ │ └─ OptionList.Option(id, label, { description?, trailing?, disabled? }) — one row (trailing = e.g. impact chip)
878
+ │ ├─ <Story.Root steps={…}> — scroll-driven narrative; prose rail + sticky stage keyframes
879
+ │ │ ├─ Props:
880
+ │ │ │ ├─ steps (required) — array of Story.Step(…)
881
+ │ │ │ ├─ layout (optional) — rail-left | rail-right | stacked
882
+ │ │ │ ├─ stepLength (optional) — compact | default | long (scroll runway per step)
883
+ │ │ │ ├─ stageHeight / height (optional) — stage sizing
884
+ │ │ │ ├─ active / progress (optional) — State.bind bindings for narrative position + within-step scrub
885
+ │ │ │ ├─ activeStep (optional) — static override: render one deterministic keyframe by step id
886
+ │ │ │ ├─ title (optional) — renders the Story.Progress chrome row
887
+ │ │ │ └─ onStepEnter / onStepExit (optional) — step activation callbacks (step id)
888
+ │ │ └─ Factories:
889
+ │ │ ├─ Story.Step(body, { id, eyebrow?, title?, stage? }) — one beat (stage = its sticky keyframe)
890
+ │ │ └─ Story.Progress({ count, active?, title? }) — standalone dots / counter / prev-next chrome
891
+ │ └─ <Disclosure> — "Show more / Show less" toggle
892
+ │ └─ Props:
893
+ │ ├─ children (required) — the truncatable text
894
+ │ ├─ lines (optional) — visible lines before truncation
895
+ │ ├─ moreLabel / lessLabel (optional) — trigger copy
896
+ │ └─ color / triggerColor (optional)
897
+ │
898
+ ├─ Navigation — within a page; an app's own navigation is its host's (#1227)
899
+ │ ├─ <Breadcrumb items={…}> — ancestor trail with '/' separators
900
+ │ │ └─ Props:
901
+ │ │ ├─ items (required) — [{ label, current (Option Bool), onClick (Option fn) }] trail entries
902
+ │ │ ├─ leadingSeparator (optional) — adds a leading '/' so it reads as a path (/ workspace / page)
903
+ │ │ └─ runAnchor (optional) — trailing run stamp pinned after a vertical rule
904
+ │ └─ <NavList sections={…}> — sidebar nav
905
+ │ └─ Props:
906
+ │ ├─ sections (required) — [{ label?, items: [{ key, label, icon?, badge?, active? }] }], or an East `Array<NavList.Types.Section>` computed from data (items built with `East.value({…}, NavList.Types.Item)`) — a rail of the pages a record holds
907
+ │ ├─ onSelect (optional) — fn(key) => Null
908
+ │ ├─ surface (optional) — "card" (default, bordered) | "shell" (drops the card chrome so the list reads as one surface with a host app-shell rail)
909
+ │ └─ background (optional) — surface background token (bg.subtle)
910
+ │
911
+ ├─ Overlays (floating content) — `trigger` is a UIComponent prop; body is children
912
+ │ ├─ <Dialog> — the one modal: a confirmation step before a destructive or irreversible act, naming it, with Cancel and the act's own verb — never a form (a form that makes or names something is a <Popover> from its trigger)
913
+ │ │ └─ Props:
914
+ │ │ ├─ trigger (required) — the opening UIComponent; children (required) — the body
915
+ │ │ ├─ eyebrow / title / description (optional) — header copy (eyebrow = mono uppercase, e.g. "Confirm · cannot be undone")
916
+ │ │ ├─ size / placement / scrollBehavior / motionPreset / role (optional) — presentation
917
+ │ │ ├─ open / defaultOpen / onOpenChange (optional) — controlled state: `open={asking.read()} onOpenChange={asking.write}` opens it from any callback
918
+ │ │ ├─ closeOnInteractOutside / closeOnEscape (optional) — behaviour; it is always modal, traps focus and holds the page still
919
+ │ │ ├─ lazyMount / unmountOnExit (optional) — mount policy
920
+ │ │ └─ onExitComplete / onEscapeKeyDown / onInteractOutside (optional) — lifecycle callbacks
921
+ │ ├─ <Drawer> — side panel
922
+ │ │ ├─ Props:
923
+ │ │ │ ├─ trigger (required) — the opening UIComponent; children (required) — the body
924
+ │ │ │ ├─ placement (optional) — start | end | top | bottom; size — panel size; contained — render within the parent container
925
+ │ │ │ ├─ eyebrow / title / description (optional) — header copy
926
+ │ │ │ ├─ bodyPadding / flush (optional) — body padding control (flush = full-bleed so a Table/Plan fills)
927
+ │ │ │ ├─ fillBody (optional) — the body becomes a definite-height flex column so a single height:100% child fills + owns its scroll
928
+ │ │ │ ├─ stacked + stackIcon (optional) — (#328) while a deeper drawer is open, this drawer collapses to a labeled vertical icon rail (instead of hiding behind) — click the rail to pop the stack back to it; Esc pops one level
929
+ │ │ │ ├─ open / defaultOpen / onOpenChange / onExitComplete (optional) — controlled state + lifecycle
930
+ │ │ │ └─ closeOnInteractOutside / closeOnEscape / lazyMount / unmountOnExit (optional) — behaviour + mount policy
931
+ │ │ └─ Factories:
932
+ │ │ └─ Drawer.open(OpenInput) — open one programmatically (nests/stacks by depth)
933
+ │ ├─ <Popover> — click-triggered floating panel; a form that makes or names something (a name, then Cancel and its commit) lives in one, hanging from the control that starts it
934
+ │ │ └─ Props:
935
+ │ │ ├─ trigger (required); children (required) — the panel body
936
+ │ │ ├─ title / description (optional) — header copy
937
+ │ │ ├─ size / placement / hasArrow / gutter (optional) — positioning + chrome
938
+ │ │ ├─ open / defaultOpen / onOpenChange (optional) — controlled state: `open={shown.read()} onOpenChange={shown.write}` opens it from any callback, at its own trigger
939
+ │ │ └─ closeOnInteractOutside / closeOnEscape / autoFocus / lazyMount / unmountOnExit (optional) — it is never modal
940
+ │ ├─ <HoverCard> — hover preview card
941
+ │ │ └─ Props:
942
+ │ │ ├─ trigger (required); children (required) — the card body
943
+ │ │ ├─ title / description (optional) — mono eyebrow header (same as Popover)
944
+ │ │ ├─ openDelay / closeDelay (optional) — hover timing
945
+ │ │ └─ size / placement / hasArrow / open / defaultOpen / onOpenChange / lazyMount / unmountOnExit (optional)
946
+ │ ├─ <Tooltip> — hover tooltip (content is a string)
947
+ │ │ └─ Props: trigger (required) / content (required) / placement / hasArrow (optional)
948
+ │ ├─ <ToggleTip> — click-toggle tooltip (sticky)
949
+ │ │ └─ Props: trigger (required) / children (required) / placement / hasArrow / open / defaultOpen / onOpenChange / closeOnInteractOutside / closeOnEscape (optional)
950
+ │ ├─ <Menu trigger={…} items={…}> — dropdown / context menu
951
+ │ │ ├─ Props:
952
+ │ │ │ ├─ trigger (required) — the opening element; items (required) — array of Menu.Item / Menu.Separator
953
+ │ │ │ └─ placement (optional) — position relative to the trigger
954
+ │ │ └─ Factories:
955
+ │ │ ├─ Menu.Item(value, label, { disabled?, icon?, command?, destructive? }) — one action (icon = FA solid name; command = right-aligned mono accelerator "⌘D"; destructive renders in the negative ink)
956
+ │ │ └─ Menu.Separator() — a group divider
957
+ │ ├─ <CommandPalette commands={…}> — ⌘K palette with search + groups
958
+ │ │ └─ Props:
959
+ │ │ ├─ commands (required) — [{ id, label, icon?, shortcut?, group?, keywords?, action }] (action = fn() => Null)
960
+ │ │ ├─ placeholder / triggerKey (optional) — search copy + global open chord ("mod+k")
961
+ │ │ ├─ open / onOpenChange (optional) — controlled state
962
+ │ │ └─ size / inputBackground / inputColor / itemColor / selectedBackground / selectedColor / groupLabelColor + COLOR overrides (optional)
963
+ │ ├─ <Hotkey chord="mod+k" onTrigger={fn}> — invisible keydown listener (no render)
964
+ │ │ └─ Props:
965
+ │ │ ├─ chord (required) — modifiers mod/ctrl/cmd/shift/alt + key
966
+ │ │ └─ onTrigger (required) — East.function([], NullType); pair with Reactive + State.bind to drive open state on CommandPalette/Dialog/Drawer
967
+ │ └─ <ActionBar items={…}> — sticky bottom bulk-action bar
968
+ │ ├─ Props:
969
+ │ │ ├─ items (required) — array of ActionBar.Item(…)
970
+ │ │ ├─ selectionCount / selectionLabel (optional) — "N items selected" copy; the bar is open while the count is above 0
971
+ │ │ ├─ open / onOpenChange (optional) — controlled state, in place of the count's
972
+ │ │ ├─ onSelect (optional) — fn(actionValue) => Null when an action is chosen
973
+ │ │ └─ closeOnInteractOutside / closeOnEscape (optional)
974
+ │ └─ Factories:
975
+ │ └─ ActionBar.Item(value, label, disabled?) — one action button
976
+ │
977
+ ├─ Container
978
+ │ └─ <Card> — chrome-bearing content card (vs <Box> which is structural-only)
979
+ │ └─ Props:
980
+ │ ├─ children (required) — the body
981
+ │ ├─ header (optional) — { eyebrow?, meta?, title?, description? } strict option object composed into the header strip
982
+ │ ├─ footer (optional) — { content?, actions? } footer strip (actions = trailing button row)
983
+ │ ├─ state (optional) — "ready" | "loading" | "empty" | "error" | "stale" | "disabled" | "permission-denied" runtime state
984
+ │ ├─ variant (optional) — elevated | outline | subtle
985
+ │ ├─ density (optional) — density provider for the body
986
+ │ ├─ bodyPadding / flush (optional) — body padding (default "18px 20px"); flush = full-bleed so a Plan / Table / Chart fills
987
+ │ ├─ accentColor / headerBackground / footerBackground (optional) — chrome colours
988
+ │ ├─ height / minHeight / maxHeight / width / minWidth / maxWidth / flex / overflow (optional) — sizing (a sized Card becomes a flex column constraining its body — see the Sizing pattern)
989
+ │ └─ background / borderColor (optional)
990
+ │
991
+ ├─ Formats (value formatting — one interpreter, in the viewer's locale; #190, #850)
992
+ │ ├─ The contract: a format-bearing prop takes a SPEC and the payload keeps the RAW value; the renderer prints it at render through ONE interpreter, in the viewer's LOCALE, every date in UTC. Two spec vocabularies — Chart.format.* and Format.* — and a shared arm prints the same whichever one declared it
993
+ │ ├─ Chart.format.* (`Chart.Spec.Types.TickFormat`) — chart axes, Slice fields, Deck, the Plan:
994
+ │ │ ├─ Chart.format.number() — plain number, grouped in the locale (1,234.5; German 1.234,5)
995
+ │ │ ├─ Chart.format.currency({ code?, compact? }) — currency; compact ⇒ $1.8M (one fraction digit)
996
+ │ │ ├─ Chart.format.percent() — 0.42 → 42% (whole percents)
997
+ │ │ ├─ Chart.format.compact() — 12400 → 12.4K (one fraction digit)
998
+ │ │ └─ Chart.format.date(pattern) / Chart.format.time(pattern) / Chart.format.datetime(pattern) — East date-token patterns
999
+ │ ├─ Format.* (`Format.Types.Tick`) — <Numeric>, <Stat>, <Table> columns:
1000
+ │ │ ├─ Format.Number({ minimumFractionDigits?, maximumFractionDigits?, signDisplay? }) · Format.Currency({ currency, display?, compact?, minimumFractionDigits?, maximumFractionDigits? }) · Format.Percent({ minimumFractionDigits?, maximumFractionDigits?, signDisplay? }) · Format.Compact({ display? }) · Format.Unit({ unit, display? }) · Format.Scientific() · Format.Engineering()
1001
+ │ │ └─ Format.Date(pattern) / Format.Time(pattern) / Format.DateTime(pattern) — East date-token patterns
1002
+ │ ├─ Where each plugs in:
1003
+ │ │ ├─ <Chart> x/y/y2 { format } — axis tick labels; an undeclared time axis prints the locale's numeric date (6/29/2026; German 29.6.2026)
1004
+ │ │ ├─ Slice.config fields { format } — filter chips, brush axis labels, range summaries (string shorthands "number"|"percent"|"compact"|{currency:{code?,compact?}}|{date|time|datetime: pattern} also accepted)
1005
+ │ │ ├─ <Numeric format> and <Stat format> — KPI values (Format.*)
1006
+ │ │ ├─ <Table columns={{ c: { format } }}> — a column's number cells and a parent's subtotals (Format.*); an undeclared number cell prints every digit, never grouped, with the viewer's decimal separator
1007
+ │ │ ├─ Deck.metric / Deck.Readout cells / card fill { format } — board metrics (Chart.format.*)
1008
+ │ │ ├─ e3-ui's Plan.axis { format } — timeline tick labels (a date pattern on a time axis; Chart.format.* on a number axis)
1009
+ │ │ ├─ e3-ui's Plan.quantity { format } and Plan.heatCells / weightCells / segmentCells { format } — a run's or a link's caption, and the values a heat arm prints (Format.*)
1010
+ │ │ └─ e3-ui's Sheet.column.quantity(R, D, { format }) — a quantity column's cells (Format.*); its edit box and copy stay bare and its grammar reads the viewer's separators (#852)
1011
+ │ ├─ The locale: react-aria's `<I18nProvider locale="de-DE">` above the app sets it for every component — `@elaraai/east-ui-components` re-exports `I18nProvider`, so a host needs no react-aria dependency of its own — and the browser's language stands in otherwise. Numbers, counts (a pager's total, a footer's "N loaded of M") and the default dates follow it: 1.234,5 · 29.6.2026 · 29. Juni 2026. What the AUTHOR wrote prints as written: labels and footer items, and a date PATTERN — East's tokens, English month and weekday names, whatever the locale
1012
+ │ ├─ Accessor alternative: Deck metric/fill format props ALSO accept a text accessor ((value) => String / (value, max) => String) — reified at authoring time into a pre-rendered `text` field; the raw value still ships, and a `none` value renders "—"
1013
+ │ ├─ Date tokens: East's date tokens incl. weekdays — dd/ddd/dddd; "ddd DD" → Mon 30. All date rendering is UTC (East DateTime is a UTC instant) — a pattern, an axis, a filter chip, a range preset (Today / 7d / 30d / YTD are UTC days) — so no component depends on the viewer's timezone
1014
+ │ └─ tickValues (#318): pin chart ticks to exact floats / DateTime instants (rendered through the date format) to line a Chart up with a Plan's bucket columns
1015
+ │
1016
+ ├─ Statuses & tones (the shared five-token status vocabulary)
1017
+ │ ├─ The tokens: "success" | "warning" | "danger" | "info" | "neutral" (StatusTokenType / StatusValueType) — the ONE semantic palette for state colour across the library; theme-mapped, never raw hex
1018
+ │ ├─ Registries (define states ONCE, reference by key):
1019
+ │ │ └─ Deck.statuses({ key: { label, color, pulse?, hint? } }) — color is a standard token OR any custom CSS colour; one entry drives the card tag + dot/pulse, face wash, fill bar, group-head swatch + hint, and legend
1020
+ │ ├─ Where a bare token / status value plugs in:
1021
+ │ │ ├─ Library.status(label, tone, ring?) — palette card status chip, a gallery card's dot (`ring` open) · Library.glyph(icon, label, tone?) — its trailing glyph
1022
+ │ │ ├─ Table rowStatus — fn(rowIndex) => StatusToken row tint
1023
+ │ │ ├─ Schematic item { status } (Option token dot) and { tone } (brand|ink|muted|success|warning|danger stroke override)
1024
+ │ │ ├─ e3-ui's Plan.run { status } (stuck ring) · Plan.marker { status } (cell rings, default danger) · Plan.event { tone } — tile tints, all ORTHOGONAL to `state`
1025
+ │ │ ├─ Matrix.marker { status } — corner markers
1026
+ │ │ ├─ <Status value> — dot + word (`ring` an open ring — not live yet); <Banner status> uses the wider notice set (info|warning|success|error|neutral|change|guard|stale)
1027
+ │ │ └─ <Meter tone> / BarStrip item { tone } / SegmentedMeter segment { tone } — bar fills
1028
+ │ ├─ Sentiment (value direction, NOT state): <MetricChip tone> positive|negative|neutral|info · <Numeric sentiment> positive|negative|neutral · <Stat indicator.sentiment> positive|negative|neutral · <Progress tone> brand|pos|neg
1029
+ │ ├─ state ≠ status: the AUDIT LIFECYCLE is orthogonal to the status tint. Blend allocations speak PlannerStateType ("committed"|"added"|"model"|"removed"|"rejected" — committed solid, proposals dashed/ghost/struck, rejected greyed; only proposed items drag); Plan elements speak the richer EventStateType ladder ("estimated"→"proposed"(added|recommended|removed)→"confirmed"→"in-progress"→"actual", plus "rejected"). A status token is the ORTHOGONAL semantic tint layered on top
1030
+ │ └─ tone vs colorPalette: tone/status/sentiment = the semantic vocabulary above (meaning-bearing, theme-stable); colorPalette = decorative hue theming (Chakra palettes) for buttons/badges/tags where the colour carries no state meaning
1031
+ │
1032
+ ├─ Reactive (state-driven re-render)
1033
+ │ ├─ <Reactive>{$ => { …State.bind reads…; return <…/>; }}</Reactive> — re-renders when read State keys change
1034
+ │ │ └─ Props:
1035
+ │ │ └─ children (required) — a builder function ($ => UIComponent); all State.bind reads live inside it
1036
+ │ └─ <Match on={bind.read()} cases={{…}}> — hosting slot over a variant (#333), the component-level twin of variant.match
1037
+ │ └─ Props:
1038
+ │ ├─ on (required) — the variant expression selecting the active case; pass the READING expression (bind.read()) — a $.let snapshot freezes the slot
1039
+ │ └─ cases (required) — one handler per case name, exhaustive; each gets that case's typed payload. Mounts ONLY the active case and REMOUNTS it on tag change (same-tag payload churn re-renders in place) — use it to swap a STATEFUL component (its own <Reactive>/binds) at one slot; a plain variant.match over mounted components keeps the first one mounted (function-blind reconciliation)
1040
+ │
1041
+ └─ State (typed reactive store)
1042
+ └─ State.bind([T], key, defaultValue) → { read, write, has } closures;
1043
+ read() tracks the dependency so <Reactive> re-renders when the value changes
1044
+ ```
1045
+
1046
+ ## Paged source snapshots
1047
+
1048
+ Paged data is BOUND: a component's `data` is local — a collection value or
1049
+ expression, or a whole-value `Data.bind` / `State.bind` handle — or a paged
1050
+ source from the platform that owns the data, e3-ui's `Data.bindPaged`. east-ui
1051
+ produces no paged source; a collection already in hand is local data. A
1052
+ component recognises a paged source by its East type, a subtype of
1053
+ `Paged.Types.PinnedSource(C)` or `Paged.Types.Source(C)` over the collection
1054
+ `C` its `page` serves, and refuses a struct with `page` / `total` that is
1055
+ neither, naming the contract's fields.
1056
+
1057
+ The contract is a PINNED source: `{ id, page, total, seek, revision, refresh }`
1058
+ — the `pinned` arm. `id` names the logical source; `revision()` names the
1059
+ snapshot every page, total and seek position belongs to (`none` while it is
1060
+ found). Call `refresh(some(committedHash))` after a confirmed write to move to
1061
+ that exact snapshot, or `refresh(none)` to the one the source holds now; a
1062
+ move invalidates every consumer, same-size rows and cached key searches
1063
+ included. `Data.bindPaged` returns one — its revision is the dataset's content
1064
+ hash. A component follows a pinned source from one snapshot to the next, and
1065
+ edits a paged source only when it is pinned: an `onApply` over a source that
1066
+ names no snapshot is refused at build time. Read the methods inside a tracked
1067
+ evaluation; call `refresh` in an event handler.
1068
+
1069
+ The same struct without `revision` and `refresh` — `{ id, page, total, seek }`,
1070
+ the `paged` arm — is the handle a UI exported before them carries. It names no
1071
+ snapshot: a component reads each window once, and the same `id` serves the
1072
+ same rows for as long as the component holds it.
1073
+
1074
+ `Data.bindPaged` also follows its dataset without a call: the workspace
1075
+ status poll reports each new content hash and the source moves to that
1076
+ snapshot, so a `refresh` after your own write only gets there sooner. A
1077
+ pinned read the server refuses because the dataset has moved on (409
1078
+ `dataset_hash_mismatch`) rediscovers the current snapshot instead of failing
1079
+ its window. How a consumer bridges the move is its own: e3-ui's `<Plan>` and
1080
+ `<Sheet>` keep the rows they show until the new snapshot's windows land; the
1081
+ Sheet clears a standing key search, and the Plan asks it again there, its
1082
+ text kept.
1083
+
1084
+ ## Key Patterns
1085
+
1086
+ ### Configurator — one array per axis, no parallel tables
1087
+
1088
+ For "change a prop, watch it react" surfaces, put each axis in a **plain array
1089
+ of the values themselves** and let the same array feed both the control and the
1090
+ preview. For a variant-typed prop that array is just the variants — `getTag()`
1091
+ supplies the segment key *and* its label, so there is no key/label table to keep
1092
+ in step:
1093
+
1094
+ ```tsx
1095
+ <Reactive>{$ => {
1096
+ const variants = $.const([
1097
+ variant("outline", null), variant("brand", null), variant("danger", null),
1098
+ ], ArrayType(Style.Types.StyleVariant));
1099
+
1100
+ const bind = $.let(State.bind([StringType], "badge_variant", "outline"));
1101
+ const key = $.let(bind.read());
1102
+ const onPick = $.const(East.function([StringType], NullType, ($, n) => { $(bind.write(n)); }));
1103
+
1104
+ // The selection is a lookup into the array the control renders.
1105
+ const selected = $.let(variants.filter((_$, v) => v.getTag().equal(key)).get(0n));
1106
+
1107
+ return (
1108
+ <Configurator
1109
+ controls={[
1110
+ Configurator.Control("Variant", key,
1111
+ <SegmentGroup value={key} onChange={onPick} size="sm"
1112
+ items={variants.map((_$, v) => SegmentGroup.Item(v.getTag(), <Text>{v.getTag().upperCase()}</Text>))} />),
1113
+ ]}
1114
+ preview={<Badge variant={selected}>{selected.getTag().upperCase()}</Badge>}
1115
+ spec={[Configurator.Spec("Radius", "sm")]}
1116
+ />
1117
+ );
1118
+ }}</Reactive>
1119
+ ```
1120
+
1121
+ Numeric and token axes collapse the same way — an opacity is a percentage
1122
+ (`[100n, 75n, 50n]`), a padding is a spacing token (`["0", "1", "3"]`). Only an
1123
+ axis with no single value to name it by (a background/foreground *pair*, say)
1124
+ needs a struct.
1125
+
1126
+ **A variant-typed prop needs a variant value, not a string** — `density={"compact"}`
1127
+ is a type error once the value comes from state, which is exactly why the array
1128
+ holds `variant(...)` rather than keys.
1129
+
1130
+ ### Reactive interactivity — builder children
1131
+
1132
+ `<Reactive>` takes a **builder function** `{$ => …}` (not a nested
1133
+ `East.function`). All `State.bind` reads live inside it so the component
1134
+ re-renders when the bound key changes.
1135
+
1136
+ ```tsx
1137
+ /** @jsxImportSource @elaraai/east-ui */
1138
+ import { East, IntegerType, NullType } from "@elaraai/east";
1139
+ import { VStack, Text, Button, Reactive, State, UIComponentType } from "@elaraai/east-ui";
1140
+
1141
+ const counter = East.function([], UIComponentType, (_$) => (
1142
+ <Reactive>{$ => {
1143
+ const count = $.let(State.bind([IntegerType], "count", 0n));
1144
+ const value = $.let(count.read());
1145
+ const inc = $.const(East.function([], NullType, $ => {
1146
+ $(count.write(count.read().add(1n)));
1147
+ }));
1148
+ return (
1149
+ <VStack gap="3">
1150
+ <Text textStyle="body-lg">{East.str`Count: ${value}`}</Text>
1151
+ <Button onClick={inc}>+1</Button>
1152
+ </VStack>
1153
+ );
1154
+ }}</Reactive>
1155
+ ));
1156
+ ```
1157
+
1158
+ ### Two callback families
1159
+
1160
+ - **Build-time accessors** — `(row) => SubtypeExprOrValue<Scalar>` for chart
1161
+ encodings (`x`/`y`/`by`/`columns`) and table column `value`. Passed through
1162
+ verbatim; they return field expressions used while building the IR.
1163
+ - **East-function handlers** — `onClick`, `onChange`, per-row builders. Pass an
1164
+ `East.function(...)` value or a typed arrow; the factory lifts it.
1165
+
1166
+ ### Text is East, not JSX text nodes
1167
+
1168
+ Children are `SubtypeExprOrValue<StringType>` — interpolate East-side, never with
1169
+ JSX braces between text:
1170
+
1171
+ ```tsx
1172
+ <Text>{East.str`Hello ${name}`}</Text> // correct
1173
+ // <Text>Hello {name}</Text> // wrong — not East
1174
+ ```
1175
+
1176
+ ### Conditionals are East
1177
+
1178
+ Use `cond.ifElse(<A/>, <B/>)` (a `UIComponentType`), never JS `{cond && <El/>}`
1179
+ or ternaries returning `null` — those aren't East values.
1180
+
1181
+ ### Data-driven components keep data on config props
1182
+
1183
+ Tables, charts, matrices, lists and item-parents take structured data on
1184
+ `data=` / `columns=` / `items=` / `layers=` props; per-row builders are typed
1185
+ callbacks returning factory values (`cell={(r, col) => Matrix.cell({…})}`).
1186
+ Non-UI sub-structures are never child sub-tags.
1187
+
1188
+ ```tsx
1189
+ // Table — columns config, inference preserved
1190
+ <Table
1191
+ data={[{ name: "Alice", role: "Admin" }, { name: "Bob", role: "User" }]}
1192
+ columns={{ name: { header: "Name" }, role: { header: "Role" } }}
1193
+ striped variant="line"
1194
+ />
1195
+
1196
+ // Chart — layers config array
1197
+ <Box height="220px" width="100%">
1198
+ <Chart
1199
+ layers={[
1200
+ Chart.Column(rows, { x: r => r.month, y: r => r.revenue }, { key: "Revenue", color: "teal.solid" }),
1201
+ Chart.Line(rows, { x: r => r.month, y: r => r.profit }, { key: "Profit", color: "purple.solid", dots: true }),
1202
+ ]}
1203
+ y={{ format: Chart.format.currency({ compact: true }) }}
1204
+ legend grid tooltip
1205
+ />
1206
+ </Box>
1207
+ ```
1208
+
1209
+ ### Sizing — one string prop, parsed everywhere
1210
+
1211
+ Every size prop is a **plain string** and every renderer parses it the same
1212
+ way (`parseCssSize`). Four spellings, uniform across data components (`<Table>`,
1213
+ e3-ui's `<Plan>`, `<Matrix>`,
1214
+ `<Library>`, `<Schematic>`, `<SnapGrid>`) and layout primitives (`<Box>` / `<Flex>` /
1215
+ `<Stack>` / `<Grid>` / `<Card>`):
1216
+
1217
+ | Value | Means |
1218
+ |---|---|
1219
+ | `"fill"` | fill the parent box (`100%`) |
1220
+ | `"240"` | a bare number → pixels (`240px`) |
1221
+ | `"50%"` / `"calc(100vh - 4rem)"` | any CSS length passes through |
1222
+ | `"18px"` | explicit units pass through |
1223
+ | `"min(420px, 100%)"` / `"clamp(240px, 50%, 420px)"` | fluid sizes pass through — the mobile-safe way to say "420px, but never wider than the container" |
1224
+
1225
+ **Fluid layouts** (desktop + mobile from one definition): prefer
1226
+ `width="min(<ideal>px, 100%)"` over a bare pixel width; a `<Grid>` with
1227
+ `templateColumns="repeat(auto-fit, minmax(240px, 1fr))"` reflows cards to
1228
+ 1 column on phones; `<Splitter collapseBelow={480}>` stacks its panels
1229
+ vertically when its container is narrower than 480px.
1230
+
1231
+ ```tsx
1232
+ // height bounds the whole component and it scrolls within; maxHeight caps
1233
+ // it but stays content-sized until the cap is hit.
1234
+ <Table data={rows} columns={cols} height="fill" /> // fills its parent
1235
+ <Matrix … maxHeight="420" /> // content up to 420px, then scrolls
1236
+
1237
+ // Layout primitives add boolean shorthands so you never hand-write the
1238
+ // flex:1 + min-height:0 + overflow incantation for a scroll region:
1239
+ <Card height="fill">
1240
+ <Box fill scrollY> {/* fill remaining space, scroll vertically */}
1241
+ <Table data={rows} columns={cols} height="fill" />
1242
+ </Box>
1243
+ </Card>
1244
+ ```
1245
+
1246
+ A `<Card>` given `height` / `maxHeight` becomes a flex column that constrains
1247
+ its body, so a single `height="fill"` child (a data component, a scroll region)
1248
+ resolves against it.
1249
+
1250
+ Caveats that save a render cycle:
1251
+
1252
+ - **`"fill"` / percentages need a definite parent.** `height="fill"` resolves
1253
+ against the nearest box with a real height (a sized `<Box>`/`<Card>`, a flex
1254
+ item with `fill`, a Drawer `fillBody`). Inside a content-sized parent it
1255
+ silently resolves to auto — bound the parent, don't add pixels to the child.
1256
+ A `<Chart height="fill">` is the exception: in a content-sized parent it
1257
+ takes its natural height.
1258
+ - **`height` vs `maxHeight`**: `height` pins the component to exactly that box
1259
+ (header pinned, body scrolls); `maxHeight` stays content-sized UP TO the cap,
1260
+ then scrolls. Bounded data components virtualize (only visible rows mount)
1261
+ and show a reserved-gutter scrollbar; unbounded ones grow to content.
1262
+ - **A definite `height`/`width` on Box/Flex/Stack also pins `flex-shrink: 0`**
1263
+ (a sized box no longer collapses under flex pressure) — opt back in with
1264
+ `flexShrink` if you want it squeezable.
1265
+ - **Bare numbers are pixels, not Chakra spacing tokens** — `width="8"` is 8px.
1266
+ `gap` / `padding` / `margin` keep token semantics (`gap="4"` is a spacing
1267
+ token, not 4px).
1268
+
1269
+ ### Nested rows — a P&L in one Table (#954)
1270
+
1271
+ A Table's rows nest the way the Plan's do: a row carries its children, to any
1272
+ depth, and a parent IS the group row. It draws its own cells, and in each
1273
+ column that declares an `aggregate`, the subtotal of what its children show —
1274
+ so a collapsed section reads as its subtotal line, and opening it drills down.
1275
+ Hierarchy comes only from the data; there is no `groupBy`.
1276
+
1277
+ ```tsx
1278
+ // Sections hold categories, categories hold accounts: the data's own tree.
1279
+ const Line = RecursiveType((self) => StructType({
1280
+ account: StringType, q1: FloatType, fy: FloatType, lines: ArrayType(self),
1281
+ }));
1282
+ const pnl = $.const(PNL, ArrayType(Line)); // a parent's own quarters are 0 — its columns show its lines' subtotals
1283
+ // One render for every cell: an account's amount, a parent's subtotal.
1284
+ const money = $.const(East.function([Table.Types.CellRenderContext], UIComponentType, (_$, ctx) => (
1285
+ <Text width="100%" textAlign="right">{East.Float.printCurrency(ctx.cellValue.unwrap("Float"))}</Text>
1286
+ )));
1287
+ return (
1288
+ <Table
1289
+ data={pnl}
1290
+ columns={{
1291
+ account: { header: "Account", width: "260px" },
1292
+ q1: { header: "Q1", aggregate: "sum", render: money },
1293
+ fy: { header: "FY", aggregate: "sum", render: money },
1294
+ }}
1295
+ tree={{
1296
+ children: (r) => r.lines, // more of the SAME row type
1297
+ collapsed: (r) => r.account.equal("Operating expenses"),
1298
+ }}
1299
+ footerRows={[{ account: { content: <Text fontWeight="bold">Net income</Text> }, /* … */ }]}
1300
+ />
1301
+ );
1302
+ ```
1303
+
1304
+ | Signature | Description | Example |
1305
+ | --- | --- | --- |
1306
+ | `tree={{ children: (r) => Array<Row> }}` **❗** | A row's children: more rows of the data's own element type (a recursive row's own field, or a lookup among the rows); another type is refused at build. A recursive row reaches every accessor — columns' `value`, `children`, `collapsed` — as its node. | `tablePnl`, `tableTree` |
1307
+ | `tree={{ collapsed: true \| (r) => Boolean }}` | Where a parent starts; the viewer's folds persist by path under the `storageKey`. | `tablePnl`, `tableTree` |
1308
+ | `aggregate: "sum" \| "mean" \| "min" \| "max" \| "count"` | A parent's cell in that column: its children's subtotal, composed bottom-up — a mean of means (a Float), `count` the leaf rows beneath. `sum` / `mean` need a numeric column. | `tablePnl`, `tableTree` |
1309
+ | `render` / `format` on an `aggregate` column | A subtotal draws like any cell: the render gets it as `ctx.cellValue`, the format prints it. A `count` prints itself through neither. | `tablePnl`, `tableTree` |
1310
+ | `rowIndex` / `path` | A row's pre-order position (a flat table's data index) — what `rowStatus`, `expandedContent`, `selection`, review and every event carry, stable under sorting and pagination — and its sibling index at each depth. | `tableTree` |
1311
+ | `pagination` / a paged source **❗** | Both page TOP-LEVEL rows, each with its whole subtree, so a parent's subtotals are exact over whatever has loaded. | `dataBindPagedTable` (e3-ui) |
1312
+
1313
+ A sort orders each parent's children among themselves (ties keep data order),
1314
+ a parent carrying its subtree. A computed statement line (Gross profit) that
1315
+ is not a plain subtotal is its own row in the data, or a `footerRows` entry.
1316
+
1317
+ Removed with #954: `groupBy` (nest the data — a data step before the table)
1318
+ and a column's `aggregateRender` (a parent is a row: its subtotal draws
1319
+ through the column's `render` or `format`).
1320
+
1321
+ ### Editing — one transaction contract (#879)
1322
+
1323
+ An editable collection's changes are drafts, applied as one checked batch
1324
+ through one contract: `Editing.apply` and `Editing.Types.*` — `ChangeSet`,
1325
+ `PatchEvent`, `Readiness`, `Origin`, `Draft`, `Entry` and the rest. The
1326
+ SnapGrid's editing canvas and e3-ui's `<Sheet>` and `<Plan>` each
1327
+ run a session on it, and e3-ui's `Sheet.apply` and `Sheet.Types.*` are its
1328
+ very values under the Sheet's names. A gesture's `origin` names what made it:
1329
+ a typed or pasted value, a fill or a proposed row taken, an entry inserted,
1330
+ moved or removed, a `resize`, a `drop`, an undo, a redo or a discard (a review
1331
+ `verdict`, which no collection makes since #1260, stays so a journal of earlier
1332
+ events still reads).
1333
+
1334
+ A host's `onApply` takes one checked `ChangeSet` and answers an
1335
+ `ApplyResult`: it checks the base the drafts began from, applies the whole
1336
+ batch or none of it, deduplicates by the request id and returns the committed
1337
+ revision. An unknown outcome retries the same frozen request, and an
1338
+ append-only journal (`onPatch`) is not an application acknowledgement.
1339
+ `Editing.apply` is that check and application as an East function, over an
1340
+ `Array` by its identity field or a keyed `Dict` by key: each change names its
1341
+ entry by key (a `String` key as it is, any other key by its `.east` text), and
1342
+ a new entry is placed `keyOrder`.
1343
+
1344
+ | Signature | Description | Example |
1345
+ | --- | --- | --- |
1346
+ | `Editing.apply(E, "id")` / `Editing.apply(DictType(K, E))` | The shared applier — an Array by its identity field, or a keyed Dict by key (`Editing.Types.ChangeSet(E, K)`): the whole batch, or a conflict saying why. | `editingApplyBatch`, `editingApplyKeyed` |
1347
+
1348
+ ### Fields — a builder inspector's typed form (#1147)
1349
+
1350
+ A builder's inspector shows what is selected as a typed form over its struct.
1351
+ `Fields.specs(R, hints, omit)` resolves each field into a `Fields.Types.Spec`:
1352
+ its editor from its East type, a hint adding only what a type cannot say.
1353
+ e3-ui's builders carry the specs in their payloads, and east-ui-components'
1354
+ `FieldForm` draws each one as the shared `<Field>` (its label, its path as the
1355
+ key) around the input its type takes — so an inspector an author writes
1356
+ themselves from `<Field>` and the form tags looks the same.
1357
+
1358
+ | Field type | Editor with no hint | Hint |
1359
+ | --- | --- | --- |
1360
+ | `String` | text | `Fields.text({ placeholder? })`; `Fields.reference({ of })` — a key of a keyed set the host lists |
1361
+ | `Integer`, `Float` | number, with its steppers | `Fields.number({ unit?, step?, min?, max? })` — bigints for an Integer field, numbers for a Float |
1362
+ | `Boolean` / `DateTime` | checkbox / date and time | — |
1363
+ | a variant of empty cases | select, each case's name spelled out | `Fields.select({ labels? })` — the cases it labels first |
1364
+ | `Set<String>`, `Array<String>` | tags, typed freely | `Fields.tags({ options? })` — suggested as a tag is typed |
1365
+ | `Array` of a struct with one String and one Boolean field | checklist | `Fields.checklist({ text?, done? })` — naming them where there are several |
1366
+ | a struct | its fields, under its name | a hint per nested field |
1367
+ | `Option<T>` | `T`'s, which can be cleared | `T`'s |
1368
+ | anything else | printed | `Fields.readonly()`; `Fields.hidden()` leaves any field out |
1369
+
1370
+ Every hint but `hidden` takes `label` and `help`. A hint is checked against its
1371
+ field's type as it compiles (`Fields.number` on a String field is a type
1372
+ error), and the specs refuse one again as they resolve, naming the field.
1373
+
1374
+ | Signature | Description | Example |
1375
+ | --- | --- | --- |
1376
+ | `Fields.specs(R, hints?, omit?): Array<Fields.Types.Spec>` **❗** | The specs: the hinted fields first, in hint order, then the rest as declared; a nested struct's fields by path, under its name; `omit`'s and the hidden fields left out. Refuses a hint that does not fit its field, naming it. | `fieldsSpecs` |
1377
+ | `Fields.select({ labels })` | A variant's select: the cases it labels first, in its order, then the rest, each name spelled out. | `fieldsSelect` |
1378
+
1379
+ ### Drag and drop — one grammar, every target (#608)
1380
+
1381
+ A `<Library>` is a source; a `<Blend>` or e3-ui's `<Plan>`, `<Calendar>` or `<Roster>`
1382
+ that lists its `id` in `sources` is a target. Every drag between them reduces
1383
+ to one `DragEventType` — `add` (a card onto a cell), `move`, `remove` (to the
1384
+ trash or back to the palette) or `resize` (a span's edge) — and the renderer
1385
+ wires the flow, so nothing is wired by hand. A target's `canDrop` is asked of
1386
+ the REAL event, so a policy on copies holds while the drag is still moving:
1387
+
1388
+ ```tsx
1389
+ // A person may be moved onto a shift, never copied there (Alt held).
1390
+ const canDrop = $.const(East.function([DragEventType], BooleanType, (_$, event) =>
1391
+ event.match({ add: (_$, add) => add.duplicate.not() }, (_$) => East.value(true))));
1392
+ ```
1393
+
1394
+ | Signature | Description | Example |
1395
+ | --- | --- | --- |
1396
+ | **The gesture** | | |
1397
+ | pointer | A mouse or pen drag starts after 4px of travel, so a click stays a click; a touch after a 300ms hold — a drift first scrolls the page; a touch on a grip at once. Only the pointer that pressed moves, drops or cancels the drag — a second finger never does. | `rosterLibraryDnd` |
1398
+ | keyboard | Every draggable is a focusable control: Space / Enter picks it up, the arrow keys carry it between the cells that take it (and along a Plan row's buckets), Space / Enter drops it, Escape / Tab cancels. A Plan element is picked up with Space alone, since Enter is its click, and carries its own keys (#825). A key pressed in a control inside it is the control's. | `rosterWarehouse`, `planRowDrop` (e3-ui) |
1399
+ | reach | A drag resting near a scroll container's edge scrolls it — the container under the pointer: a bounded Plan's body, the page — and whatever scrolls under a still drag is read again. | `planRowDrop` (e3-ui) |
1400
+ | **The verdict** | | |
1401
+ | `canDrop: fn(DragEventType) => Boolean` | Asked of the event a drop where the drag rests would deliver — an `add`'s `duplicate` is whether Alt is held now — so the ⊘ stage shows before the drop, and asked again of the event delivered. A predicate that throws allows. | `rosterLibraryDnd`, `blendLibraryDnd`, `planRowDrop` (e3-ui) |
1402
+ | the drop | Resolves where it happens: a cell that scrolled away is never dropped on, and a drop with nothing under it says so rather than vanishing. | — |
1403
+ | **Screen readers** | | |
1404
+ | announcements | The pick-up, each new cell or bucket the drag rests over (or one that refuses it), the drop and a cancel are said in a live region. Host React code re-words them with `<DragLayerProvider messages={{ pickedUp: ({ item }) => … }}>` (@elaraai/east-ui-components; `dragMessages` is the English table, and any subset overrides it). | — |
1405
+
1406
+ ### Overlays — trigger prop + body children
1407
+
1408
+ `<Dialog>` is the one modal, and it is a confirmation step: before an act that
1409
+ destroys something or cannot be undone, it names the act and offers Cancel and
1410
+ the act's own verb. It is never a form. Anything that makes or names something
1411
+ — a new page, a template, a cohort — is a `<Popover>` hanging from the control
1412
+ that starts it, its fields in the body.
1413
+
1414
+ A callback opens an overlay through the State its `open` reads, and
1415
+ `onOpenChange` writes the State back as it closes. A callback carries no
1416
+ element, so an anchored overlay — a popover, a hover card, a toggle tip —
1417
+ opens at its own trigger, whatever wrote the State:
1418
+
1419
+ ```tsx
1420
+ const shown = $.let(State.bind([BooleanType], "details_open", false));
1421
+ const openIt = $.const(East.function([], NullType, $ => { $(shown.write(true)); }));
1422
+ <Button onClick={openIt}>Open the details</Button>
1423
+ <Popover trigger={<Button>Details</Button>} open={shown.read()} onOpenChange={shown.write}>…</Popover>
1424
+ ```
1425
+
1426
+ ```tsx
1427
+ <Dialog trigger={<Button variant="outline">Remove cohort…</Button>}
1428
+ eyebrow="Can't be undone" title="Remove cohort Late?">
1429
+ <HStack gap="2" justify="flex-end">
1430
+ <Button variant="outline">Cancel</Button>
1431
+ <Button variant="solid">Remove cohort</Button>
1432
+ </HStack>
1433
+ </Dialog>
1434
+ ```
1435
+
1436
+ ### Density cascade — one prop tightens a whole surface
1437
+
1438
+ Display components (`<Tag>`, `<Badge>`, `<Kbd>`, `<MetricChip>`, `<EditableChip>`,
1439
+ `<Meter>`, `<BarStrip>`, `<SegmentedMeter>`, `<Stat>`, `<Avatar>`, `<Trace>`,
1440
+ `<ChipRail>`) take `density="condensed" | "compact" | "comfortable"` and inherit
1441
+ it from the nearest providing surface — a `<Table>` /
1442
+ `<Matrix>` / `<ChipRail>` with `density` set, or any layout container
1443
+ (`<Box>` / `<Stack>` / `<Flex>` / `<Grid>` / `<Card>`) given a `density` prop.
1444
+ All densified components share one sizing rhythm, so mixed table cells (a tag
1445
+ beside a trace beside a meter) line up; an explicit `density` on a component
1446
+ wins over the cascade. `<Badge>` and `<Kbd>` scale on a smaller micro-label
1447
+ tier so they stay subordinate to tags at every density.
1448
+
1449
+ ```tsx
1450
+ // One prop on the Table sizes every chip, trace and meter in its cells.
1451
+ <Table density="compact" data={lines} columns={{ /* render cells with <Tag>, <Trace>, <Meter>… */ }} />
1452
+
1453
+ // Or scope it to a row:
1454
+ <HStack density="condensed" gap="2">
1455
+ <Tag>Line A</Tag>
1456
+ <Badge>WK 12</Badge>
1457
+ <Meter value={72.0} tone="success" />
1458
+ </HStack>
1459
+ ```
1460
+
1461
+ ### Picking between similar components
1462
+
1463
+ - **Switch vs Toggle vs Checkbox** — `<Switch>` binds a boolean form value;
1464
+ `<Toggle>` is a pressable toolbar button; `<Checkbox>` binds a boolean in a list.
1465
+ - **SegmentGroup vs Tabs vs RadioGroup** — `<SegmentGroup>` is a compact mode
1466
+ switcher (no panels); `<Tabs>` switches content panels; `<RadioGroup>` is a form input.
1467
+ - **Banner vs Status vs Progress** — `<Banner>` spans the page for staleness /
1468
+ partial-data; `<Status>` is a dot + word; `<Progress>` shows task completion.
1469
+ - **Meter vs Progress vs SegmentedMeter** — `<Meter>` is a static value vs a
1470
+ range; `<Progress>` is completion; `<SegmentedMeter>` decomposes a meter.
1471
+ - **Stat vs MetricChip** — `<Stat>` is a tile with hero number; `<MetricChip>` is
1472
+ a compact inline delta pill.
1473
+ - **Tag vs Badge** — `<Tag>` is an operator-set keyword / filter pill (body
1474
+ font, optionally closable); `<Badge>` is a mono uppercase micro-label for
1475
+ status / taxonomy (ok / warn / danger / count) that stays a tier smaller
1476
+ than tags at the same density.
1477
+ - **BarStrip vs Chart.Bar vs Chart.Column** — `<BarStrip>` is a small ranked
1478
+ horizontal-bar list (no axes) for a KPI card; `Chart.Bar` draws horizontal
1479
+ bars inside an axis-bearing `<Chart>` (numeric x, categorical y — grid,
1480
+ legend, tooltip, stacking); `Chart.Column` is the vertical twin (formerly
1481
+ named `Chart.Bar`).
1482
+ - **Plan (subsumes the retired Gantt / Planner / AlignedStack, #571)** —
1483
+ e3-ui's `<Plan>` (#1177, #1191) is the planning canvas: ONE shared axis — time, number or
1484
+ ordinal (#631) — over heterogeneous rows (state-runs, allocation lanes, chart measures,
1485
+ heat, bucketed numerals, shift chips, event marks), laid out by the series
1486
+ list and nested from the data's own structure, or placed from event kinds
1487
+ over records (e3-ui's `Schedule`, a Calendar's too), each named by a typed id,
1488
+ with slice/key-search/series-library chrome, an editing session (every
1489
+ dropped card, move and resize a draft, saved together — #880 / #825 / #1260) and PAGED sources. A Gantt
1490
+ is a Plan with span rows, a Planner a Plan with bucket rows, an
1491
+ AlignedStack a Plan mixing chart / heat / table rows on the shared axis.
1492
+ Reach for `<Plan>` for anything scheduled on ONE shared axis — calendar
1493
+ time, a numbered day / shift / distance, or an ordered list of phases —
1494
+ with mixed row kinds, nesting to any depth, a paged source, or rows addressed
1495
+ by stable ids; the e3-ui skill documents it.
1496
+ - **Table vs Sheet** — `<Table>` DISPLAYS rows (sort, pin, nest, review,
1497
+ paginate; cells printed in the viewer's language, or drawn by `render`);
1498
+ e3-ui's `<Sheet>` (#1179, #1216) is where a planner TYPES
1499
+ them, in its builder frame: typed cells with grammars (dates, quantities,
1500
+ register lookups, a directed link), a blank tail that inserts rows, an
1501
+ East-function copilot, and a slice lens drawn as context bands rather than
1502
+ a filtered row set. Reach for `<Sheet>` when the rows are authored in place
1503
+ and written back (through an e3 record's patch, or `onUpdate` / `onApply`)
1504
+ — the e3-ui skill documents it; for reading, sorting and reviewing a
1505
+ dataset, `<Table>`.
1506
+ - **Flowchart vs Schematic** — `<Schematic>` is a world-coordinate 2D canvas
1507
+ (data carries x/y; zones, footprints, camera); e3-ui's `<Flowchart>`
1508
+ (#1243) derives its whole layout from lanes + links (no coordinates) for
1509
+ state-transition / process-flow reading, with decision triggers and
1510
+ evidence on the links — the e3-ui skill documents it.
1511
+ - **Library vs Deck** — `<Library>` is the draggable palette (DnD source),
1512
+ or with `variant="gallery"` a library a person browses — large cards, each
1513
+ with its media, a byline and an action a click follows;
1514
+ `<Deck>` is the status-coloured display board (popover VIEW state, no drag).
1515
+ - **Card vs Box** — `<Box>` is structural-only; `<Card>` carries chrome.
1516
+ - **SnapGrid vs Grid** — `<Grid>` places the children written inside it, on
1517
+ whatever tracks you template; `<SnapGrid>` lays out tiles mapped from rows —
1518
+ a page held as data, on the fixed 12-column grid whose spans reflow to the
1519
+ SnapGrid's width, with a wireframe thumbnail drawn from the same rows.
1520
+
1521
+ ## Related skills
1522
+
1523
+ - **east** — the language UI component bodies are written in.
1524
+ - **e3-ui** — bind components to live workspace data (`Data.bind`) and ship them
1525
+ as reactive `ui()` e3 tasks; pair it with east-ui whenever the UI reads,
1526
+ writes, or commits real data.
1527
+ - **e3** — the engine that runs UI tasks.
1528
+ - **e3-ui-cli** — screenshot a component from the terminal (`e3-ui shot
1529
+ --from-source`) or Node (`renderToPng`), with managed headless Chromium.