@abide/abide 0.34.2 → 0.36.0

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

@@ -1,14 +1,20 @@
 import { appNameSlot } from '../../shared/appNameSlot.ts'
 import { SSR_CACHE_CONTROL } from '../../shared/CACHE_CONTROL_VALUES.ts'
 import { formatTraceparent } from '../../shared/formatTraceparent.ts'
+import { isReplayableMethod } from '../../shared/isReplayableMethod.ts'
 import { layoutChainForRoute } from '../../shared/layoutChainForRoute.ts'
+import type { CacheEntry } from '../../shared/types/CacheEntry.ts'
+import type { CacheSnapshotEntry } from '../../shared/types/CacheSnapshotEntry.ts'
+import type { StreamedResolution } from '../../shared/types/StreamedResolution.ts'
 import { renderChain } from '../../ui/renderChain.ts'
 import { renderToStream } from '../../ui/renderToStream.ts'
 import type { UiComponent } from '../../ui/runtime/types/UiComponent.ts'
 import { pageUrlFromStore } from './pageUrlFromStore.ts'
 import { SSR_SWAP_SCRIPT } from './SSR_SWAP_SCRIPT.ts'
+import { STREAMED_HTML_HEADER } from './STREAMED_HTML_HEADER.ts'
 import { safeJsonForScript } from './safeJsonForScript.ts'
 import { serializeCacheSnapshot } from './serializeCacheSnapshot.ts'
+import { streamCacheResolutions } from './streamCacheResolutions.ts'
 import type { RequestStore } from './types/RequestStore.ts'
 
 /* A abide-ui page module: its default export is the compiled component. */
@@ -21,6 +27,19 @@ function wantsJson(request: Request): boolean {
     return (request.headers.get('accept') ?? '').includes('application/json')
 }
 
+/* Defines `window.__abideResolve` ahead of the body: the vanilla collector each
+   streamed cache resolution calls, buffering payloads for startClient to drain into
+   the store before hydration (the bundle is deferred, so it runs after every chunk). */
+const CACHE_RESOLVE_SCRIPT =
+    'window.__abideResolve=function(r){(window.__abideResumeCache=window.__abideResumeCache||[]).push(r)}'
+
+/* One streamed cache resolution as an inline `__abideResolve(...)` call. `<` is escaped
+   (as in encodeResume) so a body value can't close the script early. */
+function resolveChunk(resolution: StreamedResolution): string {
+    const payload = JSON.stringify(resolution).replace(/</g, '\\u003c')
+    return `<script>__abideResolve(${payload})</script>`
+}
+
 /*
 The abide-ui SSR document renderer. A matched route + params in, a finished HTML
 Response out.
@@ -30,9 +49,16 @@ await blocks STREAMS: the pending shell flushes first, then each resolved fragme
 (`<abide-resolve>` carrying a JSON `<script>`) as its promise settles, swapped into its boundary
 by the inline SSR_SWAP_SCRIPT — which also registers the value into the resume
 manifest so client hydration adopts it without re-fetching (see abide/ui/awaitBlock).
+Then, once the stream has run every `{#await}` thunk (creating and settling its cache
+entry mid-stream, after the render-return snapshot), each such entry streams an inline
+`__abideResolve(...)` chunk — a warm snapshot, or a `{ key, miss }` marker for an
+unshippable body (→ live refetch) — seeding the client store before the deferred bundle
+so the block's subscription read is warm (no refetch).
 
 `__SSR__` carries the route/params, mount base, trace, app name, client timeout,
-and the settled cache snapshot (the client seeds its tab store from it). A route's
+and the render-return cache snapshot (top-level `await` reads; the client seeds its tab
+store from it). `{#await}` reads aren't settled yet at render-return — they arrive over
+the stream as above. A route's
 `layout.abide` files wrap the page outermost-first (every ancestor directory's
 layout applies); the chain server-renders as one document via `renderChain`, the
 page folded into each layout's `<slot/>` outlet. The client router re-resolves the
@@ -44,6 +70,7 @@ export function createUiPageRenderer({
     clientTimeout,
     pages,
     layouts,
+    routePreloads = {},
     healthPayload,
 }: {
     shell: string
@@ -51,6 +78,7 @@ export function createUiPageRenderer({
     clientTimeout: number | undefined
     pages: Record<string, LoadPage>
     layouts: Record<string, LoadPage>
+    routePreloads?: Record<string, string[]>
     healthPayload: (request: Request) => Promise<Record<string, unknown>>
 }): {
     renderPage: (
@@ -65,13 +93,15 @@ export function createUiPageRenderer({
         stack?: string,
     ) => Promise<Response | undefined>
 } {
-    /* Build the __SSR__ <script> the client (startClient) reads on boot. */
+    /* Build the __SSR__ <script> the client (startClient) reads on boot. The inline
+       (settled) cache partition is computed once by the caller and threaded in, so the
+       streaming branch can also drain the pending partition over the same render. */
     async function stateTag(
         routeUrl: string,
         params: Record<string, string>,
         store: RequestStore,
+        inline: CacheSnapshotEntry[],
     ): Promise<string> {
-        const { inline } = await serializeCacheSnapshot(store.cache)
         const health = store.healthRead ? await healthPayload(store.req) : undefined
         const payload = safeJsonForScript({
             route: routeUrl,
@@ -86,6 +116,32 @@ export function createUiPageRenderer({
         return `<script>window.__SSR__ = ${payload};</script>`
     }
 
+    /* Per-route `<link rel=modulepreload>`s for the route's page + layout-chain chunks
+       and their route-only static runtime deps (the shell already preloads the entry's
+       shared runtime). Those chunks are dynamically imported by the entry, so the browser
+       discovers them only after the entry runs at parse-end ≈ stream-close; preloading them
+       in <head> overlaps their transfer with the stream. Rebased onto the mount base like
+       the shell's own `/_app/` refs. Cached per route — the set is render-invariant. */
+    const preloadLinkCache = new Map<string, string>()
+    function routePreloadLinks(routeUrl: string): string {
+        const cached = preloadLinkCache.get(routeUrl)
+        if (cached !== undefined) {
+            return cached
+        }
+        const links = (routePreloads[routeUrl] ?? [])
+            .map((chunk) => `<link rel="modulepreload" href="${base}/_app/${chunk}" />`)
+            .join('')
+        preloadLinkCache.set(routeUrl, links)
+        return links
+    }
+
+    /* Splices the route preloads in before the shell's </head> (case-insensitive, like the
+       build-time injector). A no-op when there are none or the shell carries no </head>. */
+    function injectRoutePreloads(html: string, routeUrl: string): string {
+        const links = routePreloadLinks(routeUrl)
+        return links === '' ? html : html.replace(/<\/head>/i, `${links}</head>`)
+    }
+
     async function renderPage(
         routeUrl: string,
         params: Record<string, string>,
@@ -117,14 +173,24 @@ export function createUiPageRenderer({
             params,
         )
 
+        /* Snapshot the cache settled by render-return — top-level `await` reads (render
+           blocked on them) — into __SSR__. A `{#await}` read is NOT here: its expression
+           is a thunk `renderToStream` runs lazily, so its entry is created mid-stream and
+           seeded after the drain (see below). */
+        const inline = await serializeCacheSnapshot(store.cache)
+        const inlinedKeys = new Set(inline.map((entry) => entry.key))
+
         /* No await blocks → render synchronously, ship buffered. */
         if (ssr.awaits.length === 0) {
-            const html = shell.replace(SSR_MARKER, (_match, key: string) =>
-                key === 'body' ? ssr.html : key === 'state' ? '' : '',
+            const html = injectRoutePreloads(
+                shell.replace(SSR_MARKER, (_match, key: string) =>
+                    key === 'body' ? ssr.html : key === 'state' ? '' : '',
+                ),
+                routeUrl,
             )
             const withState = html.replace(
                 '</body>',
-                `${await stateTag(routeUrl, params, store)}</body>`,
+                `${await stateTag(routeUrl, params, store, inline)}</body>`,
             )
             return new Response(withState, {
                 headers: {
@@ -139,9 +205,14 @@ export function createUiPageRenderer({
            Fill head/state but LEAVE the body marker intact — it's the split point for
            streaming the page body into `#app`; consuming it here would append the body
            after the whole shell (outside `#app`), breaking hydration. */
-        const head = `<script>${SSR_SWAP_SCRIPT}</script>${await stateTag(routeUrl, params, store)}`
-        const filled = shell.replace(/<!--ssr:(head|state)-->/g, (_match, key: string) =>
-            key === 'head' ? head : '',
+        const head =
+            `<script>${SSR_SWAP_SCRIPT}${CACHE_RESOLVE_SCRIPT}</script>` +
+            `${await stateTag(routeUrl, params, store, inline)}`
+        const filled = injectRoutePreloads(
+            shell.replace(/<!--ssr:(head|state)-->/g, (_match, key: string) =>
+                key === 'head' ? head : '',
+            ),
+            routeUrl,
         )
         const [before, after] = filled.split(BODY_MARKER)
         const encoder = new TextEncoder()
@@ -158,6 +229,26 @@ export function createUiPageRenderer({
                         )
                         first = false
                     }
+                    /* The {#await} reads created (and settled) their cache entries DURING the
+                       stream — the await expression is a thunk `renderToStream` ran lazily —
+                       so they missed the render-return snapshot. Drain them now: each lands an
+                       inline `__abideResolve(...)` chunk (a warm snapshot, or a `{ key, miss }`
+                       marker for an unshippable body → live refetch) before the deferred
+                       bundle, so startClient seeds the store and the block's subscription read
+                       is warm. Skip keys already shipped inline in __SSR__. */
+                    const streamedEntries = Array.from(store.cache.entries.values()).filter(
+                        (entry: CacheEntry) =>
+                            entry.settled === true &&
+                            entry.request !== undefined &&
+                            isReplayableMethod(entry.request.method.toUpperCase()) &&
+                            !inlinedKeys.has(entry.key),
+                    )
+                    for await (const resolution of streamCacheResolutions(
+                        store.cache,
+                        streamedEntries,
+                    )) {
+                        controller.enqueue(encoder.encode(resolveChunk(resolution)))
+                    }
                     controller.enqueue(encoder.encode(after ?? ''))
                     controller.close()
                 },
@@ -166,6 +257,10 @@ export function createUiPageRenderer({
                 headers: {
                     'Content-Type': 'text/html; charset=utf-8',
                     'Cache-Control': SSR_CACHE_CONTROL,
+                    /* Mark the progressively-flushed document so gzipResponse compresses it
+                       with a per-chunk-flushing gzip (the plain CompressionStream buffers the
+                       head and defeats streaming); the marker is stripped before send. */
+                    [STREAMED_HTML_HEADER]: '1',
                 },
             },
         )

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/shared/cache.ts

@@ -24,6 +24,7 @@ import type { CacheStore } from './types/CacheStore.ts'
 import type { RawRemoteFunction } from './types/RawRemoteFunction.ts'
 import type { RemoteFunction } from './types/RemoteFunction.ts'
 import type { Subscribable } from './types/Subscribable.ts'
+import { withCacheManaged } from './withCacheManaged.ts'
 
 type AnyRemote<Args, Return> = RemoteFunction<Args, Return> | RawRemoteFunction<Args>
 type Producer<Args, Return> = (args?: Args) => Promise<Return>
@@ -309,8 +310,12 @@ function invokeProducer<Args, Return>(
     }
     /* Miss: time the producer run — where a request's time actually goes (an
        external fetch, a computation). Producer path only; the remote path must
-       keep its own promise so getRemoteMeta can read the recorded Request. */
-    const promise = cacheLog.trace<Return>(`cache ${key}`, () => producer(args))
+       keep its own promise so getRemoteMeta can read the recorded Request. The
+       producer runs cache-managed so a bare RPC inside it isn't scope-bound — the
+       cache coalesces and owns this flight. */
+    const promise = cacheLog.trace<Return>(`cache ${key}`, () =>
+        withCacheManaged(() => producer(args)),
+    )
     registerEntry(store, key, promise, options, undefined, () => producer(args))
     return promise
 }
@@ -326,7 +331,9 @@ function invokeRemote<Args>(
     if (existing) {
         return shareable(existing.promise as Promise<Response>)
     }
-    const promise = rawFn(args as Args)
+    /* Cache-managed: the shared flight isn't bound to the reader that triggered the
+       miss, so its scope disposing can't abort a request other readers still join. */
+    const promise = withCacheManaged(() => rawFn(args as Args))
     const request = getRemoteMeta(promise)
     if (!request) {
         throw new Error(

package/src/lib/shared/cacheManagedSlot.ts

@@ -0,0 +1,10 @@
+/*
+Set while cache() synchronously invokes the underlying remote/producer, so the
+client's currentAbortSignal skips scope-binding for cache-managed calls. The cache
+coalesces one in-flight request across every reader and owns its lifetime (it
+evicts the entry when the request rejects), so a single reader navigating away must
+not abort a flight the others still depend on. A plain boolean — cache invokes the
+underlying call synchronously and never re-enters across an await. Harmless on the
+server, where there is no reactive observer to bind anyway.
+*/
+export const cacheManagedSlot: { active: boolean } = { active: false }

package/src/lib/shared/withCacheManaged.ts

@@ -0,0 +1,18 @@
+import { cacheManagedSlot } from './cacheManagedSlot.ts'
+
+/*
+Runs `invoke` with cacheManagedSlot flagged, so any RPC fired synchronously inside
+it (the cache's underlying remote/producer call) skips reactive scope-binding — the
+cache, not the calling reader, owns the shared flight's lifetime. Save/restore keeps
+it correct under nesting (a producer that itself reads cache). The fetch is fired
+synchronously and the flag clears before the await, so it never spans the network.
+*/
+export function withCacheManaged<T>(invoke: () => T): T {
+    const previous = cacheManagedSlot.active
+    cacheManagedSlot.active = true
+    try {
+        return invoke()
+    } finally {
+        cacheManagedSlot.active = previous
+    }
+}

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' },