@abide/abide 0.41.1 → 0.43.0

package/src/abideResolverPlugin.ts

@@ -1,9 +1,12 @@
 // 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'
 import { abideLog } from './lib/shared/abideLog.ts'
+import { escapeRegex } from './lib/shared/escapeRegex.ts'
+import { fileName } from './lib/shared/fileName.ts'
 import { fileStem } from './lib/shared/fileStem.ts'
 import { jsonSchemaForPromptArguments } from './lib/shared/jsonSchemaForPromptArguments.ts'
 import { manifestModule } from './lib/shared/manifestModule.ts'
@@ -65,10 +68,6 @@ function resolveExtensionUncached(path: string): string {
 
 const NS = 'abide-virtual'
 
-function escapeRegex(value: string): string {
-    return value.replace(/[\\^$.*+?()[\]{}|]/g, '\\$&')
-}
-
 /* Memoises a zero-arg async producer so repeat calls reuse the first in-flight promise. */
 function once<T>(produce: () => Promise<T>): () => Promise<T> {
     let promise: Promise<T> | undefined
@@ -82,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
@@ -93,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).
@@ -149,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
         }),
@@ -196,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$/,
@@ -228,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 }
                 })
             }
 
@@ -264,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)
@@ -281,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' }
             })
@@ -473,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
@@ -608,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
@@ -791,7 +879,7 @@ async function scanPages(pagesDir: string): Promise<PagesScan> {
         return { pageFiles: [], layoutFiles: [] }
     }
     const allFiles = await Array.fromAsync(new Glob('**/*.abide').scan({ cwd: pagesDir }))
-    const leafIs = (name: string) => (file: string) => (file.split('/').pop() ?? '') === name
+    const leafIs = (name: string) => (file: string) => fileName(file) === name
     return {
         pageFiles: allFiles.filter(leafIs('page.abide')),
         layoutFiles: allFiles.filter(leafIs('layout.abide')),
@@ -800,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

package/src/lib/cli/runCli.ts

@@ -67,7 +67,7 @@ a bare word runs a command:
   /disconnect                     → forget the saved connection, exit
   <cmd> [--flags]                 → one-shot RPC against the resumed target
 
-The connection verbs are `/`-prefixed only — no bare aliases — so a bare word is
+The connection rpcs are `/`-prefixed only — no bare aliases — so a bare word is
 always an RPC command and never collides. Env layers ABIDE_APP_URL/ABIDE_APP_TOKEN (shell >
 data-dir > binary-dir) supply the baked default a fresh download resumes against.
 */

package/src/lib/cli/types/CliManifest.ts

@@ -2,7 +2,7 @@ import type { CliManifestEntry } from './CliManifestEntry.ts'
 
 /*
 Map from rpc export-name (e.g. "getReport") to its manifest entry. Built
-by the bundler from the same verbRegistry MCP consumes; entries are
+by the bundler from the same rpcRegistry MCP consumes; entries are
 emitted only for rpcs with `clients.cli: true`. The CLI binary and any
 programmatic createClient caller read this to dispatch calls.
 */

package/src/lib/cli/types/CliManifestEntry.ts

@@ -1,4 +1,4 @@
-import type { HttpVerb } from '../../shared/types/HttpVerb.ts'
+import type { HttpMethod } from '../../shared/types/HttpMethod.ts'
 
 /*
 Per-command manifest entry baked into the standalone CLI binary by the
@@ -9,7 +9,7 @@ both rpcs and socket commands — a socket `tail` is a GET against
 streams it live; a socket `publish` is a POST to the same path.
 */
 export type CliManifestEntry = {
-    method: HttpVerb
+    method: HttpMethod
     url: string
     jsonSchema?: Record<string, unknown>
     // Request Accept header. Socket tail sets text/event-stream to stream live frames.

package/src/lib/mcp/annotationsForMethod.ts

@@ -1,8 +1,8 @@
-import type { HttpVerb } from '../shared/types/HttpVerb.ts'
+import type { HttpMethod } from '../shared/types/HttpMethod.ts'
 
 /*
-Maps an HTTP verb to MCP tool annotations so a model can tell a read from
-a write before calling. Abide derives these from the verb the RPC was
+Maps an HTTP method to MCP tool annotations so a model can tell a read from
+a write before calling. Abide derives these from the rpc the RPC was
 declared with rather than asking the author to repeat the intent:
   - GET / HEAD  → read-only, non-destructive
   - POST        → creates; not idempotent, not (necessarily) destructive
@@ -10,9 +10,9 @@ declared with rather than asking the author to repeat the intent:
   - PATCH       → modifies; destructive, not idempotent
   - DELETE      → removes; idempotent + destructive
 The shape matches MCP's ToolAnnotations (readOnlyHint / destructiveHint /
-idempotentHint); fields a verb doesn't imply are left off.
+idempotentHint); fields a rpc doesn't imply are left off.
 */
-export function annotationsForMethod(method: HttpVerb): Record<string, boolean> {
+export function annotationsForMethod(method: HttpMethod): Record<string, boolean> {
     switch (method) {
         case 'GET':
         case 'HEAD':

package/src/lib/mcp/createMcpServer.ts

@@ -14,10 +14,10 @@ object whose `handle(request)` is the function the bun route at
 default-constructs it; there is no user-authored server module. Server
 name/version default from package.json.
 
-Tools are derived from every verb with `clients.mcp: true` (auto-on for
-read-only verbs that carry a schema; mutating verbs opt in explicitly)
+Tools are derived from every rpc with `clients.mcp: true` (auto-on for
+read-only rpcs that carry a schema; mutating rpcs opt in explicitly)
 and from every socket with `clients.mcp: true` (a `<base>-tail` read tool
-plus a `<base>-publish` tool when clientPublish is set). The HTTP verb
+plus a `<base>-publish` tool when clientPublish is set). The HTTP method
 feeds each rpc tool's annotations. Auth inherits from the inbound request
 — bearer / cookie headers flow into the synthesized Request that hits
 each rpc handler. An optional `authorize` hook in opts can short-circuit

package/src/lib/mcp/mcpSurface.ts

@@ -1,7 +1,7 @@
 import { promptRegistry } from '../server/prompts/promptRegistry.ts'
-import { dispatchVerbInProcess } from '../server/rpc/dispatchVerbInProcess.ts'
-import { findVerbByCommandName } from '../server/rpc/findVerbByCommandName.ts'
-import { verbRegistry } from '../server/rpc/verbRegistry.ts'
+import { dispatchRpcInProcess } from '../server/rpc/dispatchRpcInProcess.ts'
+import { findRpcByCommandName } from '../server/rpc/findRpcByCommandName.ts'
+import { rpcRegistry } from '../server/rpc/rpcRegistry.ts'
 import { socketOperations } from '../server/sockets/socketOperations.ts'
 import { socketRegistry } from '../server/sockets/socketRegistry.ts'
 import { abideLog } from '../shared/abideLog.ts'
@@ -58,12 +58,12 @@ export type McpSurface = {
 /*
 Builds the array of MCP tool descriptors.
 
-RPCs: every verb with clients.mcp=true becomes one tool named after the
-export's URL (folder segments joined with `-`). The HTTP verb feeds the
+RPCs: every rpc with clients.mcp=true becomes one tool named after the
+export's URL (folder segments joined with `-`). The HTTP method feeds the
 tool's annotations (readOnlyHint / destructiveHint / idempotentHint) so
 a model can tell a read from a write; reads auto-expose while mutating
-verbs require an explicit clients.mcp (see resolveClientFlags). When the
-verb declares an `outputSchema` it's advertised as the tool outputSchema.
+rpcs require an explicit clients.mcp (see resolveClientFlags). When the
+rpc declares an `outputSchema` it's advertised as the tool outputSchema.
 
 Sockets: every socket with clients.mcp=true contributes a `<base>-tail`
 read tool (recent buffered messages) and, when clientPublish is set, a
@@ -71,7 +71,7 @@ read tool (recent buffered messages) and, when clientPublish is set, a
 */
 export function buildTools(): ToolDescriptor[] {
     const tools: ToolDescriptor[] = []
-    for (const entry of verbRegistry.values()) {
+    for (const entry of rpcRegistry.values()) {
         if (!entry.clients.mcp) {
             continue
         }
@@ -154,7 +154,7 @@ export function buildPrompts(): PromptDescriptor[] {
 }
 
 /* MCP tool-dispatch spans, opt-in via DEBUG=abide:mcp — a model's tool call,
-   wrapping the underlying verb dispatch in the same trace. */
+   wrapping the underlying rpc dispatch in the same trace. */
 const mcpLog = abideLog.channel('abide:mcp')
 
 function textResult(text: string, isError = false): ToolResult {
@@ -203,7 +203,7 @@ function callSocketTool(
 
 /*
 Tool dispatch. RPC tools synthesize a Request (with forwarded auth
-headers from `inbound`) and pipe it through verb.fetch inside the request
+headers from `inbound`) and pipe it through rpc.fetch inside the request
 scope — the same seam the HTTP router crosses, so validation, the handler,
 and the request-scoped helpers (per-call cache(), cookies(), request())
 behave identically. A handler throw is caught by the scope and framed as
@@ -217,14 +217,14 @@ export async function callTool(
     args: Record<string, unknown> | undefined,
     inbound: Request,
 ): Promise<ToolResult> {
-    const entry = findVerbByCommandName(toolName)
+    const entry = findRpcByCommandName(toolName)
     if (entry) {
-        /* A verb owns this name. If it isn't mcp-exposed it's still unavailable —
+        /* A rpc owns this name. If it isn't mcp-exposed it's still unavailable —
            don't fall through to a socket op that happens to share the name. */
         if (!entry.clients.mcp) {
             throw new Error(`unknown tool: ${toolName}`)
         }
-        const response = await dispatchVerbInProcess({
+        const response = await dispatchRpcInProcess({
             remote: entry.remote,
             args,
             baseUrl: `${new URL(inbound.url).origin}/`,
@@ -264,7 +264,7 @@ export function renderPrompt(
 
 /*
 Projects the app's MCP surface for an in-process consumer bound to `request`
-— tool calls forward that request's auth headers into the verb handler, so
+— tool calls forward that request's auth headers into the rpc handler, so
 the model acts with the caller's identity. Used by `agent()`.
 */
 export function mcpSurface(request: Request): McpSurface {

package/src/lib/mcp/types/McpServerOptions.ts

@@ -7,7 +7,7 @@ package.json by the bundler when MCP is wired into createServer).
   response. Defaults come from the project's package.json.
 - `authorize`: optional boundary check. Runs once per MCP request before
   any tool/resource dispatch. Throw HttpError (or any Error) to reject.
-  Per-tool authorization stays in the underlying verb handler.
+  Per-tool authorization stays in the underlying rpc handler.
 */
 export type McpServerOptions = {
     name?: string

package/src/lib/server/DELETE.ts

@@ -1,10 +1,10 @@
-import type { VerbHelper } from './rpc/types/VerbHelper.ts'
+import type { MutatingRpcHelper } from './rpc/types/RpcHelper.ts'
 import { unprocessed } from './rpc/unprocessed.ts'
 
 /*
-DELETE verb helper. The bundler rewrites every `export const x = DELETE(fn)` inside
-`src/server/rpc/<file>.ts` into a defineVerb call (server target) or a
+DELETE rpc helper. The bundler rewrites every `export const x = DELETE(fn)` inside
+`src/server/rpc/<file>.ts` into a defineRpc call (server target) or a
 remoteProxy stub (client target). Calling this directly throws.
 */
 // @documentation rpc
-export const DELETE: VerbHelper = (_fn: any, _opts?: any) => unprocessed('DELETE')
+export const DELETE: MutatingRpcHelper = (_fn: any, _opts?: any) => unprocessed('DELETE')

package/src/lib/server/GET.ts

@@ -1,10 +1,10 @@
-import type { VerbHelper } from './rpc/types/VerbHelper.ts'
+import type { RpcHelper } from './rpc/types/RpcHelper.ts'
 import { unprocessed } from './rpc/unprocessed.ts'
 
 /*
-GET verb helper. The bundler rewrites every `export const x = GET(fn)` inside
-`src/server/rpc/<file>.ts` into a defineVerb call (server target) or a
+GET rpc helper. The bundler rewrites every `export const x = GET(fn)` inside
+`src/server/rpc/<file>.ts` into a defineRpc call (server target) or a
 remoteProxy stub (client target). Calling this directly throws.
 */
 // @documentation rpc
-export const GET: VerbHelper = (_fn: any, _opts?: any) => unprocessed('GET')
+export const GET: RpcHelper = (_fn: any, _opts?: any) => unprocessed('GET')

package/src/lib/server/HEAD.ts

@@ -1,10 +1,10 @@
-import type { VerbHelper } from './rpc/types/VerbHelper.ts'
+import type { RpcHelper } from './rpc/types/RpcHelper.ts'
 import { unprocessed } from './rpc/unprocessed.ts'
 
 /*
-HEAD verb helper. The bundler rewrites every `export const x = HEAD(fn)` inside
-`src/server/rpc/<file>.ts` into a defineVerb call (server target) or a
+HEAD rpc helper. The bundler rewrites every `export const x = HEAD(fn)` inside
+`src/server/rpc/<file>.ts` into a defineRpc call (server target) or a
 remoteProxy stub (client target). Calling this directly throws.
 */
 // @documentation rpc
-export const HEAD: VerbHelper = (_fn: any, _opts?: any) => unprocessed('HEAD')
+export const HEAD: RpcHelper = (_fn: any, _opts?: any) => unprocessed('HEAD')

package/src/lib/server/PATCH.ts

@@ -1,10 +1,10 @@
-import type { VerbHelper } from './rpc/types/VerbHelper.ts'
+import type { MutatingRpcHelper } from './rpc/types/RpcHelper.ts'
 import { unprocessed } from './rpc/unprocessed.ts'
 
 /*
-PATCH verb helper. The bundler rewrites every `export const x = PATCH(fn)` inside
-`src/server/rpc/<file>.ts` into a defineVerb call (server target) or a
+PATCH rpc helper. The bundler rewrites every `export const x = PATCH(fn)` inside
+`src/server/rpc/<file>.ts` into a defineRpc call (server target) or a
 remoteProxy stub (client target). Calling this directly throws.
 */
 // @documentation rpc
-export const PATCH: VerbHelper = (_fn: any, _opts?: any) => unprocessed('PATCH')
+export const PATCH: MutatingRpcHelper = (_fn: any, _opts?: any) => unprocessed('PATCH')

package/src/lib/server/POST.ts

@@ -1,10 +1,10 @@
-import type { VerbHelper } from './rpc/types/VerbHelper.ts'
+import type { MutatingRpcHelper } from './rpc/types/RpcHelper.ts'
 import { unprocessed } from './rpc/unprocessed.ts'
 
 /*
-POST verb helper. The bundler rewrites every `export const x = POST(fn)` inside
-`src/server/rpc/<file>.ts` into a defineVerb call (server target) or a
+POST rpc helper. The bundler rewrites every `export const x = POST(fn)` inside
+`src/server/rpc/<file>.ts` into a defineRpc call (server target) or a
 remoteProxy stub (client target). Calling this directly throws.
 */
 // @documentation rpc
-export const POST: VerbHelper = (_fn: any, _opts?: any) => unprocessed('POST')
+export const POST: MutatingRpcHelper = (_fn: any, _opts?: any) => unprocessed('POST')

package/src/lib/server/PUT.ts

@@ -1,10 +1,10 @@
-import type { VerbHelper } from './rpc/types/VerbHelper.ts'
+import type { MutatingRpcHelper } from './rpc/types/RpcHelper.ts'
 import { unprocessed } from './rpc/unprocessed.ts'
 
 /*
-PUT verb helper. The bundler rewrites every `export const x = PUT(fn)` inside
-`src/server/rpc/<file>.ts` into a defineVerb call (server target) or a
+PUT rpc helper. The bundler rewrites every `export const x = PUT(fn)` inside
+`src/server/rpc/<file>.ts` into a defineRpc call (server target) or a
 remoteProxy stub (client target). Calling this directly throws.
 */
 // @documentation rpc
-export const PUT: VerbHelper = (_fn: any, _opts?: any) => unprocessed('PUT')
+export const PUT: MutatingRpcHelper = (_fn: any, _opts?: any) => unprocessed('PUT')