@abide/abide 0.103.0 → 0.105.0

package/src/ui/applyHead.ts

@@ -4,32 +4,57 @@
 // the document. Nothing is added to the head to mark ownership — a marker would be a fact about
 // the framework in a document an author writes, and the key is already what decides.
 //
-// 39.5 — A CONTRIBUTION WITH NO KEY APPENDS. It cannot replace anything, because there is nothing
-// it could be said to be the same as, and dropping it instead would lose the one kind of
-// contribution a page makes several of.
+// 39.5 — A CONTRIBUTION WITH NO KEY APPENDS. It cannot replace anything ANOTHER contributor wrote,
+// because there is nothing it could be said to be the same as, and dropping it instead would lose
+// the one kind of contribution a page makes several of. What its OWN contributor wrote last is
+// another matter: a head written again puts its keyless nodes where the last ones stood (39.15),
+// and a head withdrawn takes them with it (39.16). Found the way a key is — off the document, by
+// the markup the contributor last wrote — so a head the server painted is found the same as one
+// written here.
 
 import { headKeyOf } from '#shared/headKeyOf.ts'
-import { MOUNTING_LEVEL } from './MOUNTING_LEVEL.ts'
 import { markupNodes } from './parseMarkup.ts'
-import { isEmptyRegion, type Region } from './regions.ts'
-import type { Scope } from './Scope.ts'
 
-export function applyHead(markup: string): void {
+/**
+ * Writes `markup`'s contributions into the document head, a key `below` holds excepted.
+ *
+ * 39.4 — `below` is the head of every contributor deeper than the one writing, which a head
+ * re-applied live (39.13) must not undo: the deepest contributor wins whichever of them moved last.
+ *
+ * 39.15 — `last` is what the same contributor wrote before, whose keyless nodes this replaces in
+ * place, in order, rather than adding beside them. 39.14 — a key `last` held that `markup` does not
+ * is withdrawn to `outer`'s value for it, as a leaving contributor's is; a key list that did not
+ * move withdraws nothing and never asks `outer`.
+ */
+export function applyHead(
+    markup: string,
+    below = '',
+    last = '',
+    outer: () => string = () => '',
+): void {
     const head = document.head
     if (markup === '') return
     const incoming = markupNodes(head, markup)
     const standingByKey = standingKeys(head)
+    const deeper = below === '' ? undefined : keyedIn(head, below)
+    const replaced: Node[] = []
+    const withdrawn = keyedIn(head, last, replaced)
+    let next = 0
     for (const node of incoming) {
-        if (node.nodeType !== 1) {
-            head.appendChild(node)
-            continue
-        }
-        const element = node as Element
-        const key = headKey(element)
+        const key = node.nodeType === 1 ? headKey(node as Element) : undefined
         if (key === undefined) {
-            head.appendChild(element)
+            const standing = replaced[next]
+            next += 1
+            if (standing === undefined) head.appendChild(node)
+            // The same node left standing, as a key's is: a `<style>` put back as itself is not
+            // re-parsed into the cascade.
+            else if (!standing.isEqualNode(node))
+                head.replaceChild(node, standing)
             continue
         }
+        const element = node as Element
+        withdrawn.delete(key)
+        if (deeper?.has(key) === true) continue
         const standing = standingByKey.get(key)
         if (standing === undefined) {
             head.appendChild(element)
@@ -45,31 +70,52 @@ export function applyHead(markup: string): void {
         head.replaceChild(element, standing)
         standingByKey.set(key, element)
     }
+    for (; next < replaced.length; next += 1)
+        (replaced[next] as Node).parentNode?.removeChild(replaced[next] as Node)
+    if (withdrawn.size === 0) return
+    if (deeper !== undefined)
+        for (const key of deeper.keys()) withdrawn.delete(key)
+    restoreKeys(head, withdrawn, outer())
 }
 
 /**
  * Puts back, or removes, what the leaving levels keyed and the arriving ones do not.
  *
- * 39.14 — THE NEXT-OUTER CONTRIBUTOR'S VALUE, OR NONE. `leaving` and `arriving` are the heads of
- * the levels a navigation stopped and mounted; `outer` is every contributor standing above them,
- * outermost first — the shell's keyed entries, then each kept layout's — so the LAST entry for a
- * key in it is the one the server would paint there (39.4). What the arriving levels key they have
- * already written (39.6), so only the keys they are silent on are touched.
+ * 39.14 — THE NEXT-OUTER CONTRIBUTOR'S VALUE, OR NONE. `leaving` is the head of the levels a
+ * navigation stopped; `around` answers `outer`, every contributor standing above them, and
+ * `arriving`, the heads of the levels it mounted. `outer` runs outermost first — the shell's keyed
+ * entries, then each kept layout's — so the LAST entry for a key in it is the one the server would
+ * paint there (39.4). A component leaving its region is withdrawn the same way, its level's
+ * contributors either side of it standing in for the two (`Level.headsAround`). What the arriving levels key they have
+ * already written (39.6), so only the keys they are silent on are touched — and 39.16, the leaving
+ * levels' keyless nodes leave with them.
  *
- * THE COMMON NAVIGATION ENDS AT THE FIRST RETURN: two pages that both key a `<title>` withdraw
- * nothing, and `outer` is neither built nor parsed.
+ * THE COMMON NAVIGATION WITHDRAWS NOTHING BY KEY: two pages that both key a `<title>` leave
+ * `outer` built but never parsed, and a head keying nothing never asks `around`.
  */
 export function withdrawHead(
     leaving: string,
-    arriving: string,
-    outer: () => string,
+    around: () => [outer: string, arriving: string],
 ): void {
     if (leaving === '') return
     const head = document.head
-    const withdrawn = keyedIn(head, leaving)
+    const keyless: Node[] = []
+    const withdrawn = keyedIn(head, leaving, keyless)
+    for (const node of keyless) node.parentNode?.removeChild(node)
+    if (withdrawn.size === 0) return
+    const [outer, arriving] = around()
     for (const key of keyedIn(head, arriving).keys()) withdrawn.delete(key)
+    restoreKeys(head, withdrawn, outer)
+}
+
+/** 39.14 — each of `withdrawn`'s keys back to `outer`'s last value for it, or removed. */
+function restoreKeys(
+    head: HTMLHeadElement,
+    withdrawn: Map<string, Element>,
+    outer: string,
+): void {
     if (withdrawn.size === 0) return
-    const restored = keyedIn(head, outer())
+    const restored = keyedIn(head, outer)
     const standingByKey = standingKeys(head)
     for (const key of withdrawn.keys()) {
         const standing = standingByKey.get(key)
@@ -82,15 +128,29 @@ export function withdrawHead(
     }
 }
 
-/** The keyed elements `markup` parses to, by key, the last holding each (39.4). */
-function keyedIn(head: HTMLHeadElement, markup: string): Map<string, Element> {
+/**
+ * The keyed elements `markup` parses to, by key, the last holding each (39.4).
+ *
+ * Where `standing` is given, each keyless node is matched to the first node standing in the head
+ * equal to it and not already matched, and the match pushed there (39.15, 39.16).
+ */
+function keyedIn(
+    head: HTMLHeadElement,
+    markup: string,
+    standing?: Node[],
+): Map<string, Element> {
     const keyed = new Map<string, Element>()
     if (markup === '') return keyed
-    for (const node of markupNodes(head, markup))
-        if (node.nodeType === 1) {
-            const key = headKey(node as Element)
-            if (key !== undefined) keyed.set(key, node as Element)
-        }
+    for (const node of markupNodes(head, markup)) {
+        const key = node.nodeType === 1 ? headKey(node as Element) : undefined
+        if (key !== undefined) keyed.set(key, node as Element)
+        else if (standing !== undefined)
+            for (let at = head.firstChild; at !== null; at = at.nextSibling)
+                if (at.isEqualNode(node) && !standing.includes(at)) {
+                    standing.push(at)
+                    break
+                }
+    }
     return keyed
 }
 
@@ -130,50 +190,3 @@ function headKey(element: Element): string | undefined {
         element.getAttribute(name),
     )
 }
-
-/**
- * Keeps a level's head written from `markup` for as long as `scope` lives.
- *
- * 39.13 — A HEAD THAT READS A VALUE FOLLOWS IT for as long as its level is mounted, which is the
- * scope's life. The first run only subscribes: the head it would write is already there, written
- * by the server or applied by the level's mount ahead of its fill (39.6).
- */
-export function liveHead(scope: Scope, markup: () => string): void {
-    let subscribing = true
-    scope.watch(() => {
-        const text = markup()
-        if (subscribing) subscribing = false
-        else applyHead(text)
-    })
-}
-
-/**
- * A component's `<head>`, added to the page or layout the router is mounting it under (39.1).
- *
- * Joined to that level's head, so it is withdrawn as the level's is when it leaves (39.14), and
- * deeper than the level's own, so it wins by key (39.4). Applied where the component builds its own
- * markup, once the level is mounted (`MOUNTING_LEVEL.unapplied`); a region the server painted
- * already carries the head the server wrote. Nothing where no level is mounting — a row grown after
- * the fact titles nothing.
- *
- * A LIST, NOT A CLOSURE PER CONTRIBUTION: a `{#for}` of components with a `<head>` contributes once a
- * row, and a chain of them is read through as deep a stack.
- */
-export function contributeHead(region: Region, head: () => string): void {
-    const level = MOUNTING_LEVEL.current
-    if (level === undefined) return
-    let contributed = level.contributed
-    if (contributed === undefined) {
-        const own = level.head
-        const joined: (() => string)[] = []
-        contributed = joined
-        level.contributed = joined
-        level.head = () => {
-            let markup = own?.() ?? ''
-            for (const one of joined) markup += one()
-            return markup
-        }
-    }
-    contributed.push(head)
-    if (isEmptyRegion(region)) MOUNTING_LEVEL.unapplied += head()
-}

package/src/ui/index.ts

@@ -39,15 +39,16 @@ export {
 } from './adoptWalk.ts'
 // 39.6 — a module mounted into an empty region applies its own head, from inside its instance
 // (`emitClient`); only a module that carries its own markup and a `<head>` imports it.
-export { applyHead, contributeHead, liveHead } from './applyHead.ts'
+export { applyHead } from './applyHead.ts'
 export { bindElement } from './bindElement.ts'
 export { bindProperty } from './bindProperty.ts'
 export { bindSpread } from './bindSpread.ts'
 export { escapeless } from './escapeless.ts'
+// 39.1 — a component's `<head>`, joined to the routed level mounting it.
+export { contributeHead } from './Level.ts'
 export { listAt, updateList } from './List.ts'
 export { warnMismatch } from './Mismatch.ts'
 export { markupNodes } from './parseMarkup.ts'
-export { replaceRow } from './reconcile.ts'
 export {
     fillEmpty,
     fillRegion,
@@ -55,6 +56,7 @@ export {
     type Region,
 } from './regions.ts'
 export { rowKeyOf } from './rowKeyOf.ts'
+export { replaceRow } from './rows.ts'
 export { EMPTY_SCOPE, Scope } from './Scope.ts'
 export { setAttribute } from './setAttribute.ts'
 export { setClass } from './setClass.ts'

package/src/ui/reconcile.ts

@@ -1,71 +1,19 @@
 import { PATCHES } from '#shared/reactive/PATCHES.ts'
 import { LAYER_RECONCILE } from './LAYER_NAMES.ts'
-import type { List, RowBuilders } from './List.ts'
+import type { List } from './List.ts'
 import { HYDRATE_LOG } from './Mismatch.ts'
 import { beginLayer, endLayer } from './measureLayer.ts'
-import { moveRow, removeRow } from './rows.ts'
-import { EMPTY_SCOPE, type Scope } from './Scope.ts'
+import { dropRow, makeRow, moveRow, type Row } from './rows.ts'
 
 // 41.8 — a KEYED list, reconciled by moving the nodes that are already there rather than by
 // rebuilding them. A rebuild produces the right screen and the wrong document: focus, selection,
 // scroll position and anything a row was in the middle of go with the nodes that were replaced.
 //
-// What a row is in the document — its element, or its anchored range — is `rows.ts`'s. Most lists
+// What a row is — its record and its nodes, an element or an anchored range — is `rows.ts`'s. Most lists
 // carry no per-row marker at all: the nodes between the region's anchors ARE the rows, and only a
 // body with several top-level nodes gets one anchor per ROW. That is ~2.5 bytes gzipped a row, not
 // the per-SLOT marker `benchGrid.ts` measured doubling a page.
 
-export type Row = {
-    key: unknown
-    /**
-     * The value the row was built from.
-     *
-     * A row that survives a reorder keeps its NODES, which is the whole point — but if the value
-     * behind that key is a different object, its content is stale and the row is remade. Identity
-     * is the signal here, the inverse of the case where a freshly built wrapper defeats one.
-     */
-    data: unknown
-    /**
-     * The row's first node: its element, or its `ROW_OPEN` anchor where the body has several —
-     * the start of a range, not the nodes `make` handed back (`rows.ts`).
-     */
-    node: ChildNode
-    /** The row's bindings, stopped when it leaves. */
-    scope: Scope
-    /**
-     * Where this row stood in the list the document currently shows.
-     *
-     * The placement walk needs "already in order" to be a question about POSITIONS rather than
-     * about nodes, and asking the document — `compareDocumentPosition`, or counting siblings — is
-     * the walk this exists to avoid. Written by every reconcile, so it is a fact about the last one
-     * rather than about the caller, and a hydration seed sets it because that IS the order the
-     * server painted.
-     */
-    at: number
-    /**
-     * The patch epoch the row was made at (32.33).
-     *
-     * Its item written past this is content the row never saw, under the same object a kept row is
-     * matched by.
-     */
-    seen: number
-}
-
-/**
- * Rebuilds a row in place from `next`, keeping its record.
- *
- * 41.10 — a row that cannot be hydrated is rebuilt: the fresh nodes go where the row stood and the
- * row's record takes the new first node, so the reconcile still reaches all of it.
- */
-export function replaceRow(row: Row, next: Node[]): void {
-    const first = row.node
-    const parent = first.parentNode
-    if (parent === null) return
-    for (const node of next) parent.insertBefore(node, first)
-    removeRow(first)
-    row.node = next[0] as ChildNode
-}
-
 /**
  * Reconciles a keyed list's rows to `data`, moving survivors rather than remaking them.
  *
@@ -193,7 +141,7 @@ export function reconcile(list: List, data: unknown[]): void {
             const existing = survivor[at]
             if (existing === undefined || existing === null) {
                 const row = makeRow(
-                    list,
+                    list.setUp,
                     parent,
                     anchor,
                     keys[at],
@@ -234,50 +182,6 @@ export function reconcile(list: List, data: unknown[]): void {
     }
 }
 
-/** A new row, built and inserted before `before`. */
-export function makeRow(
-    list: List,
-    parent: Node,
-    before: Node,
-    key: unknown,
-    item: unknown,
-    at: number,
-): Row {
-    // 14.8 — set up ONCE for the row, and the same builders make it and mount it.
-    const builders = list.setUp(item, at)
-    const nodes = builders.make(parent.ownerDocument as Document, item, at)
-    for (const node of nodes) parent.insertBefore(node, before)
-    return rowOf(builders, key, item, nodes[0] as ChildNode, at)
-}
-
-/**
- * A row record over nodes already in the document, mounted.
- *
- * The one place a row's record is written, so its shape is fixed once for every path that makes one
- * — a made row and a hydrated one alike. The mount is handed the RECORD, because a row it rebuilds
- * (41.10) has a new first node to write back.
- */
-export function rowOf(
-    builders: RowBuilders,
-    key: unknown,
-    item: unknown,
-    node: ChildNode,
-    at: number,
-): Row {
-    const row: Row = {
-        key,
-        data: item,
-        node,
-        // A `Scope` rather than `undefined` until the mount returns, so the field holds one class
-        // for the record's whole life.
-        scope: EMPTY_SCOPE,
-        at,
-        seen: PATCHES.epoch,
-    }
-    row.scope = builders.mount(row, item, at)
-    return row
-}
-
 /**
  * Whether a patch wrote to the row's item since the row was made.
  *
@@ -291,16 +195,6 @@ function patchedSince(row: Row): boolean {
     return (PATCHES.written.get(item) ?? 0) > row.seen
 }
 
-/**
- * Stops a row's bindings, then removes its nodes.
- *
- * Stopped first, so a binding cannot wake over a node that is already gone.
- */
-export function dropRow(row: Row): void {
-    row.scope.stop()
-    removeRow(row.node)
-}
-
 /**
  * Warns about a repeated `{#for}` key, once per block.
  *

package/src/ui/rows.ts

@@ -1,9 +1,12 @@
 import { REGION_CLOSE, ROW_OPEN } from '#shared/ANCHORS.ts'
+import { PATCHES } from '#shared/reactive/PATCHES.ts'
 import { leave } from './leave.ts'
 import { moveNode } from './moveNode.ts'
 import { closeOf, opensRegion, type Region, removeUntil } from './regions.ts'
+import { EMPTY_SCOPE, type Scope } from './Scope.ts'
 
-// WHAT A ROW IS IN THE DOCUMENT, decided here and nowhere else. A row is its ELEMENT where the
+// WHAT A ROW IS — its record, how it is made, mounted, rebuilt and dropped, and what it is in the
+// document — decided here and nowhere else. `reconcile.ts` decides only WHICH rows move. 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
@@ -12,6 +15,55 @@ import { closeOf, opensRegion, type Region, removeUntil } from './regions.ts'
 // 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.
 
+export type Row = {
+    key: unknown
+    /**
+     * The value the row was built from.
+     *
+     * A row that survives a reorder keeps its NODES, which is the whole point — but if the value
+     * behind that key is a different object, its content is stale and the row is remade. Identity
+     * is the signal here, the inverse of the case where a freshly built wrapper defeats one.
+     */
+    data: unknown
+    /**
+     * The row's first node: its element, or its `ROW_OPEN` anchor where the body has several —
+     * the start of a range, not the nodes `make` handed back.
+     */
+    node: ChildNode
+    /** The row's bindings, stopped when it leaves. */
+    scope: Scope
+    /**
+     * Where this row stood in the list the document currently shows.
+     *
+     * The placement walk needs "already in order" to be a question about POSITIONS rather than
+     * about nodes, and asking the document — `compareDocumentPosition`, or counting siblings — is
+     * the walk this exists to avoid. Written by every reconcile, so it is a fact about the last one
+     * rather than about the caller, and a hydration seed sets it because that IS the order the
+     * server painted.
+     */
+    at: number
+    /**
+     * The patch epoch the row was made at (32.33).
+     *
+     * Its item written past this is content the row never saw, under the same object a kept row is
+     * matched by.
+     */
+    seen: number
+}
+
+export type RowBuilders = {
+    /**
+     * A row's nodes, BUILT in the document the list stands in — handed over by the reconcile
+     * rather than found by the row, which is the one place a row's document is decided.
+     */
+    make: (document: Document, item: unknown, at: number) => Node[]
+    /**
+     * Handed the row's RECORD rather than its nodes: a row it rebuilds (41.10) writes its new
+     * first node back there.
+     */
+    mount: (row: Row, item: unknown, at: number) => Scope
+}
+
 /**
  * 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.
@@ -37,7 +89,7 @@ function rowEnd(first: Node): Comment | null {
 }
 
 /** Removes a row's nodes, from its first node to its end. */
-export function removeRow(first: ChildNode): void {
+function removeRow(first: ChildNode): void {
     if (first.nodeType !== 8) {
         leave(first)
         return
@@ -97,3 +149,72 @@ export function rowsIn(region: Region, anchored: boolean): ChildNode[] {
         if (node.nodeType === 1) found.push(node)
     return found
 }
+
+/**
+ * Rebuilds a row in place from `next`, keeping its record.
+ *
+ * 41.10 — a row that cannot be hydrated is rebuilt: the fresh nodes go where the row stood and the
+ * row's record takes the new first node, so the reconcile still reaches all of it.
+ */
+export function replaceRow(row: Row, next: Node[]): void {
+    const first = row.node
+    const parent = first.parentNode
+    if (parent === null) return
+    for (const node of next) parent.insertBefore(node, first)
+    removeRow(first)
+    row.node = next[0] as ChildNode
+}
+
+/** A new row, built and inserted before `before`. */
+export function makeRow(
+    setUp: (item: unknown, at: number) => RowBuilders,
+    parent: Node,
+    before: Node,
+    key: unknown,
+    item: unknown,
+    at: number,
+): Row {
+    // 14.8 — set up ONCE for the row, and the same builders make it and mount it.
+    const builders = setUp(item, at)
+    const nodes = builders.make(parent.ownerDocument as Document, item, at)
+    for (const node of nodes) parent.insertBefore(node, before)
+    return rowOf(builders, key, item, nodes[0] as ChildNode, at)
+}
+
+/**
+ * A row record over nodes already in the document, mounted.
+ *
+ * The one place a row's record is written, so its shape is fixed once for every path that makes one
+ * — a made row and a hydrated one alike. The mount is handed the RECORD, because a row it rebuilds
+ * (41.10) has a new first node to write back.
+ */
+export function rowOf(
+    builders: RowBuilders,
+    key: unknown,
+    item: unknown,
+    node: ChildNode,
+    at: number,
+): Row {
+    const row: Row = {
+        key,
+        data: item,
+        node,
+        // A `Scope` rather than `undefined` until the mount returns, so the field holds one class
+        // for the record's whole life.
+        scope: EMPTY_SCOPE,
+        at,
+        seen: PATCHES.epoch,
+    }
+    row.scope = builders.mount(row, item, at)
+    return row
+}
+
+/**
+ * Stops a row's bindings, then removes its nodes.
+ *
+ * Stopped first, so a binding cannot wake over a node that is already gone.
+ */
+export function dropRow(row: Row): void {
+    row.scope.stop()
+    removeRow(row.node)
+}

package/src/ui/wire.ts

@@ -17,10 +17,11 @@
 // 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 Answer, 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 { answerChunks } from '#shared/framing.ts'
+import { HandlerRoute } from '#shared/HandlerRoute.ts'
 import { LOAD_SIGNAL } from '#shared/LOAD_SIGNAL.ts'
 import { reactive, structural } from '#shared/reactive/index.ts'
 import {
@@ -29,8 +30,6 @@ import {
 } 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. */
@@ -42,6 +41,8 @@ export function wire(
     // 11.29 — and the defaults its parameter writes, which the copy keys by as the server does.
     defaults?: Defaults,
 ): unknown {
+    // 16.9 — the handler's route, compiled once for every call through the copy.
+    const route = new HandlerRoute(address)
     // 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) => {
@@ -51,11 +52,7 @@ export function wire(
             follow(args, answer)
             return answered(answer)
         }
-        const answer = answerOf(
-            rpcRequest(method, address, args),
-            false,
-            signal,
-        )
+        const answer = answerOf(rpcRequest(method, route, 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
@@ -68,13 +65,13 @@ export function wire(
         // 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),
+            rpcRequest(method, route, args),
             true,
             signal,
         )
         follow(args, answer)
         if (answer.body !== undefined && answer.body !== null) {
-            yield* answerChunks(answer.body, answer.type)
+            yield* answerChunks(answer.body, answer.framing)
             return
         }
         const value = answered(answer)
@@ -88,22 +85,10 @@ export function wire(
     // 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),
-        )
+        if (method === 'GET' && answer.followable)
+            followRpc(address, args, answer.version, answer.life, () =>
+                (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.

package/src/compiler/hooksCalled.ts

@@ -1,35 +0,0 @@
-import { tokenize } from './tokenize.ts'
-
-/** Every hook abide exports, by name. */
-export const HOOK_NAMES: ReadonlySet<string> = new Set([
-    'middleware',
-    'onStart',
-    'onStop',
-    'onError',
-    'onConfig',
-    'onHealth',
-    'onPrincipal',
-    'onLauncher',
-    'onMenu',
-])
-
-/**
- * Each of abide's hook names called in `source`, in the order written: the name, then `(`, and not
- * a declaration — a member call included, since `server.onStart(…)` is abide's hook all the same.
- * Read, not run — what `abide routes` lists and the build's refusals of a hook called where it is
- * never read (38.107) go by.
- */
-export function hooksCalled(source: string): string[] {
-    const called: string[] = []
-    let previous = ''
-    let named: string | undefined
-    for (const token of tokenize(source)) {
-        if (named !== undefined && token.text === '(') called.push(named)
-        named =
-            HOOK_NAMES.has(token.text) && previous !== 'function'
-                ? token.text
-                : undefined
-        previous = token.text
-    }
-    return called
-}