@elaraai/east-codex-plugin 1.0.107 → 1.0.109
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.
- package/.build/daemon/lsp.js +55 -7
- package/.build/daemon/server.js +53 -5
- package/.codex-plugin/plugin.json +1 -1
- package/index.json +1698 -191
- package/package.json +1 -1
- package/skills/e3/SKILL.md +16 -8
- package/skills/e3/reference/cli.md +1 -0
- package/skills/e3/reference/from-code.md +2 -2
- package/skills/e3/reference/rack.md +69 -12
- package/skills/e3/reference/record-indexes.md +198 -7
- package/skills/e3/reference/repository.md +1 -0
- package/skills/e3-ui/SKILL.md +80 -68
- package/skills/east/SKILL.md +9 -4
- package/skills/east/reference/beast2.md +10 -1
- package/skills/east-py/SKILL.md +8 -2
- package/skills/east-py/reference/beast2.md +1 -0
- package/skills/east-ui/SKILL.md +1 -0
package/skills/e3-ui/SKILL.md
CHANGED
|
@@ -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
|
-
│
|
|
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
|
|
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,
|
|
154
|
-
│ ├─ Event kinds over records too large to read whole → the kind's source over its interval index (range: "start") + Schedule.events(record, { entries })
|
|
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
|
|
161
|
-
│ ├─
|
|
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 +
|
|
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(
|
|
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
|
|
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
|
|
243
|
-
│ ├─ The app's optimiser over the
|
|
244
|
-
│ ├─ An optimiser that sees the week's edges → Roster.Types.OptimiseRequest(
|
|
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(
|
|
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
|
|
262
|
-
│ ├─ The app's optimiser over the day → optimise={Func.bind(e3.function)} from Allocation.Types.OptimiseRequest(
|
|
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.
|
|
331
|
-
|
|
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()
|
|
338
|
-
|
|
339
|
-
|
|
340
|
-
|
|
341
|
-
|
|
342
|
-
|
|
343
|
-
|
|
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
|
|
350
|
-
|
|
351
|
-
|
|
352
|
-
|
|
353
|
-
function
|
|
354
|
-
|
|
355
|
-
|
|
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` / `
|
|
367
|
-
|
|
368
|
-
|
|
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 (
|
|
380
|
-
|
|
381
|
-
`
|
|
382
|
-
|
|
383
|
-
|
|
384
|
-
|
|
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
|
-
|
|
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`
|
|
393
|
-
|
|
394
|
-
|
|
395
|
-
|
|
396
|
-
|
|
397
|
-
|
|
398
|
-
|
|
399
|
-
|
|
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
|
-
|
|
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
|
|
package/skills/east/SKILL.md
CHANGED
|
@@ -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
|
-
|
|
192
|
-
|
|
193
|
-
|
|
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
|
package/skills/east-py/SKILL.md
CHANGED
|
@@ -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`.
|
|
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 |
|
package/skills/east-ui/SKILL.md
CHANGED
|
@@ -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
|