giles
14a6bd6411
STEP 5 (cards-as-objects). The importer no longer carries a Ghost body as one opaque sx_content string: host/blog--decompose! splits an (article …) into one stored card OBJECT per top-level block (is-a the mapped card-type + its field-values), links each by an ordered `contains` edge, and sets the post :body = (seq (ref c0) (ref c1) …). Card types now carry a render :template, so the new `ref` combinator (compose.sx) transcludes each card via the SAME typed-block path articles use. /import wired to decompose; the home index filtered to published so the "block"-status card objects stay hidden. Added the `val` leaf (raw field value, no <span>) for attribute interpolation in templates (href/src). The post page renders the transcluded cards — verified end-to-end (conformance 157/159; the 2 fails are the pre-existing relate-picker pagination pair, unrelated). PERF (the conformance-speed fix). host/blog typing — types-of / instances-of / type-defs — computed the subtype closure via lib/relations descendants/ancestors, and EVERY such call re-saturates the whole CEK-interpreted Datalog ruleset (~seconds each). Typing is the hottest path (is-a?/types-of/instances-of run per post, per picker, per render), so this dominated both the blog suite and live page latency. Now the closure is a host-side BFS over the DIRECT subtype-of edges (the edge:* KV rows, via host/blog--subtype-closure) — one snapshot per closure, O(edges), cycle-safe, Datalog-free. Same transitive set (KV == relations for direct edges, host/blog-relate! writes both), so exact, not approximate. Drops Datalog out of the typing hot path entirely — speeds conformance AND the live site (/tags etc.). Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
132 lines
9.4 KiB
Markdown
132 lines
9.4 KiB
Markdown
# Composition objects — a content-addressed, data-driven UI model
|
||
|
||
Everything the system stores is an **object**: typed, content-addressed (`:cid`), in one graph.
|
||
"Post" was the blog's word; the unit is an object. A *document* is an object whose **body** is a
|
||
composition over other objects' CIDs. This is the cards-as-objects decision, generalised.
|
||
|
||
## One mechanism: ordered, labelled forks
|
||
|
||
An object forks into children via **labelled, ordered edges** (the relations engine + `order` on
|
||
the edge value + an optional `when`). There is no separate "composition system" — relations *are*
|
||
the forks. The **label** says what a fork means:
|
||
- **structural** (`contains`) → ordered, part of identity, rendered;
|
||
- **cross-cutting** (`tagged`, `related`, `author`) → loose links, not structural.
|
||
|
||
Multiple relations from an object *are* its fork. No "multiple DAGs per object" — fork immediately;
|
||
differently-labelled forks (`body` vs `aside`) give named slots. **Join** = a child CID referenced
|
||
by two forks — free, because content-addressed. The whole structure is a **Merkle DAG** (git trees
|
||
/ IPFS / artdag): `:cid` = hash over `fields + contains-forks (child-CID + order + when)`.
|
||
|
||
## The body is a tiny UI language (the render-fold is its interpreter)
|
||
|
||
A body is a composition node. Four combinators + leaves + references:
|
||
|
||
| node | meaning | strategy |
|
||
|------|---------|----------|
|
||
| `(seq …)` | **sequence** | render all (block), in order |
|
||
| `(row …)` / `(grid …)` | **layout** (par) | render all, side-by-side |
|
||
| `(alt (when P n) … (else n))` | **conditional** (or) | render the FIRST child whose `when` holds |
|
||
| `(each src tmpl)` | **iteration** (loop) | eval `src` → items; render `tmpl` per item (item bound) |
|
||
| `(ref CID)` | transclude | fetch object by CID, render its body |
|
||
| `(card TYPE fields)` | leaf | render via the card-type's `:template` (host/blog--instantiate) |
|
||
| `(tmpl NAME)` | **recursion** | a named template, may reference itself |
|
||
|
||
`seq/row` = render-**all** passing children; `alt` = render-**first** passing child. So **and/or/choice
|
||
all come from one axis (`when` on forks) × the container's all/first strategy** — `Alt` isn't a new
|
||
node kind, it's "first" instead of "all".
|
||
|
||
## The two fundamentals we designed IN
|
||
|
||
1. **Recursion** — `(tmpl NAME)` may reference itself; `(each (children) (tmpl NAME))` renders trees
|
||
(comment threads, nested nav, the `/meta` type hierarchy itself). Terminates naturally when a
|
||
query runs dry; a **depth guard** in the context backstops it.
|
||
2. **The context is an environment, not a flat dict.** `when` reads it; `each` *extends* it
|
||
(`:item`). Make it extensible + reactive-ready and the two non-composition axes plug in with NO
|
||
new combinators:
|
||
- **Behaviour / interactivity** (Slice 9 lifecycles/effects) — a button references a behaviour;
|
||
- **Reactivity / local state** (the reactive runtime) — `alt(when local-state=active-tab)` is a
|
||
tabset, `alt(when accordion-open)` an accordion; a *live* `each` re-renders on data change.
|
||
The static render-fold becomes a live, interactive UI purely by making the context live.
|
||
|
||
## The unifying property
|
||
|
||
**The object's CID is its *definition* (the query, the template, every `when`-variant). The
|
||
*rendering* is the *execution* (which items, which branch, which context).** The object is the
|
||
program; the render is the run. One immutable content-addressed object encodes its whole
|
||
responsive/personalised/variant space; rendering picks the path. Render-fold and the Slice-9
|
||
behaviour interpreter are the **same shape** — interpreters over content-addressed objects + the
|
||
decidable-core predicate set + the graph. The system converges on: objects + small interpreters.
|
||
|
||
## Beyond content — composition is universal; a fold per domain
|
||
|
||
The render-fold isn't "the content renderer" — it's **fold #1**. The composition DAG is a
|
||
**universal algebra** (`seq/par/alt/each` over content-addressed objects); *content* is just one
|
||
*interpretation*. Same structure, a different **fold** per domain — what changes is what the
|
||
combinators and leaves *mean*:
|
||
|
||
| domain | the fold | `seq` | `par` | `alt`+`when` | `each` | substrate |
|
||
|--------|----------|-------|-------|-----------|--------|-----------|
|
||
| **content** | render → HTML | block order | layout/columns | choose variant | map items | `compose.sx` (done) |
|
||
| **behaviour** | execute → effects | steps in order | concurrent | branch (if/cond) | for-each | `[[project_flow_on_sx]]` |
|
||
| **query** | eval → results | join/chain | union | conditional | iterate/quantify | `[[project_relations_on_sx]]` (Datalog) |
|
||
| **pipeline** | reduce → data | dataflow stages | parallel ops | choose path | fan-out | `[[project_artdag_on_sx]]` (content-addressed DAG) |
|
||
| **types** | extent → set | — | ∧ intersection | — | ∨ union | the type algebra (`make-and!`/`make-or!`) |
|
||
|
||
So **"relations just a fork" generalises**: a `contains` fork folded by *render* is a document; a
|
||
`then` fork folded by *execute* is a workflow step; a `depends-on` fork folded by *eval* is a
|
||
dependency graph. **The relation kind + the fold = the domain.** This isn't aspirational — the
|
||
repo's `X-on-sx` loops ALREADY ARE these folds (flow = execute, Datalog = eval, artdag = a
|
||
content-addressed composition DAG); we just hadn't seen them as one shape. The composition DAG is
|
||
the **convergence point** the whole fleet has been circling.
|
||
|
||
The payoff is concrete: **build the composition machinery ONCE** (forks + ordered edges + the four
|
||
combinators + a fold framework) → reuse for every domain by writing one interpreter. **The block
|
||
editor edits *any* composition** — author a workflow like a document, same structure, one editor.
|
||
The whole system collapses to four ideas: **content-addressed objects + a composition algebra +
|
||
per-domain folds + the decidable-core predicates (`when`).** The render-fold's shape (walk the
|
||
composition, dispatch combinators, recurse, read the context) is the *template* for every other fold.
|
||
|
||
## What lives elsewhere (not composition primitives)
|
||
|
||
Transclusion = a `ref` leaf. Sort/filter/limit/group = the *source query* language (Datalog).
|
||
`each` reconciliation keys = the item's CID (free). Empty / missing-CID = render-fold robustness
|
||
(the per-block guard). Async/streaming, events, local state = the behaviour + reactive axes.
|
||
|
||
## Build roadmap
|
||
|
||
1. **Keystone (this):** `lib/host/compose.sx` — the render-fold interpreter over seq/row/alt/each/
|
||
ref/card/tmpl, with the context-as-environment, `when` predicates, and recursion + depth guard.
|
||
Self-contained proof: render one composed object two ways (auth on/off) + a recursive tree.
|
||
2. Wire it to objects: a document's `:body` is a composition node; `contains` forks carry order;
|
||
`host/blog-render` dispatches to the render-fold when `:body` is present (else the legacy
|
||
`sx_content` path). Card leaves render via the existing card-type `:template`.
|
||
3. **(done)** `each` source = a graph query: `(query is-a TYPE)` resolves via a `query`
|
||
resolver injected into the render context (`host/blog--comp-ctx` binds
|
||
`host/blog--comp-query` → `host/blog-instances-of` → records). compose.sx stays
|
||
self-contained — it asks the context for the data; the host supplies graph access. The
|
||
list isn't baked into the body; it's whatever is-a TYPE *right now*. (`/compose-demo`
|
||
each is now a live query over seeded `compose-item` instances.)
|
||
4. **(done)** Live context: `host/blog--comp-ctx` routes auth + device (User-Agent) + locale
|
||
(Accept-Language) — read purely from the request — into the render context, so the SAME
|
||
object renders a responsive/personalised variant (`(alt (when (eq "device" "mobile") …) …)`).
|
||
Reactive values plug into the same context later with no new combinators.
|
||
5. **(done)** The typed importer decomposes content into card OBJECTS + a `contains` body
|
||
(cards-as-objects), instead of one `sx_content` string. `host/blog--decompose!` splits an
|
||
`(article …)` into one stored card object per block (is-a a card-type + field-values),
|
||
linked by ordered `contains` edges, with `:body = (seq (ref c0) (ref c1) …)`. Card types
|
||
carry a render `:template`, so the `ref` combinator transcludes each card via the existing
|
||
typed-block path. `/import` wired; home filtered to published so `"block"` cards stay hidden.
|
||
The `val` (raw value) leaf added for attribute interpolation. (Perf: typing now reads direct
|
||
KV `subtype-of` edges via a host-side BFS, not lib/relations — no Datalog re-saturation.)
|
||
6. The block editor edits the body (insert/reorder/`alt`/`each`) — the metamodel editor for content.
|
||
7. **Prove universality with a second fold.** Write a tiny `execute`-fold over the *same*
|
||
`seq/alt/each` structure that *runs* a workflow (leaves = effects; `seq` = steps in order, `alt`
|
||
= branch, `each` = for-each) — the way the recursive tree proved recursion, this proves the
|
||
composition algebra is domain-agnostic. Then the *behaviour* model (Slice 9) is "an `execute`-fold
|
||
over a composition object", not a separate system.
|
||
8. **Factor out the shared machinery** once two folds exist: the fork model (ordered, labelled,
|
||
`when`), the combinator dispatch, the context-environment, and recursion become a reusable
|
||
`compose` core; each domain (`render`, `execute`, `eval`, …) supplies only its leaf + combinator
|
||
semantics. The block editor + the metamodel UI then generalise to *every* fold — one composition
|
||
editor authors documents, workflows, queries, and pipelines alike.
|