@abide/abide 0.37.0 → 0.38.1

package/AGENTS.md

@@ -162,7 +162,7 @@ Test suites compile `.abide` and rewrite verbs under `bun test` via `preload = [
 - `abide/ui/enterScope`, `abide/ui/exitScope` — push/pop the lexical scope around an SSR render.
 - `abide/ui/router`, `abide/ui/startClient`, `abide/ui/renderToStream` — the client router, the official client entry (reads `window.__SSR__`, seeds cache, starts the router), and the out-of-order SSR streamer.
 - `abide/ui/remoteProxy`, `abide/ui/socketProxy` — the bundler-emitted client substitutes that swap a server verb/socket import for a `fetch` proxy / ws-multiplexed `Socket`.
-- `abide/ui/dom/*` — the compiled-template DOM runtime (one node-builder per construct): `mount`, `mountChild`, `mountSlot`, `hydrate`, `skeleton`, `cloneStatic`, `anchorCursor`, `text`, `appendText`, `appendTextAt`, `appendSnippet`, `appendStatic`, `attr`, `on`, `attach`, `each`, `eachAsync`, `when`, `awaitBlock`, `tryBlock`, `switchBlock`, `applyResolved`.
+- `abide/ui/dom/*` — the compiled-template DOM runtime (one node-builder per construct): `mount`, `mountChild`, `mountSlot`, `outlet`, `hydrate`, `skeleton`, `cloneStatic`, `anchorCursor`, `text`, `appendText`, `appendTextAt`, `appendSnippet`, `appendStatic`, `attr`, `on`, `attach`, `each`, `eachAsync`, `when`, `awaitBlock`, `tryBlock`, `switchBlock`, `applyResolved`. `outlet` is the marker-range a layout `<slot/>` compiles to (no wrapper element — the router fills it with the next chain layer as a direct child).
 - `abide/ui/runtime/*` — render-pass helpers: `escapeKey` (JSON-Pointer key escaping), `nextBlockId`, `enterRenderPass`, `exitRenderPass`.
 
 ## Build / tooling — @documentation building

package/CHANGELOG.md

@@ -1,5 +1,43 @@
 # abide
 
+## 0.38.1
+
+### Patch Changes
+
+- [`67ac25f`](https://github.com/briancray/abide/commit/67ac25faf78b029d0b14659df1e4ec1a05ae7a10) - document outlet marker-range in AGENTS.md surface map ([`ab23673`](https://github.com/briancray/abide/commit/ab236733ee1f81e19ce09ee35fe44624e955a6e4))
+
+- [`67ac25f`](https://github.com/briancray/abide/commit/67ac25faf78b029d0b14659df1e4ec1a05ae7a10) - unify pages/layouts/outlets on marker-range model ([`df1c95f`](https://github.com/briancray/abide/commit/df1c95f89ff8d6d6806606dbece531c6be7aabdf))
+
+## 0.38.0
+
+### Minor Changes
+
+- [`bcfd15a`](https://github.com/briancray/abide/commit/bcfd15af169787d733355d5879bf95aec164e698) - feat(dom): make `{snippet(args)}` interpolations reactive in their arguments. Previously `appendSnippet` read the call once at mount and never re-ran, so an argument derived from reactive state froze its initial value (e.g. `{grouped(Object.groupBy([...aired, ...upcoming]))}` rendered with `upcoming` still `[]`, never updating when a later effect populated it). The call is now bounded by a range and wrapped in an effect — like `when`/`each` — so an argument change tears the snippet down and re-mounts it with fresh args (the body's own reads stay fine-grained within a mount; args behave like props). Create mode now emits the `<!--abide:snippet-->` range markers the server already rendered, so the markers are congruent on both sides rather than a server-only asymmetry.
+
+### Patch Changes
+
+- [`2efd4ad`](https://github.com/briancray/abide/commit/2efd4ad1e572c46a0611d3d1d5cd1a02f80da629) - restart ttl on revalidation and don't clobber a live streamed seed ([`2d07d53`](https://github.com/briancray/abide/commit/2d07d53b5aec54681e34f7490f636de2bf47fc7a))
+
+- [`2efd4ad`](https://github.com/briancray/abide/commit/2efd4ad1e572c46a0611d3d1d5cd1a02f80da629) - harden rpc/runtime/socket edge cases ([`39581f4`](https://github.com/briancray/abide/commit/39581f46601b71ccad6c6112e37c55a03b069068))
+
+- [`2efd4ad`](https://github.com/briancray/abide/commit/2efd4ad1e572c46a0611d3d1d5cd1a02f80da629) - propagate control-server worker start failure ([`3bb529b`](https://github.com/briancray/abide/commit/3bb529b00dc939c73212215cf6ae027b1078c053))
+
+- [`2efd4ad`](https://github.com/briancray/abide/commit/2efd4ad1e572c46a0611d3d1d5cd1a02f80da629) - handle JSON-RPC notifications without replying ([`4315aa1`](https://github.com/briancray/abide/commit/4315aa11c7b834607e315e6403bc41c4c9bd6a8c))
+
+- [`2efd4ad`](https://github.com/briancray/abide/commit/2efd4ad1e572c46a0611d3d1d5cd1a02f80da629) - drop unused error-page manifest ([`7f4f78a`](https://github.com/briancray/abide/commit/7f4f78af9829dca10a6062dd76b6e7fb9fddf739))
+
+- [`2efd4ad`](https://github.com/briancray/abide/commit/2efd4ad1e572c46a0611d3d1d5cd1a02f80da629) - auto-vivify nested bind paths and escape persisted doc keys ([`a2f7d15`](https://github.com/briancray/abide/commit/a2f7d1546201b6edb3b645ffede56519890415cf))
+
+- [`2efd4ad`](https://github.com/briancray/abide/commit/2efd4ad1e572c46a0611d3d1d5cd1a02f80da629) - avoid stdin hang and reject blank numeric flags ([`f1d47ef`](https://github.com/briancray/abide/commit/f1d47ef731235d7a4c4ebb727a83bb642102aac0))
+
+- [`2efd4ad`](https://github.com/briancray/abide/commit/2efd4ad1e572c46a0611d3d1d5cd1a02f80da629) - parse unquoted attributes and skip destructured binding rewrites ([`ff66d57`](https://github.com/briancray/abide/commit/ff66d57f5362af68f06d0e62dfc78d5f95322f99))
+
+- [`fab46dd`](https://github.com/briancray/abide/commit/fab46ddb0d3b8c4c8a1fa4f4615e8c5b1dfbf9e9) - fix(dom): skip control-flow rebuild when the end marker is detached. An effect for a `when`/`switch` block could fire one final time after an enclosing await/each block tore its branch down in the same microtask flush (before the owner scope disposed it), making `fillBefore` insert a fragment before a parentless comment — `HierarchyRequestError: The operation would yield an incorrect node tree`. `fillBefore` now bails when `end.parentNode` is null.
+
+- [`b081dd5`](https://github.com/briancray/abide/commit/b081dd5f7087c9f88960349d2477eab2c8d78005) - fix(compile): unify the layout `<slot/>` outlet rewrite across both back-ends and emit it scope-free. The hole-numbering refactor keys skeleton hole indices by node identity, but `generateBuild` ran `skeletonContext` over the original nodes while traversing `nodes.map(asOutlet)` — and `asOutlet` clones every element it descends, so a layout with any reactive hole (e.g. the kitchen-sink `layout.abide`'s active-link `<a href={url('/')}>`) threw `[abide] skeleton hole not numbered by the shared positional walk` at compile time, failing the page render. Both back-ends now apply the shared `asOutlet` before `skeletonContext`, so the indexed tree and the traversed tree are one. The rewrite also strips the outlet's style scope: the client cloned `<abide-outlet>` with the slot's annotated `data-a-…` scope while the server emitted it bare, a hydration mismatch (and `renderChain` folds the child layer via an exact bare-`<abide-outlet></abide-outlet>` match) — the outlet is a structural mount container, not styled content, so it now carries no attributes or scope on either side.
+
+- [`b081dd5`](https://github.com/briancray/abide/commit/b081dd5f7087c9f88960349d2477eab2c8d78005) - refactor(compile): fold skeleton hole numbering into the single `skeletonContext` walk. `generateBuild` previously threaded its own mutable `{ el, an }` counter through a second document-order walk parallel to the decision walk, free to drift from it — the compiler half of the hand-mirrored hole-ordering protocol. `skeletonContext` now assigns each hole its `el`/`an` index in the same pass that records `inSkeleton`/`markText` (el keyed by node, an keyed by node or by the reactive-text part), and `generateBuild` reads them via `holeIndex` instead of counting. One walk owns both the decisions and the numbering, so a counter-vs-decision drift is structurally impossible; a hole the shared walk didn't number now throws at compile time rather than surfacing as a runtime hydration desync. Behavior-preserving — no API or output change.
+
 ## 0.37.0
 
 ### Minor Changes

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@abide/abide",
-    "version": "0.37.0",
+    "version": "0.38.1",
     "type": "module",
     "sideEffects": false,
     "description": "Isomorphic multimodal HTTP framework built for humans and machines in a single Bun runtime",
@@ -89,6 +89,7 @@
         "./ui/dom/skeleton": "./src/lib/ui/dom/skeleton.ts",
         "./ui/dom/anchorCursor": "./src/lib/ui/dom/anchorCursor.ts",
         "./ui/dom/mountSlot": "./src/lib/ui/dom/mountSlot.ts",
+        "./ui/dom/outlet": "./src/lib/ui/dom/outlet.ts",
         "./ui/dom/attr": "./src/lib/ui/dom/attr.ts",
         "./ui/dom/on": "./src/lib/ui/dom/on.ts",
         "./ui/dom/attach": "./src/lib/ui/dom/attach.ts",

package/src/abideResolverPlugin.ts

@@ -201,7 +201,7 @@ export function abideResolverPlugin({
         setup(build) {
             build.onResolve(
                 {
-                    filter: /\/_virtual\/(rpc|sockets|prompts|pages|layouts|errors|app|config|mcp-resources|mcp|assets|public-assets|shell|app-info|cli-manifest|cli-name|cli-chrome|bundle-window|bundle-disconnected-component|bundle-disconnected)\.ts$/,
+                    filter: /\/_virtual\/(rpc|sockets|prompts|pages|layouts|app|config|mcp-resources|mcp|assets|public-assets|shell|app-info|cli-manifest|cli-name|cli-chrome|bundle-window|bundle-disconnected-component|bundle-disconnected)\.ts$/,
                 },
                 (args) => {
                     const name = fileStem(args.path)
@@ -434,17 +434,6 @@ ${optionLines}
                     })
                 }
 
-                if (args.path === 'abide:errors') {
-                    const { errorFiles } = await scanPagesOnce()
-                    return manifestModule({
-                        files: errorFiles,
-                        keyForFile: pageUrlForFile,
-                        importDir: pagesDir,
-                        exportName: 'errors',
-                        label: 'error pages',
-                    })
-                }
-
                 if (args.path === 'abide:app') {
                     const userApp = `${cwd}/src/app.ts`
                     const hasAppModule = await Bun.file(userApp).exists()
@@ -788,7 +777,6 @@ ${encoded.map((entry) => entry.line).join('\n')}
 type PagesScan = {
     pageFiles: string[]
     layoutFiles: string[]
-    errorFiles: string[]
 }
 
 /*
@@ -796,19 +784,17 @@ Walks src/ui/pages once and classifies each `.abide` leaf by filename: a
 `page.abide` is a route (its URL is the folder path), a `layout.abide` is a
 layout that wraps every page at or below its folder (keyed by the same folder
 URL). Any other `.abide` file (a shared component) is ignored here — free to
-live anywhere and be imported relatively. errorFiles stay empty — there is no
-framework error resolution.
+live anywhere and be imported relatively.
 */
 async function scanPages(pagesDir: string): Promise<PagesScan> {
     if (!existsSync(pagesDir)) {
-        return { pageFiles: [], layoutFiles: [], errorFiles: [] }
+        return { pageFiles: [], layoutFiles: [] }
     }
     const allFiles = await Array.fromAsync(new Glob('**/*.abide').scan({ cwd: pagesDir }))
     const leafIs = (name: string) => (file: string) => (file.split('/').pop() ?? '') === name
     return {
         pageFiles: allFiles.filter(leafIs('page.abide')),
         layoutFiles: allFiles.filter(leafIs('layout.abide')),
-        errorFiles: [],
     }
 }
 

package/src/appEntry.ts

@@ -80,14 +80,24 @@ the connect screen. Resolving before this means a successful resume opens straig
 at the app — no connect-screen flash — at the cost of a brief window-less moment
 while it boots/probes (the OS shows the launching dock icon meanwhile).
 */
-const { origin, target } = await new Promise<{ origin: string; target: string }>((resolve) => {
-    worker.addEventListener('message', (event: MessageEvent) => {
-        const data = event.data as { type: string; origin?: string; target?: string }
-        if (data.type === 'ready' && data.origin && data.target) {
-            resolve({ origin: data.origin, target: data.target })
-        }
-    })
-})
+const { origin, target } = await new Promise<{ origin: string; target: string }>(
+    (resolve, reject) => {
+        worker.addEventListener('message', (event: MessageEvent) => {
+            const data = event.data as {
+                type: string
+                origin?: string
+                target?: string
+                error?: string
+            }
+            if (data.type === 'ready' && data.origin && data.target) {
+                resolve({ origin: data.origin, target: data.target })
+            } else if (data.type === 'error') {
+                /* The worker's start() rejected — fail fast instead of hanging on `ready`. */
+                reject(new Error(data.error ?? 'control server worker failed to start'))
+            }
+        })
+    },
+)
 
 /*
 The built-in File menu (Start / Disconnect), placed before Edit. Each item is a

package/src/controlServerWorker.ts

@@ -12,6 +12,7 @@ import { binaryDirEnvPath } from './lib/shared/binaryDirEnvPath.ts'
 import { clearLastConnection } from './lib/shared/clearLastConnection.ts'
 import { createLivenessWatch } from './lib/shared/createLivenessWatch.ts'
 import { dataDirEnvPath } from './lib/shared/dataDirEnvPath.ts'
+import { messageFromError } from './lib/shared/messageFromError.ts'
 import { readEnvFile } from './lib/shared/readEnvFile.ts'
 import { readLastConnection } from './lib/shared/readLastConnection.ts'
 import { serializeEnv } from './lib/shared/serializeEnv.ts'
@@ -417,7 +418,13 @@ self.addEventListener('message', (event: MessageEvent) => {
         | { type: 'window'; handle: number }
         | { type: 'shutdown' }
     if (data.type === 'init') {
-        void start(data.init)
+        /*
+        A rejected start() would leave the launcher's `await {type:'ready'}`
+        hanging forever — surface the failure so it can fail fast instead.
+        */
+        start(data.init).catch((startError) => {
+            self.postMessage({ type: 'error', error: messageFromError(startError) })
+        })
     } else if (data.type === 'window') {
         webviewHandle = data.handle
     } else if (data.type === 'shutdown') {

package/src/lib/cli/parseArgvForRpc.ts

@@ -26,9 +26,12 @@ export async function parseArgvForRpc(
     /*
     Stdin override: if a JSON object is piped in, treat it as the
     starting args bag. `Bun.stdin.text()` reads the whole pipe; if
-    nothing was piped, the read resolves with an empty string.
+    nothing was piped, the read resolves with an empty string. Skip the
+    read entirely when argv already supplied args — a non-TTY pipe that
+    never sends EOF would otherwise hang the call forever even though the
+    args are fully on the command line.
     */
-    if (!process.stdin.isTTY) {
+    if (!process.stdin.isTTY && argv.length === 0) {
         const text = await Bun.stdin.text()
         if (text.trim()) {
             try {
@@ -81,7 +84,9 @@ export async function parseArgvForRpc(
             throw new Error(`--${name} requires a value`)
         }
         if (propType === 'number' || propType === 'integer') {
-            const n = Number(value)
+            // Reject a blank value explicitly — `Number('')` / `Number('  ')` is 0,
+            // not NaN, so the NaN guard alone would silently coerce it to zero.
+            const n = value.trim() === '' ? Number.NaN : Number(value)
             if (Number.isNaN(n)) {
                 throw new Error(`--${name} expects a number, got ${value}`)
             }

package/src/lib/mcp/createMcpServer.ts

@@ -42,6 +42,14 @@ export function createMcpServer(opts: McpServerOptions = {}): McpServer {
                 })
             }
             const envelope = await dispatchMcpRequest(request, opts, serverInfo)
+            /* A notification yields no envelope — JSON-RPC forbids replying, so
+               ack the receipt with an empty 202 instead of a response body. */
+            if (envelope === undefined) {
+                return new Response(undefined, {
+                    status: 202,
+                    headers: { 'Cache-Control': NO_STORE },
+                })
+            }
             return Response.json(envelope, { headers: { 'Cache-Control': NO_STORE } })
         },
     }

package/src/lib/mcp/dispatchMcpRequest.ts

@@ -53,18 +53,36 @@ export async function dispatchMcpRequest(
     request: Request,
     opts: McpServerOptions,
     serverInfo: { name: string; version: string },
-): Promise<JsonRpcResponse> {
+): Promise<JsonRpcResponse | undefined> {
     let envelope: JsonRpcRequest
     try {
         envelope = (await request.clone().json()) as JsonRpcRequest
     } catch {
         return jsonRpcError(null, -32700, 'Parse error')
     }
+    /* A notification has no `id` field at all (absent — `id: 0`/`id: null` are
+       valid ids). JSON-RPC 2.0 forbids replying to a notification, so dispatch it
+       for its side effect and return undefined to signal "no reply". */
+    const isNotification = !('id' in envelope)
     const id = envelope.id ?? null
     if (envelope.jsonrpc !== '2.0' || typeof envelope.method !== 'string') {
-        return jsonRpcError(id, -32600, 'Invalid Request')
+        return isNotification ? undefined : jsonRpcError(id, -32600, 'Invalid Request')
     }
 
+    // Run the method for its side effect, then drop the reply for a notification.
+    const response = await dispatchMethod(envelope, id, request, opts, serverInfo)
+    return isNotification ? undefined : response
+}
+
+/* Resolves a parsed, validated request to its JSON-RPC response. The caller
+   discards this for notifications; non-notifications get it verbatim. */
+async function dispatchMethod(
+    envelope: JsonRpcRequest,
+    id: string | number | null,
+    request: Request,
+    opts: McpServerOptions,
+    serverInfo: { name: string; version: string },
+): Promise<JsonRpcResponse> {
     if (opts.authorize) {
         try {
             await opts.authorize(request)

package/src/lib/mcp/toolResultFromResponse.ts

@@ -5,7 +5,12 @@ import { responseErrorText } from '../shared/responseErrorText.ts'
 import { streamResponse } from '../shared/streamResponse.ts'
 
 // Frames a value as MCP text content — strings verbatim, everything else as JSON.
+// An undefined body (204 / empty) becomes '' — `JSON.stringify(undefined)` is the
+// value `undefined`, not a string, which would make an invalid text content block.
 function asText(value: unknown): string {
+    if (value === undefined) {
+        return ''
+    }
     return typeof value === 'string' ? value : JSON.stringify(value)
 }
 

package/src/lib/server/rpc/parseArgs.ts

@@ -1,4 +1,5 @@
 import { carriesBodyArgs } from '../../shared/carriesBodyArgs.ts'
+import { contentTypeOf } from '../../shared/contentTypeOf.ts'
 import { HttpError } from '../../shared/HttpError.ts'
 import type { HttpVerb } from '../../shared/types/HttpVerb.ts'
 import { error } from '../error.ts'
@@ -86,7 +87,7 @@ export async function parseArgs(
                 store.req = bounded
             }
         }
-        const contentType = (bounded.headers.get('content-type') ?? '').toLowerCase()
+        const contentType = contentTypeOf(bounded.headers)
         try {
             if (contentType.includes('application/json')) {
                 const text = await bounded.text()
@@ -116,6 +117,16 @@ export async function parseArgs(
         return body
     }
 
+    /*
+    TODO(query-coercion): query params arrive as strings, so a numeric/boolean
+    field reaches schema validation as `'2'`/`'true'`. Deferred deliberately:
+    parseArgs has no access to the verb's inputSchema (it lives in defineVerb),
+    and Standard Schema exposes no type structure to drive type-aware coercion.
+    Blind value-shape coercion is unsafe — it would corrupt legitimately
+    string-typed fields whose value looks numeric/boolean (ids, zip codes,
+    version strings like '1.0'), silently breaking GET validation. A correct fix
+    needs the schema threaded in here (or a coercing schema adapter at the verb).
+    */
     const bodyObject = (body ?? {}) as Record<string, unknown>
     const merged = { ...Object.fromEntries(url.searchParams), ...bodyObject }
     if (Object.keys(merged).length === 0) {

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

@@ -20,5 +20,14 @@ export function acceptsGzip(req: Request): boolean {
         return false
     }
     const quality = directive.match(/;\s*q=([\d.]+)/)
-    return quality === null || Number(quality[1]) > 0
+    if (quality === null) {
+        return true
+    }
+    /*
+    A malformed q (e.g. `q=.` → NaN) is not an explicit refusal — fall back to
+    the default-accept path, matching how an absent q is treated. Only a parsed
+    quality of exactly 0 denies compression.
+    */
+    const parsed = Number(quality[1])
+    return Number.isNaN(parsed) || parsed > 0
 }

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

@@ -1,3 +1,4 @@
+import { contentTypeOf } from '../../shared/contentTypeOf.ts'
 import { isStreamingResponse } from '../../shared/isStreamingResponse.ts'
 import { acceptsGzip } from './acceptsGzip.ts'
 import { flushingGzipStream } from './flushingGzipStream.ts'
@@ -40,7 +41,7 @@ export function gzipResponse(req: Request, response: Response): Response {
     if (!acceptsGzip(req) || isStreamingResponse(response)) {
         return response
     }
-    const contentType = (response.headers.get('content-type') ?? '').toLowerCase()
+    const contentType = contentTypeOf(response.headers)
     if (!COMPRESSIBLE_TYPE.test(contentType)) {
         return response
     }

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

@@ -1,3 +1,4 @@
+import { contentTypeOf } from '../../shared/contentTypeOf.ts'
 import { isReplayableMethod } from '../../shared/isReplayableMethod.ts'
 import { isStreamingResponse } from '../../shared/isStreamingResponse.ts'
 import type { CacheEntry } from '../../shared/types/CacheEntry.ts'
@@ -47,7 +48,7 @@ export async function snapshotEntryFromCache(
     if (isStreamingResponse(response)) {
         return undefined
     }
-    const contentType = (response.headers.get('content-type') ?? '').toLowerCase()
+    const contentType = contentTypeOf(response.headers)
     if (!isTextual(contentType)) {
         return undefined
     }

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

@@ -46,6 +46,14 @@ export function streamFromIterator<T>(
                     enqueue throws on a closed/errored stream, and an uncaught
                     throw in a timer crashes the process. Guard + self-stop.
                     */
+                    /*
+                    Skip the tick under backpressure: a stalled consumer leaves
+                    desiredSize <= 0, and enqueuing anyway grows the internal
+                    queue unbounded. null = no HWM set, > 0 = consumer keeping up.
+                    */
+                    if (controller.desiredSize !== null && controller.desiredSize <= 0) {
+                        return
+                    }
                     try {
                         controller.enqueue(payload)
                     } catch {

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

@@ -170,7 +170,13 @@ export function createSocketDispatcher(sockets: SocketRoutes): SocketDispatcher
         can ask for "as many as available, up to N" — `0` (bare
         `for await`) replays nothing.
         */
-        send(ws, { type: 'replay', sub: frame.sub, messages: entry.snapshotTail(frame.replay) })
+        /*
+        A non-finite `replay` (NaN/Infinity from a buggy client) would make
+        snapshotTail's slice(NaN) leak the whole retained buffer — coerce it
+        to undefined, matching the REST `?tail=` guard below.
+        */
+        const replay = Number.isFinite(frame.replay) ? frame.replay : undefined
+        send(ws, { type: 'replay', sub: frame.sub, messages: entry.snapshotTail(replay) })
     }
 
     function handleUnsub(

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

@@ -176,7 +176,12 @@ export function defineSocket<T>(name: string, opts: SocketOptions = {}): Socket<
         clients,
         snapshotTail: (count?: number) => {
             pruneExpired(Date.now())
-            const start = count === undefined ? 0 : Math.max(0, buffer.length - count)
+            /* A non-finite count (NaN/Infinity) would make slice() leak the whole
+               buffer — treat it as absent (full tail), the same as count === undefined. */
+            const start =
+                count === undefined || !Number.isFinite(count)
+                    ? 0
+                    : Math.max(0, buffer.length - count)
             return buffer.slice(start).map((entry) => entry.value)
         },
     })

package/src/lib/shared/cache.ts

@@ -870,6 +870,12 @@ function fireRefetch(store: CacheStore, entry: CacheEntry): void {
             entry.promise = inflight
             entry.value = undefined
             entry.settled = true
+            /* Restart the freshness clock from the revalidation — without this the
+               entry keeps its original expiresAt and is evicted at the old deadline
+               despite holding fresh data. Mirrors registerEntry's settle path. */
+            if (entry.ttl !== undefined && entry.ttl !== 0) {
+                armTtlExpiry(store, entry, entry.ttl)
+            }
             store.markLifecycle(entry.key)
             emit(store, [entry.key])
         },

package/src/lib/shared/createPushIterator.ts

@@ -59,9 +59,14 @@ export function createPushIterator<T>(
             wake(slot)
             return
         }
-        // Drop the oldest pending value before exceeding the cap.
+        /* Drop the OLDEST value slot before exceeding the cap — never a control or
+           terminal slot (end/error/disconnect), which the contract guarantees are
+           never dropped. If the buffer holds only non-value slots, drop nothing. */
         if (slot.kind === 'value' && buffer.length >= maxBuffer) {
-            buffer.shift()
+            const oldestValue = buffer.findIndex((pending) => pending.kind === 'value')
+            if (oldestValue !== -1) {
+                buffer.splice(oldestValue, 1)
+            }
         }
         buffer.push(slot)
     }

package/src/lib/ui/COMPONENT_WRAPPER_PREFIX.ts

@@ -0,0 +1,5 @@
+/* The `abide-` tag prefix on framework-owned custom elements (the router's
+   `abide-outlet`, the streaming `abide-resolve`/`abide-cache` fragments). `scopeLabel`
+   strips it to read the outlet host's bare name. Child components no longer mount into
+   an `abide-<name>` wrapper — they build as marker ranges (see `mountRange`). */
+export const COMPONENT_WRAPPER_PREFIX = 'abide-'

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

@@ -30,6 +30,7 @@ export const UI_RUNTIME_IMPORTS: { name: string; specifier: string }[] = [
     { name: 'tryBlock', specifier: 'ui/dom/tryBlock' },
     { name: 'switchBlock', specifier: 'ui/dom/switchBlock' },
     { name: 'mountSlot', specifier: 'ui/dom/mountSlot' },
+    { name: 'outlet', specifier: 'ui/dom/outlet' },
     { name: 'mountChild', specifier: 'ui/dom/mountChild' },
     { name: 'hydrate', specifier: 'ui/dom/hydrate' },
     { name: 'escapeKey', specifier: 'ui/runtime/escapeKey' },

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

@@ -1,5 +1,6 @@
 import { relative } from 'node:path'
 import type { BunPlugin } from 'bun'
+import { messageFromError } from '../../shared/messageFromError.ts'
 import { AbideCompileError } from './AbideCompileError.ts'
 import { analyzeComponent } from './analyzeComponent.ts'
 import { compileModule } from './compileModule.ts'
@@ -57,7 +58,7 @@ export const abideUiPlugin: BunPlugin = {
                             : (({ line, column }) => `${moduleId}:${line}:${column}`)(
                                   offsetToLineColumn(source, offset),
                               )
-                    const message = error instanceof Error ? error.message : String(error)
+                    const message = messageFromError(error)
                     throw new Error(`${message.replace(/^\[abide\]\s*/, `[abide] ${at} — `)}`)
                 }
             }

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

@@ -0,0 +1,30 @@
+import { OUTLET_TAG } from '../runtime/OUTLET_TAG.ts'
+import type { TemplateNode } from './types/TemplateNode.ts'
+
+/*
+In a layout the `<slot/>` page outlet is a bare empty `OUTLET_TAG` element the router fills
+later. Rewriting it to an element node up front lets the static-clone path carry it as ordinary
+structure AND lets BOTH back-ends feed the same tree to `skeletonContext` — one decision site
+for "a layout slot is an outlet, not an anchor", instead of the client running `asOutlet` while
+SSR mirrors it with an inline special-case.
+
+The outlet is a structural mount point, not styled content, so it carries NO attrs and NO style
+scope — both back-ends lower it to the bare `<!--abide:outlet-->`…`<!--/abide:outlet-->` boundary
+`renderChain` folds the child layer into (matching its `OUTLET_PLACEHOLDER`). Stripping `scopes`
+is what makes the two back-ends agree: SSR emits the boundary bare, but without this the client
+clone would read the slot's annotated `scopes` and stamp them — a hydration mismatch for any
+scoped layout.
+
+Control-flow children are fresh build contexts (their own runtime mounts a nested slot), so they
+are not descended into — a `<slot>` inside an `{#if}` stays a slot node, handled at its own
+mount site in each back-end.
+*/
+export function asOutlet(node: TemplateNode): TemplateNode {
+    if (node.kind !== 'element') {
+        return node
+    }
+    if (node.tag === 'slot') {
+        return { ...node, tag: OUTLET_TAG, attrs: [], children: [], scopes: [] }
+    }
+    return { ...node, children: node.children.map(asOutlet) }
+}

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

@@ -42,11 +42,13 @@ export function compileModule(
         const id = JSON.stringify(options.moduleId)
         return `const { ${names}, hotReplace } = window.__abide
 ${userImports}
-function component(host, $props) {
-    return mount(host, (host) => {
+function build(host, $props) {
 ${body}
-    })
 }
+function component(host, $props) {
+    return mount(host, build, $props)
+}
+component.build = build
 component.__abideId = ${id}
 if (!hotReplace(${id}, component)) location.reload()
 `
@@ -61,17 +63,17 @@ if (!hotReplace(${id}, component)) location.reload()
        exactly which names it emitted, so it filters here. A name absent from the body
        is unreferenced; erring toward inclusion (a stray match in user script) only
        keeps a harmless unused import, never drops a needed one. */
-    const moduleBody = `export default function component(host, $props) {
-    return mount(host, (host) => {
+    const moduleBody = `function build(host, $props) {
 ${body}
-    })
+}
+
+export default function component(host, $props) {
+    return mount(host, build, $props)
 }
 
 /* Adopt the server-rendered DOM in place instead of rebuilding it. */
 export function hydrateInto(host, $props) {
-    return hydrate(host, (host) => {
-${body}
-    })
+    return hydrate(host, build, $props)
 }
 
 export function render($props) {
@@ -80,6 +82,8 @@ ${ssrBody}
 
 component.render = render
 component.hydrate = hydrateInto
+/* The bare build, so a parent can range-mount this as a nested child (no wrapper). */
+component.build = build
 component.hydratable = ${analyzed.hydratable}
 ${options.moduleId === undefined ? '' : `component.__abideId = ${JSON.stringify(options.moduleId)}\n`}`
     /* Scope each name to the surface that genuinely references it. The SSR body