@abide/abide 0.35.0 → 0.37.0

package/README.md

@@ -1,153 +1,159 @@
 # abide
 
-**Write one function. Get a typed HTTP endpoint, a CLI, an MCP tool, and an OpenAPI operation — from the same line of code.**
+**One typed RPC declaration fans out to an HTTP route, a typed browser proxy, a CLI subcommand, an MCP tool, and an OpenAPI operation — built for humans and machines.**
 
-abide is a type-safe isomorphic framework built on web standards and Bun. You declare a verb once; the bundler swaps the runtime per side and projects that one declaration onto every surface — humans hit it over HTTP or the CLI, machines hit it over MCP, and you control which surfaces each verb exposes. It's a framework built for humans *and* machines.
+abide is an isomorphic framework on Bun: the same callable has the same name and behaviour on both sides, and the bundler swaps the runtime per side — a server handler in `src/server`, a `fetch` proxy in the browser. Server-render and hydrate the same `.abide` components, broadcast over multiplexed sockets, and expose every read to an agent — all in a single Bun runtime.
 
-- Zero runtime dependencies
-- A single runtime (Bun) in every mode — dev, build, and compiled binary
+- One dependency (`typescript`, for the type-checking shadow); `tailwindcss` + `bun-plugin-tailwind` are optional peers.
+- Runs on Bun `>= 1.3.0`. No bundler config, no server framework, no client router to wire up.
 
 ## Quick start
 
 ```sh
-bunx abide scaffold my-app   # scaffolds, installs, and starts the dev server
+bunx abide scaffold my-app   # scaffolds, installs deps, and (in a TTY) starts dev
 ```
 
-To see every surface live, clone the repo and run the kitchen-sink example — each page is runnable and documented:
+Or read the exhaustive demo:
 
 ```sh
 git clone https://github.com/briancray/abide
 cd abide && bun install
-cd examples/kitchen-sink && bun run dev
+cd examples/kitchen-sink && bun dev
 ```
 
+The whole public surface — every export, CLI command, route, env var, and the `.abide` grammar — is mapped in [`AGENTS.md`](./AGENTS.md).
+
 ## RPCs
 
-An RPC is a handler wrapped by its HTTP method — one export per file under `src/server/rpc/`. The file path is the URL; the schema validates args and projects the MCP tool, CLI flags, and OpenAPI operation. Standard Schema is the contract: zod, valibot, and arktype work unadapted.
+An RPC is one export per file under `src/server/rpc/`. The file path is the URL (`getMessages.ts` → `/rpc/getMessages`), and a [Standard Schema](https://standardschema.dev) (zod / valibot / arktype, unadapted) validates the args and projects every other surface.
 
 ```ts
 // src/server/rpc/getMessages.ts
 import { GET } from '@abide/abide/server/GET'
 import { json } from '@abide/abide/server/json'
 import { z } from 'zod'
+import { history } from '../../store.ts'
 
-// query args arrive as strings — coerce in the schema
-const inputSchema = z.object({ room: z.string(), limit: z.coerce.number().default(50) })
+const inputSchema = z.object({ room: z.string() })
 
-export const getMessages = GET(
-    async ({ room, limit }) => json(await db.recentMessages(room, limit)),
-    { inputSchema },
-)
+export const getMessages = GET(({ room }) => json({ messages: history(room) }), { inputSchema })
 ```
 
-One declared verb fans out to every surface — this is the whole premise:
+That one declaration fans out:
 
 ```text
-       export const getMessages = GET(fn, { inputSchema })
-                                 │
-   ┌───────────────┬────────────┼──────────────┬────────────────┐
- SSR call      browser fetch    MCP tool      CLI subcommand   OpenAPI op
-cache(fn)()   fetch /rpc/...   getMessages   app get-messages  /openapi.json
-(in-process)  (typed proxy)  (read-only+schema) (schema→flags)   (described)
+                  getMessages   (one declaration)
+                        │
+   ┌──────────┬─────────┼─────────┬──────────────┐
+   ▼          ▼         ▼         ▼              ▼
+ SSR call   browser   MCP tool   CLI sub-     OpenAPI
+cache(fn)()  fetch   (read-only) command      operation
 ```
 
-The same callable is consumed differently per side — `cache(getMessages)({ room })` in-process, the swapped `fetch` in the browser, `.raw(args)` for a `Response`, `.stream(args)` for `tail()`. A schema gates the machine surfaces: it unlocks the CLI and (for read-only verbs) MCP; a mutating verb never auto-exposes to MCP — it needs an explicit `clients: { mcp: true }`. Per-verb `timeout` (504, on every surface) is distinct from the client-side `ABIDE_CLIENT_TIMEOUT`.
+The `inputSchema` unlocks the CLI and — because a `GET`/`HEAD` is read-only — an MCP tool. A mutating verb (`POST`/`PUT`/`PATCH`/`DELETE`) never auto-exposes to an agent; opt in with `clients: { mcp: true }`. Consume the verb four ways, all typed against the declaration: `cache(getMessages)({ room })` for an SSR-memoized in-process read, the bundler-swapped `getMessages({ room })` `fetch` proxy in the browser, `.raw(args)` for the untouched `Response`, and `.stream(args)` for a frame-by-frame `jsonl`/`sse` body.
 
-> Query args travel as strings — use `z.coerce.*` so numbers and booleans validate.
+> Query args travel as strings — use `z.coerce.*` for numbers and booleans. The per-verb `timeout` option fires a `504` on every surface and is distinct from the client-wide `ABIDE_CLIENT_TIMEOUT`.
 
 ## Sockets
 
-One broadcast topic per file under `src/server/sockets/`. A `Socket<T>` is an isomorphic `AsyncIterable<T>` — every socket multiplexes onto one ws at `/__abide/sockets`. A `schema` validates publishes, infers the frame type, and flips on the MCP/CLI read faces.
+A socket is one broadcast topic per file under `src/server/sockets/`. A `Socket<T>` is an isomorphic `AsyncIterable<T>` — `for await` it on the server, or read it reactively with `tail()` in a component — and every socket multiplexes onto one WebSocket at `/__abide/sockets`.
 
 ```ts
-// src/server/sockets/chat.ts
+// src/server/sockets/messages.ts
 import { socket } from '@abide/abide/server/socket'
 import { z } from 'zod'
 
-const schema = z.object({ id: z.string(), from: z.string(), text: z.string(), at: z.number() })
-
-// retain the last 100 frames, evict any older than an hour
-export const chat = socket({ schema, tail: 100, ttl: 3_600_000 })
-export type ChatMessage = z.infer<typeof schema>
+const schema = z.object({
+    id: z.string(),
+    room: z.string(),
+    from: z.string(),
+    text: z.string(),
+    at: z.number(),
+})
+
+// retain the last 100 frames; lazily evict any older than an hour
+export const messages = socket({ schema, tail: 100, ttl: 3_600_000 })
+export type Message = z.infer<typeof schema>
 ```
 
-For clients that can't speak the ws multiplex, each socket has an HTTP face at `/__abide/sockets/<name>` — `GET` returns the retained tail, `POST` publishes (gated by `clientPublish`, off by default).
+The schema validates every publish and flips on the read surfaces (a `messages-tail` MCP tool / CLI command). For clients that can't speak the ws multiplex, each socket has an HTTP face at `/__abide/sockets/messages`: `GET` returns the retained tail, `POST` publishes — gated by `clientPublish` (default `false`, so browsers publish through a validating verb instead).
 
 ## Components
 
-Components are `.abide` files — valid HTML with `<script>`, native `<template>` control flow, `{expr}` bindings, and a component-scoped `<style>`. Reactive state is reached through `scope()` (`scope().state(v)`, `scope().computed(fn)`); props are read by destructuring `props()` (`const { room } = props()`), and `effect` is in scope without import. This page reads the verb above through `cache()`, tails the socket live, and exercises most of the template grammar:
+A component is an `.abide` file: valid HTML with a `<script>`, native `<template>` control flow, `{expr}` bindings, and a component-scoped `<style>`. `scope()` is the sole reactive surface; `props`, `effect`, and `html` are in scope without import. This one imports the verb and socket above:
 
 ```html
 <script>
 import { cache } from '@abide/abide/shared/cache'
 import { tail } from '@abide/abide/ui/tail'
 import { getMessages } from '$server/rpc/getMessages.ts'
-import { publishChat } from '$server/rpc/publishChat.ts'
-import { chat } from '$server/sockets/chat.ts'
+import { sendMessage } from '$server/rpc/sendMessage.ts'
+import { messages } from '$server/sockets/messages.ts'
 import Avatar from '$ui/Avatar.abide'
 
-const { room } = props()                                           // typed via src/.abide/routes.d.ts
-const history = scope().computed(() => cache(getMessages)({ room })) // SSR snapshot + reactive refetch
-const latest = scope().computed(() => tail(chat))                  // re-renders on every new frame
+const { room } = props<{ room: string }>()
 
-let from = scope().state('alice')
-let text = scope().state('')
-let filter = scope().state('all')        // all | mine | others
-let onlyUnread = scope().state(false)
+let from = scope().state('alice')               // a writable cell — read/assign as a plain var
+let draft = scope().state('')
+let pinned = scope().state(false)
+let filter = scope().state('all')
+const live = scope().computed(() => tail(messages))   // re-renders on every new frame
 
 async function send(event: SubmitEvent) {
     event.preventDefault()
-    if (text.trim() === '') return
-    await publishChat({ from, text })                              // server validates, then broadcasts
-    text = ''
+    if (draft.trim() === '') return
+    await sendMessage({ room, from, text: draft })     // a mutating verb
+    draft = ''
 }
 </script>
 
-<template name="message" args={m}>                       <!-- snippet: a reusable builder -->
-    <li class="row"><Avatar name={m.from} /> <strong>{m.from}</strong>: {m.text}</li>
+<!-- a named snippet: a reusable builder, rendered like a function -->
+<template name="bubble" args={msg}>
+    <li><Avatar name={msg.from} /> <b>{msg.from}</b>: {msg.text}</li>
 </template>
 
+<h1>#{room}</h1>
+
 <form onsubmit={send}>
-    <input bind:value={from} placeholder="you" />
-    <input bind:value={text} placeholder="say something…" />
-    <label><input type="checkbox" bind:checked={onlyUnread} /> unread only</label>
-    <fieldset>
-        <label><input type="radio" bind:group={filter} value="all" /> all</label>
-        <label><input type="radio" bind:group={filter} value="mine" /> mine</label>
-    </fieldset>
-    <button type="submit" disabled={text.trim() === ''}>send</button>
+    <input bind:value={from} />
+    <input bind:value={draft} placeholder="message" />
+    <label><input type="checkbox" bind:checked={pinned} /> pin</label>
+    <label><input type="radio" bind:group={filter} value="all" /> all</label>
+    <label><input type="radio" bind:group={filter} value="mine" /> mine</label>
+    <button type="submit" disabled={draft.trim() === ''}>send</button>
 </form>
 
-<template if={latest}>
-    <p class="ping">latest from <strong>{latest.from}</strong></p>
+<template if={live}>
+    <p class="live">latest: {live.text}</p>
     <template else>
-        <p class="ping muted">no live messages yet</p>
+        <p>no messages yet</p>
     </template>
 </template>
 
 <template switch={filter}>
-    <template case={'mine'}><p>showing your messages</p></template>
-    <template default><p>showing every message</p></template>
+    <template case={'all'}><p>showing everyone</p></template>
+    <template case={'mine'}><p>showing {from}</p></template>
+    <template default><p>—</p></template>
 </template>
 
-<template await={history}>
-    <p>loading history…</p>
-    <template then="messages">
+<template await={cache(getMessages)({ room })}>
+    <p>loading…</p>
+    <template then="history">
         <ul>
-            <template each={messages} as="m" key="m.id">
-                {message(m)}                              <!-- render the snippet -->
+            <template each={history.messages} as="msg" key="msg.id">
+                {bubble(msg)}
             </template>
         </ul>
     </template>
-    <template catch="err">
-        <p class="error">{err.message}</p>
+    <template catch="error">
+        <p>failed: {error.message}</p>
     </template>
 </template>
 
 <style>
-    .row { display: flex; gap: 0.5rem; }
-    .muted { color: #94a3b8; }
-    .error { color: #dc2626; }
+    .live {
+        font-weight: 600;
+    }
 </style>
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@abide/abide",
-    "version": "0.35.0",
+    "version": "0.37.0",
     "type": "module",
     "sideEffects": false,
     "description": "Isomorphic multimodal HTTP framework built for humans and machines in a single Bun runtime",

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

@@ -0,0 +1,35 @@
+import { inFlightRequests } from './inFlightRequests.ts'
+import type { InspectorInFlightRequest } from './types/InspectorInFlightRequest.ts'
+import type { InspectorInFlightSnapshot } from './types/InspectorInFlightSnapshot.ts'
+import type { RequestStore } from './types/RequestStore.ts'
+
+function projectStore(store: RequestStore, now: number): InspectorInFlightRequest {
+    return {
+        trace: store.trace.traceId,
+        method: store.req.method,
+        path: `${store.url.pathname}${store.url.search}`,
+        /* store.start is Bun.nanoseconds() at scope entry; elapsed is current at the read. */
+        elapsedMs: (now - store.start) / 1e6,
+        route: store.route,
+        params: store.params,
+    }
+}
+
+/*
+Snapshots the request scopes currently executing their handler. Read at call
+time so it reflects the in-flight set as it stands; returns empty when the
+inspector hasn't installed the tracking Set or the server is idle. Sorted by
+elapsed ascending — newest (least elapsed) first, so a long-running request
+sinks to the bottom as its elapsed grows.
+*/
+export function buildInFlightSnapshot(): InspectorInFlightSnapshot {
+    const tracked = inFlightRequests.tracked
+    if (!tracked) {
+        return { requests: [] }
+    }
+    const now = Bun.nanoseconds()
+    const requests = Array.from(tracked, (store) => projectStore(store, now)).sort(
+        (left, right) => left.elapsedMs - right.elapsedMs,
+    )
+    return { requests }
+}

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

@@ -1,4 +1,5 @@
 import { jsonSchemaForSchema } from '../../shared/jsonSchemaForSchema.ts'
+import { promptRegistry } from '../prompts/promptRegistry.ts'
 import { verbRegistry } from '../rpc/verbRegistry.ts'
 import { socketOperations } from '../sockets/socketOperations.ts'
 import { socketRegistry } from '../sockets/socketRegistry.ts'
@@ -33,5 +34,12 @@ export function buildInspectorSurface(): InspectorSurface {
             restUrl: operation.restUrl,
         })),
     }))
-    return { verbs, sockets }
+    /* jsonSchema is already JSON Schema (built from the frontmatter `arguments`
+       list by the resolver plugin), so it's passed through, not re-projected. */
+    const prompts = Array.from(promptRegistry.values()).map((entry) => ({
+        name: entry.prompt.name,
+        description: entry.prompt.description,
+        inputSchema: entry.jsonSchema,
+    }))
+    return { verbs, sockets, prompts }
 }

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

@@ -186,6 +186,13 @@ export async function createServer({
     // In dev, append the live-reload client to the shell so every rendered
     // page reconnects to /__abide/dev and reloads after a restart.
     const devShell = dev ? shell.replace('</body>', `${DEV_RELOAD_CLIENT_SCRIPT}</body>`) : shell
+    // When the inspector is enabled, flag the client so startClient installs the
+    // BroadcastChannel bridge that streams scope + router state to the inspector
+    // page. Independent of dev — the inspector can run on a build server too.
+    const inspectedShell =
+        process.env.ABIDE_ENABLE_INSPECTOR === 'true'
+            ? devShell.replace('</body>', `<script>window.__abideInspect=true</script></body>`)
+            : devShell
     /*
     Mount base from APP_URL's pathname (e.g. https://foo.com/v2 → /v2). Install
     the server-side resolver so url() prefixes SSR-generated links, and rewrite
@@ -197,7 +204,9 @@ export async function createServer({
     setBaseResolver(() => base)
     // Rebase the shell's rooted `/_app/` entry refs onto the mount base, matching
     // either quote style so a custom app.html using single quotes still rewrites.
-    const activeShell = base ? devShell.replace(/(["'])\/_app\//g, `$1${base}/_app/`) : devShell
+    const activeShell = base
+        ? inspectedShell.replace(/(["'])\/_app\//g, `$1${base}/_app/`)
+        : inspectedShell
     /*
     Boot-path disk scans run concurrently — they share no data, and under
     `abide dev` the worker-swap window is bounded by exactly this boot.

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

@@ -0,0 +1,13 @@
+import type { RequestStore } from './types/RequestStore.ts'
+
+/*
+The set of request scopes currently executing their handler, for the inspector's
+in-flight view. `tracked` stays undefined until the inspector mounts and swaps in
+a live Set — so the request path adds nothing (no allocation, no membership
+churn) when the inspector is off. runWithRequestScope adds a store on scope entry
+and removes it when the handler settles; buildInFlightSnapshot reads it. Mirrors
+the on-demand, opt-in shape of the log/socket tap slots.
+*/
+export const inFlightRequests: { tracked: Set<RequestStore> | undefined } = {
+    tracked: undefined,
+}

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

@@ -4,7 +4,9 @@ import { requestScopeSlot } from '../../shared/requestScopeSlot.ts'
 import { socketTapSlot } from '../../shared/socketTapSlot.ts'
 import type { LogRecord } from '../../shared/types/LogRecord.ts'
 import { buildCacheSnapshot } from './buildCacheSnapshot.ts'
+import { buildInFlightSnapshot } from './buildInFlightSnapshot.ts'
 import { buildInspectorSurface } from './buildInspectorSurface.ts'
+import { inFlightRequests } from './inFlightRequests.ts'
 import { ensureRegistriesLoaded } from './registryManifests.ts'
 import type { InspectorContext } from './types/InspectorContext.ts'
 
@@ -63,6 +65,10 @@ export async function maybeMountInspector(app: {
         )
         return undefined
     }
+    /* Arm in-flight tracking now the inspector is mounting: runWithRequestScope
+       fills this Set per request, kept process-wide (the events tap teardown is
+       per-connection; the Set outlives any single feed). */
+    inFlightRequests.tracked = new Set()
     const context: InspectorContext = {
         app,
         loadSurface: async () => {
@@ -70,6 +76,7 @@ export async function maybeMountInspector(app: {
             return buildInspectorSurface()
         },
         cacheSnapshot: buildCacheSnapshot,
+        inFlightSnapshot: buildInFlightSnapshot,
         /*
         One process-wide tap each for the log and socket chokepoints; the
         inspector owns both and fans out to its readers. Socket frames arrive

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

@@ -5,6 +5,7 @@ import { formatTraceparent } from '../../shared/formatTraceparent.ts'
 import { isStreamingResponse } from '../../shared/isStreamingResponse.ts'
 import { logClosingRecord } from '../../shared/logClosingRecord.ts'
 import type { AppModule } from '../AppModule.ts'
+import { inFlightRequests } from './inFlightRequests.ts'
 import { internalErrorResponse } from './internalErrorResponse.ts'
 import { requestContext } from './requestContext.ts'
 import type { RequestStore } from './types/RequestStore.ts'
@@ -34,6 +35,10 @@ export function runWithRequestScope(
         start: Bun.nanoseconds(),
     }
     return requestContext.run(store, async () => {
+        /* Register the live handler for the inspector's in-flight view; the Set is
+           absent (a no-op) unless the inspector mounted. Removed once the handler
+           settles — its compute is done even if a streamed body keeps piping. */
+        inFlightRequests.tracked?.add(store)
         let response: Response
         try {
             response = await body(store)
@@ -44,6 +49,8 @@ export function runWithRequestScope(
                 abideLog.error(error)
                 response = internalErrorResponse(error)
             }
+        } finally {
+            inFlightRequests.tracked?.delete(store)
         }
         /*
         Flush any cookies the handler set onto the outgoing response. Only when

package/src/lib/server/runtime/types/InspectorContext.ts

@@ -1,5 +1,6 @@
 import type { LogRecord } from '../../../shared/types/LogRecord.ts'
 import type { InspectorCacheSnapshot } from './InspectorCacheSnapshot.ts'
+import type { InspectorInFlightSnapshot } from './InspectorInFlightSnapshot.ts'
 import type { InspectorSurface } from './InspectorSurface.ts'
 
 /*
@@ -19,6 +20,9 @@ export type InspectorContext = {
     /* Snapshots the persistent (global) cache store — current entries with their
        lifecycle state, retention, tags, and a value preview. */
     cacheSnapshot: () => InspectorCacheSnapshot
+    /* Snapshots the requests whose handler is executing right now — the live
+       counterpart to the closing records onRecord emits once a request settles. */
+    inFlightSnapshot: () => InspectorInFlightSnapshot
     /*
     Subscribes to the unified event stream: every emitted log record (the log's
     structured form, trace context and all) plus published socket frames shaped

package/src/lib/server/runtime/types/InspectorInFlightRequest.ts

@@ -0,0 +1,20 @@
+/*
+One in-flight request projected for the inspector — the serializable facts the
+In-flight tab renders for a handler that's currently executing. The held Request
+and CacheStore aren't included; what an operator wants is which request it is,
+how long it's been running, and where it landed in routing.
+*/
+export type InspectorInFlightRequest = {
+    /* The W3C trace id, so the row links to the same trace the Logs/Traces tabs group by. */
+    trace: string
+    /* HTTP method of the inbound request. */
+    method: string
+    /* Request path with query string (app-space, as logged). */
+    path: string
+    /* Ms the handler has been running, measured from scope entry to snapshot time. */
+    elapsedMs: number
+    /* The matched page route pattern, once routing has landed; undefined on rpc/socket requests or before a match. */
+    route: string | undefined
+    /* The matched route's decoded params, when a page route landed. */
+    params: Record<string, string> | undefined
+}

package/src/lib/server/runtime/types/InspectorInFlightSnapshot.ts

@@ -0,0 +1,10 @@
+import type { InspectorInFlightRequest } from './InspectorInFlightRequest.ts'
+
+/*
+The requests executing their handler at snapshot time — a point-in-time read of
+the in-flight set, the live counterpart to the closing records the Logs tab
+shows once a request settles. Empty when the server is idle.
+*/
+export type InspectorInFlightSnapshot = {
+    requests: InspectorInFlightRequest[]
+}

package/src/lib/server/runtime/types/InspectorPrompt.ts

@@ -0,0 +1,15 @@
+/*
+One declared MCP prompt projected for the inspector: the serializable facts the
+Surface tab renders. The render closure isn't included — what an operator wants
+is the prompt's name, what it's for, and the arguments it interpolates, the same
+trio `prompts/list` advertises. Prompts are MCP-only, so there are no client
+surface flags to show.
+*/
+export type InspectorPrompt = {
+    /* The prompt's name (stamped from its file path under src/mcp/prompts/). */
+    name: string
+    /* The frontmatter description, when the prompt declared one. */
+    description: string | undefined
+    /* The argument shape as JSON Schema (from the frontmatter `arguments` list); undefined when it takes none. */
+    inputSchema: Record<string, unknown> | undefined
+}

package/src/lib/server/runtime/types/InspectorSurface.ts

@@ -1,13 +1,16 @@
+import type { InspectorPrompt } from './InspectorPrompt.ts'
 import type { InspectorSocket } from './InspectorSocket.ts'
 import type { InspectorVerb } from './InspectorVerb.ts'
 
 /*
 The app's machine surface projected for the inspector — the static catalog the
-UI renders. Built by reading the verb and socket registries after they're
-eager-loaded, so a freshly-booted server lists its whole surface, not just the
-verbs hit so far. Pages stay out: they're the human surface, already navigable.
+UI renders. Built by reading the verb, socket, and prompt registries after
+they're eager-loaded, so a freshly-booted server lists its whole surface, not
+just the verbs hit so far. Pages stay out: they're the human surface, already
+navigable.
 */
 export type InspectorSurface = {
     verbs: InspectorVerb[]
     sockets: InspectorSocket[]
+    prompts: InspectorPrompt[]
 }

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/emitLogRecord.ts

@@ -66,6 +66,15 @@ function formatElapsed(ms: number): string {
     return `+${ms.toFixed(2)}ms`
 }
 
+/* `14:23:01.072` — local wall-clock to the ms. Every record carries `ts`, so the
+   tsv line always leads with one; `+elapsedMs` still trails as the request-relative
+   timing — the two are different axes (when it happened vs how long it took). */
+function formatClock(ts: number): string {
+    const date = new Date(ts)
+    const pad = (value: number, width = 2): string => String(value).padStart(width, '0')
+    return `${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}.${pad(date.getMilliseconds(), 3)}`
+}
+
 /*
 Builds the record from the emission's own fields plus the ambient request
 scope (trace, elapsed, verb+path), then renders it through the active
@@ -123,11 +132,12 @@ function consoleFor(level: LogRecord['level']): (...args: unknown[]) => void {
 
 /*
 The unified tsv line (the default format): tab-separated
-`<trace8>	<verb path>	[channel] <message>	+0.00ms`. Inside a
-request scope the trace column leads and the elapsed-at-emission timing
-trails; a closing record emitted outside one (asset hits sidestep the scope)
-pads a blank trace column and trails its serve duration instead, so request
-lines stay aligned whatever produced them. Every record speaks on a channel
+`<clock>	<trace8>	<verb path>	[channel] <message>	+0.00ms`. The
+wall-clock leads every line (each record carries `ts`); inside a request scope
+the trace column follows and the elapsed-at-emission timing trails; a closing
+record emitted outside one (asset hits sidestep the scope) pads a blank trace
+column and trails its serve duration instead, so request lines stay aligned
+whatever produced them. Every record speaks on a channel
 (the app name, 'abide', or a diagnostic channel), shown as a dim `[name]`
 tag opening the message field. The verb+path pair is one field — it's the
 line's anchor unit — and the tag folds into the message field so field
@@ -136,6 +146,9 @@ positions stay stable for cut/awk consumers.
 function printTsv(record: LogRecord, voice?: LogVoice): void {
     const fields: string[] = []
     const closing = record.status !== undefined
+    /* Wall-clock leads every line — a stable first column, unlike the conditional
+       trace field, and the axis `+elapsedMs` can't give (when, not how-long). */
+    fields.push(dim(formatClock(record.ts)))
     if (record.trace) {
         fields.push(dim(record.trace.slice(0, 8)))
     } else if (closing) {

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
+    }
+}