@abide/abide 0.125.0 → 0.125.2

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # @abide/abide
 
+## 0.125.2
+
+### Patch Changes
+
+- d1029ab: A `Middleware` whose `Extra` asks for `args` fits a keyed handler again — 16.86. 0.125.1's plain rung array inferred the handler's `Args` off the rung's `args: () => unknown` as well as off the `Keyed`, and refused the handler.
+
+## 0.125.1
+
+### Patch Changes
+
+- one late-read writer for a handler's address, a named handler rung, resultsOf reads Rpc's own members — 16.88 ([`b74dc3a`](https://github.com/briancray/abide/commit/b74dc3a99385125ad76d5180e8ad9479cb4798b5))
+- b9e4187: Rung helpers, `resultsOf` and a handler's address, from updating an app to 0.125 — 16.86, 16.88, 44.51
+  
+  - `resultsOf` takes any handler, whatever its args (it refused every handler with a parameter).
+  - A rung list a helper builds (`middleware: rungs()`, `[...rungs()]`) carries its `Middleware`s' named refusals onto the `Rpc`, as an inline list does.
+  - A generic rung helper takes its `Args` from the handler it is listed on again.
+  - A handler file's `rpc.address` is its route as soon as the file loads, so a `bun test` importing it matches it with no app booted.
+  
+  MIGRATION from 0.124: a rung's `next` is typed `(ctx?: RpcContext<Args>) => Promise<…>`, so a rung written for any handler whose `next` takes a ctx with `args: () => unknown` no longer fits a handler with typed args — it could hand that handler args of the wrong shape. Type the helper over the handler's `Args` (`<Args>(…) => ((next: (ctx?: { request: Request; args: () => Args }) => Promise<unknown>, ctx: { request: Request; args: () => Args }) => unknown)[]`), or write the rung as a `Middleware`. A mismatch is now reported against `middleware` rather than as the handler not being assignable to `never`.
+
 ## 0.125.0
 
 ### Minor Changes

package/docs/REGISTRY.md

@@ -225,7 +225,7 @@ type Gated<Gate, Accepted> = [Schema<Accepted>] extends [Gate] ? never : Failed<
 | `Value` | `unknown` | What the addressed `Reactive` holds. | 16.3, 16.30 |
 | `Produced` | `unknown` | What it yields, per the unit rule. | 1.2, 16.3 |
 | `Args` | `Record<string, JsonValue> \| undefined` | The arguments, in the body on a mutation and in the URL on a `GET` or `DELETE`. | 11.24, 16.18, 19.15 |
-| `Middleware` | `Middleware<Answer = never, Extra extends object = object, Refused extends Failed<string, unknown> = Failed<string, unknown>> = <Given extends { request: Request } & Extra, Result>(next: (ctx?: Given) => Promise<Result>, ctx: Given) => Result \| Answer \| Refused \| Promise<Result \| Answer \| Refused>` | One rung, written once for every lane whose context carries `Extra`. | 16.8, 16.14, 16.15, 16.16, 16.21, 16.86, 37.14, 37.15 |
+| `Middleware` | `Middleware<Answer = never, Extra extends object = object, Refused extends Failed<string, unknown> = Failed<string, unknown>> = <Given extends { request: Request } & Extra, Result extends {} \| null \| undefined>(next: (ctx?: Given) => Promise<Result>, ctx: Given) => Result \| Answer \| Refused \| Promise<Result \| Answer \| Refused>` | One rung, written once for every lane whose context carries `Extra`. | 16.8, 16.14, 16.15, 16.16, 16.21, 16.86, 37.14, 37.15 |
 | `GET` | `<Stored, Accepted, Failures, Produced, Answers extends readonly unknown[] = unknown[]>(handler: Reactive<Stored, Accepted, Failures, Produced>, options?: RpcOptions<undefined, Answers>) => Rpc<Stored, undefined, Failures \| RungRefusals<Answers>, Produced>` | Declares a read any surface may call. | 16.1, 16.2, 16.5, 16.6, 16.30, 16.31, 16.32, 16.68, 16.76, 16.34, 16.35, 16.36, 16.37, 16.39, 16.44, 16.45, 16.46, 16.47, 16.75, 16.50, 16.51, 16.52, 16.64, 12.17, 18.1, 18.3, 18.6, 18.8, 18.10, 18.12, 18.21, 18.24, 18.27 |
 | `GET` | `<Stored, Args, Accepted, Failures, Produced, Answers extends readonly unknown[] = unknown[]>(handler: Keyed<Stored, Args, Accepted, Failures, Produced>, options?: RpcOptions<Args, Answers>) => Rpc<Stored, Args, Failures \| RungRefusals<Answers>, Produced>` | The keyed overload, for a `Keyed` given an address. | 11.2, 16.1, 16.3, 16.6 |
 | `GET` | `<Chunk, Shaped = Chunk[], Gate = Schema<Chunk[]>, Answers extends readonly unknown[] = unknown[]>(handler: () => AsyncGenerator<Chunk> \| Promise<AsyncGenerator<Chunk>>, options?: Shaping<Chunk[], Shaped, never, Gate> & RpcOptions<undefined, Answers>) => Rpc<Kept<Shaped>, undefined, Refusals<Shaped, Gate, Chunk[]> \| RungRefusals<Answers>, Chunk>` | The streaming overload, whose options build the value it becomes beside its address. | 16.1, 16.6, 16.7, 16.44, 16.45, 16.46, 16.47 |
@@ -245,6 +245,7 @@ type Gated<Gate, Accepted> = [Schema<Accepted>] extends [Gate] ? never : Failed<
 | `rpc.raw` | `(args: Args, init?: RequestInit) => Promise<Response>` | The same call handed back as the raw response. | 16.11, 16.42 |
 | `rpc.method` | `string` | The HTTP method. | 16.2 |
 | `rpc.url` | `(args?: Args) => string` | The address, resolved against the mount. | 16.9, 16.10, 30.28 |
+| `rpc.address` | `string \| undefined` | Where the handler answers. | 16.88 |
 | `rpc.description` | `string \| undefined` | The human description. | 16.28 |
 | `PatchOp` | `{ op: 'add' \| 'replace' \| 'test'; path: string; value: unknown } \| { op: 'remove'; path: string } \| { op: 'move' \| 'copy'; from: string; path: string }` | One JSON Patch operation (RFC 6902), its paths JSON Pointers, as a followed `GET` is sent what an `s.patch` wrote. | 18.11, 18.13 |
 
@@ -267,7 +268,7 @@ type Reached = { readonly [REACHED]: true }
 | Name | Signature | Meaning | Rules |
 | --- | --- | --- | --- |
 | `description` | `string` | The human description carried onto every generated surface. | 16.28 |
-| `middleware` | `{ [At in keyof Answers]: (next: (ctx?: { request: Request; args: () => Args }) => Promise<Reached>, ctx: { request: Request; args: () => Args }) => Answers[At] \| Promise<Answers[At]> }` | The rungs run per call. | 16.8, 16.11, 16.12, 16.16, 16.17, 16.18, 16.19, 16.20, 16.86 |
+| `middleware` | `{ [At in keyof Answers]: (next: (ctx?: { request: Request; args: () => Args }) => Promise<Reached>, ctx: { request: Request; args: () => Args }) => Answers[At] \| Promise<Answers[At]> } \| readonly ((next: (ctx?: { request: Request; args: () => NoInfer<Args> }) => Promise<Reached>, ctx: { request: Request; args: () => NoInfer<Args> }) => unknown)[]` | The rungs run per call. | 16.8, 16.11, 16.12, 16.16, 16.17, 16.18, 16.19, 16.20, 16.86 |
 | `timeout` | `number` | How long the call may go without progress. | 16.22, 16.58, 16.59, 16.60, 16.61, 16.77 |
 | `clients` | `Clients` | Which surfaces carry this handler. | 16.37, 20.3 |
 | `crossOrigin` | `boolean \| string[]` | Whether other origins may call it, or follow it over the mux. | 16.24, 18.2, 21.19 |
@@ -365,7 +366,7 @@ type Reached = { readonly [REACHED]: true }
 | `Toolbox` | `{ list: ToolDefinition[]; call(name: string, input: unknown): Promise<ToolAnswer> }` | The app's MCP tools, called as the asker. | 44.6, 44.7, 44.35 |
 | `ToolAnswer` | `{ content: AssistantContent[]; failed: boolean }` | What a tool call answered: its pieces, and whether it failed. | 20.21, 20.22, 44.35 |
 | `ToolDefinition` | `{ name: string; description: string; inputSchema: unknown; annotations: { readOnlyHint: boolean; destructiveHint: boolean; idempotentHint: boolean }; outputSchema: unknown }` | A tool as the app's MCP surface lists it. | 20.14, 20.16, 20.19, 44.6 |
-| `resultsOf` | `<Value>(events: readonly AssistantEvent[], handler: Rpc<Value, never, unknown, unknown>) => Value[]` | What a conversation's calls to one handler answered. | 44.51 |
+| `resultsOf` | `<Value>(events: readonly AssistantEvent[], handler: ((...args: never) => Reactive<Value, never, unknown, unknown>) & { method: string; address: string \| undefined }) => Value[]` | What a conversation's calls to one handler answered. | 44.51 |
 | `imagePiece` | `(image: Blob) => Promise<{ type: 'image'; data: string; mimeType: string }>` | An image as a turn's image piece, drawn down to what a model looks at. | 44.52, 44.53, 44.54 |
 | `imageFiles` | `(data: DataTransfer \| null) => File[]` | The images a paste or a drop carries that a model is shown. | 44.55 |
 

package/docs/RULEBOOK.md

@@ -1183,6 +1183,10 @@ declaration, and a rung naming no refusal, one typed to answer anything or a `Mi
 16.87 A handler whose parameter carries no annotation MUST take its `Args` from the `args` its options
 declare.
 
+16.88 A handler file's `rpc.address` MUST be its route (23.14) under the mount (16.10) once the file is
+loaded in a process serving the app's compilation, `bun test`'s under `@abide/abide/test` included
+(38.109), whether or not `createApp` has run.
+
 # 17. Response helpers
 
 17.1 Every body helper MUST take `Values<T>`.

package/docs/abide.md

@@ -1774,6 +1774,7 @@ A handler that returns a `Blob` answers with the blob's own type, so this one is
 | --- | --- |
 | `rpc.url` | the address, with the args written in, for a link, a form or a webhook |
 | `rpc.method` | the verb it was declared with |
+| `rpc.address` | its route, once its file has loaded, in a test as in the app |
 | `rpc.raw` | the `Response` itself, for a header or a body you read yourself |
 | `rpc.description` | the sentence it was declared with |
 
@@ -8418,6 +8419,7 @@ Reactive primitives: what is written in place rather than imported.
 | `rpc.raw` | `(args: Args, init?: RequestInit) => Promise<Response>` | The same call handed back as the raw response. | [16.11](/rulebook#16.11), [16.42](/rulebook#16.42) |
 | `rpc.method` | `string` | The HTTP method. | [16.2](/rulebook#16.2) |
 | `rpc.url` | `(args?: Args) => string` | The address, resolved against the mount. | [16.9](/rulebook#16.9), [16.10](/rulebook#16.10), [30.28](/rulebook#30.28) |
+| `rpc.address` | `string \| undefined` | Where the handler answers. | [16.88](/rulebook#16.88) |
 | `rpc.description` | `string \| undefined` | The human description. | [16.28](/rulebook#16.28) |
 
 ## `outbox`
@@ -8445,7 +8447,7 @@ Reactive primitives: what is written in place rather than imported.
 
 | Name | Signature | Meaning | Rules |
 | --- | --- | --- | --- |
-| `Middleware` | `Middleware<Answer = never, Extra extends object = object, Refused extends Failed<string, unknown> = Failed<string, unknown>> = <Given extends { request: Request } & Extra, Result>(next: (ctx?: Given) => Promise<Result>, ctx: Given) => Result \| Answer \| Refused \| Promise<Result \| Answer \| Refused>` | One rung, written once for every lane whose context carries `Extra`. | [16.8](/rulebook#16.8), [16.14](/rulebook#16.14), [16.15](/rulebook#16.15), [16.16](/rulebook#16.16), [16.21](/rulebook#16.21), [16.86](/rulebook#16.86), [37.14](/rulebook#37.14), [37.15](/rulebook#37.15) |
+| `Middleware` | `Middleware<Answer = never, Extra extends object = object, Refused extends Failed<string, unknown> = Failed<string, unknown>> = <Given extends { request: Request } & Extra, Result extends {} \| null \| undefined>(next: (ctx?: Given) => Promise<Result>, ctx: Given) => Result \| Answer \| Refused \| Promise<Result \| Answer \| Refused>` | One rung, written once for every lane whose context carries `Extra`. | [16.8](/rulebook#16.8), [16.14](/rulebook#16.14), [16.15](/rulebook#16.15), [16.16](/rulebook#16.16), [16.21](/rulebook#16.21), [16.86](/rulebook#16.86), [37.14](/rulebook#37.14), [37.15](/rulebook#37.15) |
 
 ## Taught in
 
@@ -8526,7 +8528,7 @@ Reactive primitives: what is written in place rather than imported.
 | Name | Signature | Meaning | Rules |
 | --- | --- | --- | --- |
 | `description` | `string` | The human description carried onto every generated surface. | [16.28](/rulebook#16.28) |
-| `middleware` | `{ [At in keyof Answers]: (next: (ctx?: { request: Request; args: () => Args }) => Promise<Reached>, ctx: { request: Request; args: () => Args }) => Answers[At] \| Promise<Answers[At]> }` | The rungs run per call. | [16.8](/rulebook#16.8), [16.11](/rulebook#16.11), [16.12](/rulebook#16.12), [16.16](/rulebook#16.16), [16.17](/rulebook#16.17), [16.18](/rulebook#16.18), [16.19](/rulebook#16.19), [16.20](/rulebook#16.20), [16.86](/rulebook#16.86) |
+| `middleware` | `{ [At in keyof Answers]: (next: (ctx?: { request: Request; args: () => Args }) => Promise<Reached>, ctx: { request: Request; args: () => Args }) => Answers[At] \| Promise<Answers[At]> } \| readonly ((next: (ctx?: { request: Request; args: () => NoInfer<Args> }) => Promise<Reached>, ctx: { request: Request; args: () => NoInfer<Args> }) => unknown)[]` | The rungs run per call. | [16.8](/rulebook#16.8), [16.11](/rulebook#16.11), [16.12](/rulebook#16.12), [16.16](/rulebook#16.16), [16.17](/rulebook#16.17), [16.18](/rulebook#16.18), [16.19](/rulebook#16.19), [16.20](/rulebook#16.20), [16.86](/rulebook#16.86) |
 | `timeout` | `number` | How long the call may go without progress. | [16.22](/rulebook#16.22), [16.58](/rulebook#16.58), [16.59](/rulebook#16.59), [16.60](/rulebook#16.60), [16.61](/rulebook#16.61), [16.77](/rulebook#16.77) |
 | `clients` | `Clients` | Which surfaces carry this handler. | [16.37](/rulebook#16.37), [20.3](/rulebook#20.3) |
 | `crossOrigin` | `boolean \| string[]` | Whether other origins may call it, or follow it over the mux. | [16.24](/rulebook#16.24), [18.2](/rulebook#18.2), [21.19](/rulebook#21.19) |
@@ -9075,7 +9077,7 @@ Generated surfaces: what is written in place rather than imported.
 
 | Name | Signature | Meaning | Rules |
 | --- | --- | --- | --- |
-| `resultsOf` | `<Value>(events: readonly AssistantEvent[], handler: Rpc<Value, never, unknown, unknown>) => Value[]` | What a conversation's calls to one handler answered. | [44.51](/rulebook#44.51) |
+| `resultsOf` | `<Value>(events: readonly AssistantEvent[], handler: ((...args: never) => Reactive<Value, never, unknown, unknown>) & { method: string; address: string \| undefined }) => Value[]` | What a conversation's calls to one handler answered. | [44.51](/rulebook#44.51) |
 
 ## Taught in
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@abide/abide",
-    "version": "0.125.0",
+    "version": "0.125.2",
     "type": "module",
     "description": "Isomorphic type-safe framework for reactive async interfaces for humans and machines",
     "license": "MIT",

package/src/compiler/compileApp.ts

@@ -404,6 +404,7 @@ async function emitApp(
         if (!mount.private)
             handlers[mount.source] = {
                 scope: mount.scope,
+                address: mount.address,
                 client: standIns.get(mount.source) ?? '',
                 args: mount.args,
             }

package/src/server/abideModules.ts

@@ -135,6 +135,8 @@ export function serveCompilation(root: string, compilation: Compilation): void {
 // plugin per compilation because the filter is fixed at registration, and the runtime's `onLoad`
 // cannot fall through, so the filter names the handler files and nothing else. The face it names
 // is resolved by `modulesPlugin`, registered once.
+// 16.88 — AND GIVES IT ITS ADDRESS, so a test importing the file calls, links and matches it (44.51)
+// with no app booted.
 // 15.8, 19.9 — AND HOLDS ITS HANDLER TO THE SCHEMA ITS ANNOTATION DERIVES, once the face has built it:
 // this module is what every import of the file is answered with — the server's mount, a test's own
 // import, a component's under `mount` — so a call is held to it whoever makes it.
@@ -153,15 +155,20 @@ function handlerFilesPlugin(
                 },
                 (args) => {
                     const face = JSON.stringify(`${args.path}${HANDLER_SUFFIX}`)
-                    const schema = faces.get(args.path)?.args
-                    return {
-                        contents:
-                            `export { default } from ${face}\n` +
-                            (schema === undefined
-                                ? ''
-                                : `import __handler from ${face}\nimport { derivedArgs as __derivedArgs } from '${SERVER_SPECIFIER}'\n__derivedArgs(__handler, ${JSON.stringify(schema)})\n`),
-                        loader: 'js',
-                    }
+                    const { address, args: schema } = faces.get(
+                        args.path,
+                    ) as HandlerFace
+                    const lines = [
+                        `export { default } from ${face}`,
+                        `import __handler from ${face}`,
+                        `import { addressed as __addressed, derivedArgs as __derivedArgs } from '${SERVER_SPECIFIER}'`,
+                        `__addressed(__handler, ${JSON.stringify(address)})`,
+                    ]
+                    if (schema !== undefined)
+                        lines.push(
+                            `__derivedArgs(__handler, ${JSON.stringify(schema)})`,
+                        )
+                    return { contents: `${lines.join('\n')}\n`, loader: 'js' }
                 },
             )
         },

package/src/server/addressed.ts

@@ -0,0 +1,14 @@
+import { mounted } from '#shared/mount.ts'
+
+/**
+ * Gives a handler its address: `route` under the mount, read when it is reported.
+ *
+ * 16.88 — ONE WRITER, READ LATE: the mount is the configuration's, so the address a file's module
+ * is given as it loads is the one a boot would give it, and a later call only names the route again.
+ */
+export function addressed(handler: object, route: string): void {
+    Object.defineProperty(handler, 'address', {
+        get: () => mounted(route),
+        configurable: true,
+    })
+}

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/index.ts

@@ -56,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'

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'
@@ -116,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,
         {
@@ -168,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)

package/src/shared/Middleware.ts

@@ -10,12 +10,19 @@ import type { Failed } from './Failed.ts'
  *
  * `Refused` is what it may refuse with; a rung naming its refusals carries them onto the `Rpc` its
  * handler is declared with (16.86), where one left at `Failed<string, unknown>` carries none.
+ *
+ * `Result` IS BOUNDED BY EVERYTHING BUT `unknown`. A rung read outside a context — listed by a
+ * helper, or beside the plain array arm of `RpcOptions['middleware']` — is read at its erased
+ * signature, where `Result` is its bound, and an `unknown` there absorbs `Refused` in the union.
  */
 export type Middleware<
     Answer = never,
     Extra extends object = object,
     Refused extends Failed<string, unknown> = Failed<string, unknown>,
-> = <Given extends { request: Request } & Extra, Result>(
+> = <
+    Given extends { request: Request } & Extra,
+    Result extends {} | null | undefined,
+>(
     next: (ctx?: Given) => Promise<Result>,
     ctx: Given,
 ) => Result | Answer | Refused | Promise<Result | Answer | Refused>

package/src/shared/resultsOf.ts

@@ -1,11 +1,13 @@
 import type { AssistantEvent } from './AssistantEvent.ts'
+import type { Reactive } from './reactive/Reactive.ts'
 import type { Rpc } from './rpc.ts'
 
 /** What every call to `handler` in `events` answered, in order, a failed call's left out. 44.51. */
 export function resultsOf<Value>(
     events: readonly AssistantEvent[],
-    // Any handler at all: its args, failures and production are no part of what it answered.
-    handler: Rpc<Value, never, unknown, unknown>,
+    // Any `Rpc`, whatever its `Args`: only the value is read off its call.
+    handler: ((...args: never) => Reactive<Value, never, unknown, unknown>) &
+        Pick<Rpc<Value, never>, 'method' | 'address'>,
 ): Value[] {
     const values: Value[] = []
     for (const event of events)

package/src/shared/rpc.ts

@@ -122,7 +122,7 @@ export type Rpc<Value, Args, Failures = never, Produced = Value> = ((
     url(...args: undefined extends Args ? [args?: Args] : [args: Args]): string
     /** The same call, handed back as the `Response` (16.42). */
     raw(args?: Args, init?: RequestInit): Promise<Response>
-    /** Where the handler is mounted, stamped by whoever mounted it — `undefined` until then. */
+    /** Where the handler answers: its route under the mount, once its file has loaded (16.88). */
     address: string | undefined
     keyed: boolean
     timeout: number | undefined
@@ -206,6 +206,12 @@ type RungRefusals<Answers extends readonly unknown[]> =
             : never
         : never
 
+/** One rung of a handler's `middleware`, answering `Answer` in the handler's place or passing on. */
+type HandlerRung<Args, Answer> = (
+    next: (ctx?: RpcContext<Args>) => Promise<Reached>,
+    ctx: RpcContext<Args>,
+) => Answer | Promise<Answer>
+
 export type RpcOptions<
     Args = unknown,
     Answers extends readonly unknown[] = unknown[],
@@ -214,13 +220,16 @@ export type RpcOptions<
     /**
      * 16.86 — one rung per answer in `Answers`, each read in context: a rung's own refusals are
      * inferred where the list is written at the declaration.
+     *
+     * The plain array arm is the context a list built by a GENERIC helper is typed in: the mapped
+     * arm is over `Answers`, still being inferred, so the helper's own `Args` read nothing there and
+     * are `unknown`. It adds no refusal of its own — `Answers` is still read off the list — and
+     * no `Args` either: a `Middleware` asking `args: () => unknown` of its context would otherwise
+     * widen a keyed handler's to `unknown`, which its `Keyed` then refuses.
      */
-    middleware?: {
-        [At in keyof Answers]: (
-            next: (ctx?: RpcContext<Args>) => Promise<Reached>,
-            ctx: RpcContext<Args>,
-        ) => Answers[At] | Promise<Answers[At]>
-    }
+    middleware?:
+        | { [At in keyof Answers]: HandlerRung<Args, Answers[At]> }
+        | readonly HandlerRung<NoInfer<Args>, unknown>[]
     timeout?: number
     clients?: Clients
     crossOrigin?: boolean | string[]
@@ -386,6 +395,23 @@ type Declare = {
         | RungRefusals<Answers>,
         AdoptedProduced<Computed, Kept<Shaped>>
     >
+    // 16.1 — a value, `reactive`'s value overload given an address. Ahead of the arm below rather
+    // than last, so a body refused for its options is reported by that arm, naming them, and not as
+    // a value it never was: `Held` already turns every function away.
+    <
+        Accepted,
+        Shaped = Accepted,
+        Gate = Schema<Accepted>,
+        Answers extends readonly unknown[] = unknown[],
+    >(
+        handler: Held<Accepted>,
+        options?: Shaping<Accepted, Shaped, never, Gate> &
+            RpcOptions<undefined, Answers>,
+    ): Rpc<
+        Kept<Shaped>,
+        undefined,
+        Refusals<Shaped, Gate, Accepted> | RungRefusals<Answers>
+    >
     <
         Computed,
         Args,
@@ -405,21 +431,6 @@ type Declare = {
         | RungRefusals<Answers>,
         AdoptedProduced<Computed, Kept<Shaped>>
     >
-    // 16.1 — a value, `reactive`'s value overload given an address. Last, so a function is a body.
-    <
-        Accepted,
-        Shaped = Accepted,
-        Gate = Schema<Accepted>,
-        Answers extends readonly unknown[] = unknown[],
-    >(
-        handler: Held<Accepted>,
-        options?: Shaping<Accepted, Shaped, never, Gate> &
-            RpcOptions<undefined, Answers>,
-    ): Rpc<
-        Kept<Shaped>,
-        undefined,
-        Refusals<Shaped, Gate, Accepted> | RungRefusals<Answers>
-    >
 }
 
 /** What a handler's selection members answer before a call has built its value: no entries' answers. */