Expressions

Anything inside {{ … }} is an expression. The same little language is used everywhere: a node's text, a style value, an if condition, a list's data, an action step's value, an invoke's args, and an http URL.

{ "type": "text", "text": "{{ state.user.name }} has {{ count(state.cart) }} items" }

A string that is exactly one binding keeps the value's type — a boolean stays a boolean, a number stays a number, a list stays a list. A string that mixes text and bindings interpolates to a string. That distinction matters when you feed a list into data, a boolean into if, or a number into a component prop.

{ "if": "{{ state.open }}",              "text": "open" }
{ "data": "{{ state.rows }}" }
{ "text": "Rows: {{ len(state.rows) }}" }

Scopes

Which names resolve depends on where the expression sits.

Two notes that save debugging time:

• A missing name is null, not an error. {{ state.nope }} renders empty.
• Inside a map/filter/count sub-expression, **it is the only visible

name** — the surrounding scope is deliberately hidden, so map(state.nums, "state.x") yields a list of nulls, not a list of state.x.

Literals and operators

Literals: numbers, 'single' or "double" quoted strings, true, false, null.

+ concatenates when either side is a string, and adds otherwise — {{ 1 + 2 }} is 3, {{ "n=" + 2 }} is n=2.

Truthiness (used by if, !, &&, ||, the ternary, and filter): null, false, 0, "", an empty array and an empty object are falsy. Everything else is truthy.

Index access

Postfix [ … ] reads an array element or an object key, and chains freely with . member access.

{ "text": "{{ state.items[0].name }}" }
{ "text": "{{ state.grid[1][0] }}" }
{ "text": "{{ state.users[state.idx].name }}" }
{ "text": "{{ state.user['name'] }}" }
{ "text": "{{ state.user[state.key] }}" }
{ "text": "{{ split(state.csv, ',')[1] }}" }

The index may be any expression. Rules worth knowing:

• Out of range, a missing key, or indexing a non-collection is null — never

an error.

• A negative index is null. Only at() counts from the end.
• A fractional index truncates; a numeric string coerces (items['1'] is

element 1).

• An object key is stringified, so obj[0] looks up the key "0".
• Strings are not indexable — 'abc'[0] is null. Use split(s, '').

Builtin functions

Collections

map, filter and the two-argument count take a sub-expression written as a string, with the element bound to it:

{ "text": "Total {{ sum(map(state.cart, \"it.price * it.qty\")) }}" }
{ "data": "{{ filter(state.todos, \"!it.done\") }}" }
{ "text": "{{ count(state.todos, \"it.done\") }} of {{ len(state.todos) }} done" }

A non-list subject yields the empty result rather than an error, so a binding never blows up on a state key that has not loaded yet.

The list-shaping calls (push, unshift, pop, shift, reverse, sort) are functional: each returns a NEW list and never mutates its subject — assign the result back when you want to keep it:

{ "type": "state.set", "path": "items", "value": "{{ push(state.items, state.draft) }}" }

Strings

{ "text": "{{ format('%s scored %.1f%%', state.name, state.pct) }}" }
{ "text": "{{ join(map(state.tags, \"upper(it)\"), ' · ') }}" }

Numbers and logic

Type checks

JSON

Audio (canvas engine only)

Dispatch

An unknown function name evaluates to null at runtime — but the loader statically checks arity and argument types for the collection and format calls, so qorm run reports the mistake before you see a blank screen.

Derived values (computed)

When the same expression appears in a dozen bindings, declare it once in the manifest instead. computed is a map of name → expression, written beside globalState (or nested inside it, which normalises to the top level on a round trip):

{
  "type": "app", "id": "cart", "entry": "main",
  "globalState": { "schema": { "items": "array" }, "initial": { "items": [] } },
  "computed": {
    "itemCount": "{{ sum(map(state.items, \"it.qty\")) }}",
    "subtotal":  "{{ sum(map(state.items, \"it.price * it.qty\")) }}",
    "shipping":  "{{ computed.subtotal >= 50 ? 0 : 5 }}",
    "total":     "{{ computed.subtotal + computed.shipping }}",
    "isEmpty":   "{{ len(state.items) == 0 }}"
  }
}

Read them as {{ state.computed.total }} in a scene binding and {{ computed.total }} inside an action. Both spellings resolve in both places (examples/derived uses the state.-rooted form in scenes), but they are not quite the same expression inside an action — see Which spelling to use in an action below. A derived value may read other derived values in any declaration order, as shipping and total do above.

What a declaration is worth knowing about:

• Evaluated once per frame, not once per read. A value bound by twelve

nodes is computed once, and the view is stable for the whole of a dispatch: the published values refresh at frame boundaries (the end of a top-level dispatch, a render step, a scene entry), not after each step. So a step that writes state.items and a later step in the same action that reads {{ computed.subtotal }} still sees the pre-dispatch value.

• Read-only. An action step whose path / result / error targets the

namespace is a load-time error and is dropped at dispatch — the whole step, so a gated http.get never even issues its request. Both spellings are refused: "path": "computed.total" and "path": "state.computed.total" alike. (A step path is already relative to the state root, so any state.-prefixed path is a mistake — writing "path": "state.count" would create a top-level state key literally named state. The loader warns.)

• A cycle is inert, not fatal. Values on a dependency cycle (and anything

downstream of one) are reported at load time and simply evaluate to nothing; the rest of the app still works.

• Names must be plain identifiers. A derived expression sees state.*, t and

viewport.* — but not route.*, so route parameters cannot feed one.

• An app that declares no computed keeps computed as an ordinary, writable

state key; none of the above applies to it.

Which spelling to use in an action

Inside an action the two spellings read the same value until a frame lands mid-action, and then they diverge:

That is not special to computed. An action's context is built once, at dispatch entry: state is the live store, while every top-level state key also offered under its bare name ({{ count }} for {{ state.count }}) is a copy taken at that moment. {{ computed.total }} is that bare spelling of the computed key, so it behaves exactly like {{ count }} does.

{ "type": "state.set", "path": "items", "value": "{{ push(state.items, 1) }}" },
{ "type": "render" },
{ "type": "state.set", "path": "shown", "value": "{{ state.computed.subtotal }}" }

Reading {{ computed.subtotal }} on that last line would show the subtotal from before the push. Use the state.-rooted spelling in an action that renders mid-flight; the bare one is fine (and shorter) in a straight-line action, and in scene bindings both are always current.

Where to go next

• First scene — lists, item scope, and styling.
• First action — if, invoke, and http branches.
• Node & style props — every prop a binding can be written into.