@abide/abide 0.124.1 → 0.125.0

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/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,
@@ -62,6 +66,7 @@ export {
     type ConfigOptions,
     type Env,
     fileRoute,
+    type Lane,
     middleware,
     onConfig,
     onError,
@@ -80,7 +85,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 +104,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

@@ -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`.
      *
@@ -134,6 +139,7 @@ export function mountedOwn(
             cli: false,
             mcp: false,
             description: undefined,
+            middleware: [],
             copy: undefined,
             defaults: undefined,
             args: undefined,

package/src/server/principal.ts

@@ -198,13 +198,14 @@ function resolvePrincipal(): Promise<Principal> {
 /**
  * This request's principal, resolved from `claims` as a sealed cookie's are, with no cookie written.
  *
- * 42.19 — `App.run`'s `principal`, which is why it throws where `principal.set` does.
+ * 42.19, 42.20 — `App.run`'s and `App.fetch`'s `principal`, which is why it throws where
+ * `principal.set` does.
  */
 export function presumePrincipal(claims: Record<string, unknown>): void {
     const scope = within('App.run principal')
     if (!isRecord(claims))
         throw new Error(
-            'abide: App.run takes a principal of claims, as principal.set does. RULEBOOK 26.11.',
+            'abide: App.run and App.fetch take a principal of claims, as principal.set does. RULEBOOK 26.11.',
         )
     const expires = Date.now() + ttl()
     scope.principal = documentOf(claims, expires)

package/src/server/render.ts

@@ -11,7 +11,7 @@ import type { ShareScope } from '#shared/reactive/share.ts'
 import { setUpLevels } from '#shared/setUpLevels.ts'
 
 import { buildDeferred } from './deferredBuilds.ts'
-import { currentRequestScope } from './requestScope.ts'
+import { currentRequestScope, inReleasedRender } from './requestScope.ts'
 
 /**
  * A compiled component, opaque to an app.
@@ -314,7 +314,16 @@ export function render(component: Component): Promise<Uint8Array<ArrayBuffer>> {
  * `render` into `given`: abide's own document with what the server adds to it — a page's client
  * tags, the launcher page's stylesheet. NOT PUBLIC SURFACE — `server/index.ts` exports `render`.
  */
-export async function renderDocument(
+export function renderDocument(
+    component: Component,
+    given: string,
+): Promise<Uint8Array<ArrayBuffer>> {
+    // 22.11 — a server's render whether or not a request is being served; 12.5 — and torn down once
+    // written where no request is.
+    return inReleasedRender(() => documentOf(component, given))
+}
+
+async function documentOf(
     component: Component,
     given: string,
 ): Promise<Uint8Array<ArrayBuffer>> {

package/src/server/requestScope.ts

@@ -125,8 +125,20 @@ const STORAGE = new AsyncLocalStorage<RequestScope | undefined>()
 // value is filed per request (11.32), and a server module builds values as it loads — the
 // principal's document here, an app's handlers ahead of `bootApp` in a compiled entry. Anything
 // that can enter a scope imports this module, so none is built before the provider is in.
+// 22.11 — A RENDER OUTSIDE EVERY REQUEST IS STILL A SERVER'S: `render` called bare, and `mount`'s
+// first half, which a test process runs beside a DOM and the browser half that hydrates it. Marked
+// apart from STORAGE so the render's values stay the ones 11.32 files outside a request. What it
+// holds is the render's stops (12.5): a request's are its scope's.
+const RENDERING = new AsyncLocalStorage<(() => void)[]>()
+
+/** The stops of the request or the render current, or `undefined` where neither is. */
+function currentStops(): (() => void)[] | undefined {
+    return STORAGE.getStore()?.stops ?? RENDERING.getStore()
+}
+
 SCOPING.provider = {
     current: (): Scope | undefined => STORAGE.getStore(),
+    serverStops: currentStops,
     run: (scope, body, given) =>
         STORAGE.run(scope as RequestScope | undefined, body, given),
 }
@@ -179,6 +191,21 @@ export function inScope<Result>(
     return STORAGE.run(scopeFor(given, given, undefined), body)
 }
 
+/**
+ * Runs `body` as a server's render, stopping every watch it opened once it has settled.
+ *
+ * 12.5 — A RENDER OUTSIDE EVERY REQUEST IS TORN DOWN as a request's scope is, once its document is
+ * written. Inside a request or a render already open, the watches are that one's to stop.
+ */
+export function inReleasedRender<Result>(
+    body: () => Promise<Result>,
+): Promise<Result> {
+    // A REQUEST'S PAGE PAYS NOTHING HERE — no wrapping promise, no tick — as its scope stops them.
+    if (currentStops() !== undefined) return body()
+    const stops: (() => void)[] = []
+    return RENDERING.run(stops, body).finally(() => stopAll(stops))
+}
+
 /** Runs `body` in `scope`, which `scopeFor` opened, and returns what it returned. */
 export function inOpenScope<Result>(
     scope: RequestScope,
@@ -261,7 +288,11 @@ export function releaseScope(scope: RequestScope): void {
         scope.unreaped = false
         LISTENING.timeout(scope.received as Request, IDLE_TIMEOUT_SECONDS)
     }
-    const stops = scope.stops
+    stopAll(scope.stops)
+}
+
+/** Runs and drops every stop in `stops`. 12.5. */
+function stopAll(stops: (() => void)[]): void {
     for (let at = 0; at < stops.length; at += 1) (stops[at] as () => void)()
     stops.length = 0
 }
@@ -433,6 +464,35 @@ export function response(): { status: number; headers: Headers } {
     return scope.response
 }
 
+/** Where a request came from: a peer's address, `null` where the listener names none. */
+export type ReceivedFrom = {
+    address: string
+    family: 'IPv4' | 'IPv6'
+    port: number
+} | null
+
+/**
+ * The peer each request a listener received came from, keyed by the request it handed the app.
+ *
+ * 22.12 — FILED BY THE LISTENER: `App.listen` files what bun names, and `abide dev`'s worker what its
+ * listener sent beside the request (38.14). A request nobody filed was made in process.
+ */
+export const RECEIVED_FROM = new WeakMap<Request, ReceivedFrom>()
+
+/**
+ * The address the request being served came from, or `'in-process'` for one no listener received.
+ *
+ * 22.12, 22.13 — the same under `abide start`, `abide dev` and `App.listen`; `null` where the
+ * listener names no peer, as a unix socket does. A socket mux frame answers its upgrade's.
+ */
+export function requestIP(): ReceivedFrom | 'in-process' {
+    const scope = within('requestIP')
+    const asked = (scope.received ?? scope.request) as Request
+    return RECEIVED_FROM.has(asked)
+        ? (RECEIVED_FROM.get(asked) as ReceivedFrom)
+        : 'in-process'
+}
+
 /**
  * The listening server.
  *

package/src/server/responseRelay.ts

@@ -6,6 +6,7 @@
 // What `serveDev` and `devWorker` keep is the processes and the sockets.
 
 import { plainAnswer } from './plainAnswer.ts'
+import type { ReceivedFrom } from './requestScope.ts'
 
 /** One direction of the line between the halves: bun's IPC in `abide dev`, a pair of queues in a test. */
 export type Channel<Message> = { postMessage(message: Message): void }
@@ -17,6 +18,8 @@ export type Ask = {
     url: string
     headers: [string, string][]
     body: ArrayBuffer | null
+    /** 22.12 — the peer the listener received it from. */
+    from: ReceivedFrom
 }
 
 /** What the listener's half sends: a request, and a pull or cancel of its body. */
@@ -62,7 +65,7 @@ export function describe(thrown: unknown): string {
 export function serveOver(
     channel: Channel<FromRelay>,
     answering: {
-        fetch(request: Request): Promise<Response>
+        fetch(request: Request, from: ReceivedFrom): Promise<Response>
         /** 37.3 — whether the answer admits the request to the mux. */
         admits(request: Request, response: Response): boolean
         /** The answer to a throw out of `fetch`, which is an answer and not a dropped message. */
@@ -107,7 +110,7 @@ export function serveOver(
         asks.set(request, ask.id)
         let response: Response
         try {
-            response = await answering.fetch(request)
+            response = await answering.fetch(request, ask.from)
         } catch (thrown) {
             response = answering.failed(describe(thrown))
         }
@@ -207,6 +210,7 @@ type InFlight = {
     request: Request
     headers: [string, string][]
     body: ArrayBuffer | null
+    from: ReceivedFrom
     settle: (response: Response) => void
     asked: Channel<ToRelay> | undefined
     stream: ReadableStreamDefaultController<Uint8Array> | null
@@ -252,6 +256,7 @@ export function askOver(
             url: waiting.request.url,
             headers: waiting.headers,
             body: waiting.body,
+            from: waiting.from,
         })
     }
 
@@ -310,7 +315,7 @@ export function askOver(
          * what the worker rebuilds one from — and the body is collected ONCE, HERE, which is what lets
          * it be asked again of a replacement (38.24): a body can only be read off a `Request` once.
          */
-        async ask(request: Request): Promise<Response> {
+        async ask(request: Request, from: ReceivedFrom): Promise<Response> {
             const body =
                 request.body === null ? null : await request.arrayBuffer()
             return await new Promise<Response>((settle) => {
@@ -318,6 +323,7 @@ export function askOver(
                     request,
                     headers: identityOnly(request.headers),
                     body,
+                    from,
                     settle,
                     asked: undefined,
                     stream: null,