@lotics/cli 0.245.0 → 0.247.0

package/dist/src/client.d.ts

@@ -37,6 +37,13 @@ export interface AppQueryBody {
     keyset?: boolean;
     /** The previous page's `next_cursor`, in keyset mode. */
     cursor?: string;
+    /** Answer the groups of the filtered set in place of its rows: by up to two output columns and the day of an
+     *  output date, each group's `__count` and `__sum` of one output number. */
+    aggregate?: {
+        by?: string[];
+        day?: string;
+        sum?: string;
+    };
 }
 /** Result of the app query RPC. `total` answers a `count` read; `truncated` and
  *  `next_cursor` a rows read — `next_cursor` in keyset mode only, null on the
@@ -370,8 +377,6 @@ export interface ScaffoldWorkspaceRequest {
     }>>;
     /** Bind an entity whose label already names a table here. Absent, a colliding label is refused. */
     adopt?: boolean;
-    /** The account each connection alias pushes through, by `cac_` id — where more than one of its provider is usable. */
-    connections?: Record<string, string>;
 }
 export interface ScaffoldWorkspaceResult {
     /** Every entity the model declares, in contract order. */
@@ -423,48 +428,6 @@ export interface ScaffoldWorkspaceResult {
      * whose rule nobody named is the one a reader has to be told about.
      */
     carried_rules?: string[];
-    /**
-     * Every table automation the model declares that this run wrote, with the
-     * table workflow it is: created by this run, or rewritten in place — found
-     * through the binding (`id`) or by its label on its table — or `restored`
-     * from archived. `enabled` is whether it fires — a rewrite keeps the owner's
-     * switch — and is absent from an instance too old to say. Absent from an
-     * instance too old to provision one, which also refuses a model that declares
-     * any.
-     */
-    automations?: Array<{
-        alias: string;
-        entity: string;
-        table_workflow_id: string;
-        bound_by: "created" | "id" | "label" | "restored";
-        enabled?: boolean;
-    }>;
-    /**
-     * Automations this run neither created nor rewrote: deployed app workflows
-     * write the table each keeps (`keeps`, an entity alias) themselves, and both
-     * writing it would land every row twice. `live` is the table workflow already
-     * writing it beside them — twice NOW — else null. Absent from an instance too
-     * old to hold one back.
-     */
-    held_automations?: Array<{
-        alias: string;
-        entity: string;
-        keeps: string;
-        writers: AppTableWriter[];
-        live: string | null;
-    }>;
-    /**
-     * The account each connection the model declares pushes through: named by the
-     * caller (`chosen`), kept from the binding this workspace held (`id`), or the
-     * only account of its provider the applier can use (`only`). Absent from an
-     * instance too old to bind one, which also refuses a model that declares any.
-     */
-    connections?: Array<{
-        alias: string;
-        connected_account_id: string;
-        provider: string;
-        bound_by: "chosen" | "id" | "only";
-    }>;
     /**
      * Options of an ADOPTED field that kept a mark other than the model's, by
      * binding key — every surface draws the live one. Absent from an instance too
@@ -514,22 +477,11 @@ export interface BoundTarget {
 export interface BoundField extends BoundTarget {
     options: Record<string, BoundTarget>;
 }
-/** One app workflow alias whose deployed body writes a table's rows. */
-export interface AppTableWriter {
-    app_id: string;
-    app_name: string;
-    workflow_alias: string;
-}
 /** One entity of the model, as this workspace holds it. */
 export interface BoundEntity {
     table: string;
     live_label: string | null;
     fields: Record<string, BoundField>;
-    /**
-     * The deployed app workflows that write this table — only on an entity the
-     * read named in `app_writers`, and absent from an instance too old to say.
-     */
-    app_writers?: AppTableWriter[];
 }
 /**
  * WHAT EACH ALIAS OF A WORKSPACE MODEL BECAME IN ONE WORKSPACE.
@@ -544,16 +496,12 @@ export interface ModelBinding {
     entities: Record<string, BoundEntity>;
     templates: Record<string, BoundTarget>;
     roles: Record<string, BoundTarget>;
-    /** Automation alias → the table workflow it became. Absent from an instance too old to bind one. */
-    automations?: Record<string, BoundTarget>;
     /** `<entity-alias>:<row-ref>` → the record that first row became. */
     rows: Record<string, string>;
     /** The path a row attached a document by → the file it was uploaded as. */
     documents: Record<string, string>;
-    /** A plan's app alias → the app created for it here. Absent from an instance too old to bind one. */
+    /** A model's app alias → the app created for it here. Absent from an instance too old to bind one. */
     apps?: Record<string, BoundTarget>;
-    /** A connection alias → the connected account an apply chose for it. Absent from an instance too old to bind one. */
-    connections?: Record<string, BoundTarget>;
 }
 /**
  * A workspace read BACK as a model — the inverse of the scaffold above.
@@ -884,9 +832,7 @@ export declare class LoticsClient {
      * additive verb creates a second table over. Admin-only, like the scaffold it
      * is the memory of.
      */
-    getModelBinding(opts?: {
-        app_writers?: readonly string[];
-    }): Promise<ModelBinding>;
+    getModelBinding(): Promise<ModelBinding>;
     /**
      * Forget what one alias is bound to here — the escape from a binding whose
      * target has been deleted. Forgets everything addressed under it too: an

package/dist/src/client.js

@@ -396,10 +396,8 @@ var LoticsClient = class {
    * additive verb creates a second table over. Admin-only, like the scaffold it
    * is the memory of.
    */
-  async getModelBinding(opts = {}) {
-    const writers = opts.app_writers ?? [];
-    const qs = writers.length === 0 ? "" : `?${new URLSearchParams({ app_writers: writers.join(",") }).toString()}`;
-    return this.request("GET", `/v1/workspaces/model/binding${qs}`);
+  async getModelBinding() {
+    return this.request("GET", "/v1/workspaces/model/binding");
   }
   /**
    * Forget what one alias is bound to here — the escape from a binding whose

package/docs/building_an_app.md

@@ -13,43 +13,49 @@ using one to find out whether something works is the slowest possible way to lea
 ## 1 — Scaffold, or pull what exists
 
 ```
-lotics app preview model.json#<app> --shots shots/   # the plan rendered over its rows: no workspace
+lotics app preview model.json#<app> --shots shots/   # the model's app rendered: no workspace
 lotics app create "<name>"          # new: a real Vite + React + TS project, deps installed
-lotics app create "<name>" --from model.json#<app>   # new, from a checked plan: app.json, rendered
+lotics app create "<name>" --from model.json#<app>   # new, from a checked model: app.json, rendered
 lotics app create "<name>" --api    # new, no screens: its declarations are the whole surface
-cd <dir> && lotics app regenerate   # existing + generated: rewrite its spec from the plan
+cd <dir> && lotics app regenerate   # existing + generated: recompile it from the model
 cd <dir> && lotics app pull <app_id>   # existing: refresh to the latest first, then read its README
-lotics workspace build model.json      # the whole plan: check, apply, then every app in it
+lotics workspace build model.json      # the whole model: check, apply, then every app in it
 ```
 
 `lotics workspace build` is the create and regenerate lines above in one, for a model that
 declares several apps: `scaffold check`, `scaffold apply` where this workspace differs from the
-model or the model declares a table automation, then per app `create --from` into
-`<dir-of-model>/<alias-with-dashes>` when that directory does not exist and `regenerate` there when
-it does, then `app check` — and `app deploy` under `--deploy`. Each app is built after every sibling
-it names that the run creates, since a hand-off is written off the app its alias became; otherwise
-in the model's order. Two apps that name each other cannot both go second, so the one built first
-is built again once the other exists, and a hand-off binds on the first run. An app that conflicts or checks
-red is named and the rest still run, because the one you are going to fix is not a reason to leave
-the others in a state nobody knows. `--dry-run` writes nothing and says which apps it would create
-and which it would regenerate.
-
-**Look at the plan before anything exists.** `lotics app preview <model.json>#<app>` binds the app
-against the model's own ids, answers every read from the model's `rows`, renders every screen and
-record at 1280 and 375, and runs the probes `app check --screens` runs — no workspace, no
-credential, nothing created. `--shots <dir>` writes what it measured as PNGs. What a clause of the
-plan draws is `lotics docs clauses`; the preview is how you see it drawn over your own rows.
+model, then per app `create --from` into `<dir-of-model>/<alias-with-dashes>` when that directory
+does not exist and `regenerate` there when it does, then `app check` — and `app deploy` under
+`--deploy`. An app that conflicts or checks red is named and the rest still run, because the one
+you are going to fix is not a reason to leave the others in a state nobody knows. `--dry-run`
+writes nothing and says which apps it would create and which it would regenerate.
+
+**An app is stated, not drawn.** In `model.json`, `records` says how a row of each entity is
+recognised — its title, the line under it, its picture, its status, its figure, its deadlines — and
+each entry of `apps` is one register over one entity and the record its rows open: the register's
+columns and filters, the record's fact groups and blocks, the acts and the checks that guard them.
+That is the whole vocabulary (`lotics docs model/apps`). How each piece looks is the runtime's, one
+way per concept, and no key changes it. `lotics scaffold check` prints each app as its reader will
+see it, with every value a default supplied marked `(default)` — review the app there, before
+anything exists.
+
+**Look at it before anything exists.** `lotics app preview <model.json>#<app>` compiles the app
+against the model's own ids, answers every read from the model's `rows` (a few synthesized for an
+entity that states none), renders the register, the record in its door and the add dialog at 1280
+and 375, and runs the probes `app check --screens` runs — no workspace, no credential, nothing
+created. `--shots <dir>` writes what it measured as PNGs.
 
 `--from` takes the model file `lotics scaffold check` approved and the app in it, and writes
-**`app.json`** — the bound plan: its one register with the shape and slots, the record each row
-opens, the create panels and the acts, addressing the live `tbl_`/`fld_`/`opt_` ids its entities
-became — beside a five-line `src/main.tsx` that mounts `@lotics/app-runtime` over it, one
-`src/workflows/<alias>.ts` per write and an empty `src/components/index.ts`. The runtime draws the
+**`app.json`** — the app compiled against the live `tbl_`/`fld_`/`opt_` ids its entities became —
+beside a `src/main.tsx` that mounts `@lotics/app-runtime` over it, one `src/workflows/<alias>.ts`
+per write and an empty `src/components/index.ts`. Every write — a create, an edit, a remove, each
+act — is a generated workflow that re-checks on the server what the model states: required fields,
+`write_rules`, an act's `when` and `requires`, and the checks that block it. The runtime draws the
 spec; there is no screen source to edit (`node_modules/@lotics/app-runtime/AGENTS.md`). The tables
 have to exist (`lotics scaffold apply` first); a table or field the workspace lacks is refused by
-name. The app is recorded against its plan alias, so a second `--from` for the same alias is
-refused and a sibling's hand-off to it opens this app. The project's `README.md` is the plan in
-prose: the app, its register and record, and the tables behind them.
+name. The app is recorded against its model alias, so a second `--from` for the same alias is
+refused. The project's `README.md` is the app in prose: its register, its record and the tables
+behind them.
 
 `--api` scaffolds the app something OUTSIDE Lotics calls (§ 9): the manifest, `src/workflows/`, a
 CI job and the two briefs, with no `index.html`, no `src/App.tsx`, no Vite config and no kit. Its
@@ -67,15 +73,15 @@ A pull writes more than source: one `src/workflows/<alias>.ts` per bound workflo
 `src/agents/<alias>.md` per bound agent, and the `.lotics/` type companions — so an existing app
 arrives fully editable rather than as an archive you have to reconstruct.
 
-**The plan changes after the app is built, and `lotics app regenerate` is how it lands.** Run it
-inside the app; the plan is the one `package.json#lotics.plan` remembers, unless `--from` names
-another. The generator owns what it emits: `app.json` is derived from the plan and rewritten
-whole, and a workflow body is rewritten too, with the text it replaced parked in
-`.lotics/regenerate-dropped.patch`. `src/components/` is the one exception — seeded where it is
-absent, never rewritten — because it is the hatch: `lotics app eject <screen|section|act>` hands
-ONE part of the spec to a component there, and a regeneration carries that hand-over onto the new
-spec. The manifest is reconciled by ownership — the generator's aliases replaced, the ones it
-retired removed, the ones you added kept — then codegen and `app check` run.
+**The model changes after the app is built, and `lotics app regenerate` is how it lands.** Run it
+inside the app; the model is the one `package.json#lotics.plan` remembers, unless `--from` names
+another. The generator owns what it emits: `app.json` is compiled from the model and rewritten
+whole, and a generated workflow body is rewritten too, with the text it replaced parked in
+`.lotics/regenerate-dropped.patch`. Two things are yours and survive every regeneration:
+`src/components/` (seeded where it is absent, never rewritten), and the body of an act's own
+`workflow` — only the guard region at its top, between the `<lotics:guards>` markers, is the
+generator's. The manifest is reconciled by ownership — the generator's aliases replaced, the ones
+it retired removed, the ones you added kept — then codegen and `app check` run.
 
 **Nothing is pushed.** What the live app RUNS changes at `lotics app deploy` and nowhere else: the
 bundle production serves was built against the bindings it has, so a regeneration that replaced a
@@ -275,29 +281,21 @@ Authoring rules for the body itself: `lotics docs workflows`.
 
 ## 7 — Screens
 
-**A plan-built app's screens are its `app.json`, and `@lotics/app-runtime` draws them.** The
-register, the record each row opens, its sections, the creates and the acts are all stated by the
-plan, so a correction is a change to the PLAN followed by `lotics app regenerate` — or, where the
-ruling is about how every app draws, a change to the runtime that reaches every app on its next
-install. Every row the runtime draws — a register's subject, a list item, a card, a record's stop, a
-log entry — is one anatomy read off the plan's roles (`node_modules/@lotics/app-runtime/AGENTS.md`),
-and how a register is laid out is the screen's `presentation` clause. `lotics scaffold check`
-prints what each screen will draw, with every value the plan left to the runtime marked
-`(default)`, so the printout is where a screen is reviewed before one exists; `lotics app preview`
-is where it is looked at.
-
-**Where the plan has no word for a screen, a section or an act,** the spec names one of the app's
-own components — `lotics app eject` writes it from exactly what the runtime was drawing, one part at
-a time, and `lotics docs components` says what it is handed. A screen no shape fits is declared in
-the plan as `"shape": "custom"` with its slots as roles (`lotics docs model/apps-and-screens`)
-— never a shape bent to fit — and then `lotics report` with `wanted` opening `shape <name>`: a custom
-slot set that recurs becomes a shape, and the report is how the next build gets it. A component
-the kit lacks is built into the kit, never hand-rolled in one app.
+**A model-built app's screens are its `app.json`, and `@lotics/app-runtime` draws them.** The
+register, the record each row opens, its facts and blocks, the acts and the checks are all stated by
+the model, so a correction is a change to the MODEL followed by `lotics app regenerate` — or, where
+the ruling is about how every app draws, a change to the runtime or the kit that reaches every app
+on its next install.
+
+**Where the vocabulary has no word for what a record needs,** a `component` block names one of the
+app's own components (`lotics docs components`), and an act whose write `set` cannot say names its
+own `workflow`, which runs after the generated guards. A component the kit lacks is built into the
+kit, never hand-rolled in one app.
 
 **A hand-written app composes the kit itself.** Before any JSX, read `lotics docs ui` — the catalog
-and the composition grammar; the shape components (`@lotics/ui/lifecycle_desk`,
-`@lotics/ui/party_register`, …) and `@lotics/ui/record_page` own the strip, the columns, the fit at
-a phone's width and the record's door, so give them rows and slots rather than rebuilding a frame.
+and the composition grammar; the pieces the runtime draws a record with (`RecordFrame`,
+`RecordHeader`, `ChecksCallout`, `FactGroups`, `ActPanel`) and the register's (`Table` with a `Row`
+subject, `FilterBand` with `StatusChips` and `GroupByMenu`) are there to compose rather than rebuild.
 
 Two rules for any code the app writes itself — a component or a hand-written screen:
 
@@ -424,7 +422,7 @@ Once scaffolded, everything below happens locally:
 
 ```
 edit src/workflows/<alias>.ts        # or a component, or a query
-lotics app preview model.json#<app> --shots shots/   # when the PLAN moved: see it before a table does
+lotics app preview model.json#<app> --shots shots/   # when the MODEL moved: see it before a table does
 lotics app regenerate --dry-run      # then: what the new generation would do to this app
 lotics app codegen                   # after any schema change
 npm run typecheck                    # honest, because codegen is current