Commands

The one registry of verbs every surface shares — what each takes, where it can run, and what it is allowed to change.

---

A command is one thing the app can do, written the way you would write a function call:

{ "command": "incrementValue", "property": "reps", "by": 1 }

There is exactly one list of them, and every surface invokes from it: a card, a dashboard board, an automation. Cards used to have their own verbs, boards had theirs and automations had a third set; they are one vocabulary now, which is why an automation and a button can do the same thing without you learning it twice.

A handler is a flat list

An event maps to an array of commands, run in order:

"on": { "click": [
  { "command": "setValue", "property": "logged", "value": true },
  { "command": "effect", "name": "celebrate" }
] }

There is no if, no loop and no variable in that array, and that is deliberate rather than unfinished. Conditionality lives one level up, in rules and in expressions — a rule decides whether an element shows, or what it looks like, and the handler underneath it just does its job. Handlers stay short on purpose; the list is a script, not a program.

What a command may target

Each command declares the kind of property it can point at, and the app checks that structurally — by what the property actually is, never by what a Collection happens to be called.

• toggleValue targets a checkbox.
• incrementValue targets a number.
• startTimer targets a stopwatch, recordRoute targets a route.
• setValue targets anything you can write to.

Aim one at the wrong kind of property and it simply does not render. No error dialog, no dead button, no sheet that opens empty — the affordance is just not offered. So a card that a model wrote against a Collection you have since changed degrades quietly instead of breaking.

Arguments are typed and bounded the same way: an id has to look like an id, a date like a date, a number has to sit inside its range, and a word from a fixed list has to be on the list.

Writing is a normal, revertible thing

Some commands change your data — the Writes column below says which. There is nothing special about a write a document causes: it goes down the same path as an edit you make by hand, so it appears instantly, syncs in the background, and can be undone. A document cannot cause a change the app does not already know how to reverse.

That is also why decoration can act. A tappable icon is not a second, sneakier way to write — it is a command invocation like any other, and it is recorded like any other.

Surfaces

Every command lists the surfaces it may be used on:

• card — a card or a list row for one entry
• board — a dashboard widget or a canvas board
• automation — a rule that runs on its own

A command used on the wrong surface is rejected when the document is saved, with a message naming the surfaces it does allow.

The commands

Next

• Events — the on block that holds these
• Expressions — where the conditionality went
• Cards — the elements you hang handlers off
• Automations — commands that run without a tap