@abide/abide 0.121.1 → 0.123.0

package/src/compiler/readsIn.ts

@@ -246,27 +246,22 @@ export async function readsIn(
             )
         }),
     )
+    const owned = await ownMembers(checker, nodes.flat(), (node) =>
+        valueTypeOf(checker, node),
+    )
     const holding: Promise<void>[] = []
     const located: { node: Node; read: Read }[] = []
     for (let index = 0; index < nodes.length; index += 1)
         for (const node of nodes[index] as (Node | undefined)[]) {
             if (node === undefined) continue
-            const read = classifyRead(node)
+            const read = classifyRead(node, owned.has(node))
             if (read === undefined) continue
             read.byValue = byValue[index] as boolean
             read.local = index >= topLevel
             reads.push(read)
             located.push({ node, read })
             if (read.shape === 'value')
-                holding.push(
-                    declaredType(checker, node).then(async (type) => {
-                        if (
-                            type !== undefined &&
-                            (await isReactiveType(checker, abide, type, true))
-                        )
-                            read.shape = 'asWritten'
-                    }),
-                )
+                holding.push(holdIn(checker, abide, node, read))
         }
     await Promise.all(holding)
     await props
@@ -392,7 +387,7 @@ async function bindingsOfReads(
  * The tracking and type warnings a file's reactive reads earn.
  *
  * The syntax alone decides 14.14 to 14.16 (`trackingWarnings`);
- * 14.17 and 31.13 ask what a read hands back, which is the return of the `Reactive`'s call.
+ * 14.17 asks what a read hands back, which is the return of the `Reactive`'s call.
  */
 async function warningsFor(
     checker: Checker,
@@ -424,45 +419,16 @@ async function warningsFor(
             isBinaryExpression(parent) &&
             parent.left === node &&
             parent.operatorToken.kind === SyntaxKind.QuestionQuestionToken
-        const member =
-            isPropertyAccessExpression(parent) &&
-            parent.expression === node &&
-            isIdentifier(parent.name) &&
-            REACTIVE_MEMBERS.has(parent.name.text)
-                ? parent.name.text
-                : undefined
-        if (!nullish && member === undefined) continue
+        if (!nullish) continue
         typed.push(
             valueTypeOf(checker, node).then(async (value) => {
-                if (value === undefined) return
                 // 14.17 — the fallback of a read that is never nullish is never taken: an unlanded
                 // read is a hole the position fills, not an `undefined` (2.2).
-                if (nullish && !(await admitsNullish(value)))
+                if (value !== undefined && !(await admitsNullish(value)))
                     warnings.push({
                         at: read.start,
                         message: `abide: \`${name} ?? …\` never takes its fallback — a read of \`${name}\` is not undefined while it loads, and its type says it is not undefined after. Ask \`${name}.ready()\` to tell the two apart. RULEBOOK 14.17.`,
                     })
-                if (member === undefined) return
-                // Per member, because a union's properties are only those every member shares, and
-                // `undefined` shares none — so `HTMLVideoElement | undefined` would declare no `error`.
-                for (const held of await unionMembers(value)) {
-                    if ((held.flags & NULLISH) !== 0) continue
-                    for (const property of await checker.getPropertiesOfType(
-                        held,
-                    ))
-                        if (property.name === member) {
-                            const dot = (
-                                parent as { questionDotToken?: unknown }
-                            ).questionDotToken
-                                ? '?.'
-                                : '.'
-                            warnings.push({
-                                at: read.start,
-                                message: `abide: \`${name}${dot}${member}\` reaches the Reactive's own \`${member}\`, and the value it holds has one too. Write \`${name}()${dot}${member}\` for the value's. RULEBOOK 31.13.`,
-                            })
-                            return
-                        }
-                }
             }),
         )
     }
@@ -779,7 +745,7 @@ function valueLeaves(node: Node, leaves: Node[]): void {
 const ROUTE_MEMBERS = new Set(['url', 'params', 'name', 'navigating'])
 
 /**
- * 31.16 — `route`'s four values, each read by name as a name bound to a `Reactive` is.
+ * 31.15 — `route`'s four values, each read by name as a name bound to a `Reactive` is.
  *
  * `route.params.id` reads `route.params().id`, and the explicit call keeps compiling (31.7). Told
  * by the symbol, as `props` is, so an app's own `route` is not abide's.
@@ -1142,13 +1108,18 @@ async function propsReads(
                   ),
         ),
     )
+    const owned = await ownMembers(checker, found.flat(), (node) =>
+        checker.getTypeAtLocation(node),
+    )
+    // 33.27 — each prop asked whether its position holds the `Reactive`, all at once.
+    const holding: Promise<void>[] = []
     for (let at = 0; at < found.length; at += 1) {
         const binding = bindings[at] as (typeof bindings)[number]
         if (binding.rest) {
             restReads(found[at] as (Node | undefined)[], reads)
             continue
         }
-        const uses: Read[] = []
+        const uses: { node: Node; read: Read }[] = []
         let written = false
         for (const node of found[at] as (Node | undefined)[]) {
             // The binding itself is the pattern's, and not a use of the name.
@@ -1157,15 +1128,16 @@ async function propsReads(
                 node.parent?.kind === SyntaxKind.BindingElement
             )
                 continue
-            const read = classifyRead(node)
+            const read = classifyRead(node, owned.has(node))
             if (read === undefined) continue
             if (
                 read.shape === 'write' ||
                 read.shape === 'update' ||
-                isBindOperand(positions, node)
+                isBindOperand(positions, node) ||
+                writesThrough(node, owned)
             )
                 written = true
-            uses.push(read)
+            uses.push({ node, read })
         }
         if (!written) {
             for (const node of found[at] as (Node | undefined)[]) {
@@ -1173,18 +1145,141 @@ async function propsReads(
                 const read = classifyPropRead(node)
                 if (read === undefined) continue
                 read.local = binding.local
-                reads.push(read)
+                if (read.shape !== 'value') {
+                    reads.push(read)
+                    continue
+                }
+                holding.push(
+                    holdsProp(checker, abide, node, owned.has(node)).then(
+                        (held) => {
+                            if (!held) return void reads.push(read)
+                            // Classified as a page's own name is, reaching a cell over the accessor.
+                            const asHeld = classifyRead(node) as Read
+                            if (asHeld.shape === 'value')
+                                asHeld.shape = 'asWritten'
+                            asHeld.held = true
+                            asHeld.local = binding.local
+                            reads.push(asHeld)
+                        },
+                    ),
+                )
             }
             continue
         }
         binding.call.path.push({ name: binding.key, start: 0, end: 0 })
         for (const read of binding.defaults) read.through = true
-        for (const read of uses) {
+        // A written prop's cell is already a `Reactive`, and a position due one holds it.
+        for (const { node, read } of uses) {
             read.through = true
             read.local = binding.local
             reads.push(read)
+            if (read.shape === 'value')
+                holding.push(holdIn(checker, abide, node, read))
         }
     }
+    await Promise.all(holding)
+}
+
+/**
+ * 31.5 — the `Reactive`'s member a property access reaches by name, or `undefined` where the name
+ * is not one — `n.ready`, `n.set`. Whether it is the `Reactive`'s is the value's type's to say
+ * (`ownMembers`).
+ */
+function memberNamed(node: Node): string | undefined {
+    const parent = node.parent
+    return isPropertyAccessExpression(parent) &&
+        parent.expression === node &&
+        isIdentifier(parent.name) &&
+        REACTIVE_MEMBERS.has(parent.name.text)
+        ? parent.name.text
+        : undefined
+}
+
+/**
+ * 31.5 — the occurrences among `nodes` reaching a member the VALUE's own type declares, where the
+ * access is the value's rather than the `Reactive`'s — a `Map`'s `set` is the map's. Asked before
+ * any is classified, so each is classified once.
+ *
+ * Per union member, because a union's properties are only those every member shares, and
+ * `undefined` shares none — so `HTMLVideoElement | undefined` would declare no `error`. A value
+ * typed `any` or `unknown` declares none: its type says nothing of what it holds.
+ */
+async function ownMembers(
+    checker: Checker,
+    nodes: readonly (Node | undefined)[],
+    valueOf: (node: Node) => Promise<Type | undefined>,
+): Promise<Set<Node>> {
+    const owned = new Set<Node>()
+    const asked: Promise<void>[] = []
+    for (const node of nodes) {
+        if (node === undefined) continue
+        const member = memberNamed(node)
+        if (member === undefined) continue
+        asked.push(
+            valueOf(node).then(async (value) => {
+                if (value === undefined) return
+                for (const held of await unionMembers(value))
+                    if (
+                        (held.flags & NULLISH) === 0 &&
+                        (await checker.getPropertyOfType(held, member)) !==
+                            undefined
+                    )
+                        return void owned.add(node)
+            }),
+        )
+    }
+    await Promise.all(asked)
+    return owned
+}
+
+/**
+ * 31.7, 33.6, 33.7 — `n.set(v)` and `n.patch(…)` are writes by name, called or handed on, where the
+ * value's own type declares no member of that name — a `Map`'s `set` writes the map, not the prop.
+ */
+function writesThrough(node: Node, owned: ReadonlySet<Node>): boolean {
+    const member = memberNamed(node)
+    return (member === 'set' || member === 'patch') && !owned.has(node)
+}
+
+/**
+ * 33.27 — whether a prop the child only reads stands where its `Reactive` is due, as a page's own
+ * name would: an `await` operand (31.3), a `Reactive`'s member its value does not declare (31.5),
+ * or a position typed as a `Reactive` or a `Selection` (31.3, 31.13).
+ */
+async function holdsProp(
+    checker: Checker,
+    abide: Abide,
+    node: Node,
+    ownsMember: boolean,
+): Promise<boolean> {
+    if (node.parent.kind === SyntaxKind.AwaitExpression) return true
+    if (memberNamed(node) !== undefined) return !ownsMember
+    return typedReactive(checker, abide, node)
+}
+
+/**
+ * 31.3, 31.13 — `read` holds the `Reactive` where `node` stands in a position whose declared type
+ * is a `Reactive` or a `Selection`.
+ */
+async function holdIn(
+    checker: Checker,
+    abide: Abide,
+    node: Node,
+    read: Read,
+): Promise<void> {
+    if (await typedReactive(checker, abide, node)) read.shape = 'asWritten'
+}
+
+/** 31.3, 31.13 — whether `node`'s position is declared a `Reactive` or a `Selection`. */
+async function typedReactive(
+    checker: Checker,
+    abide: Abide,
+    node: Node,
+): Promise<boolean> {
+    const type = await declaredType(checker, node)
+    return (
+        type !== undefined && (await isReactiveType(checker, abide, type, true))
+    )
 }
 
 /**

package/src/server/BRIDGE_VERSION.ts

@@ -1,3 +1,3 @@
 // The `abide-bridge` release a pairing command names, so a visitor's `bunx` runs the relay this
 // server speaks. `packages/abide/tests/claudeCode.test.ts` holds it to the bridge package's own.
-export const BRIDGE_VERSION = '0.4.0'
+export const BRIDGE_VERSION = '0.5.1'

package/src/server/answerFailure.ts

@@ -10,6 +10,7 @@ import { coversRoute, parseRoutePattern } from '#shared/routePattern.ts'
 
 import type { AppSources } from './answerRequest.ts'
 import { DOCUMENT_HEADERS } from './DOCUMENT_HEADERS.ts'
+import { prefers } from './prefers.ts'
 import { boundPage, renderDocument } from './render.ts'
 import { beginRender, currentRequestScope } from './requestScope.ts'
 
@@ -100,3 +101,18 @@ export async function answerFailure(
     headers.set('content-type', 'text/plain; charset=utf-8')
     return new Response(failure.message, { status, headers })
 }
+
+/**
+ * A failure at an address whose lane only the request can say: a page's, painted, where it prefers
+ * a document, and a handler's otherwise. 15.22.
+ */
+export function laneFailure(
+    app: ErrorPages,
+    pathname: string,
+    failure: Failed<string, unknown>,
+    request: Request,
+): Response | Promise<Response> {
+    return prefers(request, 'text/html', 'application/json')
+        ? answerFailure(app, pathname, failure)
+        : answered(failure)
+}

package/src/server/answerRequest.ts

@@ -22,7 +22,7 @@ import { DEBUG_META } from '#shared/DEBUG_META.ts'
 import { decodedOrKept } from '#shared/decodedOrKept.ts'
 import { ERROR_META } from '#shared/ERROR_META.ts'
 import { escapeAttribute } from '#shared/escapeText.ts'
-import { type Failed, isFailed } from '#shared/Failed.ts'
+import { isFailed } from '#shared/Failed.ts'
 import { HandlerRoute } from '#shared/HandlerRoute.ts'
 import { health } from '#shared/health.ts'
 import { KEEP_HEADER } from '#shared/KEEP_HEADER.ts'
@@ -45,7 +45,7 @@ import {
 import type { Method, Rpc } from '#shared/rpc.ts'
 import { rpcRequest } from '#shared/rpcRequest.ts'
 
-import { answered, answerFailure } from './answerFailure.ts'
+import { answerFailure, laneFailure } from './answerFailure.ts'
 import {
     answerRpc,
     type Mounted,
@@ -64,12 +64,11 @@ import { settingOn } from './config.ts'
 import { noteCallInRender } from './deferredBuilds.ts'
 import { DOCUMENT_HEADERS } from './DOCUMENT_HEADERS.ts'
 import { answerMcp, openApi } from './generatedSurfaces.ts'
-import { type AppRung, failureOf, rungsOver } from './hooks.ts'
+import { failureOf, type LaneRung, rungsOver } from './hooks.ts'
 import { chunksOf, type Manifest } from './manifestOf.ts'
 import { muxAdmission } from './muxUpgrade.ts'
 import { OFFLINE_STALE } from './OFFLINE_STALE.ts'
 import { plainAnswer } from './plainAnswer.ts'
-import { prefers } from './prefers.ts'
 import { PRINCIPAL_MOUNT } from './principal.ts'
 import {
     boundPage,
@@ -625,7 +624,18 @@ export async function appSources(parts: SourceParts): Promise<AppSources> {
         if (row.page !== undefined)
             row.answers.set(
                 row.page,
-                answerInside(sources, row.page, rungsOver(row.pattern)),
+                answerInside(
+                    sources,
+                    row.page,
+                    // 37.14 — a page's lane paints a refusal as its error page does (35.2).
+                    rungsOver(row.pattern, (failure, request) =>
+                        answerFailure(
+                            sources,
+                            new URL(request.url).pathname,
+                            failure,
+                        ),
+                    ),
+                ),
             )
         for (const handler of row.handlers.values())
             row.answers.set(
@@ -640,7 +650,7 @@ export async function appSources(parts: SourceParts): Promise<AppSources> {
 function answerInside(
     app: AppSources,
     found: Ranked | Mounted,
-    rungs: AppRung[],
+    rungs: LaneRung[],
 ): (ctx: { request: Request }) => Promise<Response> {
     return compose(rungs, ({ request }) => answerMatched(app, request, found))
 }
@@ -774,21 +784,6 @@ async function methodRefused(
     return answer
 }
 
-/**
- * A failure at an address whose lane only the request can say: a page's, painted, where it prefers
- * a document, and a handler's otherwise. 15.22.
- */
-function laneFailure(
-    app: AppSources,
-    pathname: string,
-    failure: Failed<string, unknown>,
-    request: Request,
-): Response | Promise<Response> {
-    return prefers(request, 'text/html', 'application/json')
-        ? answerFailure(app, pathname, failure)
-        : answered(failure)
-}
-
 /**
  * A public file's answer, conditional and range-aware off the etag read at boot.
  *

package/src/server/answerRpc.ts

@@ -44,7 +44,7 @@ import {
     crossingOrigin,
     crossingRefusal,
 } from './crossingOrigin.ts'
-import { type AppRung, failureOf, rungsOver } from './hooks.ts'
+import { failureOf, type LaneRung, rungsOver } from './hooks.ts'
 import { OFFLINE_STALE } from './OFFLINE_STALE.ts'
 import { prefers } from './prefers.ts'
 import {
@@ -120,7 +120,7 @@ export type Mounted = Mount & {
      * The rungs filed over `scope`, read once at mount (16.14) — what an http call and a socket
      * subscription to it both pass through (37.2, 18.26).
      */
-    rungs: AppRung[]
+    rungs: LaneRung[]
     handler: Rpc<unknown, unknown> & Gated<unknown> & HeldToAnnotation
     /**
      * The args' JSON Schema, probed once at mount.
@@ -203,7 +203,8 @@ export async function mountHandlers(
             ...mount,
             // 37.1, 16.72 — the route its file's hooks are filed at, which the build read off
             // where the file answers (23.19's mount for a package's), never its place on disk.
-            rungs: rungsOver(mount.scope),
+            // 37.14 — a handler's lane answers a refusal as Problem Details (15.1).
+            rungs: rungsOver(mount.scope, answered),
             handler,
             argsDocument: declared ?? (mount.args as Document | undefined),
         })

package/src/server/assistant.ts

@@ -122,37 +122,58 @@ export async function* assistant(
         options.mcp === true ? appSurface() : NO_SURFACE,
         askerOf(request()),
     )
+    const signal = request().signal
     const events = provider.run(turns, tools, {
         maxTurns: options.maxTurns ?? MAX_TURNS,
-        signal: request().signal,
+        signal,
     })
     // 28.7 — a closed namespace runs the provider's stream untouched.
-    yield* ASSISTANT_LOG.enabled() ? traced(events, messages.length) : events
+    yield* ASSISTANT_LOG.enabled()
+        ? traced(events, messages.length, signal)
+        : events
 }
 
-/** `events`, and one line on `abide:assistant` once they end, however they end. 44.31. */
+/**
+ * `events`, and one line on `abide:assistant` once they end, however they end. 44.31.
+ *
+ * AN UNFINISHED CONVERSATION SAYS WHY, an abort read ahead of a throw: an aborted provider may throw
+ * as it unwinds, and the abort is what ended it.
+ */
 async function* traced(
     events: AsyncGenerator<AssistantEvent>,
     messageCount: number,
+    signal: AbortSignal,
 ): AsyncGenerator<AssistantEvent> {
     const started = performance.now()
     let calls = 0
     let done: Extract<AssistantEvent, { type: 'done' }> | undefined
+    let failure: string | undefined
     try {
         for await (const event of events) {
             if (event.type === 'tool') calls += 1
             else if (event.type === 'done') done = event
             yield event
         }
+    } catch (thrown) {
+        failure = thrown instanceof Error ? thrown.message : String(thrown)
+        throw thrown
     } finally {
+        const ending =
+            done?.stop ??
+            (signal.aborted
+                ? 'unfinished aborted'
+                : failure === undefined
+                  ? 'unfinished stopped'
+                  : 'unfinished failed')
         ASSISTANT_LOG.debug(
-            done === undefined ? 'unfinished' : done.stop,
+            ending,
             `${messageCount} messages`,
             `${calls} tool calls`,
             done === undefined
                 ? 'no usage'
                 : `${done.usage.input}/${done.usage.output} tokens`,
             `${(performance.now() - started).toFixed(1)}ms`,
+            ...(ending === 'unfinished failed' ? [failure] : []),
         )
     }
 }

package/src/server/createApp.ts

@@ -17,6 +17,7 @@ import { PRINCIPAL_HEADER } from '#shared/PRINCIPAL_HEADER.ts'
 import { RPC_SERVER } from '#shared/RPC_SERVER.ts'
 
 import { servedTable } from './abideModules.ts'
+import { laneFailure } from './answerFailure.ts'
 import { answerRequest, type AppSources } from './answerRequest.ts'
 import type { Mount } from './answerRpc.ts'
 import { Mux, type MuxConnection } from './answerSocket.ts'
@@ -278,7 +279,10 @@ export async function bootEntered(
     // 16.14, 37.3 — THE APP LANE'S ONION, composed once over the whole request path: the root
     // 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.
-    const rungs = rootRungs()
+    // 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 answer = compose(rungs, async ({ request }) => {
         const began = performance.now()
         const answered = await answerRequest(booted, request)

package/src/server/csp.ts

@@ -5,7 +5,7 @@
 // THE NONCE IS MINTED BY WHICHEVER ASKS FIRST — a page reading `csp.nonce` while it renders, or this
 // rung writing a document's header — so the two agree, and an answer that is not a document mints none.
 
-import type { Middleware } from '#shared/Middleware.ts'
+import type { Rung } from '#shared/Middleware.ts'
 
 import { randomToken } from './randomToken.ts'
 import { EARLY_CALL_HASH } from './render.ts'
@@ -64,7 +64,7 @@ function policy(
 
 export function cspRung(
     sources: Record<string, string[]> | undefined,
-): Middleware<{ request: Request }, Response> {
+): Rung<{ request: Request }, Response> {
     const written = policy(sources)
     return async (next) => {
         const answer = await next()

package/src/server/hooks.ts

@@ -13,7 +13,7 @@
 
 import { type Failed, isFailed } from '#shared/Failed.ts'
 import { namedLogger } from '#shared/log.ts'
-import type { Middleware } from '#shared/Middleware.ts'
+import type { Rung } from '#shared/Middleware.ts'
 import { aborted, refuse } from '#shared/refuse.ts'
 import {
     coversRoute,
@@ -26,7 +26,25 @@ import { config } from './config.ts'
 import type { LauncherOptions } from './launcherOptions.ts'
 import { currentRequestScope } from './requestScope.ts'
 
-export type AppRung = Middleware<{ request: Request }, Response>
+type AppContext = { request: Request }
+
+/** 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>,
+    ctx: AppContext,
+) =>
+    | Response
+    | Failed<string, unknown>
+    | Promise<Response | Failed<string, unknown>>
+
+/** An app rung as its lane composes it, a refusal it returned already answered (37.14). */
+export type LaneRung = Rung<AppContext, Response>
+
+/** How a lane answers a refusal one of its rungs returned, in that lane's representation (37.14). */
+export type RefusalAnswer = (
+    failure: Failed<string, unknown>,
+    request: Request,
+) => Response | Promise<Response>
 
 export type Env = Record<string, string | undefined>
 export type ConfigDefaults = (env: Env) => unknown
@@ -106,11 +124,24 @@ export function inOrder<T>(list: readonly Filed<T>[]): T[] {
     return items
 }
 
+/**
+ * `rung` with a refusal it returns answered by `answer`.
+ *
+ * 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 {
+    return async (next, ctx) => {
+        const result = await rung(next, 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(): AppRung[] {
-    const rungs: AppRung[] = []
+export function rootRungs(answer: RefusalAnswer): LaneRung[] {
+    const rungs: LaneRung[] = []
     for (const entry of HOOKS.rungs)
-        if (entry.route === ROOT) rungs.push(entry.item)
+        if (entry.route === ROOT) rungs.push(answering(entry.item, answer))
     return rungs
 }
 
@@ -120,12 +151,12 @@ export function rootRungs(): AppRung[] {
  * 37.2 — every rung filed at `route` or at a route that is its front, the root's aside: those ran
  * before routing (37.3).
  */
-export function rungsOver(route: string): AppRung[] {
+export function rungsOver(route: string, answer: RefusalAnswer): LaneRung[] {
     const segments = parseRoutePattern(route)
-    const rungs: AppRung[] = []
+    const rungs: LaneRung[] = []
     for (const entry of HOOKS.rungs)
         if (entry.route !== ROOT && coversRoute(entry.segments, segments))
-            rungs.push(entry.item)
+            rungs.push(answering(entry.item, answer))
     return rungs
 }
 

package/src/shared/Middleware.ts

@@ -1,7 +1,27 @@
 // ONE RUNG OF AN ONION, and the onion. The app lane's `middleware` (37.3) and a handler's rungs
 // (16.11) are the same shape over a different `Ctx`, so they compose through the one function.
 
-export type Middleware<Ctx, Result> = (
+import type { Failed } from './Failed.ts'
+
+/**
+ * A rung written once for every lane whose context carries `Extra`: generic over the context it is
+ * handed and over what `next` answers, so it passes `next()`'s answer on, refuses in its place, or
+ * answers with an `Answer` of its own.
+ */
+export type Middleware<Answer = never, Extra extends object = object> = <
+    Given extends { request: Request } & Extra,
+    Result,
+>(
+    next: (ctx?: Given) => Promise<Result>,
+    ctx: Given,
+) =>
+    | Result
+    | Answer
+    | Failed<string, unknown>
+    | Promise<Result | Answer | Failed<string, unknown>>
+
+/** A rung as one lane composes it, over that lane's context and what its center answers. */
+export type Rung<Ctx, Result> = (
     next: (ctx?: Ctx) => Promise<Result>,
     ctx: Ctx,
 ) => Result | Promise<Result>
@@ -17,17 +37,17 @@ export type Middleware<Ctx, Result> = (
  * `next()` with no argument hands the inner link the ctx this rung was given.
  */
 export function compose<Ctx, Result>(
-    rungs: readonly Middleware<Ctx, Result>[],
+    rungs: readonly Rung<Ctx, Result>[],
     terminal: (ctx: Ctx) => Promise<Result>,
 ): (ctx: Ctx) => Promise<Result> {
     let link = terminal
     for (let at = rungs.length - 1; at >= 0; at -= 1)
-        link = linkOf(rungs[at] as Middleware<Ctx, Result>, link)
+        link = linkOf(rungs[at] as Rung<Ctx, Result>, link)
     return link
 }
 
 function linkOf<Ctx, Result>(
-    rung: Middleware<Ctx, Result>,
+    rung: Rung<Ctx, Result>,
     inner: (ctx: Ctx) => Promise<Result>,
 ): (ctx: Ctx) => Promise<Result> {
     return async (ctx) => rung((given) => inner(given ?? ctx), ctx)

package/src/shared/csp.ts

@@ -3,9 +3,9 @@
 // mint one for, so `csp.nonce` answers the one its document was served with, which is what a
 // binding that wrote it on the server hydrates to.
 
-import type { Middleware } from './Middleware.ts'
+import type { Rung as LaneRung } from './Middleware.ts'
 
-type Rung = Middleware<{ request: Request }, Response>
+type Rung = LaneRung<{ request: Request }, Response>
 
 /**
  * The server's content-security-policy half, as slots `#server/installServer.ts` fills from