@abide/abide 0.44.1 → 0.46.0

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
@@ -123,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,
         )
     }
 

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>>

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

@@ -2,7 +2,61 @@ import type { ClientFlags } from '../../../shared/types/ClientFlags.ts'
 import type { ErrorSpec } from '../../../shared/types/ErrorSpec.ts'
 import type { RemoteFunction } from '../../../shared/types/RemoteFunction.ts'
 import type { StandardSchemaV1 } from '../../../shared/types/StandardSchemaV1.ts'
-import type { RemoteHandler } from './RemoteHandler.ts'
+import type { TypedError } from './TypedError.ts'
+import type { TypedResponse } from './TypedResponse.ts'
+
+/*
+The success body carried by a handler's return type `R`. Error branches
+(`TypedError`, checked first since they're also Responses) drop to `never` and
+union away, so `Return` is the body of the success `TypedResponse` members alone
+— an untagged `Response` falls back to `unknown`, matching hand-built responses.
+*/
+type SuccessBody<R> =
+    R extends TypedError<string, ErrorSpec[string]>
+        ? never
+        : R extends TypedResponse<infer Body>
+          ? Body
+          : unknown
+
+/*
+The error spec a handler's return type `R` declares — rebuilt name→entry from the
+`TypedError` brands among its branches (distributes over the union; no error
+branches → `{}`). This is what gives `rpc.isError` its typed surface with no
+`errors:` option: the errors a handler RETURNS are the errors it can raise.
+*/
+type ErrorBrand<R> =
+    R extends TypedError<infer Name, infer Entry> ? { name: Name; entry: Entry } : never
+type InferredErrors<R> = { [Brand in ErrorBrand<R> as Brand['name']]: Brand['entry'] }
+
+/*
+The handler every bare (schemaless) overload accepts: any args in, a Response (or a
+Promise of one) out. Collapsing the old `<Args, R>` pair into this single inferred
+function type is deliberate. TypeScript has no partial type-argument inference, so
+`GET<Args>(fn)` used to drop `R` to its `Response` default and silently erase the body
+to `unknown`. With one generic constrained to `RpcFn`, that same call is instead a loud
+`does not satisfy the constraint 'RpcFn'`, and `Args`/`Return`/`Errors` all read
+structurally off the handler — args from its parameter, body + errors from its return —
+which is where a normal TS function declares them anyway (no mainstream rpc framework
+parameterises the call with generics). `any` is load-bearing: `never`/`unknown` in the
+parameter position break return inference by contextually widening the handler's body.
+*/
+type RpcFn = (args: any) => Response | Promise<Response>
+
+/* The handler's declared args: its first parameter, or `undefined` for a nullary handler. */
+type RpcArgs<F extends RpcFn> = Parameters<F> extends [infer Args, ...unknown[]] ? Args : undefined
+
+/*
+The RemoteFunction a bare overload produces from handler `F`. `SuccessBody`/`InferredErrors`
+run over `Awaited<ReturnType<F>>` INLINE (not via an intermediate `extends RpcFn`-constrained
+alias) — such an alias resolves `ReturnType` against the constraint bound and degrades the
+body to `any`. `Durable` threads the outbox bit through for the durable overloads.
+*/
+type RpcOf<F extends RpcFn, Durable extends boolean = false> = RemoteFunction<
+    RpcArgs<F>,
+    SuccessBody<Awaited<ReturnType<F>>>,
+    InferredErrors<Awaited<ReturnType<F>>>,
+    Durable
+>
 
 /*
 Options every rpc overload accepts: the OpenAPI 200 `outputSchema`, the
@@ -34,14 +88,17 @@ type MutatingRpcOpts = RpcBaseOpts & {
 }
 
 /*
-Shared signature for every rpc helper (GET / POST / …). Four overloads:
+Shared signature for every rpc helper (GET / POST / …). The handler's return
+type is inferred whole (`Awaited<ReturnType<F>>`), then split: `SuccessBody`
+becomes the caller's `Return`, `InferredErrors` becomes the rpc's `Errors`
+(driving `isError`). Typed errors are raised by returning an
+`error.typed(name, status, schema?)` constructor — there is no `errors:` opt.
+Four overloads by argument source:
 
   - `Rpc(fn, { inputSchema, outputSchema?, clients? })` — `Args` infers
     from `InferInput<InputSchema>`, the handler receives
-    `InferOutput<InputSchema>`. Generic order is `<Return, InputSchema>` so
-    users can override `Return` while letting `InputSchema` infer from
-    `opts.inputSchema`. `outputSchema` is an optional Standard Schema for
-    the success body — it feeds the OpenAPI 200 response and the MCP tool
+    `InferOutput<InputSchema>`. `outputSchema` is an optional Standard Schema
+    for the success body — it feeds the OpenAPI 200 response and the MCP tool
     `outputSchema`. JSON Schema is projected from each schema's own
     `toJSONSchema()` (wrap with withJsonSchema if the library lacks one).
     `clients` controls which surfaces (browser / mcp / cli) expose this rpc.
@@ -57,9 +114,13 @@ Shared signature for every rpc helper (GET / POST / …). Four overloads:
     just abandoned.
   - `Rpc(fn, { clients })` — schemaless but with explicit client
     targeting (e.g. server-internal RPC with `clients: { browser: false }`).
-  - `Rpc(fn)` — bare handler. `Args` and `Return` come from the handler
-    type; `Return` is usually inferred via the `TypedResponse<T>` brand on
-    `json`/`error`/`redirect`/`jsonl`/`sse`.
+  - `Rpc(fn)` — bare handler, a single `F extends RpcFn` generic. Everything
+    is read off the handler: `Args` from its parameter (annotate it —
+    `POST((a: { id: string }) => …)` — or leave it nullary for `undefined`),
+    `Return` from the `TypedResponse<T>` brand on
+    `json`/`error`/`redirect`/`jsonl`/`sse`, `Errors` from any
+    `error.typed(...)` branches. You never pass `<Args, Return>` generics; a
+    stray one is a loud constraint error, not a silent `unknown` body.
 */
 type RpcHelperOf<Opts> = {
     /*
@@ -72,47 +133,76 @@ type RpcHelperOf<Opts> = {
     jsonSchemaForSchema) — so only inputSchema feeds MCP/CLI/OpenAPI.
     */
     <
-        Return = unknown,
+        R extends Response,
         InputSchema extends StandardSchemaV1 = StandardSchemaV1,
         FilesSchema extends StandardSchemaV1 = StandardSchemaV1,
-        Errors extends ErrorSpec = Record<string, never>,
     >(
-        fn: RemoteHandler<
-            StandardSchemaV1.InferOutput<InputSchema> & StandardSchemaV1.InferOutput<FilesSchema>,
-            Return,
-            Errors
-        >,
+        fn: (
+            args: StandardSchemaV1.InferOutput<InputSchema> &
+                StandardSchemaV1.InferOutput<FilesSchema>,
+        ) => R | Promise<R>,
         opts: Opts & {
             inputSchema: InputSchema
             filesSchema: FilesSchema
-            errors?: Errors
         },
-    ): RemoteFunction<StandardSchemaV1.InferInput<InputSchema>, Return, Errors>
-    <
-        Return = unknown,
-        InputSchema extends StandardSchemaV1 = StandardSchemaV1,
-        Errors extends ErrorSpec = Record<string, never>,
-    >(
-        fn: RemoteHandler<StandardSchemaV1.InferOutput<InputSchema>, Return, Errors>,
-        opts: Opts & { inputSchema: InputSchema; errors?: Errors },
-    ): RemoteFunction<StandardSchemaV1.InferInput<InputSchema>, Return, Errors>
-    <Args = undefined, Return = unknown, Errors extends ErrorSpec = Record<never, never>>(
-        fn: RemoteHandler<Args, Return, Errors>,
-        opts: Opts & { errors?: Errors },
-    ): RemoteFunction<Args, Return, Errors>
-    <Args = undefined, Return = unknown>(
-        fn: RemoteHandler<Args, Return>,
-    ): RemoteFunction<Args, Return>
+    ): RemoteFunction<StandardSchemaV1.InferInput<InputSchema>, SuccessBody<R>, InferredErrors<R>>
+    <R extends Response, InputSchema extends StandardSchemaV1 = StandardSchemaV1>(
+        fn: (args: StandardSchemaV1.InferOutput<InputSchema>) => R | Promise<R>,
+        opts: Opts & { inputSchema: InputSchema },
+    ): RemoteFunction<StandardSchemaV1.InferInput<InputSchema>, SuccessBody<R>, InferredErrors<R>>
+    <F extends RpcFn>(fn: F, opts: Opts): RpcOf<F>
+    <F extends RpcFn>(fn: F): RpcOf<F>
 }
 
 /* The read helpers (GET/HEAD): no `outbox` — a read has nothing to durably deliver. */
 export type RpcHelper = RpcHelperOf<RpcBaseOpts>
 
+/*
+Durable-call overloads: an `outbox: true` opt returns a RemoteFunction whose `Durable` bit
+is set, so `rpc.outbox` is the queue face rather than optionally-undefined. Mirrors the
+opts-bearing base overloads (multipart-upload, schema'd, schemaless); the bare `Rpc(fn)`
+form has no opts to carry `outbox`, so it stays non-durable. Intersected AHEAD of the base
+set in MutatingRpcHelper so an `outbox: true` literal resolves here first.
+*/
+type DurableMutatingRpcHelper = {
+    <
+        R extends Response,
+        InputSchema extends StandardSchemaV1 = StandardSchemaV1,
+        FilesSchema extends StandardSchemaV1 = StandardSchemaV1,
+    >(
+        fn: (
+            args: StandardSchemaV1.InferOutput<InputSchema> &
+                StandardSchemaV1.InferOutput<FilesSchema>,
+        ) => R | Promise<R>,
+        opts: MutatingRpcOpts & {
+            inputSchema: InputSchema
+            filesSchema: FilesSchema
+            outbox: true
+        },
+    ): RemoteFunction<
+        StandardSchemaV1.InferInput<InputSchema>,
+        SuccessBody<R>,
+        InferredErrors<R>,
+        true
+    >
+    <R extends Response, InputSchema extends StandardSchemaV1 = StandardSchemaV1>(
+        fn: (args: StandardSchemaV1.InferOutput<InputSchema>) => R | Promise<R>,
+        opts: MutatingRpcOpts & { inputSchema: InputSchema; outbox: true },
+    ): RemoteFunction<
+        StandardSchemaV1.InferInput<InputSchema>,
+        SuccessBody<R>,
+        InferredErrors<R>,
+        true
+    >
+    <F extends RpcFn>(fn: F, opts: MutatingRpcOpts & { outbox: true }): RpcOf<F, true>
+}
+
 /*
 The mutating helpers (POST/PUT/PATCH/DELETE). A durable (`outbox`) call is a normal
 RemoteFunction — it throws exactly like a non-durable one and only parks the request as a
 side-effect on an unreachable server — so there is no separate return shape; `outbox` rides
 MutatingRpcOpts and `rpc.outbox` exposes the queue. The distinct opts base is what makes
-`outbox` legal here and a compile error on the read helpers.
+`outbox` legal here and a compile error on the read helpers; the durable overloads then set
+the return type's `Durable` bit so `rpc.outbox` is present without an optional chain.
 */
-export type MutatingRpcHelper = RpcHelperOf<MutatingRpcOpts>
+export type MutatingRpcHelper = DurableMutatingRpcHelper & RpcHelperOf<MutatingRpcOpts>

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

@@ -0,0 +1,18 @@
+import type { ErrorSpec } from '../../../shared/types/ErrorSpec.ts'
+
+/*
+A `Response` branded with the typed error a handler RETURNED — the name it
+travels as (`$abideError`) plus its spec entry (`{ status, data? }`). The rpc
+helper reads this brand off the handler's inferred return union to build the
+function's `Errors` surface, so `rpc.isError(e, 'name')` narrows `.kind` / `.data`
+with no `errors:` option to declare.
+
+Unlike `TypedResponse`'s `__body?` (optional, so a bare `new Response()` stays
+assignable), the brand here is REQUIRED: it's the discriminant that tells the
+helper an error branch from a success branch (the success body is extracted from
+the non-error members, the error spec from these). The runtime value is a plain
+serialized Response cast to this type — the brand is phantom, never assigned.
+*/
+export type TypedError<Name extends string, Entry extends ErrorSpec[string]> = Response & {
+    readonly __abideError: { name: Name; entry: Entry }
+}

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

@@ -1,17 +1,17 @@
 import type { StandardSchemaV1 } from '../../shared/types/StandardSchemaV1.ts'
 import type { ValidationErrorData } from '../../shared/types/ValidationErrorData.ts'
-import { error } from '../error.ts'
+import { typedErrorResponse } from '../runtime/typedErrorResponse.ts'
 import { fieldErrorsFromIssues } from './fieldErrorsFromIssues.ts'
 
 /*
 The framework-reserved `validation` typed error a 422 carries: the raw Standard
 Schema `issues` plus the form-friendly field → first-message map. Routed through
-the single `error()` funnel (descriptor form) so it serializes as the same
+the shared `typedErrorResponse` serializer so it emits the same
 `{ $abideError, data }` body every typed error uses, and so the 422's reason
 phrase reaches `HttpError.statusText`. The client parses it back onto
 `HttpError.kind = 'validation'` / `.data: ValidationErrorData`.
 */
 export function validationError(issues: readonly StandardSchemaV1.Issue[]): Response {
     const data: ValidationErrorData = { issues, fields: fieldErrorsFromIssues(issues) }
-    return error({ $abideError: 'validation', status: 422, data })
+    return typedErrorResponse('validation', 422, data)
 }

package/src/lib/server/runtime/STATUS_TEXT.ts

@@ -0,0 +1,22 @@
+/*
+Standard reason phrases for the statuses abide sets explicitly. 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>` at the call site.
+*/
+export 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',
+}

package/src/lib/server/runtime/createServer.ts

@@ -50,6 +50,7 @@ import { devHotModuleResponse } from './devHotModuleResponse.ts'
 import { devReloadResponse } from './devReloadResponse.ts'
 import { disableIdleTimeoutForStream } from './disableIdleTimeoutForStream.ts'
 import { gzipResponse } from './gzipResponse.ts'
+import { installAmbientScopeStore } from './installAmbientScopeStore.ts'
 import { internalErrorResponse } from './internalErrorResponse.ts'
 import { listenOnOpenPort } from './listenOnOpenPort.ts'
 import { logExposedSurfaces } from './logExposedSurfaces.ts'
@@ -159,6 +160,12 @@ export async function createServer({
     HTTP test harness gets the same behaviour as a real boot. elapsedMs is
     computed at read time so every log line carries a current value.
     */
+    /*
+    Key the ambient lexical scope off the per-request ALS store, so concurrent
+    async SSR renders don't clobber one shared module global across the inline
+    `await`s they suspend on (see installAmbientScopeStore / CURRENT_SCOPE).
+    */
+    installAmbientScopeStore()
     setRequestScopeResolver(() => {
         const store = requestContext.getStore()
         if (!store) {

package/src/lib/server/runtime/installAmbientScopeStore.ts

@@ -0,0 +1,33 @@
+import { ambientScopeBacking } from '../../ui/runtime/ambientScopeBacking.ts'
+import type { Scope } from '../../ui/types/Scope.ts'
+import { requestContext } from './requestContext.ts'
+
+/* Ambient scope when no request is in flight (server boot, a standalone render). */
+let outsideRequest: Scope | undefined
+
+/*
+Swaps the ambient-scope backing to one keyed off the per-request AsyncLocalStorage
+store, so `CURRENT_SCOPE.current` isolates per request instead of living in one
+module global (see CURRENT_SCOPE). SSR is partly async — a render `await`s inline
+between its `enterScope`/`exitScope` bracket — and the async context propagates the
+right store across those awaits, so a resumed render reads ITS OWN scope even while
+another request renders concurrently. Called once at server boot (createServer),
+alongside the request-scope resolver install. Reads/writes outside any request fall
+back to a module variable (unchanged behaviour for standalone renders).
+*/
+export function installAmbientScopeStore(): void {
+    ambientScopeBacking.active = {
+        get: () => {
+            const store = requestContext.getStore()
+            return store ? store.currentScope : outsideRequest
+        },
+        set: (value) => {
+            const store = requestContext.getStore()
+            if (store) {
+                store.currentScope = value
+            } else {
+                outsideRequest = value
+            }
+        },
+    }
+}

package/src/lib/server/runtime/snapshotEntryFromCache.ts

@@ -74,6 +74,8 @@ export async function snapshotEntryFromCache(
         statusText: response.statusText,
         headers: Array.from(response.headers.entries()),
         body,
+        /* Deferred by the SSR resume path → seed the shipped body lazily (no hydration decode). */
+        lazy: entry.deferred === true ? true : undefined,
     }
 }
 

package/src/lib/server/runtime/typedErrorResponse.ts

@@ -0,0 +1,26 @@
+import { NO_STORE } from '../../shared/CACHE_CONTROL_VALUES.ts'
+import type { TypedResponse } from '../rpc/types/TypedResponse.ts'
+import { STATUS_TEXT } from './STATUS_TEXT.ts'
+import { withResponseDefaults } from './withResponseDefaults.ts'
+
+/*
+Serializes a typed error as a `{ $abideError, data }` JSON body at `status`, with
+the status reason phrase as statusText so it reaches `HttpError.statusText` on the
+client (which parses the body back onto `HttpError.kind` / `.data`). `data` of
+`undefined` drops the key (nullary errors). The single serializer shared by the
+`error.typed(...)` constructors and the framework-reserved `validation` error.
+*/
+export function typedErrorResponse(
+    name: string,
+    status: number,
+    data: unknown,
+): TypedResponse<never> {
+    return new Response(
+        JSON.stringify({ $abideError: name, data }),
+        withResponseDefaults(
+            { statusText: STATUS_TEXT[status] ?? `HTTP ${status}` },
+            { 'Content-Type': 'application/json', 'Cache-Control': NO_STORE },
+            status,
+        ),
+    ) as TypedResponse<never>
+}

package/src/lib/server/runtime/types/RequestStore.ts

@@ -1,5 +1,6 @@
 import type { CacheStore } from '../../../shared/types/CacheStore.ts'
 import type { TraceContext } from '../../../shared/types/TraceContext.ts'
+import type { Scope } from '../../../ui/types/Scope.ts'
 
 /*
 Per-request state propagated through AsyncLocalStorage. Every field is
@@ -68,4 +69,12 @@ export type RequestStore = {
     back to classifying the response themselves.
     */
     responseStreaming?: boolean
+    /*
+    The request's ambient lexical scope during its SSR pass — the backing for
+    `CURRENT_SCOPE.current` under the server's ALS-backed holder
+    (installAmbientScopeStore). Keeping it per-request isolates the ambient across
+    the inline `await`s a render suspends on, so concurrent renders don't clobber
+    one shared module global. Undefined until the render enters its first scope.
+    */
+    currentScope?: Scope
 }

package/src/lib/server/sse.ts

@@ -5,7 +5,7 @@ Server-Sent Events (text/event-stream) — each frame becomes one
 generator over plain HTTP so EventSource (or `tail(fn.stream(args))`
 on the client) can consume it frame-by-frame.
 
-  export const orderFeed = GET<Args>((args) =>
+  export const orderFeed = GET((args: Args) =>
       sse(async function* () {
           for await (const order of db.watchOrders(args)) yield order
       }())

package/src/lib/shared/DEFER_MIN_ARRAY_LENGTH.ts

@@ -0,0 +1,14 @@
+/*
+The array-length above which a blocking `{#await cache()}` value is worth deferring (shipped
+inert, materialized on idle) rather than inlined and hydrated eagerly at boot. Deferral trades
+a live boot for a cheaper one; below this many rows the boot decode is cheap enough that the
+trade doesn't pay, so the block stays eager — fully interactive from the first frame, no wake
+needed. Only genuinely large grids cross it and take the inert-then-idle-wake path.
+
+An O(1) `.length` heuristic (measured on the resolved value, before serialization): array-shaped
+cache reads — lists, grids, tables — are the payloads big enough to matter, and the ones the
+inert path was built for. Non-array values never defer. A deliberately generous default: with
+idle-wake, a deferred block is interactive anyway (live before a human acts), so this is a
+boot-performance knob, not a correctness one — set high so eager-and-simple is the common case.
+*/
+export const DEFER_MIN_ARRAY_LENGTH = 500

package/src/lib/shared/HttpError.ts

@@ -9,7 +9,7 @@ export class HttpError extends Error {
     readonly status: number
     readonly statusText: string
     readonly response: Response
-    /* Set when the handler returned a typed error (`error(errors.x(...))`) or a
+    /* Set when the handler returned a typed error (`error.typed(...)` constructor) or a
        validation 422: `kind` is the declared error name (or 'validation'), `data` the
        payload it carried — parsed off the `{ $abideError, data }` body by decodeResponse.
        `data` is typed `unknown` (a throw can't carry the rpc's per-kind type to the