@elaraai/east-codex-plugin 1.0.108 → 1.0.110

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.
@@ -108,6 +108,7 @@ Task → What do you need?
108
108
  │ ├─ Its current value → .read()
109
109
  │ ├─ Apply a mutation → .mutate.<name>(args…)
110
110
  │ ├─ The mutation's lifecycle → .mutate.status() / .pending() / .error()
111
+ │ ├─ A mutation as a draft, not committed → .draft.<name>(args…) · a pending Save's: Record.toDraft(record, { keyed? })
111
112
  │ ├─ Recompute what reads it → .start() (a mutation commits but does not run the dataflow)
112
113
  │ ├─ Its commit history → .history()
113
114
  │ └─ A builder's Save door → Record.bind(record) on a record declaring mutation.patch()
@@ -115,11 +116,11 @@ Task → What do you need?
115
116
  ├─ Call a named package function (e3.function) from the UI — Func.bind(fn)
116
117
  │ ├─ Launch (fire-and-forget, sync-callback safe) → .call(args…)
117
118
  │ ├─ Last successful result → .read() (Option(O))
118
- │ ├─ Lifecycle (variant) → .status() (idle|running|succeeded|failed|cancelled)
119
+ │ ├─ Lifecycle (variant) → .status() (idle|running|succeeded|failed|cancelled) · spinner boolean: .pending()
119
120
  │ ├─ Failure detail → .error() (Option — message/kind/stdout/stderr)
120
- │ ├─ Spinner boolean → .pending()
121
121
  │ ├─ Stop the call → .cancel() (asks the server to stop it; a later .call() supersedes one in flight the same way)
122
- │ └─ A function that reads workspace data too → e3.function(name, { inputs, args, output }, fn); .call(args…) takes the args alone
122
+ │ ├─ A function that reads workspace data too → e3.function(name, { inputs, args, output }, fn); .call(args…) takes the args alone
123
+ │ └─ Ask over the page's unsaved edits, saving nothing → a function listing drafts: [record]; .call(args…, [drafts]) · .drafted() · .binding.drafts
123
124
  │
124
125
  ├─ Edit a graph / ontology dataset
125
126
  │ └─ <Ontology value={view} /> (OntologyType: NodeType / LinkType)
@@ -145,35 +146,44 @@ Task → What do you need?
145
146
  │
146
147
  ├─ Draw what is scheduled on ONE shared axis — the Plan
147
148
  │ ├─ Rows derived from data by a series list → <Plan axis={…} data={…} series={[…]} />
148
- │ ├─ Event kinds over records, on resource rows → <Plan axis={…} resources={{ presses: Schedule.resources(…) }} events={{ job: Schedule.events(record, {…}) }} />
149
+ │ ├─ Event kinds over records, on the rows they land on → series={[Plan.series.resources(Row, { key: "presses", title, label, series? })]} events={{ job: Schedule.events(record, { resource: { field, of: "presses" } }) }} · rows of mixed kinds: Plan.series.kinds(Row, "what", { press: { title, label }, crew: false }), a case each, exhaustive
150
+ │ ├─ Rows beneath a resource, and a kind landing on them → a kinds case's children: Plan.children("kinds", [Plan.series.resources(Kind, { key: "kinds", keyType, label, lanes })]) — or a list's rows beneath every resource: Plan.children.of(() => kinds.read(), [series…]) — + Schedule.events(record, { resource: { field, of: "press" }, child: { field: "kind", of: "kinds" }, lane: "half" }): each event on its kind's row, a lane for each case of a variant `lane` · row: false leaves a case's own row undrawn (one press's own page)
151
+ │ ├─ One case of a variant field, on a single series → Plan.series.chart(Row, { case: ["kind", "kpi"], label: (row, key, kpi) => kpi.name, … }): the rows holding the case, each accessor handed its value; match narrows them further
149
152
  │ ├─ Read-only rows: a dataset's, or hand-built → rows={[Plan.over(data, [series…]), Plan.chart({…})]}
150
153
  │ ├─ Its axis: time, number or ordinal → Plan.axis / Plan.axis.number / Plan.axis.ordinal
151
154
  │ ├─ Rows, nested by what the data holds → Plan.series.span / buckets / chart / heat / table / cards / events / group / section / views / rows
152
155
  │ ├─ Data too large to hold whole → data={paged}, a Data.bindPaged handle
153
- │ ├─ Narrow its rows, event kinds, resources, templates → slice={{ slice: Slice.bindRecords(key, { rows?, job?, presses?, jobTemplates? }) }} (Schedule.templates(rows, { …, source }))
154
- │ ├─ Event kinds over records too large to read whole → the kind's source over its interval index (range: "start") + Schedule.events(record, { entries }); drawn within 10,000 events
155
- │ ├─ …on paged resources: read a cell at a time → the kind's source lists index.series + index.summary beside its interval index
156
+ │ ├─ Narrow its rows, event kinds, templates → slice={{ slice: Slice.bindRecords(key, { rows?, job?, jobTemplates? }) }} (Schedule.templates(rows, { …, source })); the rows source narrows the resources, which are rows
157
+ │ ├─ Event kinds over records too large to read whole → the kind's source over its interval index (range: "start") + Schedule.events(record, { entries }), drawn within 10,000 events; over paged rows its source lists index.series + index.summary too, read a cell at a time
156
158
  │ ├─ A link between two runs, or two events → Plan.link({ from: Plan.ref(…), fromRun, … }) / Plan.link({ from: Plan.eventRef(kind, key), … })
159
+ │ ├─ Links kept in a record: selected, edited, removed → links={{ flow: Plan.links(Record.bind(flows), { name, icon, from: { field, of }, to: { field, of }, quantity? }) }}: each link a row, each end the key of an event — `of` an event kind's slot, or a slot per case of a variant field
160
+ │ ├─ Links drawn by hand, and the connect veto → built in beside a link kind bound with Record.bind: the toolbar's Connect tool, a drag from one event to another; canConnect={fn(Plan.Types.ConnectCandidate) => Option<String>} refuses a pair with its message
161
+ │ ├─ Every kind's templates in one record → Schedule.templates(presets.read(), { case: ["values", "job"], name, values: (_preset, _key, job) => job, source: "templates" }): the rows whose variant field holds the kind's case, each accessor handed its value; one source of the rail for every kind
162
+ │ ├─ An event kind's record keyed by any type → nothing more to write: its events are named by their key as East prints it, saved under it, and a link's end or an optimiser's patch holds it in its own type
157
163
  │ ├─ Its library pane: templates, backlog, series, cards → library={[Plan.library.events(), Plan.library.backlog(), Plan.library.series(), Plan.library.tab(rows, {…})]}
164
+ │ ├─ Which series show, and the viewer's own choice → hidden={["utilisation"]}, the keys off to start: any series of `series`, nested or not, a member of a views or a case of a kinds · with Plan.library.series() the Series tab switches each alone, kept under id
165
+ │ ├─ A run's, a tile's, a chip's or a mark's status → its map's status: Plan.status("Over dwell", "warning"), its words and its tone · { ring: true } draws it as an open ring, as a tentative one · an Option of one passes as it is
158
166
  │ ├─ The app's own words for what it draws → vocabulary={{ unassigned, backlog, rows, dueThisWeek, confirmed, … }}
159
167
  │ ├─ Its inspector pane: what is selected → inspector (+ an event kind's own: Schedule.events(record, { inspector }))
160
- │ ├─ Drags of templates, backlog cards and events → built in with resources + events (+ library); canDrop={fn(Schedule.Types.Candidate) => Option<String>}
161
- │ ├─ The app's optimiser over the window and the backlog → optimise={Func.bind(e3.function)} from Plan.Types.OptimiseRequest({ job: Job }, { presses: Press }) to Plan.Types.OptimiseResult({ job: Job })
168
+ │ ├─ Drags of templates, backlog cards and events → built in with event kinds (+ library); canDrop={fn(Plan.Types.Candidate) => Option<String>}, the one check of every drop, its message on the ghost
169
+ │ ├─ Hold one event or item where it is: a lock, no move, form read only → Schedule.events(record, { locked: (row, key) => Boolean }) · a series item's map: locked
170
+ │ ├─ A library tab whose cards make events, as templates do → Plan.library.tab(rows, { …, create: { kind: "<slot>", duration | at, values: (row) => ({ …the kind's row less its start, end and resource }) } })
171
+ │ ├─ The app's optimiser over the window and the backlog → optimise={Func.bind(e3.function)} from Plan.Types.OptimiseRequest (the window, the zoom's unit, the run, the rail's narrowing; no row) to Plan.Types.OptimiseResult({ job: Jobs }), a patch of each kind's record
162
172
  │ ├─ Overlap warnings, without dropping overlapping events → Schedule.events(record, { overlaps: "warn" | "allow" })
163
- │ └─ Dropped cards and moves of data rows as drafts → a series' edit + editing={{ onUpdate | onApply }}
173
+ │ └─ Dropped cards and moves of data rows as drafts → a series' edit + record={Record.bind(rows)}, the record its data is read from (+ onPatch, ready)
164
174
  │
165
175
  ├─ Let planners type rows in place — the Sheet
166
176
  │ ├─ An e3 record edited as a sheet → <Sheet record={…} columns={{…}} /> (record = Record.bind(r))
167
177
  │ │ ├─ One entry's rows, groups or loose rows → entry={{ key, rows: "field", id: "id" }} (+ group)
168
178
  │ │ └─ A large record, a window at a time → window={Data.bindPaged(r)}
169
179
  │ ├─ The host's rows → <Sheet data={…} id="id" columns={{…}} />
170
- │ ├─ Narrow its rows and templates — one rail → slice={{ slice: Slice.bindRecords(key, { rows, rowTemplates, … }) }} (Sheet.templates(rows, { …, source }))
180
+ │ ├─ Narrow its rows and templates — one rail → slice={{ slice: Slice.bindRecords(key, { rows, rowTemplates, … }) }} (Sheet.templates(rows, { …, source })); its `rows` source pages the record, and `record={…}` beside it saves
171
181
  │ ├─ Its panes, each optional → library={[Sheet.library.rows(), Sheet.library.columns(), Sheet.library.tab(…)]} · inspector (+ fields)
172
182
  │ ├─ The app's own words for what it draws → vocabulary={{ members, unassigned, source, destination, wanted, actual }}
173
183
  │ ├─ Its columns, registers and the driver → Sheet.column.* / Sheet.register.* / Sheet.driver
174
184
  │ ├─ Groups, loose rows between them, read-only sub rows → Sheet.group / Sheet.Types.Entry / Sheet.subRows
175
185
  │ ├─ Data too large to hold whole → data={paged}, a Data.bindPaged handle
176
- │ ├─ The app's optimiser over the rows in view → optimise={Func.bind(e3.function)} from Sheet.Types.OptimiseRequest(R) to Sheet.Types.OptimiseResult(R)
186
+ │ ├─ The app's optimiser over the rows in view → optimise={Func.bind(e3.function)} from Sheet.Types.OptimiseRequest() — over one entry's rows OptimiseRequest({ entry: K }) — to Sheet.Types.OptimiseResult(Rows), a patch of the rows its Save reaches; over a record only
177
187
  │ ├─ On a phone: a column pinned, how many in view → narrow={{ pin?: "<column>", columns?: 1 | 2 | 3 }} (none pinned, 2 in view by default)
178
188
  │ └─ Drafts checked as they are made, one checked Save → onUpdate | onApply, ready, newRow
179
189
  │
@@ -186,14 +196,14 @@ Task → What do you need?
186
196
  │ ├─ Column groups over adjacent columns → columnGroups={[{ label, columnKeys }]}
187
197
  │ ├─ Columns from data: a member's each, a struct field's → any kind's { each: "<register>", groups?: "<register>" } over a Dict keyed by the member · { each: { field: "Header" } } · a field stored its own way: field, read, write, each given the day
188
198
  │ ├─ Words or a lock on a cell; a cell read off the row → mark: (…, day) → Option<Record.Types.Mark>, a note or a lock the grid won't edit · value: (row) => … on title, text, date, quantity, integer
189
- │ └─ Narrow it — one rail — and Apply through the door → slice={{ slice: Slice.bindRecords(key, { rows }) }} + onApply={Record.onApply(record, { keyed: true })}
199
+ │ └─ Narrow it — one rail, the record beside it → slice={{ slice: Slice.bindRecords(key, { rows }) }} + record={record} (the record its `rows` source pages; without it, read only)
190
200
  │
191
201
  ├─ Schedule bound records on a calendar — the Calendar
192
202
  │ ├─ Event records, with their backlog → <Calendar events={{ job: Calendar.events(Record.bind(jobs), { name, icon, title, start, end, resource: { field, of }, entries, backlog }) }} />
193
203
  │ ├─ Resources and templates, read whole → resources={{ machines: Calendar.resources(Data.bind(r).read(), {…}) }} · Calendar.templates(rows, {…})
194
204
  │ ├─ The app's own words for what it draws → vocabulary={{ backlog, templates, template, dueThisWeek, dueNextWeek, later, noDate, unscheduled, unassigned, resources }}
195
205
  │ ├─ Narrow it — one rail, one date window → slice={{ slice: Slice.bindRecords(key, { job: { source, range: "start" }, machines?, jobTemplates? }) }}
196
- │ └─ The app's optimiser → optimise={Func.bind(e3.function)}
206
+ │ └─ The app's optimiser → optimise={Func.bind(e3.function)} from Calendar.Types.OptimiseRequest (the window in view and its kind, the run, the rail's narrowing; no row) to Calendar.Types.OptimiseResult({ job: Jobs })
197
207
  │
198
208
  ├─ Draw a state-transition flow over the app's records — the Flowchart
199
209
  │ ├─ A kind per record: its states, transitions, lanes, decisions → <Flowchart states={Flowchart.states(record, { label, lane, order, members? })} transitions={Flowchart.transitions(record, { from, to, decision?, kind?, evidence? })} lanes={Flowchart.lanes(record, { label, order })} decisions={Flowchart.decisions(record, { label, owner? })} />
@@ -235,20 +245,21 @@ Task → What do you need?
235
245
  │ ├─ Duties in no group yet: a roster in two steps → group over an Option<String> field, none a duty in no group — on its person's row in People and in Shifts' No group band, counted in their hours, contract and rest and in no group's targets; a drop in a group's slot writes some(group), the optimiser's request and result carry none · in a check, a duty's place (Roster.Types.Place) and Roster.slotOf(place), none in no group · vocabulary={{ noGroup }}
236
246
  │ ├─ Who is rostered → resources={{ people: Schedule.resources(staff.read(), { name, icon, label, group, … }), agencies? }}
237
247
  │ ├─ The lists it reads, over the app's rows → Roster.shifts / groups / positions / activities / proposals(rows, { … })
238
- │ ├─ Publish, and the targets: the app's weeks and cover → periods={Schedule.periods(Record.bind(weeks), { every: "week", status, dismissed? })} · targets={Roster.targets(Record.bind(cover), { day, group, shift, positions, hours })}
248
+ │ ├─ Publish, and the targets: the app's weeks and cover → periods={Schedule.periods(Record.bind(weeks), { every: "week", status, dismissed? })} · targets={Roster.targets(Record.bind(cover), { day, group, shift, positions, hours, needed? })}
249
+ │ ├─ A slot's hours needed: the app's own → Roster.targets(…, { needed: (row, shiftHours) => row.heads.toFloat().multiply(shiftHours) }) — by default the sum of its hours; read again from a target edited before Save · every key of its hours draws a coverage line: the group's skills, the duties, then any other key, another group's skill under its own label with its holders
239
250
  │ ├─ Publish a day at a time: the app's days → periods={Schedule.periods(Record.bind(days), { every: "day", status, dismissed?, entries? })} — in Shifts' Day, Publish day writes the day in view; else Publish week, each day of the week that takes edits, as one request; a published day read-only in every layout and period while its week's other days take edits, a rejected proposal kept on its day's row
240
251
  │ ├─ A new duty's, target's and week's own fields → values: (d) => ({ … }) on the duty kind, over Roster.Types.NewDuty · Roster.targets(…, { values }) · Schedule.periods(…, { values })
241
252
  │ ├─ Costs in the app's own pay codes → pay={fn(Roster.Types.PayRequest(R)) → Roster.Types.Pay} currency="…"
242
- │ ├─ Who fits a Find fix: the app's fit, on e3 → fit={Func.bind(e3.function)} from Roster.Types.FitRequest(R) to FitResult, over Roster.answer(R) + Roster.fit(R)
243
- │ ├─ The app's optimiser over the week → optimise={Func.bind(e3.function)} from Roster.Types.OptimiseRequest(R) to Roster.Types.OptimiseResult(R)
244
- │ ├─ An optimiser that sees the week's edges → Roster.Types.OptimiseRequest(R, { edges: true }) to OptimiseResult(R, { edges: true }) — edges: the window's duties the Roster places in another week, drafts in place; fixed: those of a week that takes no edit, left as they are; an answer that changes a fixed duty, puts one in a week taking no edit or beyond the weeks either side, or gives a key twice is refused, naming the duty
253
+ │ ├─ Who fits a Find fix: the app's fit, on e3 → fit={Func.bind(e3.function)} from Roster.Types.FitRequest to FitResult — asked the need, the slot and the page's scope, no row; the function lists the duties in drafts, reads the week through their index (Roster.window) and whom it asks about, and answers with Roster.answer + Roster.fit() over a Roster.Types.FitContext
254
+ │ ├─ The app's optimiser over the period in view → optimise={Func.bind(e3.function)} from Roster.Types.OptimiseRequest() — the day, the week or the month it shows, `period` its kind — to Roster.Types.OptimiseResult(Duties), a patch of the duties' record
255
+ │ ├─ An optimiser that sees the week's edges → Roster.Types.OptimiseRequest({ edges: true }) — the request also names in `fixed` the edge duties the answer must leave: those of a week that takes no edit; its one patch may change a duty in the weeks either side; one that changes a fixed duty, or puts one in a week taking no edit or beyond them, is refused, naming the duty
245
256
  │ ├─ Narrow its duties, targets, people, activities, patterns → slice={{ slice: Slice.bindRecords(key, { duty: { source, range: "start" }, targets?, people?, activities?, patterns? }) }}
246
257
  │ ├─ The app's check, and a record it reads beside the duties → check={fn(Roster.Types.CheckContext(R)) → Array<Roster.Types.Issue>} · the first step's rota as the slice's reference: { duty, reference: { source, range: "start" } }, check from CheckContext(R, P) — cx.reference: Dict<String, P>, the week's rows and 12 h either side, read through its interval index, never whole; nothing draws it, the rail offers none of it
247
258
  │ ├─ People by week or by month → view={{ layout: "people", period: "week" | "month", date }}
248
259
  │ ├─ People in one list, no band over each group → peopleBands={false} — ranked as a group's people are (leads, the rest, agency staff), every group's agency requests one row at its foot; a person keeps their home group for + Assign, a Find, the fit and the optimiser
249
260
  │ ├─ The cover targets over People by week or month → on with targets: under each band its work requirement — a lane a shift its targets name, each day's hours rostered (requests included) of needed over a bar, by month a mark a day on the person marks' columns (short, requested, covered or no target), a lane opening to its skill rows, a day or a mark opening its slot in the inspector; one block over every group with peopleBands={false}; deep in a band's people its block stays under the header; on a phone a card a day before each band's people's cards, a line a shift · requirements={false} takes it away
250
261
  │ ├─ Offer only some layouts, no switch with one left → views={["people"]} or views={expr of Array<Roster.Types.Layout>}
251
- │ ├─ The app's own words for who is on it → vocabulary={{ permanent: "Employees", agency: "Contractors", agencyShort: "contr", others: "Colleagues", requests: "Contractor requests", demand: "Hours needed" }} — agencyShort the agency badge in People and on a Shifts chip, requests its rows of agency requests, demand the People layout's work requirement; a fit's reason: Roster.fit(R, { notALead })
262
+ │ ├─ The app's own words for who is on it → vocabulary={{ permanent: "Employees", agency: "Contractors", agencyShort: "contr", others: "Colleagues", requests: "Contractor requests", demand: "Hours needed" }} — agencyShort the agency badge in People and on a Shifts chip, requests its rows of agency requests, demand the People layout's work requirement; a fit's reason: Roster.fit({ notALead })
252
263
  │ ├─ The shifts' colours, and the app's week patterns → Roster.shifts(rows, { …, color }) · patterns={Roster.patterns(rows, {…})} · library={[…, Roster.library.patterns()]}
253
264
  │ └─ The week's figures in a task → Roster.coverage / check / weekHours / rest (R)
254
265
  │
@@ -258,8 +269,8 @@ Task → What do you need?
258
269
  │ ├─ The lanes and the resources → resources={{ <lanes>: Schedule.resources(rows, { name, icon, label, offset? }), <resources>: Schedule.resources(rows, { name, icon, label, min, max, … }) }}
259
270
  │ ├─ What it books from → arrivals={Allocation.arrivals(rows, { label, quantity, hold, kind?, values?, … })}
260
271
  │ ├─ Publish: the app's days, or its weeks → periods={Schedule.periods(Record.bind(days), { every: "day", status })} · or its weeks, { every: "week", … }, each keyed by its first day, week={{ start: "monday" | "sunday" }} — Publish week writes the week holding the day in view, and every day of a published week is read-only
261
- │ ├─ Who fits where: the app's fit, on e3 → fit={Func.bind(e3.function)} from Allocation.Types.FitRequest(R) to FitResult, over Allocation.answer(R) + Allocation.fit (+ Allocation.lookahead(R))
262
- │ ├─ The app's optimiser over the day → optimise={Func.bind(e3.function)} from Allocation.Types.OptimiseRequest(R) to Allocation.Types.OptimiseResult(R)
272
+ │ ├─ Who fits where: the app's fit, on e3 → fit={Func.bind(e3.function)} from Allocation.Types.FitRequest to FitResult — asked the day, the question and the page's scope, no row; the function lists the bins in drafts, reads the day's through their index, and answers with Allocation.answer + Allocation.fit (+ Allocation.lookahead) over an Allocation.Types.FitContext
273
+ │ ├─ The app's optimiser over the day → optimise={Func.bind(e3.function)} from Allocation.Types.OptimiseRequest (the day, the run, the rail's narrowing; no row) to Allocation.Types.OptimiseResult(Bins), a patch of the bins' record
263
274
  │ ├─ Narrow its bins, lanes, resources and arrivals — one rail → slice={{ slice: Slice.bindRecords(key, { bin: { source, range: "at" }, <lanes>?, <resources>?, arrivals? }) }}
264
275
  │ ├─ Its panes → library={[Allocation.library.arrivals(), Allocation.library.resources()]} · inspector
265
276
  │ ├─ The app's own words for what it holds → labels={{ lane, arrival, resource, quantity, bin, reservation, reserved, priorJob, nextJob, hold, groups: { overdue, ready, removed, allocated, free, loading, busy } }}
@@ -327,32 +338,33 @@ mutation named in the list (with `mutate.status()`, `pending()`, `error()`),
327
338
  `start()` to run the dataflow over the new state, and `history()` for its
328
339
  commits. Builders take `Record.bind(record)` of a record declaring
329
340
  `patch: mutation.patch()` and commit every Save through it; a stale Save is a
330
- conflict naming the entry, and nothing is overwritten. `Record.onApply(record,
331
- { keyed? })` adapts a record for a host's `onApply`.
341
+ conflict naming the entry, and nothing is overwritten. A builder is handed the
342
+ record itself, beside a rail too (`slice` with `record`); `Record.onApply(record,
343
+ { keyed? })` is a host's `onApply` over its own `data`: `.apply` with `.toDraft`.
332
344
 
333
345
  ### `Func.bind(fn)`
334
346
 
335
347
  A call handle for an `e3.function`. `call(args…)` is fire-and-forget and safe
336
348
  in a sync `onClick`, latest-wins; the outcome arrives reactively through
337
- `read()`, `status()`, `error()` and `pending()`. All handles bound to one
338
- function share one channel, so one component can launch while another shows the
339
- spinner. A call is the server's: it outlives the request that starts it, and
340
- runs until its timeout — the server's ceiling, ten minutes locally — however
341
- long that is, so an optimiser of several minutes is called the same way; the
342
- server keeps it for its lifetime, with its arguments, the inputs it read, its
343
- value and its logs (the **e3** skill). `cancel()` asks the server to stop the
344
- call, and `status()` reads `cancelled`; a `call` that supersedes one in flight
345
- asks the server to stop that one. A result is at most 1 MiB: a large one
346
- belongs in a task, read with `Data.bind`.
349
+ `read()`, `status()`, `error()` and `pending()`, on one channel for every
350
+ handle of the function. A call is the server's, kept for its lifetime (the
351
+ **e3** skill): it outlives its request and runs until its timeout — the
352
+ server's ceiling, ten minutes locally — so an optimiser of several minutes is
353
+ called the same way. `cancel()` asks the server to stop it, and `status()`
354
+ reads `cancelled`; a `call` that supersedes one in flight does the same. A
355
+ result is at most 1 MiB: a large one belongs in a task, read with `Data.bind`.
347
356
 
348
357
  A function that declares `inputs` (`e3.function(name, { inputs, args, output },
349
- fn)`, the **e3** skill) is bound the same way: its handle's `call` takes the
350
- `args` alone, and each call reads the inputs from the workspace as they are
351
- stored when it launches. The page binds none of them; an optimiser's eye
352
- (`optimise={Func.bind(fn)}`) passes its request as the one argument while the
353
- function reads its reference data as inputs. `e3-ui:func.examples.tsx:funcBindCall`
354
- launches a call from a button and shows its result;
355
- `e3-ui:func.examples.tsx:funcBindInputs` binds a function that declares inputs.
358
+ fn)`, the **e3** skill) is bound the same way: its `call` takes the `args`
359
+ alone, each call reads the inputs as the workspace stores them when it launches,
360
+ and the page binds none (`e3-ui:func.examples.tsx:funcBindCall`, `funcBindInputs`).
361
+
362
+ A function that lists records in `drafts` (the **e3** skill) is asked over the
363
+ page's unsaved edits: its `call` takes drafts last, an Array (`[]`: as saved),
364
+ each a mutation's call, not committed: `record.draft.<name>(args…)`, or a
365
+ pending Save's from `Record.toDraft`. e3 lays them over what the function reads
366
+ and saves nothing. A draft that no longer fits its record ends the call
367
+ `conflict`, the function not run (`e3-ui:func.examples.tsx:funcBindDrafts`).
356
368
 
357
369
  ## The builders
358
370
 
@@ -363,9 +375,9 @@ launches a call from a button and shows its result;
363
375
  fields (`title: "title"` or a function of the row, `start: "start"`,
364
376
  `resource: { field, of }`) and stores nothing of its own. Editable data is
365
377
  `Record.bind(record)` over a record declaring `mutation.patch()`.
366
- `Schedule.events` / `resources` / `templates` / `periods` are the shared
367
- vocabulary for kinds of events and resources (Plan, Calendar, Roster,
368
- Allocation).
378
+ `Schedule.events` / `templates` / `periods` are the shared vocabulary for
379
+ kinds of events (Plan, Calendar, Roster, Allocation), `Schedule.resources`
380
+ for their resources but the Plan's, which are its rows.
369
381
  - **Every gesture is a draft.** Drags, drops, typed cells and form edits are
370
382
  steps of one session with Undo / Redo, saved with one checked Save through
371
383
  each record's patch door (or the host's `onApply`), surviving paging,
@@ -376,39 +388,43 @@ launches a call from a button and shows its result;
376
388
  - **It renders in its own frame**: one toolbar, the canvas, a footer, and the
377
389
  panes its props ask for (`library`, `inspector`). Give it a box with a height.
378
390
  - **One rail narrows it**: `slice={{ slice: Slice.bindRecords(key, { … }) }}`,
379
- each source named after what it narrows (an event kind's slot, a resource
380
- kind's slot, `rows`, a templates list's `source`), each
381
- `Data.bindPaged(record, { indexes })` over that record's declared indexes.
382
- Sources with a `range` share the one time window. Calculations (coverage,
383
- costs, loads, checks) read every record, whatever the rail hides.
384
- Templates lists are records, each naming its rail `source`.
391
+ each source named after what it narrows (a kind's slot, `rows`, a templates
392
+ list's `source`) over its record's indexes (`Data.bindPaged(record, { indexes })`);
393
+ `range` sources share one window. Calculations read every row, hidden or not.
394
+ A page for one press scopes a source (`scope: { press: [press] }`): every read
395
+ and Search Records keep to the press, the rail has no control for it, a new event
396
+ takes it; it lists `index.on(["press"])`, per field offered `index.on(["press", "crew"])`, and read by area `index.area({ on: ["press"], … })`.
385
397
  - **Large records are read through their indexes** (declared in the record,
386
398
  the **e3** skill): an event kind through an interval index
387
399
  (`index.interval({ from: "start", to: "end" })`) with `range: "start"` and
388
400
  `entries: Data.bindPaged(record)` for reads by key; events on paged
389
- resources a cell at a time through `index.series` + `index.summary`; a
401
+ rows a cell at a time through `index.series` + `index.summary`; a
390
402
  drawing a window at a time through `index.area`.
391
403
  - **The app's optimiser**: `optimise={Func.bind(fn)}`, an `e3.function` from
392
- the builder's `Types.OptimiseRequest` to its `Types.OptimiseResult`; its
393
- answer lands as one undoable step.
394
- - **Which views an instance offers**: a component that switches between views
395
- takes `views` — the Roster's, Calendar's and Allocation's layouts, the
396
- Ontology's display modes and `<Query.Builder>`'s
397
- Visual · jq (and `resultViews`, Table · Tree). Literal tags (`views={["people"]}`),
398
- variants of its `Types`, or an expression of an array of them, so a page's state
399
- can choose them as it runs. Left out, or empty as the page runs, every view; one
404
+ the builder's `Types.OptimiseRequest` — the period in view, the run and the
405
+ rail's narrowing, never a row — to its `Types.OptimiseResult`, a patch of each
406
+ record it edits (`East.diff`). The function lists those records in `drafts`,
407
+ reads them through their indexes, and its answer lands as one undoable step.
408
+ - **The app's fit** (the Roster's Find fix, the Allocation's board):
409
+ `fit={Func.bind(fn)}` asks an `e3.function` the question and the page's
410
+ scope, never a row; listing in `drafts` the records it reads that the builder
411
+ edits, it answers over the unsaved edits. A subject it leaves out has no verdict.
412
+ - **Which views and periods an instance offers**: a component that switches
413
+ between views takes `views` — the Roster's, Calendar's and Allocation's
414
+ layouts, the Ontology's display modes and `<Query.Builder>`'s Visual · jq (and
415
+ `resultViews`, Table · Tree). Literal tags (`views={["people"]}`), variants of
416
+ its `Types`, or an expression of an array of them, so a page's state can
417
+ choose them as it runs. Left out, or empty as the page runs, every view; one
400
418
  left, no switch shows in any form of the toolbar; the component's own order
401
419
  stands. `e3-ui:roster.examples.tsx:rosterViews` wires a multi-select into it.
402
- `<DecisionQueue>`'s `facets` is the same.
403
- - **Which periods an instance offers**: `viewPeriods` on `<Roster>` and
404
- `<Calendar>` does the same for Day · Week · Month. (A Plan's are its axis's
405
- `resolutions`.)
420
+ `<DecisionQueue>`'s `facets` is the same, and so is `viewPeriods` on `<Roster>`
421
+ and `<Calendar>` for Day · Week · Month (a Plan's are its axis's `resolutions`).
406
422
  - **Misuse is refused at build**, naming the change — forms from earlier
407
423
  releases included — so read the error rather than guessing.
408
424
 
409
425
  | Builder | What it draws | Start from |
410
426
  |---|---|---|
411
- | `<Plan>` | Heterogeneous rows on one time / number / ordinal axis: series over data, event kinds over records, read-only rows | `e3-ui:plan-events.examples.tsx:planEvents` (smallest), `e3-ui:plan.examples.tsx:planTargetState`, `e3-ui:plan-windows.examples.tsx:planWindows`, `e3-ui:plan-records.examples.tsx:planRecordIndexes` |
427
+ | `<Plan>` | Heterogeneous rows on one time / number / ordinal axis: series over data, event kinds over records landing on its rows, read-only rows | `e3-ui:plan-events.examples.tsx:planEvents` (smallest), `e3-ui:plan.examples.tsx:planTargetState`, `e3-ui:plan-windows.examples.tsx:planWindows`, `e3-ui:plan-records.examples.tsx:planRecordIndexes`, `e3-ui:plan-events.examples.tsx:planPrintWorksRecords` (the whole of it: one record of rows, five event kinds, a link kind, templates, an optimiser) |
412
428
  | `<Sheet>` | A planning spreadsheet over a record, the host's rows or a paged source: typed columns, registers, groups, copilot, Excel round-trip | `e3-ui:sheet.examples.tsx:sheetBasic` (smallest), `e3-ui:sheet.examples.tsx:sheetWorkshop`, `e3-ui:sheet.examples.tsx:sheetPaged`, `e3-ui:sheet-records.examples.tsx:sheetRecordIndexes` |
413
429
  | `<Record>` | A system of records' rows as a table: the Sheet's kinds with title, person, boolean, toggle, cycle, age and audit; column groups, columns from data, marks and locks, Add and Delete | `e3-ui:record.examples.tsx:recordBasic` (smallest), `e3-ui:record.examples.tsx:recordSkillsMatrix`, `e3-ui:record.examples.tsx:recordEveryKind`, `e3-ui:record.examples.tsx:recordFinishes`, `e3-ui:record.examples.tsx:recordHoursByProject` (columns from data), `e3-ui:record.examples.tsx:recordSkillHistory` (a dated history, read and written at the day) |
414
430
  | `<Calendar>` | Calendar, Resources and Timeline layouts over event records with a backlog | `e3-ui:calendar.examples.tsx:calendarMinimal` (smallest), `e3-ui:calendar.examples.tsx:calendarOperations`, `e3-ui:calendar-records.examples.tsx:calendarRecordIndexes` |
@@ -481,11 +497,7 @@ in; dates print in UTC.
481
497
  - **A record's mutation from a button**: `Record.bind(r, ["increment"])`, the
482
498
  button applying `r.mutate.increment(1n)` with `loading={r.mutate.pending()}`:
483
499
  `e3-ui:record.examples.tsx:recordBindMutate`.
484
- - **Disable controls on stale data**:
485
-
486
- ```tsx
487
- <Slider value={t.read()} onChangeEnd={t.writeAndStart} disabled={t.status().hasTag('stale')} />
488
- ```
500
+ - **Disable controls on stale data**: `disabled={t.status().hasTag('stale')}`.
489
501
 
490
502
  ## Related skills
491
503
 
@@ -138,7 +138,10 @@ Task → What do you need?
138
138
  │ │ .toTree(Node, parent, build) (an element / a key is its own key; Dict callbacks take (value, key));
139
139
  │ │ Dict only: .flattenTree(children), the nodes back again (reference/trees-and-recursion.md);
140
140
  │ │ group .groupReduce(), .groupSize(), .groupSum(), .groupMean(), .groupToArrays(), .groupToSets(),
141
- │ │ .groupToDicts(), .groupEvery(), .groupSome()
141
+ │ │ .groupToDicts(), .groupEvery(), .groupSome();
142
+ │ │ a key range .range({ from?, to? }) — the entries from the first key at or past `from` up to the first
143
+ │ │ at or past `to` — and .prefix({ … }), those whose key begins with given fields: a bound is the key, or
144
+ │ │ a struct key's first fields; a new collection, found by a search and never a walk
142
145
  │ ├─ Dict → .size(), .has(), .get(), .tryGet(), .keys(), .getKeys(), .insert(), .insertOrUpdate(), .update(),
143
146
  │ │ .merge() (ONE key, as Array's and Ref's), .getOrInsert(), .delete(), .tryDelete(), .pop(), .swap(),
144
147
  │ │ .clear(), .unionInPlace(), .mergeAll(), .copy(), .union() (whole dicts; in east-py .merge() is its
@@ -188,9 +191,11 @@ Task → What do you need?
188
191
  ├─ A JSON contract for a type → jsonSchemaFor(T) · back from a vendored schema → typeFromJsonSchema(schema)
189
192
  └─ Data larger than memory → reference/beast2.md; inside a body blob.openBeast(T),
190
193
  and a file on the runner's disk FileSystem.openBeast(T, path) (east-node-std / east-c-std / east-py-std)
191
- └─ A loop over a lazy input (a large task input, an openBeast) decodes only the fields its body reads:
192
- read the row through fields (row.total, $.for(row.lines, …)), not bound whole ($.let(row));
193
- a runner's -v says "paged loops: N segments decoded to the fields read, M in full"
194
+ ├─ A loop over a lazy input (a large task input, an openBeast) decodes only the fields its body reads:
195
+ │ read the row through fields (row.total, $.for(row.lines, …)), not bound whole ($.let(row));
196
+ │ a runner's -v says "paged loops: N segments decoded to the fields read, M in full"
197
+ └─ The entries between two keys of a lazy Set or Dict → d.range({ from, to }) · d.prefix({ … }): read at the
198
+ cost of the range, never of the collection — its size by its two ends, a loop by its segments
194
199
  ```
195
200
 
196
201
  ## Types and their values
@@ -26,7 +26,7 @@ reads any container version its type was written in.
26
26
  | `intakeBeast2For(T)(delivery, sink, opts?)` | A collection from outside — a `Beast2SyncRangeReader` over a v4 or v5 blob whose header names exactly `T` — through the Writer into a `Beast2ManifestSink`, a segment at a time: each row is walked by its type, the Writer's own bytes go on as they stand, and any other row is decoded and written again. `opts.segments` takes in the index's segments `[from, to)`, a piece of a large delivery. Refuses another type, a malformed segment or one over `RUN_MAX_BYTES`, a row that does not decode, and keys that do not ascend, with `Beast2IntakeError` in the words every runner uses. What e3's intake units run, on every runner |
27
27
  | `new Beast2Writer(T, sink)` · `encodeBeast2SegmentsFor(T)(batches)` | Segments of your own choosing: one per non-empty batch, Set/Dict batches in ascending order |
28
28
  | `iterBeast2SegmentsFor(T)(blob)` | One decoded segment at a time |
29
- | `openBeast2PagesFor(T)(source)` | Random access: `.elementCount` and `.segmentCount` in O(1); `.segment(i)`, `.element(row)`, `.slice(offset, limit)` and `.get(key)` decode only the segments they touch |
29
+ | `openBeast2PagesFor(T)(source)` | Random access: `.elementCount` and `.segmentCount` in O(1); `.segment(i)`, `.element(row)`, `.slice(offset, limit)` and `.get(key)` decode only the segments they touch. `.rowRange(from, to)` gives the rows `{ lo, hi }` of a Set or Dict between two bounds — each a test "is this key at or past it?", as `SortedMap.range` takes — reading at most one segment for each end, the one before the first segment that starts at or past it, which may hold none of the range's rows; `.slice(lo, hi - lo)` then reads them |
30
30
  | `openBeast2LazyFor(T, { frozen? })(source)` | An ordinary `SortedMap` / `SortedSet` / array served from the index, a segment at a time — what `blob.openBeast` and `FileSystem.openBeast` return, frozen. `isBeast2LazySafe(T, { frozen })`: only `Ref`- and function-bearing shapes decode whole |
31
31
  | `Beast2SyncRangeReader` — `{ size, read(offset, length) }` | Positioned reads, wherever a blob goes, so a file's bytes never sit on the heap whole; `readBeast2Extents` / `readBeast2ExtentsRanged` (HTTP, S3) read the geometry |
32
32
  | **Segment manifests** — one object per segment plus a manifest naming them: how e3 stores a collection |
@@ -69,6 +69,15 @@ openBeast2PagesFor(Rows)(blob).element(4_000_000); // one row: decodes ONE segm
69
69
  `$.for` cost one segment, mutation is refused (`.copy()` first), and the
70
70
  header type is checked against `T` first. `East.Blob.encodeBeast` writes no
71
71
  index, so a paged blob comes from the writers above or a runner's output.
72
+ - **A key range of a lazy Set or Dict is read at the cost of the range.**
73
+ `d.range({ from, to })` and `d.prefix({ … })` on a lazy input give a
74
+ collection that still reads from the input's pager: making it reads nothing,
75
+ `.size()` reads at most one segment for each end — the one before the first
76
+ segment that starts at or past it — and none between, a keyed read tests the
77
+ bounds first, and a `$.for` reads the segments between the ends once each. It is a new collection — not frozen, though its input is — so a body
78
+ may change it, which decodes its own rows and leaves the input lazy, as any
79
+ other read of it does. A range of a range reads nothing outside the range.
80
+ From the host, a lazy value's `.range(from, to)` is the same.
72
81
  - **A `$.for` over a lazy input decodes each segment to the fields its body
73
82
  reads** of each row — an Array's element, a Dict's value — on every runtime:
74
83
  read through field accesses (`row.total`, `row.address.city`), inner loops
@@ -175,7 +175,8 @@ Task → What do you need?
175
175
  │ ├─ Query one with jq → East.jq(value, "jq", T) runs now · evaluate_jq(program, value, input_type=T) · check_jq checks
176
176
  │ │ without running → "Queries — East.jq"
177
177
  │ ├─ A JSON contract another system validates against → json_schema_for · type_from_json_schema → "A JSON contract"
178
- │ ├─ A collection file larger than memory → write_beast2_file · open_beast2_file (a read-only East collection value) ·
178
+ │ ├─ A collection file larger than memory → write_beast2_file · open_beast2_file (a read-only East collection value;
179
+ │ │ f.range(from_=…, to=…) / f.prefix({…}) read the entries between two keys at the cost of the range) ·
179
180
  │ │ write_beast2_file_parallel · splice_beast2_files · Beast2ManifestWriter · open_beast2_pages_for → "Beast2 streaming"
180
181
  │ ├─ Logic genuinely needs python (numpy, a model, a solver) → to_columns · from_columns · map_batches · update_many ·
181
182
  │ │ extend · to_numpy / to_torch → "Columnar escape hatches"
@@ -402,7 +403,12 @@ Read the one a task needs; each holds its sections whole.
402
403
  - **Task inputs arrive frozen**: mutating one raises `cannot mutate a frozen
403
404
  value (task inputs are immutable) — copy first`; `.copy()` gives a mutable
404
405
  value. Keyed gets and iteration on a paged input stay O(segment) through the
405
- proxy, and frozen collections compare by value under `Is`. The same frozen
406
+ proxy, and frozen collections compare by value under `Is`. A key range of
407
+ one — `d.range(from_=…, to=…)`, `d.prefix({…})`, in a body or on the proxy —
408
+ still reads from the pager: its size reads at most one segment for each end
409
+ — the one before the first segment that starts at or past it — and none
410
+ between, iterating it reads its segments, and it is a collection of its own, which a
411
+ change decodes and changes without touching the input. The same frozen
406
412
  paged value comes from `blob.open_beast(T)` and from `fs_open_beast` in
407
413
  **east-py-std**; an input e3 stages as a manifest directory opens the same
408
414
  way, reading only the segment files a read lands in.
@@ -33,6 +33,7 @@ name.
33
33
  | `len(f)` · `f.segment_count` · `f.self_contained` · `f.indexed` | O(1) from the trailing index, exact for every root kind |
34
34
  | Array: `f[i]` / `f[a:b]` · `f.get(i)` ❗bounds · `f.get_or_default(i, d)` · `f.try_get(i)` · `f.has(i)` · `f.slice(a, b)` · `f.get_keys(rows)` | `EastArray`'s names, signatures and errors; a point read decodes only the owning segment, `get_keys` each owning segment once |
35
35
  | Dict: `f[k]` ❗KeyError · `f.get(k[, default \| fn(k)])` · `f.get_or_default(k, d)` · `f.try_get(k)` · `f.has(k)` / `k in f` · `f.get_keys(keys, fill)` · `f.items()` / `values()` / iteration (streaming) · `f.keys()` (the Set) · `f.size()` — Set: `x in f` / `f.has(x)` | east-c binary-searches the segment *fences* (each segment's first key, from a bounded probe, cached), then decodes ONLY the owning segment (a small LRU keeps hot ones); `get_keys` merges the sorted keys against the fences and calls `fill` per missing key. The first keyed read verifies the fences: a corrupt or pre-contract blob raises `segments are not disjoint ascending key ranges` instead of reporting false misses |
36
+ | Dict, Set key range: `f.range(from_=…, to=…)` · `f.prefix({…})` | The entries from the first key at or past `from_` up to the first at or past `to` (either left out for that end of the file), and those whose key begins with given fields — a bound is the whole key, or a struct key's first fields as a dict. A READ-ONLY `EastDict` / `EastSet` over the same open file, read at the cost of the range: each end reads at most one segment — the one before the first segment that starts at or past it, which may hold none of the range — its size reads no segment between them, a keyed read tests the bounds first, iterating it reads its segments each once, and any other method decodes its own rows and runs on those. It holds the file open — `close()` defers until it is dropped — and `.copy()` gives a collection to change. Under `project=` the range's rows are read as it is made, the segments they span each once, projected. Either way it refuses a change at any depth. A bound that is no leading part of the key, or a `prefix(None)`, raises `EastTypeError` naming the key's fields; a bound written in a function's body raises `ExpressionError` — pass the file to the function (`.bind(f)`) and take the range of its parameter, which the pager serves |
36
37
  | Array sorted search: `f.find_sorted_first/last(target)` → a global index · `f.find_sorted_range(target)` → `{start, end}` | `EastArray`'s contract over the whole file, only the boundary segment decoded; no `key=` projection (the file pages in element order) — pair with `f.slice(start, end)` |
37
38
  | Compute: `map` `filter` `filter_map` `first_map` `reduce` `scan` `map_reduce` `sum` `mean` `maximum` `minimum` `every` `some` `find_*` `is_sorted` `to_set` `unique` `to_dict` `to_array` `to_columns` `map_batches` `string_join` `flat_map` (Array) / `flatten_to_array` (Set, Dict) `flatten_to_set` `flatten_to_dict` `for_each`, the whole `group_*` family, Set algebra | Each segment runs the ordinary eager method, and partials combine in east-c in stream order: order-dependent folds thread ONE accumulator and grouped folds seed each segment from the running per-group accumulators, so results equal `load()` exactly, float order included. Array `(el, idx)` callbacks, and the indices `find_*` / `group_find_*` report, are GLOBAL; `first_map`/`some`/`every`/`is_superset_of` stop decoding at the answer. Dict/Set compute streams disjointness-verified segments. A re-keyed collision (`to_dict`, `flatten_to_dict`, `group_to_dicts`) combines left-associatively in stream order — use an associative `combine`. `sort`/`reverse`/`copy`/`concat`/`union` materialize the collection — `load()` first |
38
39
  | Column projection — INFERRED on the compute family; EXPLICIT with `open_beast2_file(path, project=NARROW)` | The compute family builds its callbacks FIRST and decodes each segment to just the struct fields their IR reads (the rest are hopped over, never built — building values, not walking bytes, is what decoding costs). Fields subset by name at any depth; a subtree used any other way stays whole, so results never change; Dict keys and Set elements never narrow. Runner-opened task inputs infer the same from the body's loop IR. What cannot be inferred decodes whole and is COUNTED in `eager_stats()` (`beast2_segments_projected/whole`, `beast2_projection_declined_*` by reason) — a projection that silently stopped applying would be an invisible cliff. The explicit form serves the subset to EVERY read (point reads, keyed gets, `load()`); `project` must be a subset of the wire type (a missing field raises `ValueError` naming it), a declared `T` keeps its meaning, and `find_sorted_*` refuse under it. A segment decoded under one mask is never served to a read needing more. No wire change |
@@ -239,6 +239,14 @@ Rules:
239
239
  config)`.
240
240
  - Optional dependencies gate at call time: a function raises
241
241
  `NotImplementedError` naming the missing extra (`east-py-datascience[causal]`).
242
+ - **Ask for torch through the extras**
243
+ (`elaraai-east-py-datascience[torch,lightning]`), and list no `torch` of the
244
+ project's own: the extras pin the torch the release was tested with, which
245
+ its rack tier image holds, so a task on a rack is not sent torch. That holds
246
+ for torch from PyPI: a pin with no local label is met by a PyTorch index's
247
+ `+cpu` or `+cu130` build too, which is not the image's, and is sent.
248
+ - **Python 3.12 or later**, and xgboost 3.4 or later beside torch: an earlier
249
+ xgboost brings another NCCL library over torch's, and `import torch` fails.
242
250
 
243
251
  For the East-value API (eager methods, `coerce_to`, `to_numpy` / `to_torch`,
244
252
  `@East.platform_function`), load the **east-py** skill.
@@ -145,6 +145,7 @@ Task → Which tag?
145
145
  │ ├─ <Deck data={rows} statuses={Deck.statuses({…})} card={r => ({ key, title, status, metrics, fill })} /> — status-coloured mini-card board (display, not a drag source)
146
146
  │ ├─ <Blend targets={…} config={{…}} /> — blend / batch assembly surface fed by a Library; 1 target single, 2 compare, 3+ portfolio
147
147
  │ ├─ <Slice.Rail slice={slice} affordances={[…]} /> — narrowing chrome over one bound dataset (Slice.bind); consumers read Slice.rows(slice)
148
+ │ │ └─ one rail over several records' paged sources → Slice.bindRecords(key, { <source>: { source, fields?, initial?, scope? } }) — the e3-ui builders' slice; scope ({ press: [press] }) is the page's, the rail shows no control for it, and its source lists an index on exactly its fields (index.on(["press"])), which Search Records seeks the page's rows through — and, read by area, an area index led by them (index.area({ on: ["press"], … }))
148
149
  │ ├─ <Pagination> — page-number control
149
150
  │ └─ <Plan>, <Sheet>, <Calendar>, <Roster>, <Allocation>, <Flowchart>, <Schematic> — the planning builders are e3-ui's (`import { Plan } from "@elaraai/e3-ui"`)
150
151
  ├─ Charts (visualize data) — layers are a config array of factory values, never child tags