@abide/abide 0.34.1 → 0.35.0

package/src/lib/server/runtime/flushingGzipStream.ts

@@ -0,0 +1,62 @@
+import { constants, createGzip } from 'node:zlib'
+
+/*
+A gzip TransformStream that emits a decodable block after every input chunk via
+Z_SYNC_FLUSH, instead of buffering until its deflate window fills like the web
+CompressionStream. Used for the streamed SSR document so the head reaches the
+browser compressed-but-decodable immediately — the preload scanner sees the
+entry/css links and the pending shell paints — rather than only at stream close.
+node:zlib is required here: the web CompressionStream exposes no per-chunk flush.
+*/
+export function flushingGzipStream(): TransformStream<Uint8Array, Uint8Array> {
+    const gzip = createGzip()
+    let sink: TransformStreamDefaultController<Uint8Array>
+    /* `closed` gates enqueue: once the consumer cancels (client disconnect), the node
+       gzip can still emit a trailing `data` that would throw on the closed controller. */
+    let closed = false
+    gzip.on('data', (chunk: Buffer) => {
+        if (closed) {
+            return
+        }
+        /* enqueue can still race a just-closed controller (cancel is async); treat the
+           throw as the consumer having gone and tear down. */
+        try {
+            sink.enqueue(new Uint8Array(chunk))
+        } catch {
+            closed = true
+            gzip.destroy()
+        }
+    })
+    /* The spec'd Transformer.cancel hook (consumer-cancellation) postdates this TS lib's
+       Transformer type; declare it locally so the literal type-checks while the platform
+       (Bun) still invokes it. Typing the const sidesteps the fresh-literal excess-property
+       check without weakening start/transform/flush. */
+    const transformer: Transformer<Uint8Array, Uint8Array> & {
+        cancel(reason?: unknown): void
+    } = {
+        start(controller) {
+            sink = controller
+            gzip.on('error', (error) => controller.error(error))
+        },
+        /* Resolve only once the chunk is compressed AND sync-flushed, so its bytes are
+           on the wire before the stream pulls the next (possibly delayed) chunk. */
+        transform(chunk) {
+            return new Promise((resolve) => {
+                gzip.write(chunk, () => gzip.flush(constants.Z_SYNC_FLUSH, () => resolve()))
+            })
+        },
+        /* End the deflate stream; its trailing bytes arrive as `data` before `end`. */
+        flush() {
+            return new Promise((resolve) => {
+                gzip.on('end', () => resolve())
+                gzip.end()
+            })
+        },
+        /* Consumer went away — stop enqueueing and tear down the node stream. */
+        cancel() {
+            closed = true
+            gzip.destroy()
+        },
+    }
+    return new TransformStream(transformer)
+}

package/src/lib/server/runtime/gzipResponse.ts

@@ -1,5 +1,7 @@
 import { isStreamingResponse } from '../../shared/isStreamingResponse.ts'
 import { acceptsGzip } from './acceptsGzip.ts'
+import { flushingGzipStream } from './flushingGzipStream.ts'
+import { STREAMED_HTML_HEADER } from './STREAMED_HTML_HEADER.ts'
 
 /*
 Compressible Content-Types — text and structured-text payloads. Binary or
@@ -11,18 +13,27 @@ const COMPRESSIBLE_TYPE =
 
 /*
 Gzips a dynamic response (SSR HTML, rpc/json replies, the plain 404) when the
-client accepts it, piping the body through a CompressionStream so a buffered
-body and a streamed SSR document take the identical path. Static assets never
-reach here — they already carry a precompressed Content-Encoding, which
-short-circuits the first guard. Skipped for: already-encoded bodies, bodiless
-responses (204/304/HEAD), non-compressible types (images, fonts, archives),
-and frame-delimited streams (SSE/jsonl, where gzip buffering would stall
-per-frame flush). No byte-size floor: Bun doesn't expose a string body's length
-before send, and measuring would mean buffering the streamed SSR document —
-the framing overhead on the rare tiny body is negligible against compressing
-every page and rpc payload.
+client accepts it. Static assets never reach here — they already carry a
+precompressed Content-Encoding, which short-circuits the first guard. Skipped
+for: already-encoded bodies, bodiless responses (204/304/HEAD), non-compressible
+types (images, fonts, archives), and frame-delimited streams (SSE/jsonl, where
+gzip buffering would stall per-frame flush). No byte-size floor: Bun doesn't
+expose a string body's length before send, and measuring would mean buffering the
+body — the framing overhead on the rare tiny body is negligible against
+compressing every page and rpc payload.
+
+Buffered bodies take the web CompressionStream (best ratio, one flush at close).
+The streamed SSR document self-marks (STREAMED_HTML_HEADER) and takes a
+per-chunk-flushing gzip instead: the plain CompressionStream buffers the head
+until its deflate window fills, which defeats streaming (the browser can't
+preload-scan the head or paint the pending shell until the stream nearly closes).
+The marker is stripped so it never reaches the client.
 */
 export function gzipResponse(req: Request, response: Response): Response {
+    const streamedHtml = response.headers.has(STREAMED_HTML_HEADER)
+    if (streamedHtml) {
+        response.headers.delete(STREAMED_HTML_HEADER)
+    }
     if (!response.body || response.headers.has('Content-Encoding')) {
         return response
     }
@@ -38,7 +49,8 @@ export function gzipResponse(req: Request, response: Response): Response {
     headers.append('Vary', 'Accept-Encoding')
     /* The stored length no longer matches the compressed body (and is unknown for a stream). */
     headers.delete('Content-Length')
-    return new Response(response.body.pipeThrough(new CompressionStream('gzip')), {
+    const compressor = streamedHtml ? flushingGzipStream() : new CompressionStream('gzip')
+    return new Response(response.body.pipeThrough(compressor), {
         status: response.status,
         statusText: response.statusText,
         headers,

package/src/lib/server/runtime/serializeCacheSnapshot.ts

@@ -1,45 +1,34 @@
 import { isReplayableMethod } from '../../shared/isReplayableMethod.ts'
-import type { CacheEntry } from '../../shared/types/CacheEntry.ts'
-import type { CacheSnapshot } from '../../shared/types/CacheSnapshot.ts'
 import type { CacheSnapshotEntry } from '../../shared/types/CacheSnapshotEntry.ts'
 import type { CacheStore } from '../../shared/types/CacheStore.ts'
 import { snapshotEntryFromCache } from './snapshotEntryFromCache.ts'
 
 /*
-Partitions the request-scoped cache for SSR. Entries settled by the time
-`render()` returns were consumed via `await` (render blocked on them) and ship
-inline in the document's `__SSR__` blob. Entries still pending were consumed
-via `{#await}` — render emitted their pending branch without blocking — so they
-go to `pending` for the response streamer to drain and resolve over the wire.
+Snapshots the request-scoped cache for SSR at a single instant: every replayable
+(GET/DELETE) entry settled by now, serialized to a wire-safe CacheSnapshotEntry the
+client seeds its store from. Unsettled and non-replayable entries are skipped; a body
+that can't ship (binary / streaming / rejected) drops out via snapshotEntryFromCache.
 
-Unlike the old buffer-everything path, this never awaits the pending promises:
-that's the whole point of streaming. Settled entries are read concurrently (the
-awaits are immediate since they're already resolved, but their body reads run in
-parallel); pending entries are handed back as-is for the streamer to await one
-chunk at a time.
+Snapshots concurrently — the awaits are immediate (entries are already settled), but
+their body reads run in parallel. Never blocks on an unsettled entry.
+
+WHEN it's called decides what it sees. createUiPageRenderer calls it at render-return
+for `__SSR__` — that catches only top-level `await` reads (render blocked on them). A
+`{#await cache()}` read does NOT appear: its expression is a thunk renderToStream runs
+lazily, so its entry is created mid-stream, after this snapshot. The renderer snapshots
+AGAIN once the stream has drained (entries then exist and are settled) and seeds those
+over the wire — see its post-stream `__abideResolve` pass. So for a streaming page the
+render-return snapshot is typically empty; the warm cache arrives over the stream.
 */
-export async function serializeCacheSnapshot(store: CacheStore): Promise<CacheSnapshot> {
-    const settled: CacheEntry[] = []
-    const pending: CacheEntry[] = []
-    for (const entry of store.entries.values()) {
-        /* Producer entries carry no wire request — nothing to rehydrate against, skip. */
-        if (!entry.request) {
-            continue
-        }
-        if (!isReplayableMethod(entry.request.method.toUpperCase())) {
-            continue
-        }
-        if (entry.settled) {
-            settled.push(entry)
-        } else {
-            pending.push(entry)
-        }
-    }
+export async function serializeCacheSnapshot(store: CacheStore): Promise<CacheSnapshotEntry[]> {
+    const settled = Array.from(store.entries.values()).filter(
+        (entry) =>
+            entry.settled === true &&
+            entry.request !== undefined &&
+            isReplayableMethod(entry.request.method.toUpperCase()),
+    )
     const snapshots = await Promise.all(
         settled.map((entry) => snapshotEntryFromCache(store, entry)),
     )
-    const inline = snapshots.filter(
-        (snapshot): snapshot is CacheSnapshotEntry => snapshot !== undefined,
-    )
-    return { inline, pending }
+    return snapshots.filter((snapshot): snapshot is CacheSnapshotEntry => snapshot !== undefined)
 }

package/src/lib/server/runtime/snapshotEntryFromCache.ts

@@ -1,4 +1,5 @@
 import { isReplayableMethod } from '../../shared/isReplayableMethod.ts'
+import { isStreamingResponse } from '../../shared/isStreamingResponse.ts'
 import type { CacheEntry } from '../../shared/types/CacheEntry.ts'
 import type { CacheSnapshotEntry } from '../../shared/types/CacheSnapshotEntry.ts'
 import type { CacheStore } from '../../shared/types/CacheStore.ts'
@@ -38,6 +39,14 @@ export async function snapshotEntryFromCache(
     if (store.entries.get(entry.key) !== entry) {
         return undefined
     }
+    /* A streaming body (SSE / JSONL / NDJSON) can't ship: `response.text()` below would
+       hang buffering a never-ending stream, and `decodeResponse` refuses it on the client
+       anyway — so a snapshot value would diverge from a live read. Skip it (the same guard
+       `decodeResponse` applies), letting the client live-fetch and get the proper streaming
+       error. */
+    if (isStreamingResponse(response)) {
+        return undefined
+    }
     const contentType = (response.headers.get('content-type') ?? '').toLowerCase()
     if (!isTextual(contentType)) {
         return undefined

package/src/lib/server/sockets/defineSocket.ts

@@ -6,6 +6,7 @@ import { getActiveServer } from '../runtime/getActiveServer.ts'
 import { registerSocket } from './registerSocket.ts'
 import type { Socket } from './types/Socket.ts'
 import type { SocketOptions } from './types/SocketOptions.ts'
+import type { SocketServerFrame } from './types/SocketServerFrame.ts'
 
 /*
 Server-side construction of a Socket. The bundler rewrites every
@@ -118,7 +119,11 @@ export function defineSocket<T>(name: string, opts: SocketOptions = {}): Socket<
         }
         const server = cachedServer
         if (server) {
-            server.publish(topic, JSON.stringify({ type: 'msg', socket: name, message: validated }))
+            /* Typed against the shared wire contract so a `SocketServerFrame` change can't
+               silently drift from this construction site (the dispatcher's `send` is already
+               typed; this was the last `msg` frame built through an unchecked JSON.stringify). */
+            const frame: SocketServerFrame = { type: 'msg', socket: name, message: validated }
+            server.publish(topic, JSON.stringify(frame))
         }
     }
 

package/src/lib/shared/cacheEntryFromSnapshot.ts

@@ -1,3 +1,4 @@
+import { contentBodyKind } from './contentBodyKind.ts'
 import { contentTypeOf } from './contentTypeOf.ts'
 import type { CacheEntry } from './types/CacheEntry.ts'
 import type { CacheSnapshotEntry } from './types/CacheSnapshotEntry.ts'
@@ -31,30 +32,31 @@ export function cacheEntryFromSnapshot(entry: CacheSnapshotEntry): CacheEntry {
 
 /*
 Synchronously decodes a snapshot body so the warm entry reads without a
-microtask hop on first render. Mirrors decodeResponse for the textual cases the
-snapshot ships; non-2xx and 204 yield no warm value and fall back to the async
-path, which throws HttpError / returns undefined exactly as a live call would.
-Binary/xml bodies also skip the warm path and decode asynchronously.
+microtask hop on first render. A strict subset of `decodeResponse`: it warms
+only the `json`/`text` kinds (the same `contentBodyKind` the live read switches
+on, so the two cannot disagree about a body), returning a value identical to
+what awaiting the Response would yield. Every other kind — non-2xx, 204,
+streaming, binary — yields no warm value and defers to the async path, which
+throws HttpError / returns the streaming error / blobs exactly as a live call
+would.
 */
 function warmValueFromSnapshot(status: number, headers: Headers, body: string): unknown {
     if (status === 204 || status < 200 || status >= 300) {
         return undefined
     }
-    const contentType = contentTypeOf(headers)
-    if (contentType.includes('json')) {
-        /*
-        `.includes('json')` also matches streaming/non-JSON types like
-        application/x-ndjson; fall back to the async path (return undefined)
-        rather than throwing a SyntaxError synchronously during hydration.
-        */
+    const kind = contentBodyKind(contentTypeOf(headers))
+    if (kind === 'json') {
+        /* The body may still be malformed JSON; fall back to the async path rather than
+           throwing a SyntaxError synchronously during hydration. */
         try {
             return JSON.parse(body)
         } catch {
             return undefined
         }
     }
-    if (contentType.startsWith('text/')) {
+    if (kind === 'text') {
         return body
     }
+    /* streaming and binary defer to the async path (the live decode throws / blobs). */
     return undefined
 }

package/src/lib/shared/contentBodyKind.ts

@@ -0,0 +1,27 @@
+import { STREAMING_CONTENT_TYPES } from './STREAMING_CONTENT_TYPES.ts'
+
+/*
+The single classification of a Content-Type into the body kind that decides how
+its bytes become a value. One ordering, read by every decoder, so the live read
+(`decodeResponse`) and the synchronous warm read (`warmValueFromSnapshot`) cannot
+classify the same body differently — the divergence that shipped a warm value a
+live read rejected (the streaming-guard-in-one-but-not-the-other bug).
+
+`streaming` is tested FIRST and the order is load-bearing: `application/jsonl`
+and `application/x-ndjson` both contain `json`, so a json-first scan would
+mis-bucket a stream as parseable JSON.
+*/
+export type ContentBodyKind = 'streaming' | 'json' | 'text' | 'binary'
+
+export function contentBodyKind(contentType: string): ContentBodyKind {
+    if (STREAMING_CONTENT_TYPES.some((type) => contentType.startsWith(type))) {
+        return 'streaming'
+    }
+    if (contentType.includes('json')) {
+        return 'json'
+    }
+    if (contentType.startsWith('text/')) {
+        return 'text'
+    }
+    return 'binary'
+}

package/src/lib/shared/createSocketSubRegistry.ts

@@ -0,0 +1,112 @@
+import type { SocketClientFrame } from '../server/sockets/types/SocketClientFrame.ts'
+import type { SocketServerFrame } from '../server/sockets/types/SocketServerFrame.ts'
+import type { SocketChannel } from './types/SocketChannel.ts'
+import type { SocketSubCallbacks } from './types/SocketSubCallbacks.ts'
+
+/*
+The multiplex bookkeeping every SocketChannel shares: the local subscription
+registry plus the inbound `SocketServerFrame` routing. A channel supplies only
+its transport (`send`, and when to call `drainSubs` on a drop); everything that
+encodes the wire contract — how a `msg` fans out to a socket's subs, how
+`replay`/`end`/`err` address one sub — lives here once, so the browser multiplex
+and the test harness cannot drift on the protocol (ADR-0005).
+
+`send` carries an outbound client frame however the channel can (the browser
+queues until open and reconnects; the test harness queues until open). Routing
+and the registry never touch the transport, so they stay identical across both.
+*/
+export function createSocketSubRegistry(send: (frame: SocketClientFrame) => void): {
+    channel: SocketChannel
+    routeFrame: (frame: SocketServerFrame) => void
+    drainSubs: () => SocketSubCallbacks[]
+} {
+    const subs = new Map<string, { socket: string; callbacks: SocketSubCallbacks }>()
+    /* Reverse index for `msg` fan-out: one server publish addresses a socket, not a sub. */
+    const subsBySocket = new Map<string, Set<string>>()
+
+    function dropSub(id: string): void {
+        const entry = subs.get(id)
+        if (!entry) {
+            return
+        }
+        subs.delete(id)
+        const set = subsBySocket.get(entry.socket)
+        if (set) {
+            set.delete(id)
+            if (set.size === 0) {
+                subsBySocket.delete(entry.socket)
+            }
+        }
+    }
+
+    /*
+    Routes one inbound frame to its sub(s):
+      `msg`    → every local sub of that socket (addressed by socket name)
+      `replay` → the one sub that requested the seed (its batched tail)
+      `end`/`err` → the one sub, dropped first so its iterator can't take another frame
+    A frame for an unknown sub/socket is ignored — a sub torn down between request
+    and delivery.
+    */
+    function routeFrame(frame: SocketServerFrame): void {
+        if (frame.type === 'msg') {
+            const targets = subsBySocket.get(frame.socket)
+            if (!targets) {
+                return
+            }
+            for (const subId of targets) {
+                subs.get(subId)?.callbacks.onMessage(frame.message)
+            }
+            return
+        }
+        if (frame.type === 'replay') {
+            subs.get(frame.sub)?.callbacks.onReplay(frame.messages)
+            return
+        }
+        const sub = subs.get(frame.sub)
+        if (!sub) {
+            return
+        }
+        dropSub(frame.sub)
+        if (frame.type === 'end') {
+            sub.callbacks.onEnd()
+        } else {
+            sub.callbacks.onError(frame.message)
+        }
+    }
+
+    /* Tear down every sub on a transport drop and hand the caller their callbacks.
+       Clears the registry BEFORE the caller runs `onDisconnect`, so a consumer that
+       re-subscribes in reaction (in a later microtask) registers onto fresh state. */
+    function drainSubs(): SocketSubCallbacks[] {
+        const active = [...subs.values()].map((entry) => entry.callbacks)
+        subs.clear()
+        subsBySocket.clear()
+        return active
+    }
+
+    const channel: SocketChannel = {
+        subscribe(id, socket, replay, callbacks) {
+            subs.set(id, { socket, callbacks })
+            /* Not getOrInsertComputed: browser-side code, and Safari/Chrome only shipped it within the last browser cycle (26.2 / 145). */
+            let set = subsBySocket.get(socket)
+            if (!set) {
+                set = new Set()
+                subsBySocket.set(socket, set)
+            }
+            set.add(id)
+            send({ type: 'sub', sub: id, socket, replay })
+        },
+        unsubscribe(id) {
+            if (!subs.has(id)) {
+                return
+            }
+            dropSub(id)
+            send({ type: 'unsub', sub: id })
+        },
+        publish(socket, message) {
+            send({ type: 'pub', socket, message })
+        },
+    }
+
+    return { channel, routeFrame, drainSubs }
+}

package/src/lib/shared/decodeResponse.ts

@@ -1,6 +1,6 @@
+import { contentBodyKind } from './contentBodyKind.ts'
 import { contentTypeOf } from './contentTypeOf.ts'
 import { HttpError } from './HttpError.ts'
-import { isStreamingResponse } from './isStreamingResponse.ts'
 
 /*
 Decodes a Response into the natural body value based on Content-Type:
@@ -33,15 +33,16 @@ export async function decodeResponse(response: Response): Promise<unknown> {
         return undefined
     }
     const contentType = contentTypeOf(response.headers)
-    if (isStreamingResponse(response)) {
+    const kind = contentBodyKind(contentType)
+    if (kind === 'streaming') {
         throw new Error(
             `[abide] response at ${response.url} is a stream (${contentType}) — use tail(fn.stream(args)) for a reactive view, or fn.stream(args) for per-call iteration, instead of awaiting the bare call or cache()`,
         )
     }
-    if (contentType.includes('json')) {
+    if (kind === 'json') {
         return response.json()
     }
-    if (contentType.startsWith('text/')) {
+    if (kind === 'text') {
         return response.text()
     }
     return response.blob()

package/src/lib/shared/isStreamingResponse.ts

@@ -1,12 +1,12 @@
+import { contentBodyKind } from './contentBodyKind.ts'
 import { contentTypeOf } from './contentTypeOf.ts'
-import { STREAMING_CONTENT_TYPES } from './STREAMING_CONTENT_TYPES.ts'
 
 /*
 Whether a Response carries a streaming body (SSE / JSONL / NDJSON) by its
-Content-Type, so callers drain it frame-by-frame instead of buffering.
-Shared by the CLI print path and the MCP tool dispatcher.
+Content-Type, so callers drain it frame-by-frame instead of buffering. The
+streaming bucket of the shared `contentBodyKind` classification. Shared by the
+CLI print path and the MCP tool dispatcher.
 */
 export function isStreamingResponse(response: Response): boolean {
-    const contentType = contentTypeOf(response.headers)
-    return STREAMING_CONTENT_TYPES.some((type) => contentType.startsWith(type))
+    return contentBodyKind(contentTypeOf(response.headers)) === 'streaming'
 }

package/src/lib/test/createTestSocketChannel.ts

@@ -2,8 +2,7 @@ import type { Socket } from '../server/sockets/types/Socket.ts'
 import type { SocketClientFrame } from '../server/sockets/types/SocketClientFrame.ts'
 import type { SocketServerFrame } from '../server/sockets/types/SocketServerFrame.ts'
 import { buildSocketOverChannel } from '../shared/buildSocketOverChannel.ts'
-import type { SocketChannel } from '../shared/types/SocketChannel.ts'
-import type { SocketSubCallbacks } from '../shared/types/SocketSubCallbacks.ts'
+import { createSocketSubRegistry } from '../shared/createSocketSubRegistry.ts'
 
 /*
 Test-side substitute for the browser socketChannel: one ws to the booted
@@ -23,8 +22,6 @@ export function createTestSocketChannel(wsUrl: string): {
     /* `using channel = createTestSocketChannel(url)` — disposal closes the ws. */
     [Symbol.dispose]: () => void
 } {
-    const subs = new Map<string, { socket: string; callbacks: SocketSubCallbacks }>()
-    const subsBySocket = new Map<string, Set<string>>()
     let pendingSends: string[] = []
 
     const ws = new WebSocket(wsUrl)
@@ -48,20 +45,9 @@ export function createTestSocketChannel(wsUrl: string): {
         pendingSends.push(message)
     }
 
-    function dropSub(id: string): void {
-        const entry = subs.get(id)
-        if (!entry) {
-            return
-        }
-        subs.delete(id)
-        const set = subsBySocket.get(entry.socket)
-        if (set) {
-            set.delete(id)
-            if (set.size === 0) {
-                subsBySocket.delete(entry.socket)
-            }
-        }
-    }
+    /* Same sub registry + frame routing the browser channel uses; this harness owns
+       only the bare ws (no reconnect — a test drives the lifecycle through close()). */
+    const registry = createSocketSubRegistry(send)
 
     ws.addEventListener('open', flushPending)
     ws.addEventListener('message', (event) => {
@@ -71,70 +57,23 @@ export function createTestSocketChannel(wsUrl: string): {
         } catch {
             return
         }
-        if (frame.type === 'msg') {
-            const targets = subsBySocket.get(frame.socket)
-            if (!targets) {
-                return
-            }
-            for (const subId of targets) {
-                subs.get(subId)?.callbacks.onMessage(frame.message)
-            }
-            return
-        }
-        if (frame.type === 'replay') {
-            subs.get(frame.sub)?.callbacks.onReplay(frame.messages)
-            return
-        }
-        const sub = subs.get(frame.sub)
-        if (!sub) {
-            return
-        }
-        dropSub(frame.sub)
-        if (frame.type === 'end') {
-            sub.callbacks.onEnd()
-        } else {
-            sub.callbacks.onError(frame.message)
-        }
+        registry.routeFrame(frame)
     })
     /* A drop after subs are live is unexpected; surface it so iterators unblock
        instead of awaiting a frame that never comes. Idempotent — the first of
-       error/close clears subs, the second finds none. error covers a failed
+       error/close drains the subs, the second finds none. error covers a failed
        handshake (no open, no clean close) that close alone would miss. */
     function disconnectAll(): void {
-        const active = [...subs.values()]
-        subs.clear()
-        subsBySocket.clear()
-        for (const sub of active) {
-            sub.callbacks.onDisconnect()
+        for (const callbacks of registry.drainSubs()) {
+            callbacks.onDisconnect()
         }
     }
     ws.addEventListener('close', disconnectAll)
     ws.addEventListener('error', disconnectAll)
 
-    const channel: SocketChannel = {
-        subscribe(id, socket, replay, callbacks) {
-            subs.set(id, { socket, callbacks })
-            let set = subsBySocket.get(socket)
-            if (!set) {
-                set = new Set()
-                subsBySocket.set(socket, set)
-            }
-            set.add(id)
-            send({ type: 'sub', sub: id, socket, replay })
-        },
-        unsubscribe(id) {
-            if (!subs.has(id)) {
-                return
-            }
-            dropSub(id)
-            send({ type: 'unsub', sub: id })
-        },
-        publish: (socket, message) => send({ type: 'pub', socket, message }),
-    }
-
     /* Same Socket<T> builder the browser proxy uses, over this test channel. */
     function socket<T>(name: string): Socket<T> {
-        return buildSocketOverChannel<T>(name, () => channel)
+        return buildSocketOverChannel<T>(name, () => registry.channel)
     }
 
     const close = () => ws.close()

package/src/lib/ui/README.md

@@ -36,7 +36,7 @@ every page, and `.abide` files are the only component format.
 
 ## Idioms
 
-- **Signals are the surface**: `state(v)`, `derived(fn)`, `effect(fn)`, `prop(name)`.
+- **Signals are the surface**: `state(v)`, `derived(fn)`, `effect(fn)`, `props()`.
   You write plain assignment (`count += 1`, `items.push(x)`); the compiler lowers
   it. Templates auto-read (`{count}`); ordering and cross-references compose.
 - **Everything dynamic lives in `{ }`** — `{expr}` text, `name={expr}`,

package/src/lib/ui/compile/REACTIVE_CALLEES.ts

@@ -1,12 +1,12 @@
 /* The callee names the `.abide` compiler recognises as reactive declarations
-   (`let x = state(...)`, `linked(...)`, `computed(...)`, `prop(...)`): the shared
-   "is this a reactive binding" allowlist read by the desugarer, the nested-script
-   scoper, and the type-checking shadow. How each lowers — a serializable doc slot
-   vs a `.value` cell — is decided per-site; this is only the membership set, so a
-   new primitive is a single edit here. */
+   (`let x = state(...)`, `linked(...)`, `computed(...)`, and the destructuring
+   `const {…} = props()`): the shared "is this a reactive binding" allowlist read by
+   the desugarer, the nested-script scoper, and the type-checking shadow. How each
+   lowers — a serializable doc slot vs a `.value` cell — is decided per-site; this is
+   only the membership set, so a new primitive is a single edit here. */
 export const REACTIVE_CALLEES: ReadonlySet<string> = new Set([
     'state',
     'linked',
     'computed',
-    'prop',
+    'props',
 ])

package/src/lib/ui/compile/UI_RUNTIME_IMPORTS.ts

@@ -32,6 +32,7 @@ export const UI_RUNTIME_IMPORTS: { name: string; specifier: string }[] = [
     { name: 'mountSlot', specifier: 'ui/dom/mountSlot' },
     { name: 'mountChild', specifier: 'ui/dom/mountChild' },
     { name: 'hydrate', specifier: 'ui/dom/hydrate' },
+    { name: 'escapeKey', specifier: 'ui/runtime/escapeKey' },
     { name: 'nextBlockId', specifier: 'ui/runtime/nextBlockId' },
     { name: 'enterRenderPass', specifier: 'ui/runtime/enterRenderPass' },
     { name: 'exitRenderPass', specifier: 'ui/runtime/exitRenderPass' },