@abide/abide 0.123.2 → 0.124.0

package/src/server/Followers.ts

@@ -0,0 +1,399 @@
+// 18.3 — WHO FOLLOWS WHAT, for one app: every subscription to a handler, by handler, whichever lane
+// it came over — a socket on the mux, or an event stream (18.20) — and the one feed per value served
+// that its followers share (18.6). The mux and the http lane subscribe; a trigger, a sweep and an
+// answer reach them.
+//
+// A TRIGGER REACHES EVERY APP'S FOLLOWERS in the process: `rpc.invalidate({ id })` inside one request
+// reaches every browser holding that key, whichever connection it came over, and two apps in one
+// process share their `global` entries (42.12). So an app's followers are filed on `RPC_SERVER` for
+// as long as anyone follows, which is what the in-process trigger walks.
+
+import { GLOBAL_GETS } from '#shared/GLOBAL_GETS.ts'
+import type { ServerFrame } from '#shared/muxFrames.ts'
+import { matchesPattern } from '#shared/reactive/matchesPattern.ts'
+import { followServed } from '#shared/reactive/producer.ts'
+import { unowned } from '#shared/reactive/watch.ts'
+import { RPC_SERVER } from '#shared/RPC_SERVER.ts'
+
+import type { FollowedHandler } from './mountHandlers.ts'
+import { heldByApp } from './requestScope.ts'
+import { EVENT_STREAM_OPENER, streamEvent } from './streamEvent.ts'
+import { patchesSince, versionOf } from './versionOf.ts'
+
+const ENCODER = new TextEncoder()
+
+/**
+ * One `ServerFrame`, for every follower it is sent to.
+ *
+ * 18.6 — ITS BODY IS SERIALIZED ONCE PER VERSION, and each encoding of it once however many
+ * followers it reaches: a socket is sent the JSON with its follower's id spliced in, and an event
+ * stream the event, which names no follower and is the same text for every stream.
+ */
+export class Frame {
+    readonly op: ServerFrame['op']
+    readonly base: number | undefined
+    readonly version: number | undefined
+    // The value, the patch's ops or the refusal, as JSON.
+    readonly body: string | undefined
+    // What follows the id in the JSON, and the event's bytes, each written on first use.
+    private tail: string | undefined = undefined
+    private event: Uint8Array | undefined = undefined
+
+    constructor(
+        op: ServerFrame['op'],
+        base: number | undefined,
+        version: number | undefined,
+        body: string | undefined,
+    ) {
+        this.op = op
+        this.base = base
+        this.version = version
+        this.body = body
+    }
+
+    /** As `ServerFrame` JSON for `id`: `base` and `version` where it has them, then the body under its op's member. */
+    json(id: number): string {
+        if (this.tail === undefined) {
+            let tail = ''
+            if (this.base !== undefined) tail += `,"base":${this.base}`
+            if (this.version !== undefined) tail += `,"version":${this.version}`
+            if (this.body !== undefined)
+                tail += `,"${this.op === 'patch' ? 'ops' : this.op}":${this.body}`
+            this.tail = `${tail}}`
+        }
+        return `{"op":"${this.op}","id":${id}${this.tail}`
+    }
+
+    /** As the SSE event 18.20 makes it, encoded: the op its name, the version its id. */
+    asEvent(): Uint8Array {
+        this.event ??= ENCODER.encode(
+            streamEvent(
+                this.op,
+                this.version,
+                this.body ?? (this.op === 'value' ? 'null' : ''),
+            ),
+        )
+        return this.event
+    }
+}
+
+/** A trigger's frame (7.10, 7.18), the same for every follower and every trigger. */
+const TRIGGERS = {
+    invalidate: new Frame('invalidate', undefined, undefined, undefined),
+    refresh: new Frame('refresh', undefined, undefined, undefined),
+}
+
+/** What a frame is written to, under the follower's id: a socket, or an event stream. */
+export type Peer = {
+    send(id: number, frame: Frame): void
+    close(code: number, reason: string): unknown
+}
+
+type Follower = {
+    peer: Peer
+    id: number
+    args: unknown
+    // The entry key its args are filed under (`GLOBAL_GETS`), taken once as it subscribes.
+    key: string
+    // The `global` entry its productions are pushed from, which is what a refresh would otherwise
+    // re-fetch — or `undefined`, and it is sent triggers instead.
+    serving: unknown
+    stopFeed: (() => void) | undefined
+    // 18.6 — the version it was last sent, or named on subscribing.
+    sent: number | undefined
+    // 18.8 — whether the handler's rungs let it through when it opened: a guarded `GET` feeds only
+    // a follower they admitted, and sends the rest its triggers alone.
+    admitted: boolean
+}
+
+type HandlerFollowers = {
+    // 13.15 — the literal `tags` the build copied onto the browser's copy, for a sweep to match:
+    // the handler's, so one for all of its followers.
+    tags: string[] | undefined
+    // What a trigger walks, matching each follower's args against its pattern.
+    all: Set<Follower>
+    // BY ENTRY KEY, so an entry answered walks the followers of its own args alone (18.8). Filed
+    // apart from `all` rather than instead of it: a walk of every follower through a set per key
+    // measured twice a flat set's.
+    byKey: Map<string, Set<Follower>>
+}
+
+// 18.6 — ONE WATCH PER VALUE SERVED, however many follow it, and each frame's body serialized once
+// per version: every follower standing where the others stand is sent the same bytes, with its own
+// id spliced in front.
+type Feed = {
+    fed: Set<Follower>
+    landed: boolean
+    stop: () => void
+}
+
+/** Every follower one app holds, and the feeds they share. */
+export class Followers {
+    private readonly handlers = new Map<object, HandlerFollowers>()
+    private readonly feeds = new WeakMap<object, Feed>()
+    // How many follow, which files these followers where a trigger reaches them while any do.
+    private following = 0
+
+    /**
+     * Follows `followed` for `id` on `peer`: its triggers always, its value where `global` and
+     * admitted; returns what stops it.
+     *
+     * 18.3, 18.8. STATE, NOT A LOG: nothing is replayed. 18.6 — the value is sent where the version
+     * the subscription named (`held`) is not the one standing, and after that once per change, a
+     * burst in one turn going out as the value it left.
+     */
+    follow(
+        peer: Peer,
+        id: number,
+        followed: FollowedHandler,
+        args: unknown,
+        held: number | undefined,
+        admitted: boolean,
+    ): () => void {
+        const rpc = followed.handler
+        const key = GLOBAL_GETS.get(rpc)?.key(args) ?? ''
+        const follower: Follower = {
+            peer,
+            id,
+            args,
+            key,
+            serving: undefined,
+            stopFeed: undefined,
+            sent: held,
+            admitted,
+        }
+        this.attach(rpc, follower)
+        let handlerFollowers = this.handlers.get(rpc)
+        if (handlerFollowers === undefined) {
+            handlerFollowers = {
+                tags: followed.copy?.tags,
+                all: new Set(),
+                byKey: new Map(),
+            }
+            this.handlers.set(rpc, handlerFollowers)
+        }
+        const byKey = handlerFollowers.byKey
+        let followers = byKey.get(key)
+        if (followers === undefined) {
+            followers = new Set()
+            byKey.set(key, followers)
+        }
+        followers.add(follower)
+        const all = handlerFollowers.all
+        all.add(follower)
+        if (this.following++ === 0) RPC_SERVER.following.add(this)
+        return () => {
+            follower.stopFeed?.()
+            if (all.delete(follower) && --this.following === 0)
+                RPC_SERVER.following.delete(this)
+            // A key nobody follows leaves, or the index grows with every key ever followed.
+            if (followers.delete(follower) && followers.size === 0)
+                byKey.delete(key)
+        }
+    }
+
+    /**
+     * `followed` followed as an event stream: the same follow a browser's mux makes, written as SSE.
+     *
+     * 18.20 — EACH MUX FRAME IS ONE EVENT, field for field: its `op` the event's name, its version
+     * the event's `id`, and what it carries the `data` — the value for `value`, the JSON Patch for
+     * `patch`, nothing for a trigger. So an `EventSource` reconnecting hands the version back as
+     * `Last-Event-ID`, which is `held` here, and is sent nothing until the value moves past it.
+     */
+    events(
+        followed: FollowedHandler,
+        args: unknown,
+        held: number | undefined,
+    ): ReadableStream<Uint8Array> {
+        let stop = (): void => {}
+        let unhold = (): void => {}
+        let ended = false
+        return new ReadableStream({
+            start: (controller) => {
+                controller.enqueue(EVENT_STREAM_OPENER)
+                // Ended by the app's stop as any body it holds open is, or that stop waits on it.
+                unhold = heldByApp(() => {
+                    if (ended) return
+                    ended = true
+                    stop()
+                    controller.close()
+                })
+                stop = this.follow(
+                    {
+                        // 18.6 — the event written and encoded once for every stream, from the body
+                        // serialized once for every follower: nothing is parsed back.
+                        send(_id, frame) {
+                            controller.enqueue(frame.asEvent())
+                        },
+                        close() {
+                            if (ended) return
+                            ended = true
+                            unhold()
+                            controller.close()
+                        },
+                    },
+                    0,
+                    followed,
+                    args,
+                    held,
+                    // The request this stream answers passed the rungs already, or it would not be here.
+                    true,
+                )
+            },
+            cancel() {
+                ended = true
+                unhold()
+                stop()
+            },
+        })
+    }
+
+    /** A trigger on `rpc`, narrowed by the pattern it was handed as the handler's own entries are. 7.10, 7.18, 13.12. */
+    broadcast(
+        rpc: object,
+        member: 'invalidate' | 'refresh',
+        pattern: unknown,
+    ): void {
+        const handlerFollowers = this.handlers.get(rpc)
+        if (handlerFollowers === undefined) return
+        for (const follower of handlerFollowers.all) {
+            if (!matchesPattern(follower.args, pattern)) continue
+            // A fed copy is refreshed by the production the reload mints (7.18), and invalidated
+            // through the cell it is fed from (`followServed`), whichever trigger reached it — where
+            // the entry it is fed from is still the one standing.
+            if (this.attach(rpc, follower) !== undefined) continue
+            follower.peer.send(follower.id, TRIGGERS[member])
+        }
+    }
+
+    /**
+     * 13.15 — A SWEEP REACHES EVERY COPY A BROWSER FOLLOWS that carries one of its `tags`, or every
+     * copy where it is bare, as that copy's own trigger. A fed copy is skipped for `broadcast`'s
+     * reason: the sweep reloaded the entry it is fed from here, and the production that mints is
+     * its refresh.
+     */
+    sweep(member: 'invalidate' | 'refresh', tags: string[] | null): void {
+        for (const [rpc, handlerFollowers] of this.handlers) {
+            if (tags !== null && !sharesTag(handlerFollowers.tags, tags))
+                continue
+            for (const follower of handlerFollowers.all) {
+                if (this.attach(rpc, follower) !== undefined) continue
+                follower.peer.send(follower.id, TRIGGERS[member])
+            }
+        }
+    }
+
+    /**
+     * 18.8 — AN ENTRY ANSWERED THAT NOBODY IS FED FROM: one made after a follower subscribed for its
+     * args, or rebuilt after the one it was fed from was evicted. An entry already fed is the common
+     * answer, and asks nothing more; one that is not reaches the followers filed under its key.
+     */
+    served(rpc: object, serving: unknown, key: string): void {
+        if (this.feeds.has(serving as object)) return
+        const followers = this.handlers.get(rpc)?.byKey.get(key)
+        if (followers === undefined) return
+        for (const follower of followers) this.attach(rpc, follower)
+    }
+
+    /**
+     * Feeds the follower from the entry standing for its args; returns what it is fed from now.
+     *
+     * Only where that entry is not the one it is fed from already.
+     */
+    private attach(rpc: object, follower: Follower): unknown {
+        // 18.8, 18.26 — what its own rungs or its route's refused is sent its triggers alone.
+        const serving = !follower.admitted
+            ? undefined
+            : GLOBAL_GETS.get(rpc)?.at(follower.key)
+        if (serving === follower.serving) return serving
+        follower.stopFeed?.()
+        // A version is one entry's count, so what it was sent of another says nothing about this one.
+        if (follower.serving !== undefined) follower.sent = undefined
+        follower.serving = serving
+        follower.stopFeed =
+            serving === undefined ? undefined : this.feed(serving, follower)
+        return serving
+    }
+
+    private feed(serving: unknown, fed: Follower): () => void {
+        const shared =
+            this.feeds.get(serving as object) ?? this.startFeed(serving)
+        shared.fed.add(fed)
+        if (shared.landed) sendAll(serving, [fed])
+        return () => {
+            shared.fed.delete(fed)
+            if (shared.fed.size === 0) shared.stop()
+        }
+    }
+
+    private startFeed(serving: unknown): Feed {
+        const fed = new Set<Follower>()
+        // 18.11 — A VALUE FED TO A FOLLOWER KEEPS ITS PATCHES AS DATA while anyone is fed it, and
+        // 7.10 — an invalidate of the value, however it was spelled, reaches every copy it feeds.
+        const release = followServed(serving, () => {
+            for (const one of fed) one.peer.send(one.id, TRIGGERS.invalidate)
+        })
+        const feeds = this.feeds
+        const shared: Feed = {
+            fed,
+            landed: false,
+            stop: () => {
+                stopWatch()
+                release()
+                feeds.delete(serving as object)
+            },
+        }
+        feeds.set(serving as object, shared)
+        // UNOWNED: the feed is stopped when its last follower leaves, and the request it may have
+        // been started in is answered long before that (12.5).
+        const stopWatch = unowned(() =>
+            (serving as { watch(effect: () => void): () => void }).watch(() => {
+                shared.landed = true
+                sendAll(serving, fed)
+            }),
+        )
+        return shared
+    }
+}
+
+function sharesTag(held: string[] | undefined, swept: string[]): boolean {
+    if (held === undefined) return false
+    for (const tag of swept) if (held.includes(tag)) return true
+    return false
+}
+
+function sendAll(serving: unknown, fed: Iterable<Follower>): void {
+    const version = versionOf(serving)
+    let valueFrame: Frame | undefined
+    // ONE FRAME PER VERSION A FOLLOWER STANDS AT, since followers a burst left at different places
+    // along the chain are each sent the writes since their own.
+    let patchFrames: Map<number, Frame> | undefined
+    for (const one of fed) {
+        if (one.sent === version) continue
+        // 18.11 — the writes, where the follower stands on the chain they were written along.
+        const since = one.sent
+        let frame = since === undefined ? undefined : patchFrames?.get(since)
+        if (frame === undefined && since !== undefined) {
+            const ops = patchesSince(serving, since)
+            if (ops !== undefined) {
+                frame = new Frame('patch', since, version, JSON.stringify(ops))
+                patchFrames ??= new Map()
+                patchFrames.set(since, frame)
+            }
+        }
+        if (frame === undefined) {
+            if (valueFrame === undefined) {
+                const held = (serving as { peek(): unknown }).peek()
+                valueFrame = new Frame(
+                    'value',
+                    undefined,
+                    version,
+                    held === undefined ? undefined : JSON.stringify(held),
+                )
+            }
+            frame = valueFrame
+        }
+        one.peer.send(one.id, frame)
+        one.sent = version
+    }
+}

package/src/server/MODULE_QUERIES.ts

@@ -8,8 +8,12 @@ export const COMPONENT_QUERY = '?component'
 /** The file's scoped stylesheet, which its browser module imports. 34.4. */
 export const STYLE_QUERY = '?style'
 
-/** The file's text. 34.21. */
-export const TEXT_QUERY = '?text'
+/**
+ * The file's text, after its own path. 34.21. A SUFFIX WITH AN EXTENSION rather than a query: bun's
+ * runtime asks no plugin's `onResolve` of a specifier whose last segment has no extension, and
+ * `./Dockerfile?text` has none — bun loaded the file as JavaScript. The bundler asks either way.
+ */
+export const TEXT_SUFFIX = '.abide-text'
 
 /**
  * The file's browser module, asked for outside a browser bundle — a component's hydration tested

package/src/server/PageRender.ts

@@ -0,0 +1,201 @@
+// 41.13, 41.20 — ONE PAGE'S RENDER, as the calls it makes see it. A page's render calls its handlers
+// in process; each call is recorded once (1.8) — left in the seed buffer for the browser's own call
+// to be answered from, and written into the document's head as the request the browser will make
+// for it, so it starts before the bundle has arrived. The router begins one where it renders a page,
+// a call made in it records into it through `RPC_SERVER.reached`, the document takes its early-call
+// script, and the browser's call takes the seed back.
+//
+// ON THE SCOPE because that is the only thing a call made deep in a page's setup can find it through
+// when requests interleave — `RPC_SERVER.reached` is one slot for every request in flight.
+
+import { EARLY_CALLS } from '#shared/EARLY_CALLS.ts'
+import { HandlerRoute } from '#shared/HandlerRoute.ts'
+import { KEEP_HEADER } from '#shared/KEEP_HEADER.ts'
+import { KEEP_OPENED } from '#shared/KEEP_OPENED.ts'
+import type { Rpc } from '#shared/rpc.ts'
+import { type RpcRequest, rpcRequest } from '#shared/rpcRequest.ts'
+
+import { callerOf, callerOrMint } from './callerOf.ts'
+import { markPainted } from './deferredBuilds.ts'
+import { currentRequestScope, type RequestScope } from './requestScope.ts'
+import {
+    callsOnly,
+    type Outcome,
+    seedFor,
+    type SeedSink,
+    takeSeed,
+} from './seedBuffer.ts'
+
+/**
+ * One call a page's render made: the request the browser will make for it, what it reached, and
+ * whether the markup was built from it settled — `undefined` until the pass that built from it
+ * ends (41.25, `markPainted`).
+ */
+export type PageCall = {
+    request: RpcRequest
+    reached: unknown
+    painted: boolean | undefined
+}
+
+// SYNCHRONOUS SETUP IS WHAT MAKES ONE COUNTER ENOUGH. 34.3 keeps a setup from awaiting, so no other
+// request's render runs between a component's two reads, however many renders are in flight.
+let callsInRenders = 0
+
+/**
+ * How many calls renders have made, read on either side of a component's setup.
+ *
+ * 41.28 — what tells a child whose setup made a call, which is built after the turn as a page is.
+ */
+export function callsInRender(): number {
+    return callsInRenders
+}
+
+// 41.29 — the seed sink of a render no page hydrates: every call is left to run when it is made.
+const SEEDS_NOTHING: SeedSink = () => false
+
+// Each handler's route, compiled once rather than per render that calls it — as its `Rpc` keeps its
+// own; compiled again only where it was mounted at another address since.
+const ROUTE_OF = new WeakMap<object, HandlerRoute>()
+
+/** A page's render: the seed sink its calls report into, and the calls the browser will make. */
+export class PageRender {
+    readonly calls: PageCall[] = []
+    private readonly seed: SeedSink
+
+    constructor(seed: SeedSink) {
+        this.seed = seed
+    }
+
+    /**
+     * Records a call the render made: into the seed buffer (41.13), and — where the handler is
+     * mounted — as the request the browser will make for it, for the early-call script (41.20). Once
+     * per render, as the browser's `Rpc` makes it once, and the seed sink is what says which is the
+     * once.
+     */
+    record(rpc: object, args: unknown, reached: unknown): void {
+        callsInRenders += 1
+        if (!this.seed(rpc, args, reached)) return
+        // 16.10 — the address the browser's own call is made at, stamped under the mount by
+        // `mountHandlers` — and `undefined` on a handler nothing mounted.
+        const { address, method } = rpc as Rpc<unknown, unknown>
+        if (address === undefined) return
+        let route = ROUTE_OF.get(rpc)
+        if (route?.address !== address) {
+            route = new HandlerRoute(address)
+            ROUTE_OF.set(rpc, route)
+        }
+        this.calls.push({
+            request: rpcRequest(
+                method,
+                route,
+                args as Record<string, unknown> | undefined,
+            ),
+            reached,
+            painted: undefined,
+        })
+    }
+
+    /**
+     * The head markup that starts each of the page's calls before the bundle arrives, or `''` where
+     * it made none — every call marked first as the markup just built read it (41.25).
+     *
+     * 41.20 — THE SCRIPT ITSELF: each call started with `fetch`, and its answer left under the call's
+     * key in `EARLY_CALLS` for `wire` to take (41.21). An answer's body is left UNREAD (16.32), so a
+     * streaming handler's copy takes its chunks as they land rather than after the last one.
+     * Inline because nothing else runs before the bundle has arrived, which is the wait it exists
+     * to overlap.
+     *
+     * 41.25 — A ROW ENDING IN `1` IS A CALL THE MARKUP WAS BUILT FROM SETTLED, a refusal included,
+     * and its entry is marked `painted` for hydration to wait on — its body read to its bytes, so
+     * the wait covers it too. 41.26 — A CALL THAT STREAMS IS NEVER MARKED: the browser reads its
+     * chunks as they land (16.32), so no wait for its answer makes it settled where the page
+     * hydrates, and its region is 41.24's to put right.
+     *
+     * 29.9, 29.10 — THE CALLS ARE DATA AND THE RUNNER IS A CONSTANT. What a page called differs per
+     * response, so it rides in a JSON block a browser never executes, and the one script that does
+     * run is the same bytes in every response — which is what lets `csp` permit it by its hash
+     * rather than by the nonce an app's own inline script spends. The JSON has `<` escaped, so no
+     * string in it can close the element.
+     */
+    earlyCallScript(): string {
+        const calls = this.calls
+        markPainted(calls)
+        if (calls.length === 0) return ''
+        const rows: (
+            [string, string, RequestInit] | [string, string, RequestInit, 1]
+        )[] = []
+        for (const { request, painted } of calls)
+            rows.push(
+                painted === true
+                    ? [request.key, request.url, request.init, 1]
+                    : [request.key, request.url, request.init],
+            )
+        return `<script type="application/json">${JSON.stringify(rows).replace(/</g, '\\u003c')}</script><script>${EARLY_CALL_RUNNER}</script>`
+    }
+}
+
+/**
+ * Begins the render of the page `request` asks for, in its scope, and returns it.
+ *
+ * 26.5 — the caller the seed buffer is keyed by is minted where the browser carries none: the same
+ * one `principal.caller` reads for the rest of the request. 41.13 — every call the render makes is
+ * left for the browser's own call to be answered from. 41.29 — BUT NOT A PAGE A SCRIPT FETCHED, which
+ * nothing hydrates: its entries would answer the next call this caller makes with what the render
+ * saw, a sign-in since included — save the one the worker fetched for the navigation it answers,
+ * which is the page that hydrates (45.23). 41.30 — SAVE ONE THE WORKER KEEPS, whose early calls are
+ * what a later open of it starts.
+ */
+export function beginPageRender(request: Request): PageRender {
+    const caller = callerOrMint()
+    const keep = request.headers.get(KEEP_HEADER)
+    const hydrated =
+        keep === KEEP_OPENED ||
+        request.headers.get('sec-fetch-dest') !== 'empty'
+    const page = new PageRender(
+        hydrated
+            ? seedFor(caller)
+            : keep !== null
+              ? callsOnly()
+              : SEEDS_NOTHING,
+    )
+    ;(currentRequestScope() as RequestScope).page = page
+    return page
+}
+
+/** Renders on in this scope as no page's: an error page's render records nothing. 41.13. */
+export function leavePageRender(): void {
+    ;(currentRequestScope() as RequestScope).page = undefined
+}
+
+/** Records a call made in the page this scope is rendering, where it renders one. */
+export function recordInRender(
+    rpc: object,
+    args: unknown,
+    reached: unknown,
+): void {
+    currentRequestScope()?.page?.record(rpc, args, reached)
+}
+
+/**
+ * Takes what this request's caller's render reached for `rpc` and `args`, or `undefined`.
+ *
+ * 41.7 — the call a hydrating page makes for what its render already reached is answered from
+ * that, and the handler is not run again (41.13).
+ */
+export function takeSeeded(
+    rpc: object,
+    args: unknown,
+): Promise<Outcome> | undefined {
+    const caller = callerOf()
+    return caller === undefined ? undefined : takeSeed(caller, rpc, args)
+}
+
+// THE RUNNER RECORDS, IT NEVER CLASSIFIES: the `Response`, and a painted call's body read to its end
+// — the one decision is `painted`, which the server made. `answerOf` reads the record as it reads an
+// answer it fetched, so no second reading of a content type lives in a string no typecheck reaches.
+// The shape is `EarlyCall`'s. 16.80 — a page the worker answers has it answer the page's calls too,
+// which the browser alone can tell: the server cannot see whether a worker will replay this page.
+export const EARLY_CALL_RUNNER = `(function(s,c,w){for(var i=0;i<c.length;i++)(function(k,u,n,h){if(w)n.cache='force-cache';var e=s[k]={painted:h,response:void 0,bytes:void 0};e.promise=fetch(u,n).then(function(r){return h?r.arrayBuffer().then(function(b){e.bytes=b;e.response=r}):e.response=r}).catch(function(){})})(c[i][0],c[i][1],c[i][2],c[i][3])})(self.${EARLY_CALLS}||(self.${EARLY_CALLS}={}),JSON.parse(document.currentScript.previousElementSibling.textContent),(self.navigator.serviceWorker||{}).controller)`
+
+/** The early-call runner's hash, as `script-src` names it. 29.9. */
+export const EARLY_CALL_HASH = `'sha256-${new Bun.CryptoHasher('sha256').update(EARLY_CALL_RUNNER).digest('base64')}'`

package/src/server/RESUME_MILLISECONDS.ts

@@ -0,0 +1,2 @@
+/** How long a pairing whose stream dropped waits to be resumed. 44.26. */
+export const RESUME_MILLISECONDS = 60_000

package/src/server/abideModules.ts

@@ -6,9 +6,9 @@
 //
 // WHICH FACE AN IMPORT GETS IS SPELLED ON ITS SPECIFIER (`MODULE_QUERIES`), because bun hands a plugin
 // no import attributes: a compiled module asks for `?component`, a browser module for its own
-// `?style`, a text import for `?text`. A `.abide` named bare is a module abide did not compile
-// asking — on a server that is the bound face 34.16 states, and in a browser the component module
-// itself.
+// `?style`, a text import for `.abide-text` (`TEXT_SUFFIX`). A `.abide` named bare is a module abide
+// did not compile asking — on a server that is the bound face 34.16 states, and in a browser the
+// component module itself.
 //
 // THE TABLES — the route, error and handler tables, and in a browser the router's table and the
 // entry — are the build's own modules, served from `__abide` below the root, where no app writes.
@@ -22,7 +22,6 @@ import { basename, dirname, resolve } from 'node:path' // bun exposes no path he
 import { SERVER_SPECIFIER } from '#shared/SPECIFIERS.ts'
 
 import type { ServerTable } from './answerRequest.ts'
-import type { MountRow } from './answerRpc.ts'
 import {
     type Asked,
     BOUND_NAMESPACE,
@@ -44,9 +43,10 @@ import {
     HANDLER_SUFFIX,
     SERVER_QUERY,
     STYLE_QUERY,
-    TEXT_QUERY,
+    TEXT_SUFFIX,
 } from './MODULE_QUERIES.ts'
 import { MOUNTABLE } from './MOUNTABLE.ts'
+import type { MountRow } from './mountHandlers.ts'
 import { PRIVATE_EXPORT } from './PRIVATE_EXPORT.ts'
 import { realOrAsGiven } from './realOrAsGiven.ts'
 import { SERVER_TABLE } from './TABLES.ts'
@@ -293,8 +293,8 @@ function modulesPlugin(served: Held): Bun.BunPlugin {
                 new RegExp(`\\.abide${RegExp.escape(query)}$`)
             asking(
                 'text',
-                TEXT_QUERY,
-                new RegExp(`${RegExp.escape(TEXT_QUERY)}$`),
+                TEXT_SUFFIX,
+                new RegExp(`${RegExp.escape(TEXT_SUFFIX)}$`),
             )
             asking('style', STYLE_QUERY, abideWith(STYLE_QUERY))
             asking('component', COMPONENT_QUERY, abideWith(COMPONENT_QUERY))

package/src/server/answerFailure.ts

@@ -10,9 +10,10 @@ import { coversRoute, parseRoutePattern } from '#shared/routePattern.ts'
 
 import type { AppSources } from './answerRequest.ts'
 import { DOCUMENT_HEADERS } from './DOCUMENT_HEADERS.ts'
+import { leavePageRender } from './PageRender.ts'
 import { prefers } from './prefers.ts'
 import { boundPage, renderDocument } from './render.ts'
-import { beginRender, currentRequestScope } from './requestScope.ts'
+import { currentRequestScope } from './requestScope.ts'
 
 /** What a page's failure is painted from: the error pages, and the document they go into. */
 export type ErrorPages = Pick<AppSources, 'errors' | 'errorDocument'>
@@ -88,7 +89,7 @@ export async function answerFailure(
     for (const error of errorsFor(app.errors, pathname)) {
         try {
             const bound = boundPage(error, { failure: () => failure })
-            beginRender(undefined)
+            leavePageRender()
             const document = await renderDocument(bound, app.errorDocument)
             return new Response(document, { status, headers })
         } catch (thrown) {