arrmatura 6.3.2 → 6.5.0

package/docs/built-ins.md

@@ -0,0 +1,223 @@
+---
+title: "Built-ins"
+description: "Collection of Intrinsic built-in components."
+keywords: [arrmatura]
+---
+
+Built-ins are the components the runtime implements itself.
+
+## Element — native tags
+
+Lowercase tags and `div`.
+
+```xml
+<div class="card {active ? 'active'}" click="-> select(id)">{title}</div>
+```
+
+- All attributes compile through `compileAttribute`; element text compiles into the `#text` property.
+- Children are compiled lazily on first `getSubNodes`.
+- The component is built as `platform.createComponent({ tag, native: true })`.
+
+## Composite — registered components
+
+Any other capitalised tag.
+
+```xml
+<Card Ref="card" title="{doc.title}" />
+```
+
+- Content comes from the *registered template* of the tag, not from the children written at the call
+  site — those become slot content (see `Slot`).
+- `Ref` is appended to the manifest `uid`, so two usages differing only by `Ref` stay distinct.
+- Tag lookup falls back through dotted prefixes (`Page.Docs.Header` → `Page.Docs` → `Page`).
+
+## If / Then / Else
+
+```xml
+<div If="isReady">ready</div>
+
+<Fragment If="count > 0">
+  <Then><List items="{items}" /></Then>
+  <Else><Empty /></Else>
+</Fragment>
+```
+
+- The expression may be written bare or fully wrapped in `{…}`; a partial template is not supported.
+- The condition is coerced with `!!`.
+- Branches are resolved once and cached:
+
+| Children | then-branch | else-branch |
+| --- | --- | --- |
+| neither `Then` nor `Else` | the element itself, minus `If` | nothing |
+| `Else` only | the element minus the `Else` child | children of `Else` |
+| `Then` only | children of `Then` | nothing |
+| both | children of `Then` | children of `Else` |
+
+As soon as an explicit `<Then>` is present the host element is dropped and only its children render.
+Use `<Fragment If>` for if/else, and the bare form for a single branch.
+
+### Slot presence check
+
+```xml
+<div If="Slot(header)"><Slot Key="header" /></div>
+```
+
+`Slot(key)` is a compile-time special form, not an expression: the condition becomes "the caller
+passed non-empty content for that slot". It reads the enclosing `Composite` directly and must not be
+placed inside an iteration.
+
+## Each
+
+```xml
+<Item Each="item of items" data="{item}" />
+<Row  Each="row of data | mapEntries" row="{row}" />
+```
+
+Syntax is `<name> <word> <expression>`: the first token names the item, the second is ignored (`of`
+by convention), the rest is the expression.
+
+The value is normalised by `narrowData`:
+
+| Input | Items |
+| --- | --- |
+| falsy | `[]` |
+| `"a, b"` | `{ id, name }` per comma-separated token |
+| array | objects kept, `id` forced to string; scalars become `{ id, name }` |
+| iterable | spread as-is |
+| object | entries become items keyed by their key |
+
+Then:
+
+- The item key is `datum.id`, falling back to `hashCodeOf(datum)`. A **duplicate key is logged as an
+  error and skipped**, so the row disappears.
+- Each item gets a cloned manifest with `uid = <uid>#<key>`, which is what makes reuse across renders
+  stable.
+- `IterativeItem` opens a scope: `item` and `item.*` resolve against itself, everything else and all
+  `emit` calls delegate to the enclosing scope.
+- Item data is re-read from the live map on every render, so mutating an existing item propagates
+  into the reused child.
+
+## Fragment / Then / Else
+
+```xml
+<Fragment If="showContent">
+  <Header />
+  <Content />
+</Fragment>
+```
+
+Transparent grouping: no component of its own beyond a plain `Component`, no new scope, children
+render in place. `Then` and `Else` compile to the same node and are meaningful only as direct
+children of an `If` element.
+
+## Dynamic
+
+```xml
+<Dynamic As="{viewMode == 'list' ? 'ListView' : 'GridView'}" items="{items}" />
+```
+
+- `As` compiles into the internal `_dynamicTag` property; every other attribute and all children pass
+  through to the resolved tag.
+- The resolved element is compiled once per distinct tag value and cached on the node.
+- Missing `As` compiles to the tag `Error.Dynamic`; an expression resolving to `undefined` falls back
+  to the compiler default, a `div`.
+
+## Slot
+
+Content projection. `Composite` groups the children written at the call site by their `Slot`
+attribute, defaulting to the group `default`.
+
+```xml
+<!-- definition -->
+<Component id="Card">
+  <div class="card">
+    <Slot Key="header" />
+    <Slot />
+    <Slot Key="footer" />
+  </div>
+</Component>
+
+<!-- usage -->
+<Card>
+  <Fragment Slot="header"><h1>{title}</h1></Fragment>
+  <p>body</p>
+  <Fragment Slot="footer"><Btn label="OK" /></Fragment>
+</Card>
+```
+
+- `Key` selects the group; no `Key` means `default`.
+- An unfilled slot renders nothing.
+- Projected content resolves properties and refs **at the call site** (`scopeForChildren` is the
+  grandparent scope), so it sees the caller's data, not the component's internals.
+- Slot groups are compiled once per component usage and cached.
+
+## Selector
+
+Multi-way switch on one string key.
+
+```xml
+<Selector On="{node | typeOf}">
+  <Case When="object"><XmlElement node="{node}" /></Case>
+  <Case When="string"><span>{node}</span></Case>
+  <Case When="default">—</Case>
+</Selector>
+```
+
+- Children are grouped by their `When` attribute; the child tag name is never inspected, `Case` is
+  convention only.
+- Matching is exact string equality against `On`, falling back to the group `default`.
+- No match and no `default` renders nothing.
+- `On` is commonly composed from several fragments (`"{data|typeOf}{isValuable(data) ? '' : '-empty'}"`).
+
+## Connector
+
+A component with no output that forwards values. Two modes, chosen by the presence of `trigger`.
+
+| Mode | Attributes | Behaviour |
+| --- | --- | --- |
+| data | `data`, `change` | every time `data` resolves to a value other than `undefined`, call `change` with it |
+| trigger | `trigger`, `data`, `change` | every time `trigger` resolves to a value other than `undefined`, resolve `data` and call `change` with the resolved data |
+
+```xml
+<Connector data="@query.data" change="-> options" />
+<Connector data="{find(R.enums[typeSpec], value)}" change="-> item" />
+<Connector trigger="1" change="-> @service.nextQuestion()" />
+<Connector data-value="{value}" trigger="{value}" change="{onChange}" />
+```
+
+- Promises are unwrapped on both `data` and `trigger`, so async sources need no extra handling.
+- `change` is either a `->` emitter or a function-valued expression.
+- Attributes are re-ordered at compile time — `change` first, `trigger` last — because state applies
+  in that order and the firing setter must find its target already set.
+- `trigger="1"` is the idiom for "run once when this subtree mounts".
+
+## Block
+
+Renders XML nodes produced at runtime.
+
+```xml
+<Block Nodes="{@mdService.nodes}" />
+```
+
+- `Nodes` holds an `XmlNode[]` (as produced by `xmlParse` or by a service, e.g. a markdown renderer).
+- The array is compiled on every render — array input is not memoised, unlike compilation by tag.
+- `Ref` is appended to the manifest `uid`, as for `Composite`.
+- A missing or empty `Nodes` renders nothing.
+
+## Root
+
+`CRootNode` / `RootCtx` have no tag and are not reachable from CML. `launch()` and `applyTemplate()`
+wrap a template string in one: it parses the XML, opens the outermost scope, exposes no slots, and
+builds a bare `Component`.
+
+## Gotchas
+
+- `Each` and `If` on the same element: the loop is outer, the condition is evaluated per item.
+- An explicit `<Then>` drops the host element; only its children render.
+- Duplicate `id` values inside `Each` silently lose rows (logged as an error).
+- `Slot(key)` in an `If` must not be used inside an iteration.
+- Slot content sees the caller's scope, not the component's — passing data *into* a slot means passing
+  it through properties.
+- `Selector` matches strings exactly; a numeric `On` will not match `When="1"` unless it stringifies
+  to exactly that.
+- A tag whose first character is a digit is treated as a component and will be reported as unknown.

package/docs/cml.md

@@ -0,0 +1,342 @@
+---
+title: "Component Markup Language"
+description: "CML syntax: lexical rules, attribute forms, expressions, references and event bindings."
+keywords: [arrmatura, cml, syntax]
+---
+
+CML is the XML dialect Arrmatura templates are written in.
+
+A `.xml` source registers one or more component types; the runtime parses it once, compiles each element into a manifest node, and instantiates that node per live component.
+
+This document is the **syntax** reference.
+
+- for the semantics of each built-in element see [built-ins.md](./built-ins.md);
+- for the runtime model see [architecture.md](./architecture.md).
+
+## Lexical structure
+
+CML is a strict XML subset, parsed by `xmlParse` (`src/utils/xmlParse.ts`).
+
+| Production | Rule |
+| --- | --- |
+| Tag name | `[A-Za-z][A-Za-z0-9._:-]*` — dots and dashes are legal and meaningful (`Page.Speaking`, `This-Stat`) |
+| Attribute name | `[A-Za-z][A-Za-z0-9:$-]*` — **no `_`, no `.`** |
+| Attribute value | double quotes only; `'single'` and bare values are not valid XML here |
+| Bare attribute | `<input disabled>` — a valueless attribute compiles to `true` |
+| Self-closing | `<Btn />`; also implicit for `img`, `input`, `br`, `hr`, `col`, `source` |
+| Comment | `<!-- ... -->`, stripped before compilation |
+| Entity | `&amp;` `&lt;` `&gt;` `&quot;` `&nbsp;` `&#65;` `&#x41;` are decoded; an unknown 2–5 char entity becomes a space |
+| Mismatched close | throws; the platform degrades the whole template into a `div` showing the error |
+
+### Attribute values are scalar-coerced
+
+Before any expression handling, a quoted value is passed through `scalarParse`:
+
+| Source | Value | Type |
+| --- | --- | --- |
+| `size="3"` | `3` | number |
+| `open="true"` / `open="false"` | `true` / `false` | boolean |
+| `x="null"` / `x="undefined"` | `null` / `undefined` | — |
+| `name="John"` | `"John"` | string |
+| `id="12abc"` | `"12abc"` | string (NaN falls back) |
+| `code="12345678901234567890"` | string | over 17 chars stays a string |
+
+A non-string result skips expression compilation entirely and is applied once at init.
+
+### Text content
+
+- `<div>Hello</div>` — the text becomes the element's `#text` attribute and follows the normal attribute rules, so `<div>Hello {name}</div>` interpolates.
+- Mixed content — text interleaved with child elements is wrapped in a `Text` node carrying a `text` attribute: `<div>Hi <b>x</b></div>` yields `<Text text="Hi " />` plus `<b>`. A `Text` component must be registered for it to render (`arrmatura-web` provides one).
+
+## Component definition
+
+```xml
+<Component id="UserCard">
+  <Signature purpose="Display a user" group="Data">
+    <Prop id="name" type="string" required="true" />
+    <Prop id="size" type="enum" enum="sm,md,lg" />
+  </Signature>
+
+  <div class="card">{name}</div>
+</Component>
+```
+
+- `id` is the **tag** the component is used under; it is required and must be double-quoted.
+- `<Signature>` declares the component's contract; it is stripped at registration and never reaches the compiler — see [Signature](#signature).
+- One file may hold several `<Component>` blocks.
+- A tag whose first character is lowercase compiles to a native element; uppercase or digit means a registered component. A `div` is always native.
+- Tag lookup falls back through dotted prefixes: `Page.Speaking.Header` tries `Page.Speaking`, then `Page`. A component registered at a short prefix silently captures every longer tag.
+
+### Subcomponents
+
+```xml
+<Component id="Page">
+  <This-Stat value="1" />
+
+  <Subcomponent id="Stat">
+    <div>{value}</div>
+  </Subcomponent>
+</Component>
+```
+
+`<Subcomponent id="Stat">` registers as the flat tag `Page-Stat`, and `This-` inside the enclosing `<Component>` rewrites to that prefix. Subcomponents register flat, so never nest one inside another; siblings reference each other with `This-`.
+
+## Signature
+
+`<Signature>` declares a component's public contract. It is removed by `createRegisterTypes` before compilation, so it costs nothing at runtime and cannot affect rendering. It exists for tooling: `catalog.json`, the component gallery, editor completion, and agents reading the source.
+
+```xml
+<Component id="Forma">
+  <Signature purpose="Renders a whole data form from a field-metadata list"
+    description="The form engine: hands `meta` to FormController, which dispatches each field to `Field.{type}`."
+    group="Fields">
+    <Prop  id="meta" type="array" required="true" description="Field definitions" />
+    <Prop  id="disabled" type="boolean" default="false" description="Makes every field read-only" />
+    <Slot  name="default" description="Content pinned into the tab strip" />
+  </Signature>
+
+  <div class="flex flex-col-reverse {class}">...</div>
+</Component>
+```
+
+### Placement
+
+- One `<Signature>` per `<Component>`, written as its first child. The stripper removes every `<Signature>` block wherever it sits, so a second one is silently tolerated rather than reported.
+- A `<Subcomponent>` may carry its own; it is stripped with the subcomponent and never leaks into the parent template.
+- Both the self-closing `<Signature ... />` and the paired form are recognised.
+
+### Signature attributes
+
+| Attribute | Required | Meaning |
+| --- | --- | --- |
+| `purpose` | yes, by convention | one line — what the component is for |
+| `description` | recommended | prose: behaviour, caveats, when to reach for it |
+| `group` | recommended | catalog grouping (`Fields`, `Layout`, `Table`, `Markdown`, `Platform`, …) |
+| `kind` | services only | `"service"` marks a non-rendering component; omit it on UI components |
+| `name` | rarely | human-readable label; defaults to the component `id` |
+
+### Child elements
+
+| Element | Declares | Attributes |
+| --- | --- | --- |
+| `<Prop>` | an input property | `id`, `type`, `description`, `required`, `default`, `enum`, `alias` |
+| `<State>` | a property the component publishes back | `id`, `type`, `description`, `enum` |
+| `<Method>` | a method reachable through a `->` binding | `id`, `args`, `description` |
+| `<Slot>` | a named content slot | `name`, `description` |
+
+`<Method args="...">` is free text describing the call shape — a bare name (`args="id"`) or a destructured object (`args="{ fieldId, value }"`).
+
+The signature `<Slot name="…">` documents a slot; the runtime `<Slot Key="…">` renders one. Same tag, different attribute, different context.
+
+Only `<Prop>` is consumed by `generate-catalog.ts` today; `<State>`, `<Method>` and `<Slot>` are read by people and agents.
+
+### Property types
+
+`ComponentPropertyType` in `src/types.ts` declares `string | number | boolean | object | array | function | any`. Nothing validates against it, and the vocabulary actually in use is wider:
+
+| Type | Use |
+| --- | --- |
+| `string`, `number`, `boolean`, `object`, `array`, `any` | as expected |
+| `action` | a `->` handler property — the most common type after `string` |
+| `enum` | a closed set; pair with `enum="sm,md,lg"` |
+| `class` | a CSS class list |
+
+`enum="a,b,c"` is a comma-separated list, split by the catalog generator. `required="true"` and `default="..."` are plain attribute values, so they pass through scalar coercion like any other.
+
+### Services
+
+A TypeScript service is declared in CML as a signature-only component. Its body is the diagnostic shown when the class was not registered:
+
+```xml
+<Component id="OnMount">
+  <Signature kind="service" purpose="Fires one action once, when the component mounts"
+    description="Arrmatura exposes no DOM mount event, so one-shot side effects wire through __init. Renders nothing."
+    group="Platform">
+    <Prop id="action" type="action" required="true" description="Handler invoked once on mount" />
+  </Signature>
+  <p class="error">Service OnMount is not imported</p>
+</Component>
+```
+
+### Escaping
+
+Descriptions are ordinary attribute values, so `<`, `>` and `"` must be written as entities: `filter_&lt;fieldId&gt;`, `action=&quot;-&gt; @docs.refresh()&quot;`. Backticks and `{}` are safe — the stripped block is never compiled.
+
+## Attribute forms
+
+`ManifestNode.compileAttribute` classifies every attribute. The first matching row wins.
+
+| # | Form | Example | Compiled as |
+| --- | --- | --- | --- |
+| 1 | `data-*` (except `data-theme`) | `data-row="{row}"` | merged into the `data` object under `row` |
+| 2 | `Ref` | `Ref="api"` | reference name, not state |
+| 3 | `Props` | `Props="{item}"` | object spread — each entry becomes a property |
+| 4 | non-string value | `size="3"`, `open` | literal, applied once at init |
+| 5 | `'…'`-wrapped value | `args="'key=value'"` | literal string, applied once at init — **the escape hatch for text containing `{` or `->`** |
+| 6 | `@ref` (no `{`) | `data="@ctrl.options"` | reference or bound expression (see below) |
+| 7 | `-> …` (no `{`) | `click="-> save()"` | event handler, applied once at init |
+| 8 | contains `{` | `title="Hi {name}"` | expression, re-resolved on every render pass |
+| 9 | anything else | `class="card"` | constant string |
+
+Rows 6 and 7 are tested **only when the value contains no `{`**. `click="-> pick({id})"` is therefore not a handler — it is form 8, an interpolated string.
+
+## Expressions
+
+A value containing `{` is an expression. Two shapes:
+
+| Shape | Example | Result |
+| --- | --- | --- |
+| Whole-attribute placeholder | `count="{items.length}"` | the **raw value** — number, object, array, promise |
+| Interpolated template | `title="{first} {last}"` | a **string**; each part is stringified, `null`/`undefined` render as `""` |
+
+A whole-attribute placeholder must have no nested `{`; otherwise the template path is taken and the value becomes a string.
+
+### Primary forms
+
+| Form | Example |
+| --- | --- |
+| Literals | `true`, `false`, `null`, `undefined`, `42`, `-5`, `'text'`, `"text"` |
+| Identifier | `name` — resolved against the enclosing scope's component |
+| Event payload | `it`, `event` — the handler argument; `undefined` outside a `->` binding |
+| Resources | `R.app.name`, `R.enums[typeSpec]` — `R` is the whole resource tree |
+| Member access | `obj.prop`, `arr[0]`, `obj["a" + b]` |
+| Call | `find(items, id)`, `slice(data, 0, 5)` |
+| Grouping | `(a + b) * c` |
+
+Every `.prop` access is optional-chained, so a missing link yields `undefined` rather than throwing.
+
+Functions resolve from `resources.functions` — an app helper cannot shadow a library one.
+
+Identifier characters are `[A-Za-z0-9_$-]`, which **includes `-`**. `count-1` is one identifier; subtraction needs spaces: `count - 1`.
+
+### Pipes
+
+```xml
+{value | upper}
+{value | pipe:arg1:arg2 | pipe2 | pipe3}
+{@histo.data | filter : 'isSelected' : true}
+```
+
+A pipe is a function call with the piped value as the first argument. Pipes apply to the **whole placeholder only** — `{(name | upper)}` is a parse error.
+
+### Operator precedence
+
+Loosest to tightest:
+
+| Level | Operators | Notes |
+| --- | --- | --- |
+| 1 | `\|` (pipe) | top level of a placeholder only |
+| 2 | `? :` | the `:` branch is optional; `{a ? b}` yields `undefined` when false |
+| 3 | `??` | |
+| 4 | `\|\|`, `OR` | |
+| 5 | `&&`, `AND` | |
+| 6 | `===`, `==`, `!=` | does not chain |
+| 7 | `>=`, `>`, `<=`, `<`, `GTE`, `GT`, `LT` | does not chain |
+| 8 | `+`, `-` | |
+| 9 | `*`, `/`, `%` | |
+| 10 | `!` | the only prefix operator |
+| 11 | literal, identifier, `.`, `[]`, `(args)`, `(…)` | |
+
+Word forms exist for use where `<` and `&` are awkward in XML.
+
+**Not supported**: `**`, `!==`, `LTE`, unary `-` on an expression (only on a numeric literal), assignment, object and array literals, arrow functions, `new`, template literals.
+
+### Divergences from JavaScript
+
+| Expression | CML | JS |
+| --- | --- | --- |
+| `1 == '1'` | `false` — `==` is strict | `true` |
+| `10 - 3 - 2` | `9` — binary operators are **right**-associative | `5` |
+| `12 / 6 / 2` | `4` | `1` |
+| `'a' + 1 + 2` | `"a3"` | `"a12"` |
+| `a == b == c` | parse error | `false` |
+
+Parenthesise anything that chains a `-` or a `/`: `{(10 - 3) - 2}`.
+
+## References
+
+`@` addresses another component by its `Ref=` name. Names resolve up the scope chain — current scope, then each parent — so a reference is visible only inside the subtree of the component that declares it.
+
+```xml
+<Service Ref="api" />
+
+<Display data="{@api.result}" />        <!-- reactive: a connector -->
+<Editor  service="@api" />              <!-- inject the component instance itself -->
+<button click="-> @api.refresh()">Go</button>
+```
+
+| Form | Meaning |
+| --- | --- |
+| `@ref` (alone, no dot) | inject the referenced component instance, read once at init |
+| `@ref.prop` | a **connector** — subscribes to `ref` and re-applies the value whenever it changes |
+| `@ref.prop` inside `->` | a plain read at call time, compiled to `$RefProp('ref','prop')`; no subscription |
+| `@ref.method()` inside `->` | a call on the referenced component |
+
+`this` / `This` are always resolvable and mean the current component.
+
+`@` is rewritten by a regex that ignores quoting, so `@word.word` inside a string literal also becomes a reference: `'example@gmail.com'` resolves a phantom `gmail` ref.
+
+## Event bindings
+
+A handler is an attribute whose value starts with `->` and contains no `{`.
+
+```xml
+<button click="-> count = count + 1">+1</button>
+<button click="-> @api.refresh()">Refresh</button>
+<button click="-> save(it)">Save</button>
+<input  change="-> value = it; touched = true" />
+```
+
+| Form | Effect |
+| --- | --- |
+| `-> key = expr` | `up({ key: <expr> })` on the enclosing component |
+| `-> @ref.key = expr` | same, on the referenced component |
+| `-> method(args)` | calls `method` on the enclosing component; no args passes the event payload |
+| `-> @ref.method(args)` | calls the method on the referenced component |
+| `-> key` | `up({ key: <payload> })` on the enclosing component |
+| `a; b; c` | statements run in order, each awaited |
+
+`it` and `event` inside a handler are the payload the platform passed in. A single argument is awaited before the call; two or more are passed as-is. A failing handler is logged, never rethrown.
+
+## Control flow
+
+Control flow is expressed by reserved attributes and reserved tags. Syntax only here — see [built-ins.md](./built-ins.md) for behaviour.
+
+| Syntax | Rule |
+| --- | --- |
+| `If="expr"` | expression; surrounding `{}` optional. Tested **before** the tag, so it works on any element |
+| `If="Slot(name)"` | compile-time special form: true when slot `name` has content |
+| `Each="item of expr"` | literally `<name> of <expression>`; **no braces**, the second word is skipped |
+| `Each` + `If` together | legal: `Each` is tested first and wraps the loop, `If` then applies per item |
+| `<Then>` / `<Else>` | branch wrappers, valid only as direct children of an `If` element |
+| `<Fragment>` | groups nodes without emitting an element |
+| `<Dynamic As="{expr}" Props="{obj}" />` | tag chosen at runtime; `As` also accepts a template: `As="Field.{type \| capitalize}"` |
+| `<Block Nodes="{nodes}" />` | renders a runtime `XmlNode[]` |
+| `<Slot Key="name" />` / `Slot="name"` | slot declaration / assignment of a child to a slot |
+| `<Selector On="{expr}">` with `<Case When="value">` | exact string match; `When="default"` is the fallback |
+| `<Connector data="{…}" change="-> …" />` | data-driven; add `trigger="{…}"` for the trigger-driven variant |
+
+```xml
+<div If="isReady">Content</div>
+
+<Fragment If="{@docs.loading}">
+  <Then><Spinner /></Then>
+  <Else><Article /></Else>
+</Fragment>
+
+<Row Each="row of pivot.rows" data="{row}" />
+<Tag Each="tag of slice(data, 0, data.length > 6 ? 5 : 6)" data="{tag}" />
+```
+
+Inside an `Each` body the item name is the only identifier resolved locally; everything else falls through to the enclosing scope. Items are keyed by the datum's own `id` field (not by any `id` attribute) — a duplicate is logged and **skipped**, so a list without unique ids renders one row.
+
+## Gotchas
+
+- **`If="false"` is ignored.** `false`, `0` and `""` are scalar-coerced to falsy values, and the compiler tests `attrs.If` for truthiness — so the attribute is dropped and the element always renders. Use `If="{false}"`.
+- **An unbraced value is a constant, not an expression.** `disabled="isBusy"` is the string `"isBusy"` (permanently truthy) and `click="save"` is a string, not a call. Only `If`, `Each`, `Props`, `As` and `Ref` read their value as an expression without braces.
+- **Literal `{` needs the quote escape.** `<p>{id}</p>` compiles an expression; `<p args="'{id}'" />` keeps the braces. Text patterns containing braces are better supplied from resources via `Props=`.
+- **`==` is strict.** Compare like with like — an id typed as a number never equals its string form.
+- **`-` and `/` are right-associative**, and `a-b` without spaces is one identifier.
+- **Exponentiation is not a CML operator.** `a ** b` silently yields `NaN` instead of a parse error.
+- **Attribute names cannot contain `_` or `.`** — the attribute regex drops them.
+- **A `Ref` is subtree-scoped.** `@foo` is unreachable from a sibling subtree; hoist the declaration or repeat it.

package/index.ts

@@ -1,22 +1 @@
-import { IArrmatron, IPlatform } from "arrmatura/types";
-
-import { CRootNode } from "./src/registry/root";
-
-export * from "./src/registry";
-export { CRootNode } from "./src/registry/root";
-export * from "./src/core/Component";
-
-/**
- * Launches the runtime with given top-level template on the specified platform.
- *
- * @param {IPlatform} platform - The platform on which to launch the template.
- * @param {string} template - The template to launch with.
- * @return {IArrmatron} The root context object.
- */
-export const launch = (platform: IPlatform, template: string): IArrmatron => {
-  const root = new CRootNode(template).createArrmatron(platform);
-
-  root.up({}, true);
-
-  return root;
-};
+export * from "./src";

package/package.json

@@ -1,27 +1,29 @@
 {
   "name": "arrmatura",
-  "version": "6.3.2",
-  "description": "Arrmatura runtime engine",
-  "author": "alitskevich@gmail.com",
-  "license": "ISC",
+  "version": "6.5.0",
+  "description": "General-purpose FRP framework",
+  "author": "alitskevich",
+  "license": "MIT",
   "type": "module",
+  "types": "./index.ts",
   "exports": {
-    "import": "./index.ts",
-    "require": "./dist/index.js"
+    "types": "./src/index.ts",
+    "require": "./dist/index.js",
+    "import": "./index.ts"
   },
   "files": [
-    "src",
     "dist",
+    "docs",
     "index.ts",
-    "types.ts",
-    "docs/**/*"
+    "src"
   ],
-  "dependencies": {
-    "arrmatura": "6.3.2",
-    "ultimus": "2.1.10"
-  },
   "scripts": {
-    "esbuild": "esbuild index.ts --bundle --outdir=./dist --platform=browser --format=esm --sourcemap --target=esnext --external:* --minify",
-    "pnpm:publish": "pnpm publish --no-git-checks"
+    "build": "esbuild index.ts --bundle --outdir=dist --format=cjs --platform=node --target=esnext --packages=external --minify --keep-names",
+    "lint": "biome check ./src",
+    "lint:fix": "biome check ./src --fix",
+    "test": "vitest",
+    "typecheck": "tsc",
+    "prepublish": "npm run build",
+    "publish": "npm publish"
   }
-}
+}