@abide/abide 0.124.1 → 0.125.1

package/src/server/claudeCode.ts

@@ -8,17 +8,15 @@
 // directory, settings — is not an option here at all, and its built-in `tools` are a request the visitor
 // grants or does not: the bridge decides (44.15, 44.16, 44.29).
 
+import type {
+    AssistantContent,
+    AssistantMessage,
+} from '#shared/AssistantEvent.ts'
 import { BRIDGE_SCHEME } from '#shared/BRIDGE_SCHEME.ts'
 import { mounted } from '#shared/mount.ts'
 import { refuse } from '#shared/refuse.ts'
 
-import {
-    type AssistantContent,
-    type AssistantMessage,
-    blocksOf,
-    forwardOf,
-    type Provider,
-} from './assistant.ts'
+import { blocksOf, forwardOf, type Provider } from './assistant.ts'
 import { BRIDGE_VERSION } from './BRIDGE_VERSION.ts'
 import { mintCode, pairingStatus, runTurn } from './bridgeRelay.ts'
 import { callerOf } from './callerOf.ts'
@@ -45,12 +43,13 @@ type PairingOptions = Pick<ClaudeCodeConfig, 'tools'>
 
 /**
  * Whether this browser's bridge is connected, and the command and the link that pair one where it is
- * not.
+ * not, with the command that installs the app the link opens.
  */
 export type BridgeStatus = {
     paired: boolean
     command: string | undefined
     link: string | undefined
+    install: string | undefined
 }
 
 /** The visitor's own Claude Code, reached through the bridge paired to their browser. */
@@ -123,17 +122,21 @@ function askingCaller(): string {
 function bridgeCommand(options: PairingOptions = {}): {
     command: string
     link: string
+    install: string
     expires: number
 } {
     const { code, expires } = mintCode(askingCaller(), signedInAs())
     return { ...commandFor(code, options), expires }
 }
 
-/** The command and the link that pair a bridge by `code`, granting `tools`. */
+/**
+ * The command and the link that pair a bridge by `code`, granting `tools`, and the command that
+ * installs the app the link opens — of the release the command runs, 44.56.
+ */
 function commandFor(
     code: string,
     { tools }: PairingOptions,
-): { command: string; link: string } {
+): { command: string; link: string; install: string } {
     const site = `${appOrigin() ?? new URL(request().url).origin}${mounted('')}`
     const granted = tools?.length ? tools.join(',') : undefined
     const query = new URLSearchParams({ site, code, version: BRIDGE_VERSION })
@@ -142,6 +145,7 @@ function commandFor(
     return {
         command: `bunx @abide/bridge@${BRIDGE_VERSION} ${site} ${code}${grant}`,
         link: `${BRIDGE_SCHEME}://pair?${query}`,
+        install: `bunx @abide/bridge@${BRIDGE_VERSION} install`,
     }
 }
 
@@ -159,7 +163,12 @@ async function* bridge(
         request().signal,
     ))
         yield code === undefined
-            ? { paired: true, command: undefined, link: undefined }
+            ? {
+                  paired: true,
+                  command: undefined,
+                  link: undefined,
+                  install: undefined,
+              }
             : { paired: false, ...commandFor(code, options) }
 }
 

package/src/server/commands.ts

@@ -245,10 +245,11 @@ function usage(host: Host, commands: Row[]): string {
             text += `  ${command.padEnd(width)}  ${meaning}\n`
     if (!sourced)
         return `${text}
-  --port     the listen port the app is served on
-  --url      the running app the shell, call, watch, openapi and mcp talk to
-  --method   the method call sends, where the handler answers more than one
-  --version  the version of this executable's app
+  --port      the listen port the app is served on
+  --hostname  the interface it listens on — every one where none is named
+  --url       the running app the shell, call, watch, openapi and mcp talk to
+  --method    the method call sends, where the handler answers more than one
+  --version   the version of this executable's app
 `
     text += `
   --root       the app's source directory, where its pages sit —
@@ -256,6 +257,7 @@ function usage(host: Host, commands: Row[]): string {
   --out        where the build goes, beside the app by default; the file compile and
                bundle write — named after the app, where you stand
   --port       the listen port for dev, start and the shell's app
+  --hostname   the interface they listen on — every one where none is named
   --url        the running app the shell, call, watch, openapi and mcp talk to
   --target     the platform compile builds for — linux-x64, darwin-arm64, windows-x64…
   --platforms  several of them, comma-separated, one executable each
@@ -291,6 +293,8 @@ function parseFlags(argv: string[]) {
             // `PORT` and then falls back to 3000 — `abide dev` scanning on from there, 38.63 — and
             // a default written here would take that away from every host that sets it.
             port: { type: 'string' },
+            // NO DEFAULT EITHER: `Bun.serve` given none binds every interface (38.136).
+            hostname: { type: 'string' },
             url: { type: 'string' },
             method: { type: 'string' },
             target: { type: 'string' },
@@ -321,14 +325,17 @@ async function served(
     process.env.NODE_ENV ??= 'production'
     const booted = await booting(host, app, given)
     if (typeof booted === 'number') return booted
-    const port = given.values.port
-    await booted.listen(port === undefined ? {} : { port: Number(port) })
+    const { port, hostname } = given.values
+    await booted.listen({
+        ...(port === undefined ? {} : { port: Number(port) }),
+        ...(hostname === undefined ? {} : { hostname }),
+    })
     stopOnSignalOrFault(booted)
     const server = LISTENING.server as Bun.Server<unknown>
     return {
         app: booted,
         url: withoutTrailingSlash(server.url.href),
-        heading: banner(host.name, 'start', app.package, server),
+        heading: banner(host.name, 'start', app.package, server, hostname),
     }
 }
 

package/src/server/createApp.ts

@@ -17,7 +17,7 @@ import { PRINCIPAL_HEADER } from '#shared/PRINCIPAL_HEADER.ts'
 import { RPC_SERVER } from '#shared/RPC_SERVER.ts'
 
 import { laneFailure } from './answerFailure.ts'
-import { answerRequest, type AppSources } from './answerRequest.ts'
+import { answerRequest, type AppSources, laneOf } from './answerRequest.ts'
 import { Mux, type MuxConnection } from './answerSocket.ts'
 import {
     type Builder,
@@ -26,6 +26,7 @@ import {
     spawnedBuild,
 } from './appBuild.ts'
 import { holdsApp } from './appTree.ts'
+import { presumeCaller } from './callerOf.ts'
 import {
     APP_PACKAGE,
     type AppPackage,
@@ -35,7 +36,14 @@ import {
 } from './config.ts'
 import { Followers } from './Followers.ts'
 import { McpSurface } from './generatedSurfaces.ts'
-import { HOOKS, inOrder, reportUnexpected, rootRungs } from './hooks.ts'
+import {
+    type AppContext,
+    HOOKS,
+    inOrder,
+    type Lane,
+    reportUnexpected,
+    rootRungs,
+} from './hooks.ts'
 import { IDLE_TIMEOUT_SECONDS } from './IDLE_TIMEOUT_SECONDS.ts'
 import { installServer } from './installServer.ts'
 import { followedIn, type Mount } from './mountHandlers.ts'
@@ -51,6 +59,7 @@ import {
     holdScope,
     inReleasedScope,
     LISTENING,
+    RECEIVED_FROM,
     rungsTook,
     serverTiming,
 } from './requestScope.ts'
@@ -65,12 +74,15 @@ const REQUEST_LOG = namedLogger('abide:request')
 // by it.
 const STOP_TIMEOUT = 5000
 
+/** Who a scope `App.run` or `App.fetch` opens is answered as, over what its request's cookies say. */
+type Presumed = { principal?: Record<string, unknown>; caller?: string }
+
 /** The app object: what a host, a test or a script holds the app as. */
 export interface App {
-    fetch(request: Request): Promise<Response>
+    fetch(request: Request, options?: Presumed): Promise<Response>
     run<Result>(
         fn: () => Result | Promise<Result>,
-        options?: { request?: Request; principal?: Record<string, unknown> },
+        options?: { request?: Request } & Presumed,
     ): Promise<Result>
     listen(options?: {
         port?: number
@@ -247,8 +259,15 @@ export async function bootEntered(
     // route's rungs, the ones below it running after routing (37.2, `answerRequest`). 21.20 — the
     // center takes its own time back out of what `fetch` counts for the whole onion.
     // 37.14 — before routing, the lane is the request's to say (15.22).
-    const rungs = rootRungs((failure, request) =>
-        laneFailure(booted, new URL(request.url).pathname, failure, request),
+    const rungs = rootRungs(
+        (failure, request) =>
+            laneFailure(
+                booted,
+                new URL(request.url).pathname,
+                failure,
+                request,
+            ),
+        (request) => laneOf(booted, request),
     )
     const answer = compose(rungs, async ({ request }) => {
         const began = performance.now()
@@ -265,23 +284,32 @@ export async function bootEntered(
     let stopping = false
     let bound: Bun.Server<unknown> | undefined
 
+    // 42.19, 42.20, 42.21 — inside the scope, ahead of anything that reads either.
+    const presume = (options: Presumed | undefined): void => {
+        if (options?.principal !== undefined)
+            presumePrincipal(options.principal)
+        if (options?.caller !== undefined) presumeCaller(options.caller)
+    }
+
     const run: App['run'] = async (fn, options) => {
-        const claims = options?.principal
-        // 42.19 — a principal is a request's, so one given alone is given a request to be.
+        // 42.19, 42.21 — a principal or a caller is a request's, so one given alone is given a request
+        // to be.
         const request =
             options?.request ??
-            (claims === undefined ? undefined : new Request(IN_PROCESS_ORIGIN))
+            (options?.principal === undefined && options?.caller === undefined
+                ? undefined
+                : new Request(IN_PROCESS_ORIGIN))
         return inReleasedScope(
             request,
             async () => {
-                if (claims !== undefined) presumePrincipal(claims)
+                presume(options)
                 return await fn()
             },
             answering,
         )
     }
 
-    const fetch = async (given: Request): Promise<Response> => {
+    const fetch: App['fetch'] = async (given, options) => {
         if (stopping) return plainAnswer('the app is stopping', 503)
         const request = belowMount(given)
         if (request instanceof Response) return request
@@ -294,9 +322,12 @@ export async function bootEntered(
             return await inReleasedScope(
                 request,
                 async () => {
+                    presume(options)
                     let answered: Response
                     try {
-                        answered = await answer({ request })
+                        answered = await answer(
+                            new RootContext(booted, request),
+                        )
                         if (rungs.length > 0)
                             rungsTook(performance.now() - started)
                     } catch (thrown) {
@@ -431,6 +462,8 @@ export async function bootEntered(
                 maxRequestBodySize: Number.MAX_SAFE_INTEGER,
                 // 18.1, 37.3 — THE ONE MUX, upgraded where the app lane admitted it.
                 fetch: async (request, server) => {
+                    // 22.12 — where it came from, for `requestIP` to answer.
+                    RECEIVED_FROM.set(request, server.requestIP(request))
                     const answered = await fetch(request)
                     return admitsMux(request, answered, booted)
                         ? upgraded(server, request, {
@@ -465,6 +498,26 @@ export async function bootEntered(
     }
 }
 
+/**
+ * What a root rung is handed: the request, and what answers it, asked on the first read.
+ *
+ * 37.19 — LAZILY, because routing a request twice is a cost only an app whose root rungs read the
+ * lane pays: the dispatch routes it again after them, and an app with none reads nothing here.
+ */
+class RootContext implements AppContext {
+    readonly request: Request
+    #sources: AppSources
+    #lane: Lane | undefined = undefined
+    constructor(sources: AppSources, request: Request) {
+        this.#sources = sources
+        this.request = request
+    }
+    get lane(): Lane {
+        this.#lane ??= laneOf(this.#sources, this.request)
+        return this.#lane
+    }
+}
+
 /**
  * The answer with the headers every answer carries, and what was written through `response`.
  *

package/src/server/devWorker.ts

@@ -35,7 +35,7 @@ import { bootApp, type BootedApp } from './createApp.ts'
 import { keepServing } from './faultPolicy.ts'
 import { type Manifest, NO_MANIFEST } from './manifestOf.ts'
 import { admitsMux, muxSocketOptions } from './muxUpgrade.ts'
-import { LISTENING } from './requestScope.ts'
+import { LISTENING, RECEIVED_FROM, type ReceivedFrom } from './requestScope.ts'
 import {
     describe,
     type FromRelay,
@@ -70,6 +70,7 @@ export type ToWorker =
           connection: number
           url: string
           headers: [string, string][]
+          from: ReceivedFrom
       }
     | { kind: 'socket-message'; connection: number; text: string }
     | { kind: 'socket-close'; connection: number }
@@ -113,7 +114,9 @@ let failure = ''
 const relay = serveOver(
     { postMessage: toListener },
     {
-        async fetch(request) {
+        async fetch(request, from) {
+            // 22.12 — where the listener received it from, which is not this process.
+            RECEIVED_FROM.set(request, from)
             await opening
             return app === undefined
                 ? failedDocument(failure)
@@ -161,21 +164,20 @@ async function receive(message: ToWorker): Promise<void> {
     await opening
     if (message.kind === 'socket-open') {
         const numbered = message.connection
-        const connection = mux?.connect(
-            new Request(message.url, { headers: message.headers }),
-            {
-                send(text: string) {
-                    toListener({
-                        kind: 'socket-send',
-                        connection: numbered,
-                        text,
-                    })
-                },
-                // NOTHING TO CLOSE: the listener holds the browser's socket, and it outlives this
-                // worker (38.14). Nothing here stops the mux, either.
-                close() {},
+        const upgrade = new Request(message.url, { headers: message.headers })
+        RECEIVED_FROM.set(upgrade, message.from)
+        const connection = mux?.connect(upgrade, {
+            send(text: string) {
+                toListener({
+                    kind: 'socket-send',
+                    connection: numbered,
+                    text,
+                })
             },
-        )
+            // NOTHING TO CLOSE: the listener holds the browser's socket, and it outlives this
+            // worker (38.14). Nothing here stops the mux, either.
+            close() {},
+        })
         if (connection !== undefined) connections.set(numbered, connection)
         return
     }

package/src/server/faceOf.ts

@@ -43,10 +43,12 @@ export type Asked =
 
 /**
  * One handler file, as `Compilation.handlers` holds it — and 19.9's schema its default's annotation
- * derives, which the module at the file's path holds it to (`derivedArgs`).
+ * derives, which the module at the file's path holds it to (`derivedArgs`), and the address it is
+ * stamped with on load (16.2).
  */
 export type HandlerFace = {
     scope: string
+    address: string
     client: string
     args: JsonValue | undefined
 }

package/src/server/generatedSurfaces.ts

@@ -15,6 +15,7 @@
 
 import { isFailed } from '#shared/Failed.ts'
 import { essenceOf } from '#shared/framing.ts'
+import { IMAGE_TYPES } from '#shared/IMAGE_TYPES.ts'
 import { namedLogger } from '#shared/log.ts'
 import { mounted } from '#shared/mount.ts'
 import { type Reactive, reactive } from '#shared/reactive/index.ts'
@@ -26,7 +27,6 @@ import { bodyWithin } from './answerRpc.ts'
 import type { ToolAnswer, ToolDefinition } from './assistant.ts'
 import { appIdentity } from './config.ts'
 import { crossingOrigin, crossingRefusal } from './crossingOrigin.ts'
-import { IMAGE_TYPES } from './IMAGE_TYPES.ts'
 import { MCP_PROTOCOL_VERSION } from './MCP_PROTOCOL_VERSION.ts'
 import type { Mounted } from './mountHandlers.ts'
 import { type Listed, surfaceOf } from './surfaceOf.ts'
@@ -326,7 +326,7 @@ export class McpSurface {
 
     /** What calling the tool `name` as `asker` answered, a refusal or a missing tool a failed one. */
     call(name: string, args: unknown, asker: Request): Promise<ToolAnswer> {
-        const tool = this.#tool(name)
+        const tool = this.tool(name)
         if (tool === undefined) {
             logCall(String(name), 404, undefined)
             return Promise.resolve({
@@ -337,12 +337,13 @@ export class McpSurface {
         return this.#called(tool, args as Record<string, unknown>, asker)
     }
 
-    #tool(name: unknown): Published | undefined {
+    /** The tool it lists as `name`, or `undefined` where it lists none. */
+    tool(name: unknown): Listed | undefined {
         return this.#published().find((one) => one.name === name)
     }
 
     async #called(
-        one: Published,
+        one: Listed,
         args: Record<string, unknown> | undefined,
         asker: Request,
     ): Promise<ToolAnswer> {
@@ -416,7 +417,7 @@ export class McpSurface {
             case 'tools/list':
                 return { result: { tools: this.list() } }
             case 'tools/call': {
-                const tool = this.#tool(params?.name)
+                const tool = this.tool(params?.name)
                 if (tool === undefined) {
                     logCall(String(params?.name), 404, undefined)
                     return mcpFailure(

package/src/server/handlerFileMount.ts

@@ -13,6 +13,7 @@ export function handlerFileMount(
         | 'cli'
         | 'mcp'
         | 'description'
+        | 'middleware'
         | 'copy'
         | 'defaults'
         | 'args'
@@ -32,6 +33,7 @@ export function handlerFileMount(
         cli: declared.cli,
         mcp: declared.mcp,
         description: declared.description,
+        middleware: declared.middleware,
         copy: declared.copy,
         defaults: declared.defaults,
         args: declared.args,

package/src/server/hooks.ts

@@ -26,11 +26,29 @@ import { config } from './config.ts'
 import type { LauncherOptions } from './launcherOptions.ts'
 import { currentRequestScope } from './requestScope.ts'
 
-type AppContext = { request: Request }
+/**
+ * What answers a request, by the lane the app sends it down. 37.19.
+ *
+ * One per arm of `answerRequest`'s dispatch: a page (and every address no route answers), a
+ * handler, a public file, the three surfaces of abide's own a gate decides about one by one, the
+ * socket mux's upgrade, and the rest of `/__abide`.
+ */
+export type Lane =
+    | 'page'
+    | 'handler'
+    | 'file'
+    | 'openapi'
+    | 'mcp'
+    | 'bridge'
+    | 'socket'
+    | 'abide'
+
+/** What an app rung is handed: the request, and what answers it (37.19). */
+export type AppContext = { request: Request; lane: Lane }
 
 /** A rung `middleware` files: what `next` answered passed on, or a refusal in its place (37.14). */
 export type AppRung = (
-    next: (ctx?: AppContext) => Promise<Response>,
+    next: (ctx?: { request: Request }) => Promise<Response>,
     ctx: AppContext,
 ) =>
     | Response
@@ -130,18 +148,46 @@ export function inOrder<T>(list: readonly Filed<T>[]): T[] {
  * 37.14, 37.15 — PER LINK, not at the onion's edge: a rung outside this one is handed the answer
  * from `next`, so one that reads a `Response` (29.2's) reads one whichever rung inside it refused.
  */
-function answering(rung: AppRung, answer: RefusalAnswer): LaneRung {
+function answering(
+    rung: AppRung,
+    answer: RefusalAnswer,
+    laneOf: ((request: Request) => Lane) | undefined,
+): LaneRung {
     return async (next, ctx) => {
-        const result = await rung(next, ctx)
+        // 37.19 — A REQUEST A RUNG HANDS `next` IS ANSWERED BY WHAT ITS OWN ADDRESS ROUTES TO, asked
+        // again before routing (`laneOf`) and kept after it, where routing has already chosen.
+        const result = await rung(
+            (given) =>
+                next(
+                    given === undefined || given.request === ctx.request
+                        ? ctx
+                        : {
+                              request: given.request,
+                              lane:
+                                  laneOf === undefined
+                                      ? ctx.lane
+                                      : laneOf(given.request),
+                          },
+                ),
+            ctx,
+        )
         return isFailed(result) ? answer(result, ctx.request) : result
     }
 }
 
-/** The rungs filed at the root route, which run before routing. 37.3. */
-export function rootRungs(answer: RefusalAnswer): LaneRung[] {
+/**
+ * The rungs filed at the root route, which run before routing. 37.3.
+ *
+ * `laneOf` is what the dispatch would answer a request with (37.19), asked of one a rung hands on.
+ */
+export function rootRungs(
+    answer: RefusalAnswer,
+    laneOf: (request: Request) => Lane,
+): LaneRung[] {
     const rungs: LaneRung[] = []
     for (const entry of HOOKS.rungs)
-        if (entry.route === ROOT) rungs.push(answering(entry.item, answer))
+        if (entry.route === ROOT)
+            rungs.push(answering(entry.item, answer, laneOf))
     return rungs
 }
 
@@ -156,7 +202,7 @@ export function rungsOver(route: string, answer: RefusalAnswer): LaneRung[] {
     const rungs: LaneRung[] = []
     for (const entry of HOOKS.rungs)
         if (entry.route !== ROOT && coversRoute(entry.segments, segments))
-            rungs.push(answering(entry.item, answer))
+            rungs.push(answering(entry.item, answer, undefined))
     return rungs
 }
 

package/src/server/index.ts

@@ -26,13 +26,17 @@ export {
     type RpcOptions,
 } from '#shared/rpc.ts'
 // 45 — a conversation with a model, piped through a handler, and the two providers abide ships.
+// 44 — what a page sends and is handed back, which the isomorphic entry carries too.
+export type {
+    AssistantContent,
+    AssistantEvent,
+    AssistantMessage,
+} from '#shared/AssistantEvent.ts'
 export {
-    type AssistantContent,
-    type AssistantEvent,
-    type AssistantMessage,
     type AssistantOptions,
     assistant,
     type Provider,
+    type ProviderEvent,
     type ToolAnswer,
     type Toolbox,
     type ToolDefinition,
@@ -52,6 +56,9 @@ export { type App, createApp } from './createApp.ts'
 // 41.28's run-time half: an emitted component reads it on either side of its setup, and one whose
 // setup made a call answers as a page does. Not an app's name.
 export { callsInRender } from './PageRender.ts'
+// 16.88's run-time half: what the module a handler file is loaded through calls to give it its
+// address. Not an app's name.
+export { addressed } from './addressed.ts'
 // 19.9's run-time half: what the module a handler is loaded through calls to hold it to the schema
 // its annotation derives (15.8). Not an app's name.
 export { derivedArgs } from './argsContract.ts'
@@ -62,6 +69,7 @@ export {
     type ConfigOptions,
     type Env,
     fileRoute,
+    type Lane,
     middleware,
     onConfig,
     onError,
@@ -80,7 +88,14 @@ export { type Component, render } from './render.ts'
 // child's markup one thing for the client to walk to.
 export { renderComponent } from './renderComponent.ts'
 // 22.1 — the request being served, the response being built for it, and the listening server.
-export { request, response, server } from './requestScope.ts'
+// 22.12 — and where it came from.
+export {
+    type ReceivedFrom,
+    request,
+    requestIP,
+    response,
+    server,
+} from './requestScope.ts'
 // 17 — the response helpers, each a write through `response`.
 export {
     bytes,
@@ -92,6 +107,8 @@ export {
     sse,
     type Values,
 } from './responseHelpers.ts'
+// 8.25 — a `Store` in a `bun:sqlite` table.
+export { sqliteStore } from './sqliteStore.ts'
 // 24 — the trace this work belongs to.
 export { trace } from './trace.ts'
 

package/src/server/invokeHandler.ts

@@ -222,7 +222,7 @@ async function routeAdmits(
         const answered = await compose(mounted.rungs, async () => {
             reached = true
             return new Response(null, { status: 204 })
-        })({ request })
+        })({ request, lane: 'handler' })
         return reached && answered.ok
     } catch {
         return false

package/src/server/mountHandlers.ts

@@ -3,11 +3,11 @@
 
 import type { CopyOptions } from '#shared/CopyOptions.ts'
 import type { JsonValue } from '#shared/JsonValue.ts'
-import { mounted as underMount } from '#shared/mount.ts'
 import type { Gated, HeldToAnnotation } from '#shared/reactive/argsContract.ts'
 import type { Defaults } from '#shared/reactive/parameterDefaults.ts'
 import type { Method, Rpc } from '#shared/rpc.ts'
 
+import { addressed } from './addressed.ts'
 import { answered } from './answerFailure.ts'
 import { derivedArgs } from './argsContract.ts'
 import { type LaneRung, rungsOver } from './hooks.ts'
@@ -44,6 +44,11 @@ export type Mount = {
     mcp: boolean
     /** Its `description`, where the declaration writes one as a literal the build can read. */
     description: string | undefined
+    /**
+     * The rung each entry of its declaration's `middleware` names, as written; `null` where the
+     * options are not written where the build can read them. 38.135.
+     */
+    middleware: string[] | null
     /**
      * What a `GET`'s value declares that the browser's copy behaves by, or `undefined`.
      *
@@ -111,11 +116,7 @@ export function mountedOwn(
     name: string,
     handler: object,
 ): [string, Mounted] {
-    // 16.10 — READ WHEN IT IS REPORTED, where a mounted handler's is stamped at boot: the mount is
-    // the configuration's, and nothing boots this handler.
-    Object.defineProperty(handler, 'address', {
-        get: () => underMount(address),
-    })
+    addressed(handler, address)
     return [
         address,
         {
@@ -134,6 +135,7 @@ export function mountedOwn(
             cli: false,
             mcp: false,
             description: undefined,
+            middleware: [],
             copy: undefined,
             defaults: undefined,
             args: undefined,
@@ -162,7 +164,7 @@ export async function mountHandlers(
         const handler = exported as Mounted['handler']
         // 16.9, 16.10 — the address `rpc.url` and `rpc.raw` build on, under the mount — and what a
         // page's render turns a call it made into the browser's request by (41.20).
-        handler.address = underMount(mount.address)
+        addressed(handler, mount.address)
         // 19.9 — the schema the build derived off its annotation, for a handler whose module did not
         // file it on load: a bundled executable's faces carry no `derivedArgs` call.
         if (mount.args !== undefined) derivedArgs(handler, mount.args)