@abide/abide 0.58.0 → 0.101.0

package/src/ui/rows.ts

@@ -0,0 +1,99 @@
+import { REGION_CLOSE, ROW_OPEN } from '#shared/ANCHORS.ts'
+import { leave } from './leave.ts'
+import { moveNode } from './moveNode.ts'
+import { closeOf, opensRegion, type Region, removeUntil } from './regions.ts'
+
+// WHAT A ROW IS IN THE DOCUMENT, decided here and nowhere else. A row is its ELEMENT where the
+// body has one; a body with several top-level nodes — `<dt>{k}</dt><dd>{v}</dd>` — is the RANGE
+// from its `ROW_OPEN` anchor to the next row's anchor or the region's close, as a region is its
+// pair. A range rather than the nodes `make` handed back: a region at the row's top level fills
+// AFTER the row is made, and a row held as that array moved without the arm's content.
+//
+// AN ANCHOR IS A COMMENT AND A SINGLE ROOT IS AN ELEMENT, so a row's first node says which kind of
+// row it is and no flag is carried beside it.
+
+/**
+ * The anchor ending the anchored row whose first node is `first`: the next `ROW_OPEN` or
+ * `REGION_CLOSE` at the row's own depth, or null where there is none in this parent.
+ *
+ * A region nested in the row is stepped over whole (`closeOf`), so a `{#for}` inside one — whose
+ * rows carry anchors of their own — is never mistaken for this row's end.
+ */
+function rowEnd(first: Node): Comment | null {
+    for (
+        let node: Node | null = first.nextSibling;
+        node !== null;
+        node = node.nextSibling
+    ) {
+        if (node.nodeType !== 8) continue
+        const data = (node as Comment).data
+        if (data === ROW_OPEN || data === REGION_CLOSE) return node as Comment
+        if (opensRegion(data)) {
+            node = closeOf(node)
+            if (node === null) return null
+        }
+    }
+    return null
+}
+
+/** Removes a row's nodes, from its first node to its end. */
+export function removeRow(first: ChildNode): void {
+    if (first.nodeType !== 8) {
+        leave(first)
+        return
+    }
+    removeUntil(first, rowEnd(first))
+}
+
+/**
+ * Moves a row's nodes, first to last, to before `before` through `moveNode`.
+ *
+ * TO THE LAST NODE RATHER THAN TO THE ROW'S END: a row moved before its own end puts each node it
+ * moves between its tail and the end, so the sibling after the tail is the row's own anchor again
+ * by the time the walk reaches it.
+ */
+export function moveRow(
+    parent: Node,
+    first: ChildNode,
+    before: Node | null,
+): void {
+    if (first.nodeType !== 8) {
+        moveNode(parent, first, before)
+        return
+    }
+    const end = rowEnd(first)
+    const last = end === null ? parent.lastChild : end.previousSibling
+    let node = first
+    for (;;) {
+        const next = node.nextSibling as ChildNode
+        moveNode(parent, node, before)
+        if (node === last) return
+        node = next
+    }
+}
+
+/**
+ * The first node of each row the server painted in `region`.
+ *
+ * Each element between the region's anchors, or each `ROW_OPEN` standing at the region's own depth
+ * — a `{#for}` nested in a row's arm carries anchors of its own, one depth down.
+ */
+export function rowsIn(region: Region, anchored: boolean): ChildNode[] {
+    const found: ChildNode[] = []
+    if (anchored) {
+        for (
+            let node = rowEnd(region.open);
+            node !== null && node !== region.close;
+            node = rowEnd(node)
+        )
+            found.push(node)
+        return found
+    }
+    for (
+        let node = region.open.nextSibling;
+        node !== null && node !== region.close;
+        node = node.nextSibling
+    )
+        if (node.nodeType === 1) found.push(node)
+    return found
+}

package/src/ui/setAttribute.ts

@@ -0,0 +1,37 @@
+import { attributeText } from '#shared/attributeText.ts'
+import { WORK } from '#shared/WORK.ts'
+
+/**
+ * Writes, or removes, a bound attribute, skipping an unchanged write.
+ *
+ * 32.3 — what an attribute binding writes, and the client half the server never had: `emitComponent`
+ * writes the value standing at render and, without this, nothing writes it again. A page whose
+ * `{count}` moved while its `class={tone}` did not is the shape that was shipping, and no
+ * correctness test of the first slot could see the second.
+ *
+ * NOT ESCAPED, for `escapeless`'s reason: the server concatenates into markup a browser parses, and
+ * `setAttribute` is not a parse. Escaping here would put `&` in a `title` where the server put
+ * `&`.
+ *
+ * 32.37 — PRESENT, ABSENT OR TEXT is `attributeText`'s answer, the one the server's markup took, so
+ * `disabled={busy}` going false removes the attribute the server wrote, and 32.20's scheme check is
+ * the same call on both sides.
+ *
+ * THE COMPARE IS THE REST OF THE POINT. `getAttribute` reads a value the element already holds —
+ * it is not a layout read and forces nothing — and a binding re-run by a value that landed on the
+ * same string is the common case rather than the rare one, so the branch is cheaper than the
+ * mutation it skips.
+ */
+export function setAttribute(
+    element: Element,
+    name: string,
+    value: unknown,
+): void {
+    WORK.bindingRuns += 1
+    const next = attributeText(name, value)
+    if (next === null) {
+        if (element.hasAttribute(name)) element.removeAttribute(name)
+        return
+    }
+    if (element.getAttribute(name) !== next) element.setAttribute(name, next)
+}

package/src/ui/setClass.ts

@@ -0,0 +1,27 @@
+import { WORK } from '#shared/WORK.ts'
+
+/**
+ * Toggles the one class a `class:name` binding owns.
+ *
+ * 32.10 on the client — `class:name` sets ONE class, and keeps setting it. Written through
+ * `classList` rather than through the `class` attribute the server built, for the reason
+ * `setStyleProperty` is written through the CSSOM: the server MERGED every `class:name` on the
+ * element into that one attribute beside the author's own `class`, so writing the attribute back
+ * would take the other names with it, where `toggle` touches exactly the one this binding owns.
+ *
+ * NO COMPARE OF ITS OWN, unlike `setAttribute` and `setStyleProperty`. `toggle` given a `force`
+ * is SPECIFIED to run the update steps only where the token's presence differs from it, so the
+ * branch its two siblings each carry is already inside the call. That is the spec and not a number
+ * taken here, and it is not one this package can take: `measure` counts the CALL, and happy-dom
+ * records an attribute mutation for a toggle that changes nothing, so neither instrument in
+ * `bun test` can tell the two apart. Pricing it needs `RecalcStyleCount` off the engine lane.
+ *
+ * THE VALUE IS A CONDITION, not a string: `class:overdue={days > 0}` is the shape 32.10 names, so
+ * the coercion is the whole of the value handling and there is nothing to escape. It is the one
+ * ToBoolean the server's `?:` makes (`classValue`), so the two read every value alike. The NAME is the
+ * author's own markup, fixed where the module was emitted.
+ */
+export function setClass(element: Element, name: string, on: unknown): void {
+    WORK.bindingRuns += 1
+    element.classList.toggle(name, Boolean(on))
+}

package/src/ui/setMarkup.ts

@@ -0,0 +1,20 @@
+import { WORK } from '#shared/WORK.ts'
+import { RawRun, refillRun, textToMarkup } from './RawRun.ts'
+
+/**
+ * Writes markup into a live run while part of it is `Raw`; returns the run's new state.
+ *
+ * 32.26 — what a live run's binding writes while a part of it is `Raw`: the run's markup, parsed
+ * between its anchors. `setText`'s other half, and the run's new state is what it hands back —
+ * the binding holds whichever the last write made.
+ *
+ * THE COMPARE IS `setText`'s: markup that landed on the same string is not parsed again, and a run
+ * the server painted keeps its nodes (see `RawRun`).
+ */
+export function setMarkup(target: Text | RawRun, markup: string): RawRun {
+    WORK.bindingRuns += 1
+    if (!(target instanceof RawRun)) return textToMarkup(target, markup)
+    if (target.html === undefined) target.html = markup
+    else if (target.html !== markup) refillRun(target, markup)
+    return target
+}

package/src/ui/setStyleProperty.ts

@@ -0,0 +1,30 @@
+import { oneStyleValue } from '#shared/escapeText.ts'
+import { textOf } from '#shared/Raw.ts'
+import { WORK } from '#shared/WORK.ts'
+
+/**
+ * Sets the one CSS property a `style:prop` binding owns, cut the way the server cuts it.
+ *
+ * 32.10 on the client — `style:prop` sets ONE property, and keeps setting it. Written through the
+ * CSSOM rather than through the `style` attribute the server built, because the server MERGED every
+ * `style:prop` on the element into that one attribute: writing the attribute back would take the
+ * other declarations with it, where `setProperty` touches exactly the one this binding owns.
+ *
+ * THE CUT IS THE SAME CUT THE SERVER MAKES, and sharing it is the whole reason it is a function.
+ * `escapeStyleValue` drops everything from the first `;` because a value carrying one declares
+ * more than one property; the CSSOM refuses such a value outright, so without this the server
+ * renders `color: red` from `red; position: fixed` and the first binding run removes it — one
+ * injection guard, two different answers. The ESCAPING is not shared: an attribute value is parsed
+ * and a CSSOM value is not, which is `escapeless`'s distinction again.
+ */
+export function setStyleProperty(
+    element: Element,
+    property: string,
+    value: unknown,
+): void {
+    WORK.bindingRuns += 1
+    const style = (element as HTMLElement).style
+    const next = oneStyleValue(textOf(value))
+    if (style.getPropertyValue(property) !== next)
+        style.setProperty(property, next)
+}

package/src/ui/setText.ts

@@ -0,0 +1,28 @@
+import { WORK } from '#shared/WORK.ts'
+import { markupToText, RawRun } from './RawRun.ts'
+
+/**
+ * Writes a slot's text, skipping an unchanged write; returns the run as a text node.
+ *
+ * What a slot's binding writes, and where a COMPILED SLOT RUNNING is counted. The emitted watch
+ * writes `setText(node, escapeless(a) + '…' + escapeless(b))` — or `setMarkup` where a part is
+ * `Raw` (32.26) — the node resolved once before it, so this is the LAST call in it and the only one
+ * that runs exactly once per slot however many dynamic parts the run has. `bindingRuns` is counted
+ * here rather than in the emitted code so the count is a property of the runtime and not of what a
+ * particular emitter remembered to write.
+ *
+ * The COMPARE is the rest of the point: a write to `data` that does not change it still costs,
+ * and a slot re-run by a value that landed on the same string is the common case rather than the
+ * rare one.
+ *
+ * THE RUN'S STATE COMES BACK, because a run that held markup is a text node again after this and the
+ * binding holds whichever it is. For a run that held text — every run whose value was never `Raw` —
+ * it is the node it was handed.
+ */
+export function setText(target: Text | RawRun, value: unknown): Text {
+    WORK.bindingRuns += 1
+    const next = value == null ? '' : String(value)
+    if (target instanceof RawRun) return markupToText(target, next)
+    if (target.data !== next) target.data = next
+    return target
+}

package/src/ui/socketWire.ts

@@ -0,0 +1,258 @@
+// 18.1 — THE MUX, AS A BROWSER HOLDS IT: one web socket per page, over which every `GET` the page
+// reads is followed (18.3). Each copy is kept in step with the value it was answered from: the value
+// where the version it holds is not the server's, and the writes of each patch over it (18.6, 18.11).
+
+import { ABIDE_ADDRESS, SOCKET_ADDRESS } from '#shared/ADDRESSES.ts'
+import { canonicalKey } from '#shared/reactive/canonicalKey.ts'
+import {
+    heldGenerationOf,
+    loadOf,
+    type Reactive,
+} from '#shared/reactive/index.ts'
+import { PATCHES } from '#shared/reactive/PATCHES.ts'
+import type { BrowserFrame, ServerFrame } from '#shared/muxFrames.ts'
+import { applyPatch } from '#shared/applyPatch.ts'
+import { onPrincipalRotated } from '#shared/principalRotated.ts'
+import { HYDRATE_LOG } from './Mismatch.ts'
+
+const RETRY_FLOOR_MS = 250
+const RETRY_CEILING_MS = 10_000
+
+/**
+ * A handler followed over the socket mux, its copy the `Rpc`'s entry for these args.
+ *
+ * 18.3 — beside the sockets on the same mux. The copy is reached through `entry` — a lookup by
+ * then, the follow starting once it has loaded. STATE, NOT A LOG: it names the version it holds
+ * (18.9) and takes whatever value it is sent (18.10).
+ */
+class Following {
+    id: number
+    address: string
+    args: unknown
+    version: number | undefined
+    entry: () => unknown
+    expiry: ReturnType<typeof setTimeout> | undefined
+    // 18.21 — WHERE THE COPY WAS LAST IN STEP: the generation it stood at, which a `set` or a new
+    // load moves, and the patch epoch then, which a local `s.patch` writes past on what it holds.
+    generation: number | undefined
+    epoch: number
+
+    constructor(
+        id: number,
+        address: string,
+        args: unknown,
+        version: number | undefined,
+        entry: () => unknown,
+    ) {
+        this.id = id
+        this.address = address
+        this.args = args
+        this.version = version
+        this.entry = entry
+        this.expiry = undefined
+        this.generation = undefined
+        this.epoch = 0
+    }
+
+    /** Marks the copy in step as it stands, its load in flight included. */
+    inStep(): void {
+        const copy = this.entry()
+        this.generation = loadOf(copy) ?? heldGenerationOf(copy)
+        this.epoch = PATCHES.epoch
+    }
+
+    /** Whether the copy was written to since it was last in step. 18.21. */
+    diverged(copy: unknown): boolean {
+        if (heldGenerationOf(copy) !== this.generation) return true
+        const held = (copy as Reactive<unknown>).peek()
+        return (
+            held !== null &&
+            typeof held === 'object' &&
+            (PATCHES.written.get(held) ?? 0) > this.epoch
+        )
+    }
+
+    /**
+     * Marks the copy stale once `lifeMs` runs out.
+     *
+     * 18.14 — the life is what is left of the production's own on the server (21.8). Stale rather
+     * than dropped: it goes on being served until a read or a probe runs the producer (7.17). The
+     * later answer's timer replaces the earlier, and an answer naming no life is bounded by
+     * `invalidate` alone (21.17).
+     */
+    expireAfter(lifeMs: number | undefined): void {
+        clearTimeout(this.expiry)
+        this.expiry =
+            lifeMs === undefined
+                ? undefined
+                : setTimeout(
+                      () => (this.entry() as Reactive<unknown>).invalidate(),
+                      lifeMs,
+                  )
+    }
+
+    frame(): BrowserFrame {
+        return {
+            op: 'sub',
+            id: this.id,
+            address: this.address,
+            args: this.args,
+            version: this.version,
+        }
+    }
+
+    receive(frame: ServerFrame): void {
+        const copy = this.entry() as Reactive<unknown>
+        if (frame.op === 'value') {
+            this.version = frame.version
+            copy.set(frame.value)
+            this.inStep()
+        } else if (frame.op === 'patch') {
+            // 18.12 — WRITES MADE OVER ANOTHER VERSION WOULD LAND SOMEWHERE ELSE, and 18.21 over a
+            // copy written to here, so the copy reads the value again instead, and the answer's
+            // version puts it back in step (18.9).
+            if (this.version !== frame.base || this.diverged(copy))
+                copy.refresh()
+            else {
+                this.version = frame.version
+                copy.patch((value) => applyPatch(value, frame.ops ?? []))
+                this.inStep()
+            }
+        } else if (frame.op === 'invalidate') copy.invalidate()
+        else if (frame.op === 'refresh') copy.refresh()
+        else if (frame.op === 'error')
+            HYDRATE_LOG.warning('a handler refused to be followed', frame.error)
+    }
+}
+
+/** One web socket carrying every followed `GET` under one address. */
+class Mux {
+    url: string
+    socket: WebSocket | null
+    subscriptions: Map<number, Following>
+    nextId: number
+    retry: number
+
+    constructor(url: string) {
+        this.url = url
+        this.socket = null
+        this.subscriptions = new Map()
+        this.nextId = 1
+        this.retry = RETRY_FLOOR_MS
+        onPrincipalRotated(() => this.reopen(), true)
+    }
+
+    /**
+     * Opens the socket again, so its upgrade carries the cookie as it now stands: a connection is
+     * answered as the caller it opened as (18.16), and a sign-in or sign-out has changed who that is.
+     */
+    reopen(): void {
+        const socket = this.socket
+        if (socket === null) return
+        socket.onopen = null
+        socket.onmessage = null
+        socket.onclose = null
+        socket.close()
+        this.socket = null
+        if (this.subscriptions.size !== 0) this.connect()
+    }
+
+    /**
+     * Registers a subscription and sends it, opening the socket where it is not open.
+     *
+     * A subscription is never queued: `onopen` sends every one standing, so one registered before
+     * the socket opens goes out with them.
+     */
+    subscribe(subscription: Following): void {
+        this.subscriptions.set(subscription.id, subscription)
+        if (this.socket?.readyState === WebSocket.OPEN)
+            this.socket.send(JSON.stringify(subscription.frame()))
+        else this.connect()
+    }
+
+    connect(): void {
+        if (this.socket !== null) return
+        const socket = new WebSocket(this.url)
+        this.socket = socket
+        socket.onopen = () => {
+            this.retry = RETRY_FLOOR_MS
+            // Every subscription again, carrying the version it holds (18.9).
+            for (const each of this.subscriptions.values())
+                socket.send(JSON.stringify(each.frame()))
+        }
+        // THE CLOSE THAT FOLLOWS IS WHAT RETRIES; an error left unhandled is only noise on top of it.
+        socket.onerror = () => {}
+        socket.onmessage = (event) =>
+            this.receive(JSON.parse(String(event.data)) as ServerFrame)
+        socket.onclose = () => {
+            this.socket = null
+            if (this.subscriptions.size === 0) return
+            setTimeout(() => this.connect(), this.retry)
+            this.retry = Math.min(this.retry * 2, RETRY_CEILING_MS)
+        }
+    }
+
+    receive(frame: ServerFrame): void {
+        this.subscriptions.get(frame.id)?.receive(frame)
+    }
+}
+
+// Exported for a test to forget: a page never does, and a test process outlives one.
+export const MUXES = new Map<string, Mux>()
+
+/**
+ * The mux a socket's or a handler's address is carried over, made on first use.
+ *
+ * `SOCKET_ADDRESS` under whatever the address stands below, so an app under a sub-path opens its
+ * own.
+ */
+function muxFor(address: string): Mux {
+    const below = address.indexOf(ABIDE_ADDRESS)
+    const path = `${below === -1 ? '' : address.slice(0, below)}${SOCKET_ADDRESS}`
+    const url = new URL(path, location.href)
+    url.protocol = url.protocol === 'https:' ? 'wss:' : 'ws:'
+    let mux = MUXES.get(url.href)
+    if (mux === undefined) {
+        mux = new Mux(url.href)
+        MUXES.set(url.href, mux)
+    }
+    return mux
+}
+
+/**
+ * The follow standing per handler and args, one for the life of the page.
+ *
+ * One however often the entry loads. A later answer names a later version, which is what a
+ * reconnect then names (18.9).
+ */
+const FOLLOWING = new Map<string, Following>()
+
+/**
+ * Follows a loaded `GET`'s copy over the mux, raising its version and resetting its expiry.
+ *
+ * `version` and `lifeMs` are what the answer named, read off its headers by the wire.
+ */
+export function followRpc(
+    address: string,
+    args: unknown,
+    version: number | undefined,
+    lifeMs: number | undefined,
+    entry: () => unknown,
+): void {
+    const key = `${address} ${canonicalKey(args)}`
+    let following = FOLLOWING.get(key)
+    if (following === undefined) {
+        const mux = muxFor(address)
+        following = new Following(mux.nextId++, address, args, version, entry)
+        FOLLOWING.set(key, following)
+        mux.subscribe(following)
+    } else if (version !== undefined && (following.version ?? 0) < version)
+        // 18.7 — versions only rise, so the larger is the later.
+        following.version = version
+    // IN STEP AS THE ANSWER THIS FOLLOWS LANDS, at its load's generation. A turn later rather than
+    // now: an answer that had already arrived lands while its entry is still being built, and a reach
+    // of the entry from here would build a second one, which fetches.
+    const stepping = following
+    queueMicrotask(() => stepping.inStep())
+    following.expireAfter(lifeMs)
+}

package/src/ui/wire.ts

@@ -0,0 +1,141 @@
+// 16.28 — A HANDLER, AS A BROWSER HOLDS IT. What a page imported as `getInvoice` is, in the bundle,
+// `wire('GET', '/__abide/rpc/invoices/getInvoice')`: the same declaration the server made, over a
+// body that fetches rather than one that reads the database. So it is the same `Rpc` — the call
+// hands back a `Reactive`, the keyed face narrows by args, a mutation's `ttl` is 0 (16.7), and a
+// refusal narrows through `isError` — because it is built by the one `declare` both seams share.
+//
+// 41.21 — A CALL THE PAGE ALREADY STARTED IS TAKEN, NOT MADE AGAIN. A server-rendered page's early-call
+// script (41.20) sent this page's calls while the body was still arriving; the first reach of each
+// takes its answer — at once where it has arrived and the server painted it settled, which lands the
+// value in the same run as hydration's setup (41.25, 41.27) — and every reach after that fetches, a refresh
+// being a new call.
+//
+// 18.3, 18.9 — EVERY `GET` LOADED IS FOLLOWED over the mux, naming the version its answer carried:
+// a trigger on the server reaches the copy for these args, and a `global` value's changes arrive as
+// values the copy takes (18.10).
+//
+// An entry of its own (`@abide/abide/wire`) rather than a name on the runtime barrel: only a generated
+// wrapper imports it, and a page with no handler pays nothing for it.
+
+import { answered, answerOf } from '#shared/answerOf.ts'
+import type { CopyOptions } from '#shared/CopyOptions.ts'
+import { isFailed } from '#shared/Failed.ts'
+import { answerChunks, carriesBytes } from '#shared/framing.ts'
+import { LOAD_SIGNAL } from '#shared/LOAD_SIGNAL.ts'
+import { reactive, structural } from '#shared/reactive/index.ts'
+import {
+    type Defaults,
+    declareDefaults,
+} from '#shared/reactive/parameterDefaults.ts'
+import { declare, type Method } from '#shared/rpc.ts'
+import { rpcRequest } from '#shared/rpcRequest.ts'
+import type { Answer } from '#shared/takeEarlyCall.ts'
+import { versionInEtag } from '#shared/versionInEtag.ts'
+import { followRpc } from './socketWire.ts'
+
+/** The browser's `Rpc` for a handler: the server's declaration over a body that fetches. */
+export function wire(
+    method: Method,
+    address: string,
+    // 18.4 — what the build read off the handler's declaration.
+    options?: CopyOptions,
+    // 11.29 — and the defaults its parameter writes, which the copy keys by as the server does.
+    defaults?: Defaults,
+): unknown {
+    // ONE PARAMETER, so the value is keyed by args whatever the handler declared (16.6's arity rule):
+    // an unkeyed handler is reached with no args, which is one key.
+    const body = (args: Record<string, unknown> | undefined) => {
+        // 16.49 — the load's own signal, set by the call starting it and read before anything awaits.
+        const signal = LOAD_SIGNAL.current
+        const settle = (answer: Answer): unknown => {
+            follow(args, answer)
+            return answered(answer)
+        }
+        const answer = answerOf(
+            rpcRequest(method, address, args),
+            false,
+            signal,
+        )
+        return answer instanceof Promise ? answer.then(settle) : settle(answer)
+    }
+    // 16.32 — A STREAMING HANDLER'S COPY IS A STREAM OF ITS OWN, whose chunks land as the answer's
+    // lines arrive: collected into one value, a page reading it showed nothing until the handler's
+    // last chunk. A refusal is thrown, which is how a stream refuses (9.6).
+    const streamed = async function* (
+        args: Record<string, unknown> | undefined,
+    ): AsyncGenerator<unknown> {
+        // 16.49 — read on the first line: the core's pump takes the first step inside the reach, so
+        // this runs while the call that started the load still has its signal set.
+        const signal = LOAD_SIGNAL.current
+        const answer = await answerOf(
+            rpcRequest(method, address, args),
+            true,
+            signal,
+        )
+        follow(args, answer)
+        if (answer.body !== undefined && answer.body !== null) {
+            yield* answerChunks(answer.body, answer.type)
+            return
+        }
+        const value = answered(answer)
+        if (isFailed(value)) throw value
+        if (Array.isArray(value)) yield* value
+    }
+    // 18.3, 18.9 — the version the answer named, and 18.14 — the `max-age` left of its life, where
+    // it named one: `max-age=0` is a life the server rounded down to nothing, and stale now.
+    //
+    // 18.24 — A REFUSAL IS NOT FOLLOWED: the mux answers in the scope its upgrade carried (18.16),
+    // so a caller signed out since would be fed what this answer just refused it. Nor a binary,
+    // which the mux's JSON frames cannot carry.
+    const follow = (args: unknown, answer: Answer): void => {
+        if (
+            method !== 'GET' ||
+            answer.status === undefined ||
+            answer.status < 200 ||
+            answer.status >= 300 ||
+            carriesBytes(answer.type)
+        )
+            return
+        const seconds = /max-age=(\d+)/.exec(answer.life ?? '')?.[1]
+        followRpc(
+            address,
+            args,
+            versionInEtag(answer.version),
+            seconds === undefined ? undefined : Number(seconds) * 1000,
+            () => (value as (args: unknown) => unknown)(args),
+        )
+    }
+    // A KEYED VALUE OF ITS OWN where the handler's declares what its copy behaves by, so every entry —
+    // the copy a page walks — carries it: its key (32.32), its tags (11.43) and its comparator (5.3). A `GET` alone: a mutation's value is written and read once.
+    const produce = options?.stream === true ? streamed : body
+    if (defaults !== undefined) declareDefaults(produce, defaults)
+    // A `GET`'S ENTRY IS LOOKED UP BY ITS FOLLOW through the value, not the `Rpc`: a call made with no
+    // signal pins the load it reaches (16.48), and a frame from the server would pin one a page was
+    // still free to abort. A mutation's is `declare`'s to make, which is where its `ttl` of 0 is.
+    const value =
+        method === 'GET'
+            ? reactive(
+                  produce,
+                  options === undefined ? undefined : copyOptions(options),
+              )
+            : produce
+    // Typed as the body either way: `declare` reads which arm off the brand (16.5), and its types
+    // keep a built value off the arms that build one.
+    const rpc = declare(method)(value as typeof produce)
+    // 16.9 — the address `rpc.url` and `rpc.raw` build on.
+    rpc.address = address
+    return rpc
+}
+
+/**
+ * The build's copy options as a value takes them, `structural` resolved to its function.
+ *
+ * Checked against the value's own types where they were written, on the server; here they are data.
+ */
+function copyOptions(options: CopyOptions): never {
+    // `stream` is the wire's to read, and not an option a value takes.
+    const { identity, stream: _, ...rest } = options
+    return (
+        identity === 'structural' ? { ...rest, identity: structural } : rest
+    ) as never
+}