@abide/abide 0.42.0 → 0.43.0

package/CHANGELOG.md

@@ -1,5 +1,39 @@
 # abide
 
+## 0.43.0
+
+### Minor Changes
+
+- 6453cf9: repurpose the bare outbox() export to the global reactive aggregate ([`003713d`](https://github.com/briancray/abide/commit/003713dab125b3df72d6cf832ec18ea546922c79))
+- 6453cf9: typed navigate params, scope-destructured primitives, precise prop diagnostics ([`0769896`](https://github.com/briancray/abide/commit/07698966147e96970c27e0278e2152a23e48b219))
+- 6453cf9: OutboxEntry type + status ([`08d9b03`](https://github.com/briancray/abide/commit/08d9b036501110ab24c18258cc79364f9ac71ea8))
+- 6453cf9: migrate kitchen-sink to rpc-native outbox; AGENTS.md surface ([`1b8aa3f`](https://github.com/briancray/abide/commit/1b8aa3fe631181e7798d0703eb09a0f22dba0f88))
+- 6453cf9: persist request body + content-type, replay on reload ([`26c309f`](https://github.com/briancray/abide/commit/26c309f20bf573e512b74477ba2319c22218f7d9))
+- 6453cf9: client registry of durable rpc queues ([`2b89c20`](https://github.com/briancray/abide/commit/2b89c20b1f1f1794f90152f46958ee760333bab5))
+- 6453cf9: reject server-only imports in the client bundle with an evidence chain ([`2de1730`](https://github.com/briancray/abide/commit/2de1730872898d320c240a89b570dfaa9acace7a))
+- 6453cf9: name-keyed typed errors via a handler errors ctx ([`62f75a8`](https://github.com/briancray/abide/commit/62f75a8341d61ac9cfd1e7cbeccc66ddec991643))
+- 6453cf9: createOutboxQueue enqueue + reactive/persisted entries ([`88560c9`](https://github.com/briancray/abide/commit/88560c942d0f28623a68ed1315bb2341ad66a9c3))
+- 6453cf9: bundler threads outbox:true into the client proxy emission ([`b279960`](https://github.com/briancray/abide/commit/b27996089f4a3c8786fcd1ade530057a34f086fc))
+- 6453cf9: pending() reflects the durable queue (in-flight or queued) ([`bfa505d`](https://github.com/briancray/abide/commit/bfa505d8d5326f0464be35568ac8ae6fc4bd1901))
+- 6453cf9: class: and style: directives for surgical reactive class/style writes ([`c5ee6d1`](https://github.com/briancray/abide/commit/c5ee6d13faad82ac45c6c1627c6e9435c9c59c5f))
+- 6453cf9: durable return type — outbox:true overload on mutating rpc helpers ([`d916c6b`](https://github.com/briancray/abide/commit/d916c6b5b563ddc4dee07a015cde08d32e6dd750))
+- 6453cf9: outbox:true rpc option, gated to mutating methods ([`e37f2a3`](https://github.com/briancray/abide/commit/e37f2a333e201ef40303dd25bafb9f0ca82dd220))
+- 6453cf9: drain loop — deliver/retry/error/cancel under the entry signal ([`ec32868`](https://github.com/briancray/abide/commit/ec32868eb860b6185f21c196b18f03c7b3605ba8))
+- 6453cf9: durable client invoke path + rpc.outbox face ([`f96a0c0`](https://github.com/briancray/abide/commit/f96a0c025cfda5f6daf713f4d69857854b8f3459))
+
+### Patch Changes
+
+- 6453cf9: notify() forEach callback must not return a value ([`1c7f20f`](https://github.com/briancray/abide/commit/1c7f20fa5b6a24f3a5e90ab20521f7d24ba55d57))
+- 6453cf9: Breaking: rename defineVerb export to defineRpc ([`29fe778`](https://github.com/briancray/abide/commit/29fe7782844e0de15c53fad711d6616cc90a27e0))
+- 6453cf9: rename VERB*\* constants to RPC*\* ([`391687a`](https://github.com/briancray/abide/commit/391687a252a33ba355ba929944cd1a2cef83c1ef))
+- 6453cf9: rename verb-named rpc helpers to rpc ([`4ebdd8f`](https://github.com/briancray/abide/commit/4ebdd8ff862121a48a39fbdb7b2893a14fd52022))
+- 6453cf9: rename verbRegistry to rpcRegistry ([`507adf5`](https://github.com/briancray/abide/commit/507adf5d5ae3a1b66ef85fc495ba1a974a530abf))
+- 6453cf9: rename Verb-named types/helpers/files to Rpc ([`8342e96`](https://github.com/briancray/abide/commit/8342e963babbddcb9a87dcc99fc2e4958dbc5750))
+- 6453cf9: refresh AGENTS surface map ({#…} blocks, scaffold flags, migration error) ([`88cc4d9`](https://github.com/briancray/abide/commit/88cc4d97205bd3de74a08a6dbae3f2221f0275fe))
+- 6453cf9: commit working tree — outbox, rpc errors, compile plans, cache refactor ([`c673dc7`](https://github.com/briancray/abide/commit/c673dc71522e33ad4f9b48f41ac73fa6c4f03a02))
+- 6453cf9: rename HttpVerb type to HttpMethod ([`d64a59a`](https://github.com/briancray/abide/commit/d64a59a045f77c627b98dbb1b3a12b545f3d3c60))
+- 6453cf9: scrub verb from comments, AGENTS.md, and inspector surface (rpc/method) ([`d9356ce`](https://github.com/briancray/abide/commit/d9356ce9eeba6b03d43ef67fc500cf697e34d39c))
+
 ## 0.42.0
 
 ### Minor Changes

package/README.md

@@ -1,170 +1,127 @@
 # abide
 
-**One typed declaration fans out to HTTP, a CLI, an MCP tool, and an
-OpenAPI spec — the bundler swaps the runtime per side.**
+**One typed declaration fans out to an HTTP endpoint, a CLI subcommand, an MCP tool, and an OpenAPI operation — and the same callable runs on the server and in the browser.**
 
-abide is an isomorphic framework on Bun where you write a function once and
-it serves every consumer: a browser fetch, an in-process SSR call, a CLI
-subcommand, an MCP tool, an OpenAPI operation. The same callable keeps its
-name and behaviour on both sides — the bundler decides whether it runs the
-real handler or a network proxy. Built for humans _and_ machines.
+abide is a type-safe isomorphic framework on Bun and web standards. You declare an RPC, a socket, or a `.abide` component once; the bundler swaps the runtime per side (in-process on the server, a typed `fetch` proxy in the browser) so the name, the call, and the behaviour are identical wherever you import it. Built for humans *and* the machines that now read and drive software.
 
-- One direct dependency (`typescript`); `tailwindcss` + `bun-plugin-tailwind`
-  are optional peers. Single runtime: Bun ≥ 1.3.0.
+- One direct dependency (TypeScript). Bun is the only runtime — no Node, no separate bundler, no dev server to wire up.
 
 ## Quick start
 
 ```sh
-bunx abide scaffold my-app   # scaffolds, installs deps, and starts dev
+bunx abide scaffold my-app   # scaffolds the project, installs it, and starts dev
 ```
 
-Or read the full feature tour in the kitchen-sink example:
+Or read the runnable tour — every primitive below, live:
 
 ```sh
-git clone https://github.com/briancray/abide
+git clone git@github.com:briancray/abide.git
 cd abide/examples/kitchen-sink
 bun install
-bun run dev
+bun dev
 ```
 
 ## RPCs
 
-An RPC is one export per file under `src/server/rpc/`. The file path is the
-URL; the export name is the verb. A Standard Schema (zod / valibot / arktype,
-unadapted) validates the args and projects the same shape into the MCP tool,
-the CLI flags, and the OpenAPI operation.
+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 (zod / valibot / arktype, unadapted) validates the args once and projects the same declaration into every 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 { recent } from '../../chatState.ts'
 
-const inputSchema = z.object({ room: z.string(), limit: z.coerce.number().default(20) })
+const inputSchema = z.object({ room: z.string() })
 
-export const getMessages = GET(({ room, limit }) => json(recent(room).slice(-limit)), {
-    inputSchema,
-})
+export const getMessages = GET(({ room }) => json(db.messages(room)), { inputSchema })
 ```
 
-One declaration, every surface:
+That single declaration fans out:
 
 ```text
-              getMessages = GET(fn, { inputSchema })
-                              │
-      ┌─────────────┬─────────┼──────────┬──────────────┐
-      ▼             ▼         ▼          ▼              ▼
-  SSR call      browser    MCP tool   CLI sub-      OpenAPI
-  cache(fn)()   fetch       (read)    command       operation
-                proxy
+      export const getMessages = GET(fn, { inputSchema })
+                            │
+  ┌────────────┬────────────┬────────────┬────────────┐
+  ▼            ▼            ▼            ▼            ▼
+  SSR call     browser      MCP tool     CLI cmd      OpenAPI
+  cache(fn)()  fetch proxy  (read-only)  abide cli    /openapi.json
 ```
 
-A schema unlocks the CLI for every verb and MCP for read-only verbs (`GET` /
-`HEAD`); a mutating verb never auto-exposes to MCP — it needs an explicit
-`clients: { mcp: true }`. Consume the verb four ways: `cache(getMessages)(args)`
-in-process (warm SSR hydration), the swapped `fetch` proxy in the browser,
-`getMessages.raw(args)` for the untouched `Response`, and
-`getMessages.stream(args)` to iterate a `jsonl`/`sse` body.
+The schema is the gate: it unlocks the CLI and — for read-only methods (GET/HEAD) — the MCP tool automatically. A mutating method (POST/PUT/PATCH/DELETE) never auto-exposes to MCP; it opts in with `clients: { mcp: true }`. Consume a call four ways: `cache(getMessages)()` in-process (warm SSR + hydration), the swapped `fetch` proxy in the browser, `getMessages.raw(args)` for the untouched `Response`, and `getMessages.stream(args)` for a frame stream.
 
-> Query args arrive as strings — wrap numeric/boolean fields in `z.coerce.*`.
-> The per-verb `timeout` (504 on every surface) is distinct from the
-> client-side `ABIDE_CLIENT_TIMEOUT`.
+> Query args travel as strings — use `z.coerce.*` for numbers/booleans on GET/DELETE/HEAD. A per-RPC `timeout` (a 504 on every surface) is distinct from the client-wide `ABIDE_CLIENT_TIMEOUT`.
 
 ## Sockets
 
-A socket is one broadcast topic per file under `src/server/sockets/`. A
-`Socket<T>` is an isomorphic `AsyncIterable<T>`; every socket multiplexes onto
-one WebSocket at `/__abide/sockets`.
+A socket is one broadcast topic per file under `src/server/sockets/`. A `Socket<T>` is an isomorphic `AsyncIterable<T>` — `for await (const m of chat)` is the live stream — and every socket multiplexes onto one WebSocket at `/__abide/sockets`.
 
 ```ts
 // src/server/sockets/chat.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() })
+const schema = z.object({ from: z.string(), text: z.string(), at: z.number() })
 
-// retain the last 100 frames; evict any older than an hour
+// tail: retain the last 100 frames for late joiners; ttl: evict frames older than an hour.
 export const chat = socket({ schema, tail: 100, ttl: 3_600_000 })
 export type ChatMessage = z.infer<typeof schema>
 ```
 
-It also has an HTTP face for clients that can't speak the multiplex (the CLI
-and MCP): `GET /__abide/sockets/chat` returns the retained tail, and
-`POST /__abide/sockets/chat` publishes — gated by `clientPublish` (default off,
-so browsers publish through a validating verb instead).
+Each socket also has an HTTP face at `/__abide/sockets/<name>`: `GET` returns the retained tail, `POST` publishes (only when the socket declares `clientPublish`). `chat.publish(m)` is isomorphic — server-side it fans out in-process and to remote subscribers; client-side it sends a validated `pub` frame.
 
-## Components — the full template
+## Components
 
-A `.abide` component pulls the verb and the socket above into one page and
-exercises the template grammar. `scope`, `props`, `effect`, `html`, and
-`snippet` are ambient — no import needed.
+A component is a `.abide` file: valid HTML with a `<script>`, `{#…}` control-flow blocks, `<template name>` snippets, `{expr}` bindings, and a component-scoped `<style>`. This page imports the RPC and socket above — `cache(getMessages)` seeds the list warm at SSR, `tail(chat)` layers live frames on top after hydration.
 
-<!-- prettier-ignore -->
 ```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 { createMessage } from '$server/rpc/createMessage.ts'
 import { chat } from '$server/sockets/chat.ts'
 import Avatar from '$ui/Avatar.abide'
 
-const { room } = props()
+const { room = 'lobby' } = props()
+const { state, computed } = scope()
 
-// warm on the server, live on the client
-const history = scope().computed(() => cache(getMessages)({ room }))
-const latest = scope().computed(() => tail(chat))
+let draft = state('')
+let notify = state(true)
+const live = computed(() => tail(chat))            // read-only derived
+const ready = computed(() => draft.trim().length > 0)
 
-let from = scope().state('alice')
-let text = scope().state('')
-let pinned = scope().state(false)
-let view = scope().state('all')
-
-async function send() {
-    await publishChat({ from, text })
-    text = ''
+async function send(event: SubmitEvent) {
+    event.preventDefault()
+    await createMessage({ room, text: draft, notify })
+    draft = ''
 }
 </script>
 
-<template name="line" args={message}>
-    <li><Avatar name={message.from} /> <b>{message.from}</b>: {message.text}</li>
+<template name="row" args={{ msg }}>
+    <li><Avatar name={msg.from} /> {msg.text}</li>
 </template>
 
 <form onsubmit={send}>
-    <input bind:value={from} placeholder="name" />
-    <input bind:value={text} placeholder="message" />
-    <label><input type="checkbox" bind:checked={pinned} /> pin</label>
-    <label><input type="radio" bind:group={view} value="all" /> all</label>
-    <label><input type="radio" bind:group={view} value="mine" /> mine</label>
-    <button disabled={!text}>send</button>
+    <input bind:value={draft} placeholder="message" />
+    <label><input type="checkbox" bind:checked={notify} /> notify</label>
+    <button disabled={!ready()}>Send</button>
 </form>
 
-{#if latest}
-    <p>latest from {latest.from}</p>
-{:else}
-    <p>no messages yet</p>
-{/if}
-
-{#switch view}
-{:case 'mine'}<p>showing your messages</p>
-{:default}<p>showing every message</p>
-{/switch}
+{#if live()}<p class="muted">latest: {live().text}</p>{/if}
 
-{#await history}
-    <p>loading…</p>
-{:then data}
+{#await cache(getMessages)({ room })}
+    <p>Loading…</p>
+{:then messages}
     <ul>
-        {#for message, i of data by message.id}
-            {i}. {line(message)}
-        {/for}
+        {#for msg of messages by msg.at}{row({ msg })}{/for}
     </ul>
-{:catch reason}
-    <p>failed: {reason.message}</p>
+{:catch error}
+    <p class="error">{error.message}</p>
 {/await}
 
 <style>
-form { display: flex; gap: 0.5rem; }
+    .muted { color: #64748b; }
+    .error { color: #b91c1c; }
 </style>
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@abide/abide",
-    "version": "0.42.0",
+    "version": "0.43.0",
     "type": "module",
     "sideEffects": false,
     "description": "Isomorphic multimodal HTTP framework built for humans and machines in a single Bun runtime",
@@ -54,7 +54,7 @@
         "./server/AppModule": "./src/lib/server/AppModule.ts",
         "./server/InspectorContext": "./src/lib/server/runtime/types/InspectorContext.ts",
         "./server/agent": "./src/lib/server/agent.ts",
-        "./server/rpc/defineVerb": "./src/lib/server/rpc/defineVerb.ts",
+        "./server/rpc/defineRpc": "./src/lib/server/rpc/defineRpc.ts",
         "./server/sockets/defineSocket": "./src/lib/server/sockets/defineSocket.ts",
         "./server/prompts/definePrompt": "./src/lib/server/prompts/definePrompt.ts",
         "./ui/tail": "./src/lib/ui/tail.ts",
@@ -62,6 +62,7 @@
         "./shared/pending": "./src/lib/shared/pending.ts",
         "./shared/refreshing": "./src/lib/shared/refreshing.ts",
         "./shared/HttpError": "./src/lib/shared/HttpError.ts",
+        "./shared/ValidationErrorData": "./src/lib/shared/types/ValidationErrorData.ts",
         "./shared/html": "./src/lib/shared/html.ts",
         "./shared/snippet": "./src/lib/shared/snippet.ts",
         "./shared/withJsonSchema": "./src/lib/shared/withJsonSchema.ts",

package/src/abideResolverPlugin.ts

@@ -1,5 +1,6 @@
 // node:fs existsSync — Bun plugin onResolve is sync-only; Bun.file().exists() is async
 import { existsSync, statSync } from 'node:fs'
+import { dirname, join } from 'node:path'
 import type { BunPlugin } from 'bun'
 import { Glob } from 'bun'
 import { abideImportName } from './lib/shared/abideImportName.ts'
@@ -80,7 +81,7 @@ function once<T>(produce: () => Promise<T>): () => Promise<T> {
 
 /*
 Bun plugin that wires every virtual import abide produces at build time:
-- `abide:rpc`     — { rpcUrl: () => import(rpc-module) } HTTP-verb manifest
+- `abide:rpc`     — { rpcUrl: () => import(rpc-module) } HTTP-method manifest
 - `abide:sockets` — { socketName: () => import(socket-module) } socket manifest
 - `abide:pages`   — { pageUrl: () => import(page.abide) } manifest
 - `abide:prompts` — { promptName: () => import(prompt-module) } manifest
@@ -91,8 +92,8 @@ Bun plugin that wires every virtual import abide produces at build time:
 - `abide:shell`   — app.html content (custom or default)
 
 Also rewrites modules under src/server/rpc and src/server/sockets:
-- src/server/rpc/<file>.ts: each HTTP-verb export is bound to a runtime
-  implementation — defineVerb on the server, remoteProxy on the client.
+- src/server/rpc/<file>.ts: each HTTP-method export is bound to a runtime
+  implementation — defineRpc on the server, remoteProxy on the client.
 - src/server/sockets/<file>.ts: each `socket(opts)` export is bound to
   defineSocket on the server (with the socket name + opts) or
   socketProxy on the client (name only — opts are server-side).
@@ -147,7 +148,7 @@ export function abideResolverPlugin({
         scanDir(rpcDir, '**/*.ts').then(async (rpcFiles) => {
             const importName = await abideImportNameOnce()
             await writeRpcDts({ cwd, rpcDir, rpcFiles, importName })
-            /* Typed createTestApp `app.rpc.<verb>` surface. */
+            /* Typed createTestApp `app.rpc.<rpc>` surface. */
             await writeTestRpcDts({ cwd, rpcFiles, importName })
             return rpcFiles
         }),
@@ -194,9 +195,91 @@ export function abideResolverPlugin({
     const socketsFilter = new RegExp(`^${escapeRegex(socketsDir)}/.*\\.ts$`)
     const promptsFilter = new RegExp(`^${escapeRegex(promptsDir)}/.*\\.md$`)
 
+    /*
+    Side-crossing guard (client target only). The client bundle must never pull a
+    server-only name into the browser. The exception is a registered rpc/socket —
+    `$server/rpc/*` and `$server/sockets/*` are replaced with remoteProxy/socketProxy
+    stubs by the onLoad hooks below — so only OTHER paths under src/server/ (helpers,
+    runtime/) and the public `abide/server/*` names are violations. `importerOf` records
+    each resolved edge so a violation can show the import chain back to its client-side
+    origin as evidence; it is reset per build in onStart.
+    */
+    const importerOf = new Map<string, string>()
+    const isProxiedServerModule = (path: string): boolean =>
+        path.startsWith(`${rpcDir}/`) || path.startsWith(`${socketsDir}/`)
+    const isServerOnlyModule = (path: string): boolean =>
+        path.startsWith(`${serverDir}/`) && !isProxiedServerModule(path)
+    const showPath = (path: string): string =>
+        path.startsWith(`${cwd}/`) ? path.slice(cwd.length + 1) : path
+    /* Walks the recorded edges from the offending importer back to a graph root (cycle-safe),
+       formatting each module relative to cwd — the evidence a side-crossing throws. */
+    function sideCrossingChain(leaf: string, importer: string): string {
+        const chain = [leaf, importer]
+        const seen = new Set([importer])
+        let cursor = importer
+        while (importerOf.has(cursor)) {
+            cursor = importerOf.get(cursor) as string
+            if (seen.has(cursor)) {
+                break
+            }
+            seen.add(cursor)
+            chain.push(cursor)
+        }
+        return chain.reverse().map(showPath).join('\n  → ')
+    }
+    function throwSideCrossing(leaf: string, label: string, importer: string): never {
+        throw new Error(
+            `[abide] a client module imports the server-only name \`${label}\` — server code must not reach the browser bundle. Move it to src/shared/ or behind an RPC. Import chain:\n  ${sideCrossingChain(leaf, importer)}`,
+        )
+    }
+    /* Records the edge and, on the client target, rejects a non-server module reaching a
+       server-only one. Shared by the relative-import and `$server` alias resolvers. */
+    function recordAndGuard(resolved: string, label: string, importer: string | undefined): void {
+        if (importer === undefined) {
+            return
+        }
+        importerOf.set(resolved, importer)
+        if (target === 'client' && isServerOnlyModule(resolved) && !isServerOnlyModule(importer)) {
+            throwSideCrossing(resolved, label, importer)
+        }
+    }
+
     return {
         name: 'abide-resolver',
         setup(build) {
+            /* Fresh edge graph each build (dev watch reuses the plugin instance).
+               onStart is build-time only — absent in the runtime/preload plugin context. */
+            build.onStart?.(() => {
+                importerOf.clear()
+            })
+
+            /*
+            Relative-import edge recorder + side-crossing guard. Matches `./` and `../`
+            specifiers, records the edge for the evidence chain, and (client target) throws
+            when a non-server module reaches a server-only file. Returns undefined so normal
+            resolution proceeds — this only observes and, on violation, aborts.
+            */
+            build.onResolve({ filter: /^\.\.?\// }, (args) => {
+                if (args.importer) {
+                    const resolved = resolveExtension(join(dirname(args.importer), args.path))
+                    recordAndGuard(resolved, args.path, args.importer)
+                }
+                return undefined
+            })
+
+            /*
+            The public `abide/server/*` names are server-only. Importing one into the client
+            bundle is a side-crossing (the canonical `abide` and `@abide/abide` specifiers; a
+            custom package alias falls through to the relative/`$server` guards). The server
+            target resolves these normally.
+            */
+            build.onResolve({ filter: /(^|\/)abide\/server\// }, (args) => {
+                if (target === 'client' && args.importer && !isServerOnlyModule(args.importer)) {
+                    throwSideCrossing(args.path, args.path, args.importer)
+                }
+                return undefined
+            })
+
             build.onResolve(
                 {
                     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$/,
@@ -226,7 +309,11 @@ export function abideResolverPlugin({
             for (const [alias, baseDir] of Object.entries(dirAliases)) {
                 build.onResolve({ filter: new RegExp(`^\\${alias}(\\/.*)?$`) }, (args) => {
                     const subpath = args.path.slice(alias.length)
-                    return { path: resolveExtension(subpath ? `${baseDir}${subpath}` : baseDir) }
+                    const resolved = resolveExtension(subpath ? `${baseDir}${subpath}` : baseDir)
+                    /* `$server/rpc/*` + `$server/sockets/*` are proxied (allowed); other
+                       `$server/*` imports into the client bundle are side-crossings. */
+                    recordAndGuard(resolved, args.path, args.importer)
+                    return { path: resolved }
                 })
             }
 
@@ -262,7 +349,7 @@ export function abideResolverPlugin({
                 const prepared = prepareRpcModule(source, importName)
                 if (!prepared) {
                     throw new Error(
-                        `[abide] src/server/rpc/${relativePath} has no \`export const <name> = <VERB>(...)\` — every $rpc module must declare exactly one remote function`,
+                        `[abide] src/server/rpc/${relativePath} has no \`export const <name> = <METHOD>(...)\` — every $rpc module must declare exactly one remote function`,
                     )
                 }
                 const expectedName = fileStem(relativePath)
@@ -279,22 +366,25 @@ export function abideResolverPlugin({
                 so page imports resolve identically on both sides.
                 */
                 if (target === 'client') {
+                    /* A durable rpc (`outbox: true`) gets the third arg so its client proxy
+                       parks unreachable calls onto the outbox. */
+                    const durableArg = prepared.durable ? ', { outbox: true }' : ''
                     const contents = `import { remoteProxy as __abideRemoteProxy__ } from '${importName}/ui/remoteProxy';
-export const ${prepared.exportName} = __abideRemoteProxy__(${JSON.stringify(prepared.verb)}, ${JSON.stringify(url)});
+export const ${prepared.exportName} = __abideRemoteProxy__(${JSON.stringify(prepared.method)}, ${JSON.stringify(url)}${durableArg});
 `
                     return { contents, loader: 'ts' }
                 }
                 /*
-                Server target: strip the user's verb import, then rewrite
-                the `<VERB>(` call so the verb (from the identifier) and
+                Server target: strip the user's rpc import, then rewrite
+                the `<METHOD>(` call so the method (from the identifier) and
                 the URL (from the file path) are threaded into the
-                runtime constructor — defineVerb. The user's handler body
+                runtime constructor — defineRpc. The user's handler body
                 stays intact between the parens; any generics on the call
                 are dropped (they carry no runtime info). Rewriting is
                 tokenizer-driven so `GET` mentions inside strings and
                 comments are left alone.
                 */
-                const banner = `import { defineVerb as __abideDefineVerb__ } from '${importName}/server/rpc/defineVerb';
+                const banner = `import { defineRpc as __abideDefineRpc__ } from '${importName}/server/rpc/defineRpc';
 `
                 return { contents: `${banner}${prepared.rewriteForServer(url)}`, loader: 'ts' }
             })
@@ -471,7 +561,7 @@ ${optionLines}
                     The CLI binary's bake-time manifest. Discovery (a
                     one-shot script the bundler runs separately) writes
                     `${cwd}/dist/cli-manifest.json` from the populated
-                    verbRegistry; this virtual splices that JSON in as a
+                    rpcRegistry; this virtual splices that JSON in as a
                     default-exported object. Empty manifest when the
                     discovery file is missing — the binary still works
                     but exposes no subcommands until the user runs the
@@ -606,7 +696,7 @@ export const footer = ${JSON.stringify(footer)}
                 if (args.path === 'abide:mcp') {
                     /*
                     The MCP server is fully framework-generated — tools from
-                    the verb registry, prompts from src/mcp/prompts, resources
+                    the rpc registry, prompts from src/mcp/prompts, resources
                     from src/mcp/resources. createMcpServer is internal; there
                     is no user-authored server module. Server identity comes
                     from package.json so the `mcp__<name>__*` permission prefix
@@ -798,7 +888,7 @@ async function scanPages(pagesDir: string): Promise<PagesScan> {
 
 /*
 Walks one registry directory once: src/server/rpc (every `.ts` file is an
-HTTP-verb rpc handler), src/server/sockets (each `.ts` file declares one
+HTTP-method rpc handler), src/server/sockets (each `.ts` file declares one
 socket, loaded lazily on first sub/pub frame), or src/mcp/prompts (each `.md`
 file declares one MCP prompt — frontmatter for metadata, body for the
 template). Returns an empty list when the directory doesn't exist so an app

package/src/buildCli.ts

@@ -21,7 +21,7 @@ the compiled server beside it, so `/start` can spawn a local instance.
   1. Client build (once): `build` produces the platform-independent `dist/_app`
      the server binaries embed. It clears dist first, so it runs before everything.
   2. Discovery: build the discovery entry into a temporary JS bundle and run it. It
-     imports every rpc/socket module so defineVerb / defineSocket populate the
+     imports every rpc/socket module so defineRpc / defineSocket populate the
      registries, then prints the CLI manifest to stdout → `dist/cli-manifest.json`.
   3. Per target: a server binary (`compile`, reusing the shared `dist/_app` via
      `buildClient:false`) plus the CLI binary, written side by side. The resolver's

package/src/discoveryEntry.ts

@@ -3,14 +3,14 @@ import { rpc } from './_virtual/rpc.ts'
 // @ts-expect-error virtual module resolved by abideResolverPlugin
 import { sockets } from './_virtual/sockets.ts'
 import type { CliManifestEntry } from './lib/cli/types/CliManifestEntry.ts'
-import { verbRegistry } from './lib/server/rpc/verbRegistry.ts'
+import { rpcRegistry } from './lib/server/rpc/rpcRegistry.ts'
 import { socketOperations } from './lib/server/sockets/socketOperations.ts'
 import { socketRegistry } from './lib/server/sockets/socketRegistry.ts'
 import { commandNameForUrl } from './lib/shared/commandNameForUrl.ts'
 import { jsonSchemaForSchema } from './lib/shared/jsonSchemaForSchema.ts'
 
 /*
-One-shot script that imports every rpc + socket module so defineVerb /
+One-shot script that imports every rpc + socket module so defineRpc /
 defineSocket populate the process-wide registries, then prints the CLI
 manifest to stdout as JSON. Used by buildCli to bake the manifest into
 the standalone binary at build time without resorting to static source
@@ -23,7 +23,7 @@ await Promise.all([
 
 const manifest: Record<string, CliManifestEntry> = {}
 
-for (const entry of verbRegistry.values()) {
+for (const entry of rpcRegistry.values()) {
     if (!entry.clients.cli) {
         continue
     }

package/src/lib/bundle/BundleMenuItem.ts

@@ -8,7 +8,7 @@ handles it:
         if (event.detail.name === 'sync') syncNow()
     })
 
-Emitting an event (rather than calling a verb directly) is what lets a menu
+Emitting an event (rather than calling a rpc directly) is what lets a menu
 drive parameterised work: a click carries no arguments, so the app computes
 them and makes the call itself. `shortcut` is the key for the Cmd-based
 equivalent (e.g. `'r'` → Cmd-R).

package/src/lib/cli/createClient.ts

@@ -1,8 +1,8 @@
-import { dispatchVerbInProcess } from '../server/rpc/dispatchVerbInProcess.ts'
-import { findVerbByCommandName } from '../server/rpc/findVerbByCommandName.ts'
+import { dispatchRpcInProcess } from '../server/rpc/dispatchRpcInProcess.ts'
+import { findRpcByCommandName } from '../server/rpc/findRpcByCommandName.ts'
 import { buildRpcProxy } from '../shared/buildRpcProxy.ts'
 import { buildRpcRequest } from '../shared/buildRpcRequest.ts'
-import type { HttpVerb } from '../shared/types/HttpVerb.ts'
+import type { HttpMethod } from '../shared/types/HttpMethod.ts'
 import type { RpcInvoker } from '../shared/types/RpcInvoker.ts'
 import type { CliManifest } from './types/CliManifest.ts'
 
@@ -24,8 +24,8 @@ decided at construction:
     against `<url>/<manifest[name].url>` using the manifest's method.
     Auth header is set from `token` when provided.
   - Without `url`: in-process mode. Each property access looks up the
-    verb in the registry (populated by importing the project's rpc
-    modules) and calls `verb.fetch(synthesizedRequest)` — same code
+    rpc in the registry (populated by importing the project's rpc
+    modules) and calls `rpc.fetch(synthesizedRequest)` — same code
     path the HTTP router uses, no network hop.
 
 The `manifest` is the bundler-emitted CLI manifest baked into the thin
@@ -62,9 +62,9 @@ export function createClient<Api extends AnyApi = AnyApi>(opts?: {
     undefined when the name is unknown in the active mode. Remote mode (url set)
     resolves method + url from the baked manifest — registry fallback for
     same-project callers — and sends the synthesized Request over the network.
-    In-process mode resolves the verb from the registry and routes through
-    dispatchVerbInProcess, the same synthesize-and-fetch the MCP dispatcher
-    uses, so the two consumer surfaces can't drift on how a verb is invoked.
+    In-process mode resolves the rpc from the registry and routes through
+    dispatchRpcInProcess, the same synthesize-and-fetch the MCP dispatcher
+    uses, so the two consumer surfaces can't drift on how a rpc is invoked.
     */
     function resolveSend(name: string): ((args?: unknown) => Promise<Response>) | undefined {
         if (url) {
@@ -83,12 +83,12 @@ export function createClient<Api extends AnyApi = AnyApi>(opts?: {
                     }),
                 )
         }
-        const entry = findVerbByCommandName(name)
+        const entry = findRpcByCommandName(name)
         if (!entry) {
             return undefined
         }
         return (args) =>
-            dispatchVerbInProcess({
+            dispatchRpcInProcess({
                 remote: entry.remote,
                 args,
                 baseUrl: 'http://localhost/',
@@ -99,8 +99,8 @@ export function createClient<Api extends AnyApi = AnyApi>(opts?: {
     // Remote-mode registry fallback for callers passing a url but no manifest.
     function registryCommand(
         name: string,
-    ): { method: HttpVerb; url: string; accept?: string } | undefined {
-        const found = findVerbByCommandName(name)
+    ): { method: HttpMethod; url: string; accept?: string } | undefined {
+        const found = findRpcByCommandName(name)
         return found ? { method: found.remote.method, url: found.remote.url } : undefined
     }
 

package/src/lib/cli/dispatchCommand.ts

@@ -12,7 +12,7 @@ import type { CliManifest } from './types/CliManifest.ts'
 Runs one RPC command against a target server and prints the result, returning a
 process exit code. Shared by the one-shot path (runCli) and the interactive
 session (runSession) so a command behaves identically typed at the shell or at
-the session prompt. Streaming responses (sse/jsonl — a streaming verb or a socket
+the session prompt. Streaming responses (sse/jsonl — a streaming rpc or a socket
 `tail`) print frame-by-frame as NDJSON; everything else decodes and prints once.
 */
 export async function dispatchCommand({

package/src/lib/cli/printSessionStatus.ts

@@ -5,7 +5,7 @@ import type { CliTarget } from './types/CliTarget.ts'
 Prints the session's connection line. A local instance (spawned child) reads as
 "running a local instance"; a remote one reads as "connected to <name>", using the
 name the target already carries from its resolve-time probe and only re-probing
-when it doesn't. No target → the not-connected hint listing the verbs.
+when it doesn't. No target → the not-connected hint listing the rpcs.
 */
 export async function printSessionStatus(target: CliTarget | undefined): Promise<void> {
     if (!target) {

package/src/lib/cli/resolveCliTarget.ts

@@ -11,7 +11,7 @@ const AUTO_START_CEILING_MS = 3000
 
 /*
 Resolves the connection to resume when the CLI runs without an explicit
-connection verb — the terminal analogue of the bundle's resolveLaunchTarget.
+connection rpc — the terminal analogue of the bundle's resolveLaunchTarget.
 Reads the saved intent:
   - embedded         → boot a fresh local instance (bounded; undefined on failure)
   - url, still alive → connect to it