The host app's per-request hook, for headers a value cannot hold, a rotating bearer token
above all. It lives at the edge like the AbortController, changing independently of any step
event. This namespace holds the seam, barebuild.transport calls it.

The effect vocabulary: every value `step` may hand back for the executor to perform, and
nothing else. This namespace knows what an effect is, `resource` knows when to emit one and
what to put in it, and the executor in `elements/server-resource` performs exactly `tags`.

The request configuration the host declares as attributes, read into the keys the resource value
carries. Knows nothing of resources, effects or the engine.

The consumers one <server-resource> drives: which elements they are, what they may call back
into, and handing each a projected view.

One performer per tag in `effect/tags`, each named after the tag it performs. Every decision was
made inside `step` and rides the effect value, so nothing here decides anything. The three
effects that are round trips hand their outcome back through `emit!`, and are the only three the
table wraps.

One replaceable function the host app installs, called at the edge. The slot and the rule for
filling it live here. What calling the hook means belongs to whoever owns the slot, and that is
the whole of the difference between the two that exist.

The dev-only seam a debugger installs to watch every step, at the edge like the request
decorator.

Getting the bytes: decorate the request, send it, and give up when the budget runs out or a
teardown aborts. Knows nothing of resources, consumers, intents or the DOM.

The query value. A map of keyword to non-blank string, what both the URL projection and the
request are about. `canonicalize-query` is its normal form, so two queries that mean the same
compare equal wherever they came from.

The request value `step` hands the executor on a :fetch or a :write effect. Everything past
:url is absent rather than nil when it does not apply, so two requests that mean the same
compare equal.

The URL projection: how a resource reads its query out of the address bar and writes it back,
scoped so several resources can share one URL without colliding.

What a payload must satisfy, and how a record is read into its declared types. Two checkers
over the same declared shape: `validate-contract` for an accepted envelope the server sent,
`validate-payload` for a record the client is about to send.

Conversion 1, the JSON-to-CLJS edge. A server JS object read as an envelope value, or as a
marker saying why it could not be read. Only the protocol's own closed vocabulary becomes
keywords, opaque domain keys stay strings, and what leaves here is CLJS.