@abide/abide 0.44.0 → 0.45.0

package/src/devEntry.ts

@@ -6,6 +6,7 @@ import { DEV_READY_MESSAGE } from './lib/server/runtime/DEV_READY_MESSAGE.ts'
 import { DEV_REBUILD_MESSAGE } from './lib/server/runtime/DEV_REBUILD_MESSAGE.ts'
 import { findOpenPort } from './lib/server/runtime/findOpenPort.ts'
 import { abideLog } from './lib/shared/abideLog.ts'
+import { changeAffectsClient } from './lib/shared/changeAffectsClient.ts'
 
 /*
 Dev orchestrator. Replaces `bun --watch` (which only watches the import graph,
@@ -174,30 +175,51 @@ async function replaceServer(port: number): Promise<void> {
 
 let building = false
 let queued = false
+// True once any change collapsed into the queued run needs the client rebuilt;
+// a client-affecting change can never be downgraded to a server-only restart.
+let queuedNeedsClient = false
 
 /*
-Rebuild the client, then (on success) swap in a fresh server child. Serialized:
-a change arriving mid-build sets `queued` so exactly one more rebuild runs
-after, collapsing any further changes in between. A failed build leaves the
-current child untouched — the error is logged and the last-good server keeps
-serving.
+Apply a change: rebuild the client (unless `skipClientBuild` — a server/MCP-only
+change leaves the client bundle byte-identical), then on success swap in a fresh
+server child. The worker restart always runs: SSR renders through Bun's module
+cache, so a new process is the only reliable way to reflect any source edit,
+client-affecting or not.
+
+Serialized: a change arriving mid-build sets `queued` so exactly one more run
+follows, collapsing further changes in between; `queuedNeedsClient` records
+whether any of them needs the client, so the collapsed run never skips a client
+rebuild a queued change required. A failed build leaves the current child
+untouched — the error is logged and the last-good server keeps serving.
 */
-async function rebuild(port: number): Promise<void> {
+async function rebuild(port: number, skipClientBuild = false): Promise<void> {
     if (building) {
         queued = true
+        queuedNeedsClient ||= !skipClientBuild
         return
     }
     building = true
     try {
-        const succeeded = await build(buildOptions)
+        const succeeded = skipClientBuild ? true : await build(buildOptions)
         if (succeeded) {
             await replaceServer(port)
         }
+        /* A server/MCP-only change reuses the existing client bundle. That's correct for
+           an rpc/socket handler BODY edit, but changing an rpc's method, its export name,
+           or `outbox: true` changes the client proxy stub too — the stale bundle then
+           calls with the old shape (e.g. a 405). Flag the skip so that case isn't silent. */
+        if (skipClientBuild) {
+            abideLog.info(
+                'server-only change — kept the existing client bundle; if you changed an rpc method, export name, or outbox, save a client file (or restart dev) for a full rebuild',
+            )
+        }
     } finally {
         building = false
         if (queued) {
             queued = false
-            void rebuild(port)
+            const needsClient = queuedNeedsClient
+            queuedNeedsClient = false
+            void rebuild(port, !needsClient)
         }
     }
 }
@@ -223,14 +245,26 @@ an agent editing the app's own source — isn't yanked mid-run by a save.
 const manualRebuild = Bun.env.ABIDE_DEV_NO_WATCH === '1'
 
 let debounce: ReturnType<typeof setTimeout> | undefined
+/*
+True only while every change collapsed into the pending debounce is server/MCP-
+only; one client-affecting change in the burst flips it false (latches until the
+debounce fires), so a multi-file save that touches the client never skips the
+client rebuild.
+*/
+let pendingSkipClientBuild = true
 const watcher = manualRebuild
     ? undefined
     : watch(SOURCE_DIR, { recursive: true }, (_event, filename) => {
           if (!filename || isGenerated(filename)) {
               return
           }
+          pendingSkipClientBuild &&= !changeAffectsClient(filename)
           clearTimeout(debounce)
-          debounce = setTimeout(() => void rebuild(port), REBUILD_DEBOUNCE_MS)
+          debounce = setTimeout(() => {
+              const skipClientBuild = pendingSkipClientBuild
+              pendingSkipClientBuild = true
+              void rebuild(port, skipClientBuild)
+          }, REBUILD_DEBOUNCE_MS)
       })
 if (manualRebuild) {
     abideLog.info(

package/src/lib/cli/parseArgvForRpc.ts

@@ -1,3 +1,5 @@
+import { tokenizeArgvFlags } from './tokenizeArgvFlags.ts'
+
 /*
 Parses an argv tail into the JSON args bag for an RPC. The JSON Schema
 on the manifest entry (when present) drives flag typing:
@@ -47,44 +49,39 @@ export async function parseArgvForRpc(
         }
     }
 
-    for (let index = 0; index < argv.length; index++) {
-        const token = argv[index] as string
-        if (token === '--json') {
-            const next = argv[++index]
-            if (!next) {
+    /* The shared tokenizer owns the flag-consumption grammar (boolean / inline /
+       `--json` / `--no-` negation). This loop layers RPC value semantics on each
+       yielded token: JSON-blob merge, Number coercion, array accumulation. */
+    for (const token of tokenizeArgvFlags(argv, jsonSchema)) {
+        if (token.positional !== undefined) {
+            throw new Error(`unexpected positional argument: ${token.positional}`)
+        }
+        if (token.isJson) {
+            if (token.missingValue || token.value === undefined) {
                 throw new Error('--json requires a value')
             }
-            const parsed = JSON.parse(next)
+            const parsed = JSON.parse(token.value)
             if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
                 throw new Error('--json value must be a JSON object')
             }
             Object.assign(args, parsed)
             continue
         }
-        if (!token.startsWith('--')) {
-            throw new Error(`unexpected positional argument: ${token}`)
+        // The tokenizer treats `--help` / `-h` as a help token; in RPC parsing
+        // they are an unrecognised flag, surfaced loudly like any other.
+        if (token.isHelp || token.name === undefined) {
+            throw new Error('unexpected --help flag')
         }
-        const stripped = token.slice('--'.length)
-        const [literalName, eqValue] = stripped.includes('=')
-            ? [stripped.slice(0, stripped.indexOf('=')), stripped.slice(stripped.indexOf('=') + 1)]
-            : [stripped, undefined]
-        /* `--no-x` negates only a known boolean property x; otherwise the literal
-           name wins, so a property legitimately named `no-…` stays reachable. */
-        const negatedName = literalName.startsWith('no-')
-            ? literalName.slice('no-'.length)
-            : undefined
-        const isNegated = negatedName !== undefined && properties[negatedName]?.type === 'boolean'
-        const name = isNegated ? (negatedName as string) : literalName
-        const prop = properties[name]
-        const propType = prop?.type
+        const name = token.name
+        const propType = properties[name]?.type
         if (propType === 'boolean') {
-            args[name] = !isNegated
+            args[name] = !token.negated
             continue
         }
-        const value = eqValue ?? argv[++index]
-        if (value === undefined) {
+        if (token.missingValue || token.value === undefined) {
             throw new Error(`--${name} requires a value`)
         }
+        const value = token.value
         if (propType === 'number' || propType === 'integer') {
             // Reject a blank value explicitly — `Number('')` / `Number('  ')` is 0,
             // not NaN, so the NaN guard alone would silently coerce it to zero.

package/src/lib/cli/runCli.ts

@@ -9,6 +9,7 @@ import { printTrimmed } from './printTrimmed.ts'
 import { resolveCliTarget } from './resolveCliTarget.ts'
 import { runSession } from './runSession.ts'
 import { startLocalInstance } from './startLocalInstance.ts'
+import { tokenizeArgvFlags } from './tokenizeArgvFlags.ts'
 import type { CliManifest } from './types/CliManifest.ts'
 import type { CliTarget } from './types/CliTarget.ts'
 
@@ -16,37 +17,21 @@ const isHelpFlag = (arg: string): boolean => arg === '--help' || arg === '-h'
 
 /*
 Whether a command's argv tail genuinely requests help, i.e. a help flag appears
-at a flag position rather than as the value of a value-expecting flag. Mirrors
-parseArgvForRpc's flag rule: boolean props (and `--name=…`) consume no following
-token, everything else consumes the next token as its value — so `--title --help`
-passes `--help` as the title value, not a help request.
+at a flag position rather than as the value of a value-expecting flag. Shares
+tokenizeArgvFlags' grammar with parseArgvForRpc so the two can't drift: the
+tokenizer applies the flag-consumption rule (boolean / `--name=…` / `--json`
+consume their value), so a `--help` that was a flag's value is already swallowed
+and never surfaces as a help token — `--title --help` passes `--help` as the
+title value, not a help request.
 */
 function commandArgvRequestsHelp(
     argvTail: string[],
     jsonSchema: Record<string, unknown> | undefined,
 ): boolean {
-    const properties =
-        (jsonSchema?.properties as Record<string, { type?: string }> | undefined) ?? {}
-    for (let index = 0; index < argvTail.length; index += 1) {
-        const token = argvTail[index] as string
-        if (isHelpFlag(token)) {
+    for (const token of tokenizeArgvFlags(argvTail, jsonSchema)) {
+        if (token.isHelp) {
             return true
         }
-        if (!token.startsWith('--')) {
-            continue
-        }
-        if (token === '--json') {
-            index += 1 // consumes its value
-            continue
-        }
-        const rawName = token.slice('--'.length)
-        if (rawName.includes('=')) {
-            continue // inline value, consumes no following token
-        }
-        const name = rawName.startsWith('no-') ? rawName.slice('no-'.length) : rawName
-        if (properties[name]?.type !== 'boolean') {
-            index += 1 // a value-expecting flag consumes the next token
-        }
     }
     return false
 }

package/src/lib/cli/tokenizeArgvFlags.ts

@@ -0,0 +1,84 @@
+/*
+The single argv-tail flag grammar shared by help-detection (runCli) and RPC arg
+parsing (parseArgvForRpc) so the two can never drift. Walks the tail and yields
+one token per flag occurrence, honouring the schema-driven consumption rule:
+
+  - `--help` / `-h`               → { isHelp: true }, consumes no following token
+  - `--json <blob>`               → { isJson: true, value }, consumes the next token
+                                     (the value is the verbatim JSON args bag)
+  - boolean props (and `--no-x`)  → { name, value: undefined }, consumes no token
+  - `--name=value`                → { name, value }, inline, consumes no token
+  - everything else               → { name, value }, consumes the next token
+
+`--no-x` negates only a known boolean property x; otherwise the literal `no-…`
+name is kept so a property legitimately named `no-…` stays reachable. Reports
+`negated` and `missingValue` so the parser can apply boolean/coercion semantics
+and throw precise errors. A bare positional (no leading `--`) yields
+{ positional: token } so each consumer rejects or ignores it as it sees fit.
+
+Pure; reads the schema's `properties` only to classify boolean props.
+*/
+export function* tokenizeArgvFlags(
+    argvTail: string[],
+    jsonSchema: Record<string, unknown> | undefined,
+): Generator<{
+    isHelp?: boolean
+    isJson?: boolean
+    positional?: string
+    name?: string
+    value?: string
+    negated?: boolean
+    missingValue?: boolean
+}> {
+    const properties =
+        (jsonSchema?.properties as Record<string, { type?: string }> | undefined) ?? {}
+    for (let index = 0; index < argvTail.length; index += 1) {
+        const token = argvTail[index] as string
+        if (token === '--help' || token === '-h') {
+            yield { isHelp: true }
+            continue
+        }
+        if (!token.startsWith('--')) {
+            yield { positional: token }
+            continue
+        }
+        // `--json <blob>`: the next token is the verbatim JSON args bag.
+        if (token === '--json') {
+            const value = argvTail[index + 1]
+            if (value === undefined) {
+                yield { isJson: true, missingValue: true }
+            } else {
+                index += 1
+                yield { isJson: true, value }
+            }
+            continue
+        }
+        const stripped = token.slice('--'.length)
+        const [literalName, inlineValue] = stripped.includes('=')
+            ? [stripped.slice(0, stripped.indexOf('=')), stripped.slice(stripped.indexOf('=') + 1)]
+            : [stripped, undefined]
+        /* `--no-x` negates only a known boolean property x; otherwise the literal
+           name wins, so a property legitimately named `no-…` stays reachable. */
+        const negatedName = literalName.startsWith('no-')
+            ? literalName.slice('no-'.length)
+            : undefined
+        const negated = negatedName !== undefined && properties[negatedName]?.type === 'boolean'
+        const name = negated ? (negatedName as string) : literalName
+        // Boolean props and inline `--name=value` consume no following token.
+        if (properties[name]?.type === 'boolean') {
+            yield { name, negated }
+            continue
+        }
+        if (inlineValue !== undefined) {
+            yield { name, value: inlineValue }
+            continue
+        }
+        const value = argvTail[index + 1]
+        if (value === undefined) {
+            yield { name, missingValue: true }
+        } else {
+            index += 1
+            yield { name, value }
+        }
+    }
+}

package/src/lib/server/error.ts

@@ -1,7 +1,10 @@
 import { NO_STORE } from '../shared/CACHE_CONTROL_VALUES.ts'
 import { TEXT_PLAIN } from '../shared/TEXT_PLAIN.ts'
-import type { ErrorDescriptor } from '../shared/types/ErrorDescriptor.ts'
+import type { StandardSchemaV1 } from '../shared/types/StandardSchemaV1.ts'
+import type { TypedError } from './rpc/types/TypedError.ts'
 import type { TypedResponse } from './rpc/types/TypedResponse.ts'
+import { STATUS_TEXT } from './runtime/STATUS_TEXT.ts'
+import { typedErrorResponse } from './runtime/typedErrorResponse.ts'
 import { withResponseDefaults } from './runtime/withResponseDefaults.ts'
 
 /*
@@ -18,37 +21,15 @@ text/plain so intermediaries don't try to render or sniff it. A final
 `ResponseInit` adds headers (e.g. `Retry-After` on a 429); the positional
 `status` always wins over any `init.status`.
 
-To short-circuit a handler instead of returning, `throw new Error(...)`
-or `throw new HttpError(error(...))` — the framework's `app.handleError`
-hook catches thrown errors. This helper deliberately returns a Response
-rather than throwing one so a single `return error(...)` is the
-expected pattern, with the same control flow as `return json(...)`.
+For a NAMED, typed error the client can branch on, declare a constructor with
+`error.typed(name, status, schema?)` and return it (see below). To short-circuit
+a handler instead of returning, `throw new Error(...)` or
+`throw new HttpError(error(...))` — the framework's `app.handleError` hook
+catches thrown errors. This helper deliberately returns a Response rather than
+throwing one so a single `return error(...)` is the expected pattern, with the
+same control flow as `return json(...)`.
 */
 
-/*
-Standard reason phrases for the statuses error() is realistically called
-with. Maintained explicitly because Bun's `Response` does not populate
-`statusText` from the status code, so there's no platform table to read.
-Unlisted codes fall back to `HTTP <status>`.
-*/
-const STATUS_TEXT: Record<number, string> = {
-    400: 'Bad Request',
-    401: 'Unauthorized',
-    403: 'Forbidden',
-    404: 'Not Found',
-    405: 'Method Not Allowed',
-    409: 'Conflict',
-    410: 'Gone',
-    413: 'Content Too Large',
-    422: 'Unprocessable Content',
-    429: 'Too Many Requests',
-    500: 'Internal Server Error',
-    501: 'Not Implemented',
-    502: 'Bad Gateway',
-    503: 'Service Unavailable',
-    504: 'Gateway Timeout',
-}
-
 /*
 Body type is `never` because `error()` only travels the non-2xx path on
 the wire — the caller's `await fn(args)` throws `HttpError` and never
@@ -57,32 +38,11 @@ the union of branches in a handler narrow to whatever the success
 branch carries (`TypedResponse<{user}> | TypedResponse<never>` → Return
 = {user}).
 */
-// @documentation response
-export function error(descriptor: ErrorDescriptor): TypedResponse<never>
-export function error(status: number, message?: string, init?: ResponseInit): TypedResponse<never>
-export function error(
-    statusOrDescriptor: number | ErrorDescriptor,
+function errorResponse(
+    status: number,
     message?: string,
     init?: ResponseInit,
 ): TypedResponse<never> {
-    /* A typed-error descriptor (`error(errors.invalidCoupon({…}))`) serializes as a
-       JSON `{ $abideError, data }` body at the descriptor's status — the client
-       parses it back onto the thrown HttpError's `.kind` / `.data`. */
-    if (typeof statusOrDescriptor === 'object') {
-        const descriptor = statusOrDescriptor
-        return new Response(
-            JSON.stringify({ $abideError: descriptor.$abideError, data: descriptor.data }),
-            withStatusText(
-                withResponseDefaults(
-                    undefined,
-                    { 'Content-Type': 'application/json', 'Cache-Control': NO_STORE },
-                    descriptor.status,
-                ),
-                descriptor.status,
-            ),
-        ) as TypedResponse<never>
-    }
-    const status = statusOrDescriptor
     const body = message ?? STATUS_TEXT[status] ?? `HTTP ${status}`
     return new Response(
         body,
@@ -113,3 +73,38 @@ function withStatusText(init: ResponseInit, status: number): ResponseInit {
     }
     return init
 }
+
+/*
+Declares a reusable, typed error as a single constructor. With a `data` schema
+the constructor requires that input; without one it's nullary. Returning the
+constructor from a handler IS the error — it serializes a `{ $abideError, data }`
+body at `status`, and the rpc reads the constructor's branded return type to
+expose the error on `rpc.isError(e, 'name')` (`.kind` and typed `.data`). No
+`errors:` option, no set to register — compose by returning whichever you want:
+
+  const duplicateSlug = error.typed('duplicateSlug', 409, z.object({ slug: z.string() }))
+  const rateLimited = error.typed('rateLimited', 429)               // nullary
+
+  export const createPost = POST(({ slug }) =>
+      taken(slug) ? duplicateSlug({ slug }) : json(save(slug)),
+  )
+
+`name` is the wire identity and the `isError` key, so it's an explicit string
+(a const can't read its own variable name); `schema` types `.data` and is never
+validated at runtime here.
+*/
+function typed<Name extends string, Schema extends StandardSchemaV1>(
+    name: Name,
+    status: number,
+    schema: Schema,
+): (data: StandardSchemaV1.InferInput<Schema>) => TypedError<Name, { status: number; data: Schema }>
+function typed<Name extends string>(
+    name: Name,
+    status: number,
+): () => TypedError<Name, { status: number; data?: undefined }>
+function typed(name: string, status: number, _schema?: StandardSchemaV1) {
+    return (data?: unknown) => typedErrorResponse(name, status, data)
+}
+
+// @documentation response
+export const error = Object.assign(errorResponse, { typed })

package/src/lib/server/json.ts

@@ -9,13 +9,14 @@ unless the caller overrides it. Intermediary caches (browsers, CDNs,
 shared proxies) shouldn't cache rpc replies by default; the framework's
 own per-request cache handles in-process dedupe.
 
-  export const getOrder = GET<{ id: string }>(async ({ id }) =>
+  export const getOrder = GET(async ({ id }: { id: string }) =>
       json(await db.getOrder(id)),
   )
 
 The return type carries `T` as a phantom brand so the rpc helper can
-infer the caller-facing `Return` from the handler body — no need to
-annotate `GET<Args, Return>` just to type the response shape.
+infer the caller-facing `Return` from the handler body — you type the
+handler's parameter and let the body infer; there are no `<Args, Return>`
+call generics (a stray one is a compile error).
 
 For non-default cache policy pass `init.headers`; explicit
 `cache-control` wins over the default.

package/src/lib/server/jsonl.ts

@@ -4,7 +4,7 @@ Wraps an AsyncIterable<Frame> in a Response whose body is JSON Lines
 inside an rpc handler to turn a generator into a streaming HTTP response
 that `tail(fn.stream(args))` consumes frame-by-frame on the client.
 
-  export const orderFeed = GET<Args>((args) =>
+  export const orderFeed = GET((args: Args) =>
       jsonl(async function* () {
           for await (const order of db.watchOrders(args)) yield order
       }())

package/src/lib/server/rpc/defineRpc.ts

@@ -5,12 +5,10 @@ import { forwardHeaders } from '../../shared/forwardHeaders.ts'
 import { isReadOnlyMethod } from '../../shared/isReadOnlyMethod.ts'
 import { resolveClientFlags } from '../../shared/resolveClientFlags.ts'
 import type { ClientFlags } from '../../shared/types/ClientFlags.ts'
-import type { ErrorSpec } from '../../shared/types/ErrorSpec.ts'
 import type { HttpMethod } from '../../shared/types/HttpMethod.ts'
 import type { RemoteFunction } from '../../shared/types/RemoteFunction.ts'
 import type { StandardSchemaV1 } from '../../shared/types/StandardSchemaV1.ts'
 import { requestContext } from '../runtime/requestContext.ts'
-import { buildErrorConstructors } from './buildErrorConstructors.ts'
 import { parseArgs } from './parseArgs.ts'
 import { registerRpc } from './registerRpc.ts'
 import { runWithRpcTimeout } from './runWithRpcTimeout.ts'
@@ -55,7 +53,6 @@ export function defineRpc<Args, Return>(
         inputSchema?: StandardSchemaV1
         outputSchema?: StandardSchemaV1
         filesSchema?: StandardSchemaV1
-        errors?: ErrorSpec
         clients?: Partial<ClientFlags>
         crossOrigin?: boolean
         /* Per-rpc cap on actual received body bytes (413 past it); omitted = Bun's server-wide maxRequestBodySize. */
@@ -81,8 +78,6 @@ export function defineRpc<Args, Return>(
     const inputSchema = opts?.inputSchema
     const outputSchema = opts?.outputSchema
     const filesSchema = opts?.filesSchema
-    /* The declared error constructors handed to the handler as its `{ errors }` ctx. */
-    const errors = buildErrorConstructors(opts?.errors ?? {})
     /*
     An input schema makes the handler safe to advertise to non-browser
     surfaces. CLI flips on for any rpc with one (a human/script invokes it
@@ -100,7 +95,15 @@ export function defineRpc<Args, Return>(
     function buildRequest(args: Args | undefined): Request {
         const store = requestContext.getStore()
         const baseUrl = store ? store.url.href : 'http://localhost/'
-        const headers = store ? forwardHeaders(store.req.headers) : new Headers()
+        /* The forwarded allowlist is request-invariant — derive it once per scope
+           and clone per call (buildRpcRequest mutates the Headers). */
+        let headers: Headers
+        if (store) {
+            store.forwardedHeaders ??= forwardHeaders(store.req.headers)
+            headers = new Headers(store.forwardedHeaders)
+        } else {
+            headers = new Headers()
+        }
         return buildRpcRequest({ method, url, args, baseUrl, headers })
     }
 
@@ -115,7 +118,7 @@ export function defineRpc<Args, Return>(
     async function runHandler(args: Args | undefined): Promise<Response> {
         return rpcLog.trace(
             `rpc ${method} ${url}`,
-            () => handler(args as Args, { errors }) as unknown as Response,
+            () => handler(args as Args) as unknown as Response,
         )
     }
 
@@ -158,8 +161,7 @@ export function defineRpc<Args, Return>(
     /* Abort the controller parseArgsForFetch stashed on store.req; a no-op when none was stashed (SSR cache reads). */
     function abortRpcTimeout(): void {
         const req = requestContext.getStore()?.req as
-            | (Request & { [RPC_TIMEOUT_ABORT]?: AbortController })
-            | undefined
+            (Request & { [RPC_TIMEOUT_ABORT]?: AbortController }) | undefined
         req?.[RPC_TIMEOUT_ABORT]?.abort(new DOMException('handler timeout', 'TimeoutError'))
     }
 

package/src/lib/server/rpc/types/RemoteHandler.ts

@@ -1,5 +1,3 @@
-import type { ErrorConstructors } from '../../../shared/types/ErrorConstructors.ts'
-import type { ErrorSpec } from '../../../shared/types/ErrorSpec.ts'
 import type { TypedResponse } from './TypedResponse.ts'
 
 /*
@@ -23,11 +21,11 @@ untagged Responses fall back to `Return = unknown`.
 Handlers that need the inbound Request (headers, `request.signal`, …) read
 it via `request()` from `abide/server` rather than a handler parameter, so
 the signature stays a single parsed-`args` bag.
+
+A typed error is raised by returning an `error.typed(name, status, schema?)`
+constructor (`return outOfStock({…})`) — there is no `ctx` param; the rpc reads
+the error surface off the returned constructors' brands.
 */
-export type RemoteHandler<Args, Return, Errors extends ErrorSpec = Record<never, never>> = (
+export type RemoteHandler<Args, Return> = (
     args: Args,
-    /* The rpc's declared error constructors (`error(errors.invalidCoupon({…}))`), typed
-       from its `errors` opt; an empty object when none declared. A handler that takes only
-       `args` is still assignable here (fewer params is assignable to more). */
-    ctx: { errors: ErrorConstructors<Errors> },
 ) => TypedResponse<Return> | Promise<TypedResponse<Return>>