@lotics/cli 0.318.25 → 0.318.26
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/dist/src/cli.js +178 -165
- package/dist/src/client.js +1 -1
- package/docs/agent_surface.md +19 -20
- package/docs/app_architecture.md +5 -5
- package/docs/building_an_app.md +1 -1
- package/docs/cli_reference.md +2 -2
- package/docs/design.md +27 -47
- package/docs/examples.md +180 -212
- package/docs/first_build.md +46 -45
- package/docs/workflows.md +8 -3
- package/docs/working_in_a_workspace.md +1 -1
- package/package.json +1 -1
package/dist/src/client.js
CHANGED
|
@@ -435,7 +435,7 @@ var LoticsClient = class {
|
|
|
435
435
|
return this.request("GET", "/v1/workspaces/dangling-references");
|
|
436
436
|
}
|
|
437
437
|
// ── App iframe RPC endpoints ──────────────────────────────────────────────
|
|
438
|
-
// These mirror the two ops handled by frontend/features/app_ui/
|
|
438
|
+
// These mirror the two ops handled by frontend/features/app_ui/app_frame.tsx.
|
|
439
439
|
// The deployed iframe sends postMessage to the parent frontend, which calls
|
|
440
440
|
// these same endpoints via the user's session cookie; here they run under the
|
|
441
441
|
// client's API key.
|
package/docs/agent_surface.md
CHANGED
|
@@ -11,9 +11,9 @@ reach them, over MCP and as `lotics run <tool>`:
|
|
|
11
11
|
| `run_app_workflow` | One write — or several in order — or a dry run of it that writes nothing |
|
|
12
12
|
|
|
13
13
|
An app generates this surface from its tree; Query and Workflow nodes declare what the screen never
|
|
14
|
-
asks (§ Declaring more).
|
|
15
|
-
Lists and its Acts are queries and workflows of the same app, named by that List's table
|
|
16
|
-
|
|
14
|
+
asks (§ Declaring more). Every root List of an app (a change may add one at any time) is part of it: each List's list, its rows by id, its page's
|
|
15
|
+
Lists and its Acts are queries and workflows of the same app, named by that List's table — `get_app` lists them in the
|
|
16
|
+
one roster, and nothing of a root List is another app's. Every caller the app is shared with is answered them, its rows narrowed by the app's row rules. A custom-code app's surface is the queries and workflows bound on it
|
|
17
17
|
(`app_bindings`).
|
|
18
18
|
|
|
19
19
|
## Finding what an app offers
|
|
@@ -31,8 +31,8 @@ app has.
|
|
|
31
31
|
|
|
32
32
|
| Called | What it says of itself | Takes | Generated for |
|
|
33
33
|
|---|---|---|---|
|
|
34
|
-
| `<entity>_list` | Every row of <entity> the reader may see. | `search`?; `<scope entity>_id` where the app states `scope`; `<filter>_is`? per List `filters` field holding one value — a select, a one-row link, a member, a yes/no; `<filter>_from`? / `<filter>_to`? per date filter — none for a date holding a span; `<filter>_min`? / `<filter>_max`? per number filter — none over
|
|
35
|
-
| `<entity>_list_<tab>` | The <entity> rows of the tab "<tab>". | the list's; `from`? / `to`? on a tab dated `in` a period; `to` on a tab of rows `open` on a day | each Tab of the register; none over
|
|
34
|
+
| `<entity>_list` | Every row of <entity> the reader may see. | `search`?; `<scope entity>_id` where the app states `scope`; `<filter>_is`? per List `filters` field holding one value — a select, a one-row link, a member, a yes/no; `<filter>_from`? / `<filter>_to`? per date filter — none for a date holding a span; `<filter>_min`? / `<filter>_max`? per number filter — none over sources, none for a looked-up link or member, none for a number read in each row's own unit or currency | every entity the app draws; the filter params on the app's own entity alone |
|
|
35
|
+
| `<entity>_list_<tab>` | The <entity> rows of the tab "<tab>". | the list's; `from`? / `to`? on a tab dated `in` a period; `to` on a tab of rows `open` on a day | each Tab of the register; none over sources, none for a Tab whose period reads a date holding a span |
|
|
36
36
|
| `<entity>_totals_<tab>` | The <child> rows added per <entity> row, by "<link>", over the period from `from` to `to`, dated by "<date>": . | `from`; `to` | each Tab of the register stating `totals` |
|
|
37
37
|
| `<entity>_record` | One row of <entity> by its id. | `<entity>_id` | every entity the app draws |
|
|
38
38
|
| `<child>_by_<link>` | The <child> rows under one <entity>, through "<link>". | `<entity>_id` | each List of child rows on the record; one narrowed by `where` or ordered by `sort` adds `_<field>_<option>` and `_sorted_<field>` to its name |
|
|
@@ -41,15 +41,13 @@ app has.
|
|
|
41
41
|
| `<child>_by_<link>_days` | The <child> rows of the <entity> rows handed in whose "<day>" falls from one day to another. | `<entity>_ids`; `from`; `to` | a roster List: the List of its cells |
|
|
42
42
|
| `<entity>_<link>_pick` | The <target> rows "<link>" may point at, narrowed by what the reader typed. | `search`?; `same_<link>` per `same` link | a written link a write rule narrows (`options_where`, `same`) |
|
|
43
43
|
| `<child>_by_<link>_picks` | The <child> rows no <entity> holds through "<link>" yet, that one <entity> may pick, narrowed by what the reader typed. | `search`?; `same_<link>` per `same` link | a List with `pick`: it picks existing rows into the record |
|
|
44
|
-
| `<
|
|
45
|
-
| `<
|
|
46
|
-
| `<
|
|
47
|
-
| `<entity>_<key>` | <label>: how many <entity> rows there are. Each row carries `__count`. | the list's; `from`? / `to`? where the reading states `over` | each Reading of a log's List, called `<entity>_<key>` |
|
|
48
|
-
| `<entity>_<key>` | <label>: how many <child> rows there are. Each row carries `__count`. | `<entity>_id`; `same_<field>` where it is a list stating `same` | each Reading of the record a row of a Book or of a log opens and each List or funnel on it, called `<entity>_<key>` by the Book's or the log's entity |
|
|
44
|
+
| `<key>` | <label>: how many <entity> rows there are. Each row carries `__count`. | the list's; `from`? / `to`? where the reading states `over`, or its `tab` is dated `in` a period; `to` where its `tab` is of rows `open` on a day | each Reading of a List's band, called by its `key` — but the work against its plan (a Reading stating `planned` and `done`), which reads the List's own rows; none over sources |
|
|
45
|
+
| `<key>` | <label>: how many <entity> rows there are. Each row carries `__count`. | `from`? / `to`? where the reading states `over` | each Reading and List of a Sheet, called by its `key` |
|
|
46
|
+
| `<key>` | <label>: how many <child> rows there are. Each row carries `__count`. | `<entity>_id`; `same_<field>` where it is a List stating `same` | each Reading of a Record page, each List that only reads on it (its `key`, else its entity's alias) and each funnel, called by its `key` |
|
|
49
47
|
| `<reading>_bound` | <label> / <bound>: the sum of "<bound>" over the <entity> rows. Each row carries `__count`, `__sum`. | its reading's | a Reading whose value `records.limits` bounds: the bound's sum, beside the Reading's own |
|
|
50
48
|
| `<reading>_on_hand` | <label> / <on-hand entity>: how many <on-hand entity> rows there are, per "<field>". Each row carries `<field>`, `__count`. | none: every row of its entity its `where` keeps, whatever the place | a Reading with `on_hand` (a shortfall): the on-hand rows' groups, beside the Reading's own |
|
|
51
49
|
| `<entity>_export_rows` | Every row of <entity> the reader may see, with every field "<template>" may print. | the list's | an Export of the register that fills a template |
|
|
52
|
-
| `<entity>_export_rows_of_<
|
|
50
|
+
| `<entity>_export_rows_of_<source>` | Every row of <entity> the reader may see, with every field "<template>" may print. | the list's | an Export over some of a List's sources: their rows alone, each source named in turn |
|
|
53
51
|
| `<entity>_moves` | Each move in <history> of the <entity> rows handed in: the status it went to, when and by whom, earliest first. | `<entity>_ids` | an entity whose status keeps a history (`records.status.history`) |
|
|
54
52
|
| `<entity>_plan_load` | How many <entity> rows each <place> holds, over every table the register reads — the rows with no <place> counted apart. | | a register laid out as a `plan`: its places' counts of present rows |
|
|
55
53
|
|
|
@@ -60,8 +58,7 @@ splits by, or per day. Each row carries the alias of each field it splits by, `_
|
|
|
60
58
|
day, `__count`, and `__sum` where it sums a number; its description states which. An average is `__sum`
|
|
61
59
|
over `__count`, both over the rows holding a value.
|
|
62
60
|
|
|
63
|
-
A Reading is called by its `key` (`reference/reading-node`), so
|
|
64
|
-
log's table before the name: `<entity>_<key>`.
|
|
61
|
+
A Reading is called by its `key` (`reference/reading-node`), and a List that only reads by its `key`, else its entity's alias — wherever its List stands in the app, so a move in the tree changes no name. Each is its own among the app's Readings, Lists that only read and Queries.
|
|
65
62
|
|
|
66
63
|
A register reading's query reads the rows it names, whatever a screen has open: the rows of its `tab` where
|
|
67
64
|
it states one, every tab's where it states none — its description says which. One placed in time (`over`)
|
|
@@ -81,7 +78,7 @@ the screen already holds.
|
|
|
81
78
|
| `<entity>_pictures` | The picture and name of each <entity> row among the ids handed in. | `<entity>_ids` | a link to several pictured rows |
|
|
82
79
|
| `<entity>_count_by_<scope>` | How many <entity> rows each <scope entity> holds. | | an app stating `scope` |
|
|
83
80
|
| `<task>_progress_by_<link>` | How many <task> rows each <entity> row handed in holds, at each status. | `<entity>_ids` | rows whose task rows are counted done |
|
|
84
|
-
| `<rows>_measured_by_<link>` | The share of each <entity> row handed in its <rows> rows add, day by day. | `<entity>_ids` | a
|
|
81
|
+
| `<rows>_measured_by_<link>` | The share of each <entity> row handed in its <rows> rows add, day by day. | `<entity>_ids` | a Reading stating `planned`, `done` and `measured` |
|
|
85
82
|
| `<entity>_sub_counts_by_<link>` | How many <entity> rows stand under each <entity> row handed in, through <link>, at each status. | `<entity>_ids` | a record's rows block over a hierarchy (`nests`), for the rows it draws |
|
|
86
83
|
| `<entity>_plan_places` | Every <place> the <entity> rows stand at, with what the plan draws of each. | | a register laid out as a `plan`: the places its rows stand at |
|
|
87
84
|
| `<lane>_lanes` | The <lane> rows of one <scope entity>, each a lane of the board. | `<scope entity>_id` | a lanes board inside an app stating `scope` |
|
|
@@ -101,7 +98,6 @@ the screen already holds.
|
|
|
101
98
|
| `restore_<entity>` | Brings back one deleted row of <entity>. | `record_id` | an entity the app removes rows of |
|
|
102
99
|
| `act_<act>` | <label> — on one row of <entity>, refused where its conditions do not hold. | `record_id` — `record_ids` on an act over several rows — and what the act asks | each Act that names no workflow of its own |
|
|
103
100
|
| `archive_<act>` | Hands back every file of <label> on one row of <entity> as one archive. | `record_id` | an Act making a set of papers (`templates`) |
|
|
104
|
-
| `<workflow>_<book>` | The workflow of that name as a Book of the app, or a log of it, runs it, where its own table or page makes it differ. | that workflow's | an app with Books or logs |
|
|
105
101
|
|
|
106
102
|
<!-- generated:end workflows -->
|
|
107
103
|
|
|
@@ -136,10 +132,10 @@ take are the ones on the query's `returns` line.
|
|
|
136
132
|
A list's params are how a person narrows that register: `search`, the row's id on an app that works inside
|
|
137
133
|
one row (`scope`), and a param for each filter the register states that one value or a range narrows. A
|
|
138
134
|
filter with no param — on a looked-up link or member, on a number read in each row's own unit or currency,
|
|
139
|
-
on a date holding a span, or on a
|
|
135
|
+
on a date holding a span, or on a List of several tables (`sources`) — is narrowed by `filters`, where a
|
|
140
136
|
number condition names the unit its value is in as `unit_option`, an option of the figure's select by label
|
|
141
137
|
or key. Each tab of a register is a query of its own, taking the list's params and the period its rows are
|
|
142
|
-
read over.
|
|
138
|
+
read over; a tab's totals take the folder's id too, in an app that works inside one row.
|
|
143
139
|
|
|
144
140
|
## Exporting a file
|
|
145
141
|
|
|
@@ -149,7 +145,7 @@ run_app_query {"app_id":"app_…","export":{"key":"by_carrier","per":"…","tab"
|
|
|
149
145
|
|
|
150
146
|
`export` makes the file the register's Export button makes, from what the caller reads, and answers it under `files` as a workspace
|
|
151
147
|
file like any other a tool makes: `file_id`, `url`, `filename`, `mime_type`. `key` is the
|
|
152
|
-
key of an Export
|
|
148
|
+
key of an Export of a List in `get_app`'s tree, at the root or below a row's page; it is sent without `alias` or any other argument of a
|
|
153
149
|
read. An option is named by its name or its id, as a read's filters name it; a member by its id or its name, for a member
|
|
154
150
|
of the app's organization; a row, by its id. The other keys
|
|
155
151
|
narrow the file as the register's own controls do, each absent one leaving the register's opening view:
|
|
@@ -162,6 +158,7 @@ narrow the file as the register's own controls do, each absent one leaving the r
|
|
|
162
158
|
| `filters` | `{ "<field>": <value> }` by the field's alias, a value `null` clearing the register's opening chip; a value is one of the shapes below |
|
|
163
159
|
| `search`, `overdue`, `waiting` | Words searched, one line each of a pasted list; `true`: only the rows past a deadline; `true`: only the rows waiting on the caller |
|
|
164
160
|
| `sort`, `group`, `folder` | `{ "field", "dir" }`; a field alias; a folder id |
|
|
161
|
+
| `row` | The id of the row whose rows a List below a row's page exports: required there and refused on a root View, and the reader must be able to open that row |
|
|
165
162
|
|
|
166
163
|
| A `filters` value | For a field that is |
|
|
167
164
|
|---|---|
|
|
@@ -185,7 +182,7 @@ run_app_workflow {"app_id":"app_…","alias":"act_hand_over","inputs":{"record_i
|
|
|
185
182
|
|---|---|
|
|
186
183
|
| `inputs` | The workflow's declared inputs. An update takes the record and only the fields that change |
|
|
187
184
|
| `dry_run` | `true`: the run is made and taken back, so nothing is kept, and the answer is what the run would return, with the calls it would make — or `status: "not_previewed"` where the workflow cannot be dry-run (§ A dry run) |
|
|
188
|
-
| `as_member` | With `dry_run`, for a workspace admin: the run is judged as that member would press it — their stage owners, row rules and app access — and writes nothing. Anyone else is refused; `dry_run` on a record tool takes it the same way, and so
|
|
185
|
+
| `as_member` | With `dry_run`, for a workspace admin: the run is judged as that member would press it — their stage owners, row rules and app access — and writes nothing. Anyone else is refused; `dry_run` on a record tool takes it the same way, and so do `query_records` and `run_app_query`, which answer what that member would read, and `screenshot_app`, which draws the app as that member sees it |
|
|
189
186
|
| `runs` | Several runs in one call, 50 at most, in order, each its own write, answered under `runs`. The first one refused, failed or not dry-run ends the call. An input `{"from_run": 0, "path": "data.record_id"}` is an earlier run's answer at that path. A run states its own `dry_run`, or takes the call's. Dry runs one after another share their rows, taken back together, so a run reads what the one before it made; a run reads a dry run's answer only from a run dry-run in that stretch |
|
|
190
187
|
|
|
191
188
|
```
|
|
@@ -195,6 +192,8 @@ run_app_workflow {"app_id":"app_…","runs":[
|
|
|
195
192
|
]}
|
|
196
193
|
```
|
|
197
194
|
|
|
195
|
+
An act that reads papers (`intake`) is read by the caller: no platform agent reads for it. Its save `act_<alias>` takes `fields` (what the papers state), `rows` (the child rows listed) and `papers` (`[{"file":"fil_…","kind":"<option>"}]`), and `dry_run` shows the record and rows it would make.
|
|
196
|
+
|
|
198
197
|
## A dry run
|
|
199
198
|
|
|
200
199
|
A dry run is the run itself on the real inputs, taken back: it is made in a transaction that is rolled back, so a read after a write reads that write, a branch or a loop walks the values the run would hold, and a call fed by an earlier call's answer gets it. No row, number, event, audit entry or table workflow outlives it. A write of the workspace's rows is made by its table — checks, write rules, stage owners — and the first refusal is the dry run's answer. A connected service's read-only call is made; a service write, a send, a notification or a button that runs another workflow is not, and is answered as a "would" with its payload. A guard (`when`, `requires`, a check, a lock) refuses it with the press's own sentence. A paper it makes is rendered for the answer and its file is removed with the dry run; an act that makes a paper is dry-run like any other, never refused for it. A body that sets the record's status also answers `moves`. Its answer carries `status`,
|
|
@@ -285,7 +284,7 @@ Acts: every figure or list whose definition is the business's own (open orders,
|
|
|
285
284
|
```
|
|
286
285
|
|
|
287
286
|
It reads under the app's `rows` (every row, where the app states none of the table) and, on the app's own table, exactly the rows its list reads —
|
|
288
|
-
so never the table of an app
|
|
287
|
+
so never the table of an app whose List reads `sources`, several tables. A condition reading an
|
|
289
288
|
optional param narrows nothing when the call leaves it out; no param compares a number read in each row's
|
|
290
289
|
own unit or currency, or a date holding a span. `"reading"` in place of `"fields"` returns a count or a sum —
|
|
291
290
|
`{ "value": "price", "by": "item" }` — as a Reading does. A Query, a Workflow and
|
package/docs/app_architecture.md
CHANGED
|
@@ -2,19 +2,19 @@
|
|
|
2
2
|
|
|
3
3
|
The rule that splits a business into apps is in `first_build`, § 3: one app per main entity, and everything that belongs to a row on that row's page. This is one split it produces, settled before any tree is written, since it decides who sees what.
|
|
4
4
|
|
|
5
|
-
One
|
|
5
|
+
One bakery's wholesale arm, five people, seven apps:
|
|
6
6
|
|
|
7
7
|
| App (its list) | Opened by | On a row's page |
|
|
8
8
|
|---|---|---|
|
|
9
9
|
| Customers | Sales rep, owner | Their prices, orders and unpaid invoices |
|
|
10
|
-
| Products | Sales rep,
|
|
11
|
-
| Orders | Sales rep,
|
|
12
|
-
|
|
|
10
|
+
| Products | Sales rep, head baker | Price breaks, recipe, stock on hand |
|
|
11
|
+
| Orders | Sales rep, head baker, owner | Lines, the quote paper (an Act), the bake orders it starts |
|
|
12
|
+
| Bake orders | Head baker | Steps, the Acts that move a stage, the tasting |
|
|
13
13
|
| Suppliers | Buyer | Their price list and purchase orders |
|
|
14
14
|
| Purchase orders | Buyer, storekeeper | Lines, goods received |
|
|
15
15
|
| Materials | Storekeeper, buyer | Movements in and out, the Receive and Issue Acts |
|
|
16
16
|
|
|
17
|
-
An order's lines, a
|
|
17
|
+
An order's lines, a bake order's steps and a customer's prices make sense only under their parent: each is a child
|
|
18
18
|
List on that row's page, never an app or a Tab. An order stands in the Orders app and on its customer's page: one
|
|
19
19
|
record, one page. The owner reads the figures each register leads with. Each app's `name` is its list and its `description` says what is worked there:
|
|
20
20
|
|
package/docs/building_an_app.md
CHANGED
|
@@ -18,7 +18,7 @@ you tried it, stay where they are. Try a write on a throwaway record.
|
|
|
18
18
|
|
|
19
19
|
- **An app stated as a tree** — the default, and the right one for almost every job. The tree (a
|
|
20
20
|
JSON file, one per app) is a List of one table, whose rows are recognised by the
|
|
21
|
-
table's own `records`, and the page its rows open (`pages`), with the
|
|
21
|
+
table's own `records`, and the page its rows open (`pages`), with the Lists and Sheets that stand beside it at the root as peers (which a change may add at any time, each a View of its own, shown to whoever the app is shared with): its columns and filters, its Sections in the order its work
|
|
22
22
|
reaches them, its Acts and the Checks that guard them (`lotics docs reference/app-tree`,
|
|
23
23
|
`reference/list-node`, `reference/section-node`, `reference/act-node`, `reference/check-node`). The platform
|
|
24
24
|
compiles each app and draws it with the runtime every such app shares, so how each piece looks is
|
package/docs/cli_reference.md
CHANGED
|
@@ -47,8 +47,8 @@ Per-command syntax, flags, contracts, and gotchas for the public `lotics` CLI. S
|
|
|
47
47
|
| `lotics knowledge rm <id...>` | Delete docs via `set_knowledge` (`{ knowledge_doc_id, delete: true }`), one call per id: each must be a live doc you manage that no app or workflow names, and the command reports which succeeded and which failed. Sharing and history are kept. The REST execute path does not gate `needsApproval`, so this runs unattended. |
|
|
48
48
|
| `lotics knowledge restore <id...>` | Bring deleted docs back via `set_knowledge` (`{ knowledge_doc_id, restore: true }`), one call per id: each must be a deleted doc you manage, and the command reports which succeeded and which failed. Refuses the no-argument form. |
|
|
49
49
|
| `lotics app create <name> --custom [path]` | **A custom-code app**: creates the app (`POST /v1/apps`) and links `[path]` (default `./<name>`, made when absent) to it by writing `package.json#lotics` (the app and its workspace, which is how `app deploy` in that directory finds both) — into the project's own `package.json` when it has one, every other key kept, otherwise a `package.json` holding the link alone. Nothing else is written and nothing is installed: the project is yours. `app deploy` needs `@lotics/app-sdk` (React 19) and an `npm run build` that writes a static `dist/` with an `index.html`. A directory already linked to an app is refused before the app row exists. The app has no version until the first `lotics app deploy`. `--custom` is required: a JSON app is made by `lotics app apply` (the tool `set_app`). The SDK's reference is `node_modules/@lotics/app-sdk/AGENTS.md` once the project installs it. |
|
|
50
|
-
| `lotics app pull [app_id] [path]` | **An app's live definition, pulled.** The app is read with `get_app`: its author is shown a body, a JSON **tree** (with the addresses of its nodes) pulled as that tree and a custom-code app (the identity alone) as its source; an app whose stored tree
|
|
51
|
-
| `lotics app apply <file> [--app <app_id>] [--check] [--json]` | **A JSON app, one at a time, through the tool `set_app`.** The file is an app's tree (`lotics docs reference`: the App node with the nodes under it, its tables and templates named by alias). **No app known** (no `--app`, no `<file>.lotics.json` beside it): the file is sent as `{ "body": … }` to make a new app, named by the body's `name`, and the id made is printed, then recorded with its version in `<file>.lotics.json`. **An app known**: its current tree is read (`get_app`) and the **RFC 7396 merge patch** that turns it into the file is sent as `body` with the `app_id` and the version the patch was computed against as `base_version_id` — a key the file drops is `null` in the patch, a list is replaced whole, what the file leaves alone is left alone, and a tree the app already has sends nothing and says so. **A file pulled at a version the app has since left is refused** where the stored tree changed since the pull (a version that moved only for a workflow's body applies) before anything is sent, naming both versions and `lotics app pull <app_id> <path>`: pull the current tree into another path, carry the edits over, apply that file. `--app` naming an app other than the sibling file's is refused too. A write that races the apply is refused by the server, which names the app's current version. A file that sets an object key to `null` is refused naming the key, since a merge patch reads `null` as a removal. `--app` names the app, else the sibling file does; an app whose `get_app` shows no body (it is not yours)
|
|
50
|
+
| `lotics app pull [app_id] [path]` | **An app's live definition, pulled.** The app is read with `get_app`: its author is shown a body, a JSON **tree** (with the addresses of its nodes) pulled as that tree and a custom-code app (the identity alone) as its source; an app whose stored tree does not read in this release is pulled as it is stored, with a warning giving the reason `get_app` gives (where the stored value is not a JSON object, nothing is pulled and the reason is the error); an app that shows the caller no body (the caller does not author it, or it has no version) is refused. **A JSON app**: the tree is written as JSON to `[path]` (a directory receives `./<name>.app.json`; default `./<name>.app.json`), and the app's id and current version beside it in `<file>.lotics.json` (`{ "app_id": "…", "version_id": "…", "digest": "…" }`, the digest being the file as the CLI last left it; a record without all three is refused by `app apply`, naming `lotics app pull`) — a custom-code project records both in `package.json#lotics`, a single file has no such place — so the next `lotics app apply <file>` edits that app, and is refused if the app has since moved past that version. An existing file is overwritten only when its `.lotics.json` names this same app and the file is unchanged since it was last pulled or applied; a file with edits, or whose record names the app but no digest, is refused, naming `--force`, which overwrites it. `--force` is a flag of `app pull` alone. `--json` prints `{workspace_id, app_id, path, outcome}`. **A custom-code app**: its live source, as a project ready to deploy on it. The target is `[path]`, else this directory when it is the app's project (or no app is named), else `./<name>`. **The app's own project is brought up to date in place** — but only when it holds no edit since the version `package.json#lotics.current_version_id` names: its source (packed as a deploy packs it) is compared with that version's archive, ignoring `.lotics/` and `package.json#lotics`, and any difference refuses the pull, naming the changed files; a pull never merges, so local work is never lost. Already at the live version is a no-op that says so. **An empty or new directory receives the source whole**; any other directory is refused. Downloads come from `GET /v1/apps/{id}/versions/{version_id}/source`. `package.json#lotics` is then set to exactly the app, its workspace and the pulled version, dropping every other key an older CLI wrote there, so the next `lotics app deploy` builds on the live version; then `.lotics/` is written (`GET /v1/apps/{id}/types`) and dependencies installed (`npm ci` with a lockfile, else `npm install`, both `--ignore-scripts`). |
|
|
51
|
+
| `lotics app apply <file> [--app <app_id>] [--check] [--json]` | **A JSON app, one at a time, through the tool `set_app`.** The file is an app's tree (`lotics docs reference`: the App node with the nodes under it, its tables and templates named by alias). **No app known** (no `--app`, no `<file>.lotics.json` beside it): the file is sent as `{ "body": … }` to make a new app, named by the body's `name`, and the id made is printed, then recorded with its version in `<file>.lotics.json`. **An app known**: its current tree is read (`get_app`) and the **RFC 7396 merge patch** that turns it into the file is sent as `body` with the `app_id` and the version the patch was computed against as `base_version_id` — a key the file drops is `null` in the patch, a list is replaced whole, what the file leaves alone is left alone, and a tree the app already has sends nothing and says so. **A file pulled at a version the app has since left is refused** where the stored tree changed since the pull (a version that moved only for a workflow's body applies) before anything is sent, naming both versions and `lotics app pull <app_id> <path>`: pull the current tree into another path, carry the edits over, apply that file. `--app` naming an app other than the sibling file's is refused too. A write that races the apply is refused by the server, which names the app's current version. A file that sets an object key to `null` is refused naming the key, since a merge patch reads `null` as a removal. `--app` names the app, else the sibling file does; an app whose `get_app` shows no body (it is not yours) is refused, **over a stored tree that does not read in this release the file is sent whole** (`set_app` with `app_id`, the file as `body` and the version read as `base_version_id`; no merge patch is computed against a tree that does not read) where it states `"type": "App"`, and any other file is refused, naming that only a whole tree replaces it; a custom-code app takes its identity (name, description, icon, colour) only, and no `<file>.lotics.json` records it, since an identity write makes no version — its source deploys with `app deploy`. **The file is never rewritten**: a node the tree leaves out draws as the rows call for it and is stored nowhere (`lotics docs design`). It prints what `set_app` answered and reports its `outcome`: its notes and findings, every finding at once, and the saves, adds and Deletes the write grants and removes. **`--check` sends `dry_run`** (a flag of `app apply` alone, as is `--app`) — what would refuse the tree, and what it would grant and remove — and writes nothing, the file and its sibling included; an `outcome` of `refused` exits 1. A tree the app already has, or one `set_app` answers `unchanged`, records the version the app stays at in the sibling. **To go back to an earlier version, apply the earlier tree again.** Resolves and ANNOUNCES its workspace first. `--json` prints `{workspace_id, app_id, outcome, write}`, `outcome` being `set_app`'s: `created`, `updated`, `unchanged` or `refused` (with `--check`, what it would be). |
|
|
52
52
|
| `lotics app deploy [-m <message>]` | **Build this directory and upload it as a new version of the live app.** Rewrites `.lotics/` with the declarations of the app's live bindings (`GET /v1/apps/{id}/types`, replacing each file there), then runs the project's `npm run typecheck` (warned about when absent; a type error in the app's own files stops the deploy, one inside an installed package is reported and does not) and `npm run build`, tars the source (without `node_modules`, `dist`, `.git`, `*.tsbuildinfo`) and `dist/`, and posts both to `POST /v1/apps/{id}/versions` on the version `package.json#lotics.current_version_id` names, then stamps the new one there. The version carries the app's queries, workflows, agents and capabilities forward unchanged — those are written through their tools. A project with no `build` script, or whose `package.json#lotics` still declares `queries`, `workflows`, `agents` or `capabilities`, is refused before anything is built; the refusal names the tool that sets each. **A 409 because another version went live since this directory's last deploy** (a deploy from elsewhere, a rollback) prints the server's sentence and the version that is live, and names `lotics app pull`: run in this directory, it brings an unedited project up to date, and lists the files a project with edits changed, to carry over into a fresh pull. `-m` (or a bare positional) is the version's message, optional. The workspace comes from `package.json#lotics.workspace_id` unless `--workspace` / `LOTICS_WORKSPACE` names another. |
|
|
53
53
|
| `lotics docs` \| `lotics docs <area>[/<section>]` \| `lotics docs [<area>[/<section>]] --grep <text>` | **This CLI's own references, carried inside the binary** — the model reference, this index, and every doc under `docs/` — so the doc a reader opens describes the binary answering, listed by the job a reader comes to do. Capped at ONE PAGE: a doc that does not fit prints its opening and the addresses of what it holds (`lotics docs <area>/<section>`, each section's size beside it, or a table's row names), and every address prints within a page. **A reference the binary's copy lacks, or a part of one the server serves, is read from the server's `docs` tool** with this machine's credential, after the copy's refusal — a page the server added since this binary was built, which a server refusal can cite. A name matching more than one reference, or a part missing from a guide to this CLI, is answered by the copy alone. **`--grep` searches the references the server serves** (not this CLI's own guides, which it refuses), with this machine's credential, narrowed to the area or section named: literal text unless `--regex`; a literal search that finds nothing while the pattern read as an expression matches (`a|b`) returns those lines under a note saying so, and `--literal` keeps the literal zero; with `--case-sensitive`, `--diacritic-insensitive`, `--context-lines <n>` and `--limit <n>` — the dialect the knowledge lines of `get_workspace` with `search` are read in — each hit under the address that opens its page; any of those options without `--grep` is refused. A custom-code app's SDK reference ships inside `@lotics/app-sdk` in the app's `node_modules`. |
|
|
54
54
|
| `lotics upgrade` | Update this CLI in place. Runs the same installer a person would, chosen by how THIS copy arrived: an npm install upgrades through npm, a script install re-runs the script — the runtime knows which (the executable is compiled, the npm bin runs under node), so nobody has to. It downloads nothing itself; resolving a version, verifying the checksum and replacing a running executable already exist in the installers, and a second copy of that inside the binary would be a second thing to get right. Replacing the binary while it runs is safe — a rename leaves the running image mapped on unix, and on Windows the installer moves the old aside precisely because the file is in use. Already current is a no-op that says so. Needs no auth. |
|
package/docs/design.md
CHANGED
|
@@ -4,7 +4,7 @@ An app is a tree of components: a List of one table, the Record a row opens, its
|
|
|
4
4
|
tree states COMPOSITION — which fields, lists and acts each job's screen holds; how each piece looks is the platform's,
|
|
5
5
|
one way per concept. A node the tree leaves out draws its default, from the table's facts (`records`, the stage, the
|
|
6
6
|
write rules): a List's Readings band, the stage buttons, the picture, a Record's Sections. State a node to change it,
|
|
7
|
-
or `false` at it to turn it off (`"readings": false`, `"row": { "image": false }`). A drawn Field is a control unless it
|
|
7
|
+
or `false` at it to turn it off (`"readings": false`, a Record's `"row": { "image": false }`). A drawn Field is a control unless it
|
|
8
8
|
or its entity is read-only (`edit: false`); a stepped status never is, since Acts move it. Each prop's keys are in `reference`, a treatment
|
|
9
9
|
worked in a whole workspace is `examples/<treatment>`, and which apps a business needs is `first_build`, § 3.
|
|
10
10
|
|
|
@@ -26,7 +26,8 @@ worked in a whole workspace is `examples/<treatment>`, and which apps a business
|
|
|
26
26
|
- A thing shows its picture, a file its preview, a plan its days on a time axis, a quantity a meter (`records.limits`) or
|
|
27
27
|
a chart, a register its Readings, and long text reads whole (a markdown Field; `block: true` on plain long text).
|
|
28
28
|
- Every category the job reads is coloured: each option's `color`, and a `mark` where a brand or glyph names it, on
|
|
29
|
-
every option of a select read down a column (how it was paid, the channel).
|
|
29
|
+
every option of a select read down a column (how it was paid, the channel). Colour an option only where the colour
|
|
30
|
+
means something.
|
|
30
31
|
- Every app states its tile's `color`, apart from the workspace's other apps where it can be.
|
|
31
32
|
- The paperwork is the proof of the work: a files field per purpose (what arrived, what was issued to the customer, the
|
|
32
33
|
carrier, the authority) in the Section where that work happens, kept visible after its stage, and the source of a
|
|
@@ -59,7 +60,7 @@ node that would state it; a note refuses nothing. Each kind of row's view is cho
|
|
|
59
60
|
| Booked on a resource | List `layout: {"lanes": {"by": …}}`, and the table's `no_overlap` | `reference/lanes`, `reference/write-rules` |
|
|
60
61
|
| A log of what happened | a child List with `layout: "timeline"` | `reference/layouts` |
|
|
61
62
|
| Opened to be worked on | the Record's Sections, in the order the work reaches them — `at` where it moves in steps; fields only one kind of row holds (a delay's cause, a safety issue's hours lost) in a Section whose `when` names that kind | `reference/section-node` |
|
|
62
|
-
| Rows that each belong to another row | a child List on that row's Record, with `create` and `remove` — and a child's own rows a List in that child's page, as deep as the data goes; a List with `same`
|
|
63
|
+
| Rows that each belong to another row | a child List on that row's Record, with `create` and `remove` — and a child's own rows a List in that child's page, as deep as the data goes; a List with `same` where read-only | `reference/list-node` |
|
|
63
64
|
| A related row's value on the list (the newest contract's end date) | a `lookup` field of the table, ordered, as a column | `reference/lookup` |
|
|
64
65
|
| Moving through a status | an Act per move, `status.dates` for the moment of each stage, and the register's Readings | `reference/act-node`, `reference/status`, `reference/reading-node` |
|
|
65
66
|
| Counted over a period | the register's Tabs over one `period`; a Tab's `totals` for a child's sums before, during and through it; an open Tab's `where` reads only what was true at the period's end, never a status the row moves on from | `reference/tab-node` |
|
|
@@ -74,26 +75,25 @@ node that would state it; a note refuses nothing. Each kind of row's view is cho
|
|
|
74
75
|
| A number painted on the thing, or a barcode or QR code on it | `records.scan: "iso6346"` or `"text"` (read off one photo by an agent), or `"code"` (decoded on the device, no agent): the title read on a phone, beside each search matching it | `reference/record-places-pins-and-cadence` |
|
|
75
76
|
| Who did what on which day | List `layout: "roster"` with the List of its cells inside | `reference/roster` |
|
|
76
77
|
| Someone with no seat signs off one record (a buyer approves a proof, a client signs a handover) | the Record's `Outside`: the Fields and Lists the link shows as they are, and Acts that each move the status out of its `at` — a link a member makes of the record, never a seat; the link's page names the record only where the Outside states its title's field | `reference/outside-node` |
|
|
77
|
-
| A record whose page is its own arrangement of pieces the app already states | Record `compose` | `reference/composed-page` |
|
|
78
78
|
| Steps people drop out of between | a Reading with `steps` on the record whose child rows count them | `reference/reading-node` |
|
|
79
79
|
| A record's own numbers nobody keys, read at a glance | consecutive Readings with no `entity` (two to eight tiles) | `reference/reading-node` |
|
|
80
80
|
| Rows that are each a place a record is sent | a List with `expect` on the link to those places and `post`: each ticked, the post written there and read as its feed shows it | `reference/publish-desk` |
|
|
81
81
|
| Papers an agent reads, where the owner asked for one | an Act's `intake` with `fills` | `reference/act-node` |
|
|
82
82
|
| Calls and visits | an Act's `record` | `reference/act-node` |
|
|
83
|
-
| A tool on a record that the model cannot draw (a drawing editor, a folded-box preview) | a custom-code app over the same table, opened by an Act's `open` | `reference/act-node` |
|
|
84
83
|
| Changes a workflow proposes that a person approves row by row — a price list applied, a statement matched to what is owed | an Act's `workflow` with `review`, its body returning a changeset in `data.review` | `reference/act-node` |
|
|
85
84
|
| Documents covering lines | a List with `under` | `reference/list-node` |
|
|
86
85
|
| Rows on file a record takes in | a List with `pick` | `reference/list-node` |
|
|
87
86
|
| One owner's question across jobs | an App of Tabs and Readings and no register | `reference/app-node` |
|
|
88
87
|
|
|
88
|
+
What these nodes do not state, a long-form writing page or a bespoke tool, is a custom-code app (`lotics app create <name> --custom`, `building_an_app`), never a new node.
|
|
89
|
+
|
|
89
90
|
### Faces and pictures
|
|
90
91
|
|
|
91
92
|
#### Party
|
|
92
93
|
|
|
93
94
|
`records.party` is `"person"` where the rows are people (a contact, a patient, a driver) and
|
|
94
95
|
`"organization"` where they are companies (a customer, a supplier, a carrier). Every surface drawing one of
|
|
95
|
-
its rows
|
|
96
|
-
its `image` (a photo, a logo), else its initials. Without it, a person is drawn as a thing. A workspace
|
|
96
|
+
its rows then draws a face: its `image` (a photo, a logo), else its initials. Without it, a person is drawn as a thing. A workspace
|
|
97
97
|
member is a `member` field, and is drawn by their face already. Worked: `examples/party`.
|
|
98
98
|
|
|
99
99
|
#### Image
|
|
@@ -106,16 +106,7 @@ papers is drawn as a Field, read whole. Worked: `examples/cards`.
|
|
|
106
106
|
|
|
107
107
|
#### A link opens its row
|
|
108
108
|
|
|
109
|
-
|
|
110
|
-
row's face — mark, name, status, line and its figure by its field's name — and nothing to edit. A link read in a
|
|
111
|
-
row's cell or on its line opens from its name; a link the record keeps as a field rests as its picker, and
|
|
112
|
-
its way out stands at the field's label where the row has somewhere to go. The peek's one act leaves for
|
|
113
|
-
the app whose register is that table's rows — the first, in the member's own order of apps, that the member
|
|
114
|
-
can open — at the row's address, or goes to the row inside this app where the table is the app's own,
|
|
115
|
-
one of its Books' or a log's, in that list — a log's rows only from their own app. With no such app the peek has no act, and a link answered in what an Act
|
|
116
|
-
asks opens no peek. No prop states it: give the table an app of its own and
|
|
117
|
-
its links lead there. The app opened decides what the member reads of the row; a row it withholds
|
|
118
|
-
lands them on its not-found.
|
|
109
|
+
Every row an app draws opens on its page, the one you state or a default. A List's rows default to the table's fields; a link's row defaults to its name, line, status and figure. State `pages/<e>` to show more or to edit.
|
|
119
110
|
|
|
120
111
|
### Rows in time
|
|
121
112
|
|
|
@@ -145,7 +136,7 @@ and `of` a role of the model, each member of it a lane, idle ones too. Worked: `
|
|
|
145
136
|
#### Gantt
|
|
146
137
|
|
|
147
138
|
`layout: {"gantt": {"start": …}}` (and `end`, else the table's first `due`; a `due` is a deadline, never an appointment date): one bar a row over
|
|
148
|
-
its run of days
|
|
139
|
+
its run of days, read against today. `milestones` marks
|
|
149
140
|
dates on the bar, `planned` the plan under it, `progress` how far it is done, `after` the rows it waits on;
|
|
150
141
|
the List's `group` is its lanes; a table holding rows under rows nests each bar under its row above, folded as the
|
|
151
142
|
register's outline is. A child List on a record with this layout draws the bars of the rows its link names. Worked: `examples/gantt`.
|
|
@@ -161,27 +152,29 @@ Worked: `examples/roster`.
|
|
|
161
152
|
|
|
162
153
|
A child List with `layout: {"agenda": {…}}` on a record: a child's planned entries by day, soonest first, today marked, each with its
|
|
163
154
|
picture; within a day by the hour, or by a single select of the part of the day. `start` counts Day 1 from a
|
|
164
|
-
date of the record
|
|
155
|
+
date of the record.
|
|
165
156
|
|
|
166
157
|
#### Timeline
|
|
167
158
|
|
|
168
159
|
A child List with `layout: "timeline"` on a record: a child read as a log of dated entries, newest first, with a composer — the
|
|
169
160
|
calls, visits and notes about the record, each with who and when, and its files where the child's `image`
|
|
170
|
-
names them. Entries planned ahead are an agenda; the status's moves are its history. Worked:
|
|
161
|
+
names them. An app's Record draws no comment thread: a team's discussion on a record is a child table. Entries planned ahead are an agenda; the status's moves are its history. Worked:
|
|
171
162
|
`examples/party`.
|
|
172
163
|
|
|
173
164
|
### Moves and numbers
|
|
174
165
|
|
|
175
166
|
#### Moves
|
|
176
167
|
|
|
177
|
-
|
|
168
|
+
The rows of a root List that a status stages towards its `closed` options move by Acts: each moves one option on to the next (`when` the
|
|
178
169
|
status holds it, `set` to the next), at the foot of the Section whose work it ends. A status with nothing closed is a
|
|
179
170
|
condition a person sets. A value decided as a row reaches an outcome — why it was lost, refused, voided — is that
|
|
180
171
|
Act's `asks`, never a field the reader must remember to fill. An Act reaching past the workspace — sending an invoice
|
|
181
172
|
to a service, a letter by mail — runs its `workflow`, and what the workflow keeps from the answer (an invoice's id,
|
|
182
173
|
its link) is named in the Act's `set`. A stage the work only steps aside into from one step
|
|
183
174
|
and leaves only back to it — a pause, a repair — is a detour: its option and its Section stand before that step,
|
|
184
|
-
entered by its own Act; listed after, it reads as the work's next step.
|
|
175
|
+
entered by its own Act; listed after, it reads as the work's next step. An Act also moves a row back (`when` the later
|
|
176
|
+
stage, `set` the earlier): the row draws it beside the way on, and without one a row moved on by mistake stays until an
|
|
177
|
+
admin edits the table. What a `workflow` or a paper did stands, so a way back there is a correction of its own.
|
|
185
178
|
|
|
186
179
|
#### Stages
|
|
187
180
|
|
|
@@ -211,22 +204,21 @@ stage is signed once per person, read off who moved the row.
|
|
|
211
204
|
|
|
212
205
|
#### Readings
|
|
213
206
|
|
|
214
|
-
A List
|
|
207
|
+
A List usually opens with one band of figures or a chart, chosen for what that person watches. Its Readings stand above the rows and its filters and read the rows under the open tab, never narrowed by the controls below them. Lead with the job's headline number —
|
|
215
208
|
its exception as a formula's yes/no in a Reading's `where` (what is short), never a stage the
|
|
216
209
|
status chips already count, nor the overdue rows the register's summary line counts from `records.due` — then at most the mix (`by` a field) and the movement (`by` a date), varied by job. A movement over a date is stated, never defaulted, and so is a sum: a status register with no single select to split by gets no default band.
|
|
217
|
-
A grid (`by` and `across`) reads on a
|
|
218
|
-
Reading windowed by the period the
|
|
219
|
-
|
|
220
|
-
Record's Readings read its own child rows. Sums of each row's child rows are a Tab's `totals`. Worked: `examples/approval`, `examples/dashboard`.
|
|
210
|
+
A grid (`by` and `across`) reads on a Sheet. A Sheet — a View of Readings at the App's root, beside its Lists or alone —
|
|
211
|
+
answers one owner's question across jobs, each Reading windowed by the reader's period (the App's `period`), and a
|
|
212
|
+
List on it hands over the rows to act on. Many Readings stand on several Sheets, each a View the reader picks. A
|
|
213
|
+
dashboard varies its charts by the job. A question one app's rows answer goes on a Sheet there; one spanning apps gets a small app of its own. A Record's Readings read its own child rows. Sums of each row's child rows are a Tab's `totals`. Worked: `examples/approval`, `examples/dashboard`.
|
|
221
214
|
|
|
222
215
|
#### Funnel
|
|
223
216
|
|
|
224
|
-
A Reading with `steps` reads a record's child rows as steps, each a number column summed over them —
|
|
225
|
-
from
|
|
217
|
+
A Reading with `steps` reads a record's child rows as steps, each a number column summed over them — an order's lines
|
|
218
|
+
from ordered to shipped. It states how much of the first step
|
|
226
219
|
each later one keeps, the share lost between two neighbours, and the last over the first. State two to six
|
|
227
220
|
`steps` in one unit; where the path turns — reach, then conversion — state two Readings one straight after the
|
|
228
|
-
other, so the second's bars are read over its own first step
|
|
229
|
-
edge and every value ending at another, each under its own label. A step no row holds a number in reads as not measured: leave it empty, never a zero nobody measured.
|
|
221
|
+
other, so the second's bars are read over its own first step, on one grid. A step no row holds a number in reads as not measured: leave it empty, never a zero nobody measured.
|
|
230
222
|
|
|
231
223
|
#### Priced lines
|
|
232
224
|
|
|
@@ -244,12 +236,10 @@ an app (`first_build` § 3).
|
|
|
244
236
|
|
|
245
237
|
The Record's Sections, in the order the work reaches them: the fields people write, a Field per paper the record
|
|
246
238
|
keeps, a child List per child, the Acts at each one's foot. A register's `columns` are in the order the job reads them, as many as fit a desk; what is read only on the way deeper is the Record's, and a figure that is final only from a stage is a Field of that stage's Section, never a column read on every row at every stage. A register laid out in time (calendar, lanes, roster) opens the
|
|
247
|
-
default record: every field a person writes.
|
|
248
|
-
do, and never for behaviour, which belongs in an Act.
|
|
239
|
+
default record: every field a person writes. Behaviour belongs in an Act.
|
|
249
240
|
|
|
250
|
-
A Section of more than about six fields reads as Fieldsets of related facts: a patient's record holds "Contact"
|
|
251
|
-
|
|
252
|
-
`label` a few words. A gallery or prose Field stands beside the Fieldsets (`reference/fieldset-node`). Fields stand two
|
|
241
|
+
A Section of more than about six fields reads as Fieldsets of related facts: a patient's record holds "Contact" and
|
|
242
|
+
"Insurance" rather than one run of nine, each Fieldset's `label` a few words. A gallery or prose Field stands beside the Fieldsets (`reference/fieldset-node`). Fields stand two
|
|
253
243
|
to a line in the order stated, and files, prose and a link to several rows take the whole line: stated after a lone
|
|
254
244
|
short field, one leaves the half beside that field empty.
|
|
255
245
|
|
|
@@ -284,7 +274,7 @@ the reader ticking which to make. Worked: `examples/case`.
|
|
|
284
274
|
|
|
285
275
|
A paper the business is brought and reads is an Act's `intake`: the press takes the papers, an agent reads
|
|
286
276
|
them, and each is filed as the line of its kind in the child the record `expect`s, while `fills` writes what
|
|
287
|
-
they state into the record's fields — a single link as a row the agent finds among those the app reads — shown before it is saved. Worked: `examples/case`.
|
|
277
|
+
they state into the record's fields — a single link as a row the agent finds among those the app reads — shown before it is saved. Stated with `on: "view"` at the register's title, the papers make a NEW record instead: `fills` names what it requires, `<link>.<field>` fills the row a required link names (found on its entity's `natural_key`, else added), and the register opens the record made. Worked: `examples/case`.
|
|
288
278
|
|
|
289
279
|
An agent Act — an `intake`, a `record`'s `fills` — spends a run on every press, so it is stated only where the
|
|
290
280
|
owner asked for an agent to do that job; otherwise a paper brought is its `expect` line, and a person types what it states.
|
|
@@ -303,13 +293,3 @@ An Act's `record`: the press records a call, visit or meeting — audio, transcr
|
|
|
303
293
|
files it as a new row of the record's `timeline` child (`into`), stamped `at` and `by`; `fills` lets an agent fill
|
|
304
294
|
that row's fields from the transcript, where the owner asked. Worked: `examples/calls`.
|
|
305
295
|
|
|
306
|
-
### Other apps
|
|
307
|
-
|
|
308
|
-
#### Open act
|
|
309
|
-
|
|
310
|
-
An Act's `open`: the id of another app — usually a custom-code app drawing what the model cannot — that the press
|
|
311
|
-
opens at this record. It is navigation only: no workflow of either app runs, and what the tool writes it writes
|
|
312
|
-
through its own declared workflows. It stands alone with `label` and `when`, on one record of the app's own (an Act
|
|
313
|
-
in a Record's section, or a compose `Act` piece naming it). The target must be an app of the workspace that reaches the
|
|
314
|
-
record's table — a register over it, or custom code declaring no table or declaring it; anything else is refused at
|
|
315
|
-
save. A reader without `use` on the target meets that app's own "cannot open" state.
|