@orpc/server 2.0.0-beta.35 → 2.0.0-beta.37

package/dist/adapters/node/index.mjs

@@ -1,59 +1,32 @@
 export { R as BodyLimitPlugin } from '../../shared/server.1ExWFMze.mjs';
-import { sortPlugins, intercept, resolveMaybeOptionalOptions } from '@orpc/shared';
+import { resolveMaybeOptionalOptions } from '@orpc/shared';
 import { toStandardLazyRequest, sendStandardResponse } from '@standard-server/node';
 import { r as resolveFriendlyStandardHandlerHandleOptions } from '../../shared/server.W91HSRkE.mjs';
-import { R as RPCHandlerCodec, S as StandardHandler } from '../../shared/server.sNWd6DAG.mjs';
+import { R as RPCHandlerCodec, S as StandardHandler } from '../../shared/server.C0lFtoHU.mjs';
 import '@orpc/client';
 import '@standard-server/core';
 import '@standard-server/fetch';
 import '../../shared/server.Djb_ebJT.mjs';
 import '@orpc/contract';
-import '../../shared/server.BYnwk7Xz.mjs';
-
-class CompositeNodeHttpHandlerPlugin {
-  name = "~composite/node-http";
-  plugins;
-  constructor(plugins = []) {
-    this.plugins = sortPlugins(plugins);
-  }
-  initNodeHttpHandlerOptions(options) {
-    for (const plugin of this.plugins) {
-      if (plugin.initNodeHttpHandlerOptions) {
-        options = plugin.initNodeHttpHandlerOptions(options);
-      }
-    }
-    return options;
-  }
-}
+import '../../shared/server.BynNaBBA.mjs';
 
 class NodeHttpHandler {
   constructor(standardHandler, options = {}) {
     this.standardHandler = standardHandler;
-    options = new CompositeNodeHttpHandlerPlugin(options.plugins).initNodeHttpHandlerOptions(options);
-    this.nodeHttpInterceptors = options.nodeHttpInterceptors;
     this.sendStandardResponseOptions = options.sendStandardResponse;
   }
   sendStandardResponseOptions;
-  nodeHttpInterceptors;
   async handle(request, response, ...rest) {
-    return intercept(
-      this.nodeHttpInterceptors,
-      {
-        ...resolveFriendlyStandardHandlerHandleOptions(resolveMaybeOptionalOptions(rest)),
-        request,
-        response,
-        sendStandardResponseOptions: this.sendStandardResponseOptions
-      },
-      async ({ request: request2, response: response2, sendStandardResponseOptions, ...options }) => {
-        const standardRequest = toStandardLazyRequest(request2, response2);
-        const result = await this.standardHandler.handle(standardRequest, options);
-        if (!result.matched) {
-          return result;
-        }
-        await sendStandardResponse(response2, result.response, sendStandardResponseOptions);
-        return result;
-      }
+    const standardRequest = toStandardLazyRequest(request, response);
+    const result = await this.standardHandler.handle(
+      standardRequest,
+      resolveFriendlyStandardHandlerHandleOptions(resolveMaybeOptionalOptions(rest))
     );
+    if (!result.matched) {
+      return result;
+    }
+    await sendStandardResponse(response, result.response, this.sendStandardResponseOptions);
+    return result;
   }
 }
 
@@ -65,4 +38,4 @@ class RPCHandler extends NodeHttpHandler {
   }
 }
 
-export { CompositeNodeHttpHandlerPlugin, NodeHttpHandler, RPCHandler };
+export { NodeHttpHandler, RPCHandler };

package/dist/adapters/standard/index.d.mts

@@ -1,19 +1,93 @@
-import { c as StandardHandlerHandleOptions } from '../../shared/server.R0uHWfBo.mjs';
-export { C as CompositeStandardHandlerPlugin, b as StandardHandler, d as StandardHandlerCodec, e as StandardHandlerCodecResolvedProcedure, h as StandardHandlerHandleResult, i as StandardHandlerInterceptor, g as StandardHandlerInterceptorOptions, a as StandardHandlerOptions, S as StandardHandlerPlugin, j as StandardHandlerRoutingInterceptor, f as StandardHandlerRoutingInterceptorOptions, T as TracingHandlerPlugin } from '../../shared/server.R0uHWfBo.mjs';
-export { a as RPCHandlerCodec, R as RPCHandlerCodecOptions, b as RPCMatcher, c as RPCMatcherOptions, d as RPC_DEFAULT_ALLOW_METHODS } from '../../shared/server.DcHlvZFK.mjs';
-import { Context } from '../../index.mjs';
-import '@orpc/client';
-import '@orpc/shared';
-import '@standard-server/core';
-import '@orpc/contract';
-import '../../shared/server.BpmUhems.mjs';
+import { R as ResolvedStandardHandlerHandleOptions, f as StandardHandlerCodec, g as StandardHandlerCodecResolvedProcedure } from '../../shared/server.B5K1CViq.mjs';
+export { C as CompositeStandardHandlerPlugin, S as StandardHandler, a as StandardHandlerHandleOptions, h as StandardHandlerHandleResult, i as StandardHandlerInterceptor, e as StandardHandlerInterceptorOptions, c as StandardHandlerOptions, b as StandardHandlerPlugin, j as StandardHandlerRoutingInterceptor, d as StandardHandlerRoutingInterceptorOptions, T as TracingHandlerPlugin } from '../../shared/server.B5K1CViq.mjs';
+import { RPCSerializer, AnyORPCError } from '@orpc/client';
+import { Value, Public, Promisable } from '@orpc/shared';
+import { StandardMethod, StandardLazyRequest, StandardResponse } from '@standard-server/core';
+import { AnyProcedure, Context } from '../../index.mjs';
+import { AnyRouter } from '../../index.mjs';
+import { AnyProcedureContract } from '@orpc/contract';
+export { F as FriendlyStandardHandlerHandleOptions, r as resolveFriendlyStandardHandlerHandleOptions } from '../../shared/server.CFqSIFnT.mjs';
 
-type FriendlyStandardHandlerHandleOptions<T extends Context> = Omit<StandardHandlerHandleOptions<T>, 'context'> & (object extends T ? {
-    context?: T;
-} : {
-    context: T;
-});
-declare function resolveFriendlyStandardHandlerHandleOptions<T extends Context>(options: FriendlyStandardHandlerHandleOptions<T>): StandardHandlerHandleOptions<T>;
+/**
+ * Methods that can invoke procedures by default. Browsers cannot trigger them
+ * cross-site without a CORS preflight or an HTML form, unlike `GET`, which a plain
+ * `<a>` click or redirect can trigger with `SameSite=Lax` cookies attached. Other
+ * methods (`HEAD`, `OPTIONS`, `QUERY`, ...) have safe semantics that should not
+ * invoke a procedure that can modify data.
+ *
+ * @see {@link https://orpc.dev/docs/rpc/handler#supported-http-methods | RPC Handler - Supported HTTP Methods}
+ */
+declare const RPC_DEFAULT_ALLOW_METHODS: readonly StandardMethod[];
+interface RPCMatcherOptions {
+    /**
+     * Filter which procedures are exposed for matching. Return `false` to exclude.
+     *
+     * @default true
+     */
+    filter?: Value<boolean, [procedure: AnyProcedureContract | AnyProcedure, path: string[]]>;
+    /**
+     * Restricts which HTTP methods can invoke procedures, either with a list of allowed
+     * methods or decided per request via a function. Requests using a disallowed method
+     * are treated as unmatched. `GET` is excluded by default because it is exposed to
+     * Cross-Site Request Forgery (CSRF) attacks.
+     *
+     * @default RPC_DEFAULT_ALLOW_METHODS (['POST', 'PUT', 'PATCH', 'DELETE'])
+     * @see {@link https://orpc.dev/docs/rpc/handler#supported-http-methods | RPC Handler - Supported HTTP Methods}
+     */
+    allowMethods?: readonly StandardMethod[] | ((method: StandardMethod, procedure: AnyProcedure, path: string[]) => boolean);
+}
+declare class RPCMatcher {
+    private readonly filter;
+    private readonly allowMethodsSet;
+    private readonly allowMethodsFn;
+    private readonly rootRouter;
+    private readonly tree;
+    private readonly pendingLazyRouters;
+    constructor(router: AnyRouter, options?: RPCMatcherOptions);
+    private index;
+    match(method: StandardMethod, pathname: `/${string}`, prefix: `/${string}` | undefined): Promise<{
+        path: string[];
+        procedure: AnyProcedure;
+    } | undefined>;
+    private resolvePendingLazyRouters;
+    private loadPendingLazyRouters;
+    private loadPendingLazyRouter;
+    private indexPendingLazyRouter;
+    private resolveProcedure;
+}
 
-export { StandardHandlerHandleOptions, resolveFriendlyStandardHandlerHandleOptions };
-export type { FriendlyStandardHandlerHandleOptions };
+interface RPCHandlerCodecOptions<T extends Context> extends RPCMatcherOptions {
+    /**
+     * Override the default RPC serializer.
+     */
+    serializer?: Public<RPCSerializer>;
+    /**
+     * Resolve HTTP status for encoded successful outputs.
+     *
+     * Value should be in the `2xx` range and must be less than `400`.
+     * Return `undefined` or `null` to fallback to default
+     *
+     * @default DEFAULT_SUCCESS_STATUS (200)
+     */
+    outputStatus?: Value<number | undefined | null, [output: unknown, procedure: AnyProcedure, path: string[], options: ResolvedStandardHandlerHandleOptions<T>]>;
+    /**
+     * Mapping ORPCError Code -> HTTP Status Code
+     * The status code should be in the `4xx` or `5xx` range (must be greater than or equal to `400`).
+     *
+     * @default COMMON_ERROR_STATUS_MAP
+     */
+    errorStatusMap?: Record<string, number> | undefined;
+}
+declare class RPCHandlerCodec<T extends Context> implements StandardHandlerCodec<T> {
+    private readonly matcher;
+    private readonly serializer;
+    private readonly errorStatusMap;
+    private readonly outputStatus;
+    constructor(router: AnyRouter, options?: RPCHandlerCodecOptions<T>);
+    resolveProcedure(request: StandardLazyRequest, options: ResolvedStandardHandlerHandleOptions<T>): Promise<StandardHandlerCodecResolvedProcedure | undefined>;
+    encodeOutput(output: unknown, procedure: AnyProcedure, path: string[], options: ResolvedStandardHandlerHandleOptions<T>): Promisable<StandardResponse>;
+    encodeError(error: AnyORPCError, _procedure: AnyProcedure, _path: string[], _options: ResolvedStandardHandlerHandleOptions<T>): Promisable<StandardResponse>;
+}
+
+export { RPCHandlerCodec, RPCMatcher, RPC_DEFAULT_ALLOW_METHODS, ResolvedStandardHandlerHandleOptions, StandardHandlerCodec, StandardHandlerCodecResolvedProcedure };
+export type { RPCHandlerCodecOptions, RPCMatcherOptions };

package/dist/adapters/standard/index.d.ts

@@ -1,19 +1,93 @@
-import { c as StandardHandlerHandleOptions } from '../../shared/server.DEeCcNd6.js';
-export { C as CompositeStandardHandlerPlugin, b as StandardHandler, d as StandardHandlerCodec, e as StandardHandlerCodecResolvedProcedure, h as StandardHandlerHandleResult, i as StandardHandlerInterceptor, g as StandardHandlerInterceptorOptions, a as StandardHandlerOptions, S as StandardHandlerPlugin, j as StandardHandlerRoutingInterceptor, f as StandardHandlerRoutingInterceptorOptions, T as TracingHandlerPlugin } from '../../shared/server.DEeCcNd6.js';
-export { a as RPCHandlerCodec, R as RPCHandlerCodecOptions, b as RPCMatcher, c as RPCMatcherOptions, d as RPC_DEFAULT_ALLOW_METHODS } from '../../shared/server.BGMO5dst.js';
-import { Context } from '../../index.js';
-import '@orpc/client';
-import '@orpc/shared';
-import '@standard-server/core';
-import '@orpc/contract';
-import '../../shared/server.CRwPbhLO.js';
+import { R as ResolvedStandardHandlerHandleOptions, f as StandardHandlerCodec, g as StandardHandlerCodecResolvedProcedure } from '../../shared/server.Cxranw-8.js';
+export { C as CompositeStandardHandlerPlugin, S as StandardHandler, a as StandardHandlerHandleOptions, h as StandardHandlerHandleResult, i as StandardHandlerInterceptor, e as StandardHandlerInterceptorOptions, c as StandardHandlerOptions, b as StandardHandlerPlugin, j as StandardHandlerRoutingInterceptor, d as StandardHandlerRoutingInterceptorOptions, T as TracingHandlerPlugin } from '../../shared/server.Cxranw-8.js';
+import { RPCSerializer, AnyORPCError } from '@orpc/client';
+import { Value, Public, Promisable } from '@orpc/shared';
+import { StandardMethod, StandardLazyRequest, StandardResponse } from '@standard-server/core';
+import { AnyProcedure, Context } from '../../index.js';
+import { AnyRouter } from '../../index.js';
+import { AnyProcedureContract } from '@orpc/contract';
+export { F as FriendlyStandardHandlerHandleOptions, r as resolveFriendlyStandardHandlerHandleOptions } from '../../shared/server.RRVK1xTV.js';
 
-type FriendlyStandardHandlerHandleOptions<T extends Context> = Omit<StandardHandlerHandleOptions<T>, 'context'> & (object extends T ? {
-    context?: T;
-} : {
-    context: T;
-});
-declare function resolveFriendlyStandardHandlerHandleOptions<T extends Context>(options: FriendlyStandardHandlerHandleOptions<T>): StandardHandlerHandleOptions<T>;
+/**
+ * Methods that can invoke procedures by default. Browsers cannot trigger them
+ * cross-site without a CORS preflight or an HTML form, unlike `GET`, which a plain
+ * `<a>` click or redirect can trigger with `SameSite=Lax` cookies attached. Other
+ * methods (`HEAD`, `OPTIONS`, `QUERY`, ...) have safe semantics that should not
+ * invoke a procedure that can modify data.
+ *
+ * @see {@link https://orpc.dev/docs/rpc/handler#supported-http-methods | RPC Handler - Supported HTTP Methods}
+ */
+declare const RPC_DEFAULT_ALLOW_METHODS: readonly StandardMethod[];
+interface RPCMatcherOptions {
+    /**
+     * Filter which procedures are exposed for matching. Return `false` to exclude.
+     *
+     * @default true
+     */
+    filter?: Value<boolean, [procedure: AnyProcedureContract | AnyProcedure, path: string[]]>;
+    /**
+     * Restricts which HTTP methods can invoke procedures, either with a list of allowed
+     * methods or decided per request via a function. Requests using a disallowed method
+     * are treated as unmatched. `GET` is excluded by default because it is exposed to
+     * Cross-Site Request Forgery (CSRF) attacks.
+     *
+     * @default RPC_DEFAULT_ALLOW_METHODS (['POST', 'PUT', 'PATCH', 'DELETE'])
+     * @see {@link https://orpc.dev/docs/rpc/handler#supported-http-methods | RPC Handler - Supported HTTP Methods}
+     */
+    allowMethods?: readonly StandardMethod[] | ((method: StandardMethod, procedure: AnyProcedure, path: string[]) => boolean);
+}
+declare class RPCMatcher {
+    private readonly filter;
+    private readonly allowMethodsSet;
+    private readonly allowMethodsFn;
+    private readonly rootRouter;
+    private readonly tree;
+    private readonly pendingLazyRouters;
+    constructor(router: AnyRouter, options?: RPCMatcherOptions);
+    private index;
+    match(method: StandardMethod, pathname: `/${string}`, prefix: `/${string}` | undefined): Promise<{
+        path: string[];
+        procedure: AnyProcedure;
+    } | undefined>;
+    private resolvePendingLazyRouters;
+    private loadPendingLazyRouters;
+    private loadPendingLazyRouter;
+    private indexPendingLazyRouter;
+    private resolveProcedure;
+}
 
-export { StandardHandlerHandleOptions, resolveFriendlyStandardHandlerHandleOptions };
-export type { FriendlyStandardHandlerHandleOptions };
+interface RPCHandlerCodecOptions<T extends Context> extends RPCMatcherOptions {
+    /**
+     * Override the default RPC serializer.
+     */
+    serializer?: Public<RPCSerializer>;
+    /**
+     * Resolve HTTP status for encoded successful outputs.
+     *
+     * Value should be in the `2xx` range and must be less than `400`.
+     * Return `undefined` or `null` to fallback to default
+     *
+     * @default DEFAULT_SUCCESS_STATUS (200)
+     */
+    outputStatus?: Value<number | undefined | null, [output: unknown, procedure: AnyProcedure, path: string[], options: ResolvedStandardHandlerHandleOptions<T>]>;
+    /**
+     * Mapping ORPCError Code -> HTTP Status Code
+     * The status code should be in the `4xx` or `5xx` range (must be greater than or equal to `400`).
+     *
+     * @default COMMON_ERROR_STATUS_MAP
+     */
+    errorStatusMap?: Record<string, number> | undefined;
+}
+declare class RPCHandlerCodec<T extends Context> implements StandardHandlerCodec<T> {
+    private readonly matcher;
+    private readonly serializer;
+    private readonly errorStatusMap;
+    private readonly outputStatus;
+    constructor(router: AnyRouter, options?: RPCHandlerCodecOptions<T>);
+    resolveProcedure(request: StandardLazyRequest, options: ResolvedStandardHandlerHandleOptions<T>): Promise<StandardHandlerCodecResolvedProcedure | undefined>;
+    encodeOutput(output: unknown, procedure: AnyProcedure, path: string[], options: ResolvedStandardHandlerHandleOptions<T>): Promisable<StandardResponse>;
+    encodeError(error: AnyORPCError, _procedure: AnyProcedure, _path: string[], _options: ResolvedStandardHandlerHandleOptions<T>): Promisable<StandardResponse>;
+}
+
+export { RPCHandlerCodec, RPCMatcher, RPC_DEFAULT_ALLOW_METHODS, ResolvedStandardHandlerHandleOptions, StandardHandlerCodec, StandardHandlerCodecResolvedProcedure };
+export type { RPCHandlerCodecOptions, RPCMatcherOptions };

package/dist/adapters/standard/index.mjs

@@ -1,8 +1,8 @@
-export { C as CompositeStandardHandlerPlugin, R as RPCHandlerCodec, a as RPCMatcher, b as RPC_DEFAULT_ALLOW_METHODS, S as StandardHandler, T as TracingHandlerPlugin } from '../../shared/server.sNWd6DAG.mjs';
+export { C as CompositeStandardHandlerPlugin, R as RPCHandlerCodec, a as RPCMatcher, b as RPC_DEFAULT_ALLOW_METHODS, S as StandardHandler, T as TracingHandlerPlugin } from '../../shared/server.C0lFtoHU.mjs';
 export { r as resolveFriendlyStandardHandlerHandleOptions } from '../../shared/server.W91HSRkE.mjs';
 import '@orpc/client';
 import '@orpc/shared';
 import '@standard-server/core';
 import '../../shared/server.Djb_ebJT.mjs';
 import '@orpc/contract';
-import '../../shared/server.BYnwk7Xz.mjs';
+import '../../shared/server.BynNaBBA.mjs';

package/dist/adapters/standard-peer/index.d.mts

@@ -1,16 +1,11 @@
-import { Value, Promisable } from '@orpc/shared';
 import { StandardLazyRequest, StandardResponse } from '@standard-server/core';
 import { Context } from '../../index.mjs';
-import { StandardHandlerHandleOptions, StandardHandler } from '../standard/index.mjs';
+import { StandardHandler } from '../standard/index.mjs';
+import { FriendlyStandardHandlerHandleOptions } from '../standard/index.mjs';
 import '@orpc/client';
 import '@orpc/contract';
+import '@orpc/shared';
 
-type StandardPeerRequestHandlerOptions<T extends Context> = Omit<StandardHandlerHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
-    context?: Value<Promisable<T>, [request: StandardLazyRequest]>;
-} : {
-    context: Value<Promisable<T>, [request: StandardLazyRequest]>;
-});
-declare function createStandardPeerRequestHandler<T extends Context>(handler: StandardHandler<T>, options: StandardPeerRequestHandlerOptions<T>): (request: StandardLazyRequest) => Promise<StandardResponse>;
+declare function createStandardPeerRequestHandler<T extends Context>(handler: StandardHandler<T>, options: FriendlyStandardHandlerHandleOptions<T>): (request: StandardLazyRequest) => Promise<StandardResponse>;
 
 export { createStandardPeerRequestHandler };
-export type { StandardPeerRequestHandlerOptions };

package/dist/adapters/standard-peer/index.d.ts

@@ -1,16 +1,11 @@
-import { Value, Promisable } from '@orpc/shared';
 import { StandardLazyRequest, StandardResponse } from '@standard-server/core';
 import { Context } from '../../index.js';
-import { StandardHandlerHandleOptions, StandardHandler } from '../standard/index.js';
+import { StandardHandler } from '../standard/index.js';
+import { FriendlyStandardHandlerHandleOptions } from '../standard/index.js';
 import '@orpc/client';
 import '@orpc/contract';
+import '@orpc/shared';
 
-type StandardPeerRequestHandlerOptions<T extends Context> = Omit<StandardHandlerHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
-    context?: Value<Promisable<T>, [request: StandardLazyRequest]>;
-} : {
-    context: Value<Promisable<T>, [request: StandardLazyRequest]>;
-});
-declare function createStandardPeerRequestHandler<T extends Context>(handler: StandardHandler<T>, options: StandardPeerRequestHandlerOptions<T>): (request: StandardLazyRequest) => Promise<StandardResponse>;
+declare function createStandardPeerRequestHandler<T extends Context>(handler: StandardHandler<T>, options: FriendlyStandardHandlerHandleOptions<T>): (request: StandardLazyRequest) => Promise<StandardResponse>;
 
 export { createStandardPeerRequestHandler };
-export type { StandardPeerRequestHandlerOptions };

package/dist/adapters/standard-peer/index.mjs

@@ -1,2 +1,10 @@
-export { c as createStandardPeerRequestHandler } from '../../shared/server.CX4vUnDk.mjs';
-import '@orpc/shared';
+import { r as resolveFriendlyStandardHandlerHandleOptions } from '../../shared/server.W91HSRkE.mjs';
+
+function createStandardPeerRequestHandler(handler, options) {
+  return async (request) => {
+    const { response } = await handler.handle(request, resolveFriendlyStandardHandlerHandleOptions(options));
+    return response ?? { status: 404, headers: {}, body: "No procedure matched" };
+  };
+}
+
+export { createStandardPeerRequestHandler };

package/dist/adapters/websocket/index.d.mts

@@ -2,7 +2,7 @@ import { Arrayable, MaybeOptionalOptions } from '@orpc/shared';
 import { EncodePeerMessageOptions, DecodePeerMessageOptions } from '@standard-server/peer';
 import { Context } from '../../index.mjs';
 import { StandardHandler, StandardHandlerOptions } from '../standard/index.mjs';
-import { StandardPeerRequestHandlerOptions } from '../standard-peer/index.mjs';
+import { FriendlyStandardHandlerHandleOptions } from '../standard/index.mjs';
 import { Router } from '../../index.mjs';
 import { RPCHandlerCodecOptions } from '../standard/index.mjs';
 import '@orpc/client';
@@ -44,7 +44,7 @@ declare class WebSocketHandler<T extends Context> {
      * @param ws The WebSocket instance. Use the same instance for all messages.
      * @param data The received message. Binary data should already be loaded (not a `Blob`).
      */
-    message(ws: WebSocketLike, data: Arrayable<string | ArrayBuffer | Pick<Uint8Array<ArrayBuffer>, 'buffer' | 'byteOffset' | 'byteLength'>>, ...rest: MaybeOptionalOptions<StandardPeerRequestHandlerOptions<T>>): Promise<{
+    message(ws: WebSocketLike, data: Arrayable<string | ArrayBuffer | Pick<Uint8Array<ArrayBuffer>, 'buffer' | 'byteOffset' | 'byteLength'>>, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): Promise<{
         matched: boolean;
     }>;
     /**
@@ -58,7 +58,7 @@ declare class WebSocketHandler<T extends Context> {
      *
      * Prefer this over calling `.message()` and `.close()` manually.
      */
-    upgrade(ws: Pick<WebSocket, 'send' | 'addEventListener' | 'removeEventListener'>, ...rest: MaybeOptionalOptions<StandardPeerRequestHandlerOptions<T>>): void;
+    upgrade(ws: Pick<WebSocket, 'send' | 'addEventListener' | 'removeEventListener'>, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): void;
 }
 
 interface RPCHandlerOptions<T extends Context> extends StandardHandlerOptions<T>, RPCHandlerCodecOptions<T>, WebSocketHandlerOptions<T> {

package/dist/adapters/websocket/index.d.ts

@@ -2,7 +2,7 @@ import { Arrayable, MaybeOptionalOptions } from '@orpc/shared';
 import { EncodePeerMessageOptions, DecodePeerMessageOptions } from '@standard-server/peer';
 import { Context } from '../../index.js';
 import { StandardHandler, StandardHandlerOptions } from '../standard/index.js';
-import { StandardPeerRequestHandlerOptions } from '../standard-peer/index.js';
+import { FriendlyStandardHandlerHandleOptions } from '../standard/index.js';
 import { Router } from '../../index.js';
 import { RPCHandlerCodecOptions } from '../standard/index.js';
 import '@orpc/client';
@@ -44,7 +44,7 @@ declare class WebSocketHandler<T extends Context> {
      * @param ws The WebSocket instance. Use the same instance for all messages.
      * @param data The received message. Binary data should already be loaded (not a `Blob`).
      */
-    message(ws: WebSocketLike, data: Arrayable<string | ArrayBuffer | Pick<Uint8Array<ArrayBuffer>, 'buffer' | 'byteOffset' | 'byteLength'>>, ...rest: MaybeOptionalOptions<StandardPeerRequestHandlerOptions<T>>): Promise<{
+    message(ws: WebSocketLike, data: Arrayable<string | ArrayBuffer | Pick<Uint8Array<ArrayBuffer>, 'buffer' | 'byteOffset' | 'byteLength'>>, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): Promise<{
         matched: boolean;
     }>;
     /**
@@ -58,7 +58,7 @@ declare class WebSocketHandler<T extends Context> {
      *
      * Prefer this over calling `.message()` and `.close()` manually.
      */
-    upgrade(ws: Pick<WebSocket, 'send' | 'addEventListener' | 'removeEventListener'>, ...rest: MaybeOptionalOptions<StandardPeerRequestHandlerOptions<T>>): void;
+    upgrade(ws: Pick<WebSocket, 'send' | 'addEventListener' | 'removeEventListener'>, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): void;
 }
 
 interface RPCHandlerOptions<T extends Context> extends StandardHandlerOptions<T>, RPCHandlerCodecOptions<T>, WebSocketHandlerOptions<T> {

package/dist/adapters/websocket/index.mjs

@@ -1,12 +1,13 @@
 import { toStringOrBytes, resolveMaybeOptionalOptions, sequential, loadBytes } from '@orpc/shared';
 import { ServerPeer, encodePeerMessage, decodePeerMessage, isClientPeerSendMessage } from '@standard-server/peer';
-import { c as createStandardPeerRequestHandler } from '../../shared/server.CX4vUnDk.mjs';
-import { R as RPCHandlerCodec, S as StandardHandler } from '../../shared/server.sNWd6DAG.mjs';
+import { createStandardPeerRequestHandler } from '../standard-peer/index.mjs';
+import { R as RPCHandlerCodec, S as StandardHandler } from '../../shared/server.C0lFtoHU.mjs';
+import '../../shared/server.W91HSRkE.mjs';
 import '@orpc/client';
 import '@standard-server/core';
 import '../../shared/server.Djb_ebJT.mjs';
 import '@orpc/contract';
-import '../../shared/server.BYnwk7Xz.mjs';
+import '../../shared/server.BynNaBBA.mjs';
 
 class WebSocketHandler {
   constructor(handler, options = {}) {

package/dist/index.mjs

@@ -5,8 +5,8 @@ export { AsyncIteratorClass, asyncIteratorToStream, asyncIteratorToUnproxiedData
 import { L as Lazy, P as Procedure, c as createProcedureClient } from './shared/server.Djb_ebJT.mjs';
 export { u as unlazy } from './shared/server.Djb_ebJT.mjs';
 import { D as DecoratedProcedure } from './shared/server.24nXyhbl.mjs';
-import { b as augmentRouter, d as augmentImplementedRouter, e as withHiddenRouterContract, f as createGuardedProcedureLazy, g as getRouter } from './shared/server.BYnwk7Xz.mjs';
-export { a as DEFAULT_ERROR_STATUS, D as DEFAULT_SUCCESS_STATUS, h as call, c as createContractProcedure, i as getHiddenRouterContract, u as unlazyRouter, j as walkProcedureContractsAsync, w as walkProcedureContractsSync } from './shared/server.BYnwk7Xz.mjs';
+import { b as augmentRouter, d as augmentImplementedRouter, e as withHiddenRouterContract, f as createGuardedProcedureLazy, g as getRouter } from './shared/server.BynNaBBA.mjs';
+export { a as DEFAULT_ERROR_STATUS, D as DEFAULT_SUCCESS_STATUS, h as call, c as createContractProcedure, i as getHiddenRouterContract, u as unlazyRouter, j as walkProcedureContractsAsync, w as walkProcedureContractsSync } from './shared/server.BynNaBBA.mjs';
 import { RECURSIVE_CLIENT_UNWRAP_KEYS } from '@orpc/client';
 export { COMMON_ERROR_STATUS_MAP, ORPCError, RPCJsonSerializer, RPCSerializer, cloneORPCError, isDefinedError, safe, toORPCError } from '@orpc/client';
 export { ErrorEvent, getEventMeta, unwrapEvent, withEventMeta } from '@standard-server/core';
@@ -388,13 +388,11 @@ function createRouterImplementerInternal(contract, config, middlewares) {
     });
   }
   const implementer = {};
-  for (const key in contract) {
-    const child = contract[key];
+  for (const [key, child] of Object.entries(contract)) {
     implementer[key] = createRouterImplementerInternal(child, config, middlewares);
   }
   const shared = bindMethods(SharedRouterImplementer.create(contract, config, middlewares));
-  for (const key in shared) {
-    const method = shared[key];
+  for (const [key, method] of Object.entries(shared)) {
     if (key in implementer) {
       const child = implementer[key];
       implementer[key] = new Proxy(method, {

package/dist/plugins/index.d.mts

@@ -2,7 +2,7 @@ import { Value, Promisable, ThrowableError } from '@orpc/shared';
 import { StandardLazyRequest, StandardHeaders, StandardMethod } from '@standard-server/core';
 import { Context } from '../index.mjs';
 import { StandardHandlerPlugin, StandardHandlerRoutingInterceptorOptions, StandardHandlerOptions, StandardHandlerInterceptorOptions } from '../adapters/standard/index.mjs';
-export { R as RequestLimitHandlerPlugin, a as RequestLimitHandlerPluginOptions } from '../shared/server.CAiLRqPf.mjs';
+export { R as RequestLimitHandlerPlugin, a as RequestLimitHandlerPluginOptions } from '../shared/server.C7xllBNN.mjs';
 import '@orpc/client';
 import '@orpc/contract';
 

package/dist/plugins/index.d.ts

@@ -2,7 +2,7 @@ import { Value, Promisable, ThrowableError } from '@orpc/shared';
 import { StandardLazyRequest, StandardHeaders, StandardMethod } from '@standard-server/core';
 import { Context } from '../index.js';
 import { StandardHandlerPlugin, StandardHandlerRoutingInterceptorOptions, StandardHandlerOptions, StandardHandlerInterceptorOptions } from '../adapters/standard/index.js';
-export { R as RequestLimitHandlerPlugin, a as RequestLimitHandlerPluginOptions } from '../shared/server.b2-J4t6T.js';
+export { R as RequestLimitHandlerPlugin, a as RequestLimitHandlerPluginOptions } from '../shared/server.D0dr-F8u.js';
 import '@orpc/client';
 import '@orpc/contract';
 

package/dist/shared/{server.R0uHWfBo.d.mts → server.B5K1CViq.d.mts}

@@ -1,5 +1,5 @@
 import { AnyORPCError } from '@orpc/client';
-import { OrderablePlugin, Interceptor, Promisable } from '@orpc/shared';
+import { OrderablePlugin, Value, Promisable, Interceptor } from '@orpc/shared';
 import { StandardLazyRequest, StandardResponse } from '@standard-server/core';
 import { C as Context, c as ProcedureClientInterceptor, A as AnyProcedure } from './server.BsujoJoF.mjs';
 import { Schema, ErrorMap } from '@orpc/contract';
@@ -36,6 +36,17 @@ declare class CompositeStandardHandlerPlugin<T extends Context> implements Stand
 
 interface StandardHandlerHandleOptions<T extends Context> {
     prefix?: `/${string}` | undefined;
+    /**
+     * The initial context, or a function (sync or async) that receives the request and returns it.
+     * The function only runs once the request passes the prefix check.
+     */
+    context: Value<Promisable<T>, [request: StandardLazyRequest]>;
+}
+/**
+ * `StandardHandlerHandleOptions` after the context has been resolved,
+ * this is what interceptors and codecs receive.
+ */
+interface ResolvedStandardHandlerHandleOptions<T extends Context> extends Omit<StandardHandlerHandleOptions<T>, 'context'> {
     context: T;
 }
 type StandardHandlerHandleResult = {
@@ -45,11 +56,11 @@ type StandardHandlerHandleResult = {
     matched: false;
     response?: undefined;
 };
-interface StandardHandlerInterceptorOptions<T extends Context> extends StandardHandlerCodecResolvedProcedure, StandardHandlerHandleOptions<T> {
+interface StandardHandlerInterceptorOptions<T extends Context> extends StandardHandlerCodecResolvedProcedure, ResolvedStandardHandlerHandleOptions<T> {
     request: StandardLazyRequest;
 }
 type StandardHandlerInterceptor<T extends Context> = Interceptor<StandardHandlerInterceptorOptions<T>, Promise<StandardResponse>>;
-interface StandardHandlerRoutingInterceptorOptions<T extends Context> extends StandardHandlerHandleOptions<T> {
+interface StandardHandlerRoutingInterceptorOptions<T extends Context> extends ResolvedStandardHandlerHandleOptions<T> {
     request: StandardLazyRequest;
 }
 type StandardHandlerRoutingInterceptor<T extends Context> = Interceptor<StandardHandlerRoutingInterceptorOptions<T>, Promise<StandardHandlerHandleResult>>;
@@ -82,7 +93,7 @@ declare class StandardHandler<T extends Context> {
     private readonly interceptors;
     private readonly clientInterceptors;
     constructor(codec: StandardHandlerCodec<T>, options: StandardHandlerOptions<T>);
-    handle(request: StandardLazyRequest, { context, prefix }: StandardHandlerHandleOptions<T>): Promise<StandardHandlerHandleResult>;
+    handle(request: StandardLazyRequest, options: StandardHandlerHandleOptions<T>): Promise<StandardHandlerHandleResult>;
 }
 declare class TracingHandlerPlugin implements StandardHandlerPlugin<any> {
     name: string;
@@ -95,10 +106,10 @@ interface StandardHandlerCodecResolvedProcedure {
     decodeInput: () => Promise<unknown>;
 }
 interface StandardHandlerCodec<T extends Context> {
-    resolveProcedure(request: StandardLazyRequest, options: StandardHandlerHandleOptions<T>): Promisable<StandardHandlerCodecResolvedProcedure | undefined>;
-    encodeOutput(output: unknown, procedure: AnyProcedure, path: string[], options: StandardHandlerHandleOptions<T>): Promisable<StandardResponse>;
-    encodeError(error: AnyORPCError, procedure: AnyProcedure, path: string[], options: StandardHandlerHandleOptions<T>): Promisable<StandardResponse>;
+    resolveProcedure(request: StandardLazyRequest, options: ResolvedStandardHandlerHandleOptions<T>): Promisable<StandardHandlerCodecResolvedProcedure | undefined>;
+    encodeOutput(output: unknown, procedure: AnyProcedure, path: string[], options: ResolvedStandardHandlerHandleOptions<T>): Promisable<StandardResponse>;
+    encodeError(error: AnyORPCError, procedure: AnyProcedure, path: string[], options: ResolvedStandardHandlerHandleOptions<T>): Promisable<StandardResponse>;
 }
 
-export { CompositeStandardHandlerPlugin as C, TracingHandlerPlugin as T, StandardHandler as b };
-export type { StandardHandlerPlugin as S, StandardHandlerOptions as a, StandardHandlerHandleOptions as c, StandardHandlerCodec as d, StandardHandlerCodecResolvedProcedure as e, StandardHandlerRoutingInterceptorOptions as f, StandardHandlerInterceptorOptions as g, StandardHandlerHandleResult as h, StandardHandlerInterceptor as i, StandardHandlerRoutingInterceptor as j };
+export { CompositeStandardHandlerPlugin as C, StandardHandler as S, TracingHandlerPlugin as T };
+export type { ResolvedStandardHandlerHandleOptions as R, StandardHandlerHandleOptions as a, StandardHandlerPlugin as b, StandardHandlerOptions as c, StandardHandlerRoutingInterceptorOptions as d, StandardHandlerInterceptorOptions as e, StandardHandlerCodec as f, StandardHandlerCodecResolvedProcedure as g, StandardHandlerHandleResult as h, StandardHandlerInterceptor as i, StandardHandlerRoutingInterceptor as j };

package/dist/shared/{server.BYnwk7Xz.mjs → server.BynNaBBA.mjs}

@@ -93,8 +93,8 @@ function augmentRouter(router, options) {
     return router;
   }
   const enhanced = {};
-  for (const key in router) {
-    enhanced[key] = augmentRouter(router[key], options);
+  for (const [key, child] of Object.entries(router)) {
+    enhanced[key] = augmentRouter(child, options);
   }
   return enhanced;
 }
@@ -125,8 +125,8 @@ function augmentImplementedRouter(router, options) {
     return router;
   }
   const enhanced = {};
-  for (const key in router) {
-    enhanced[key] = augmentImplementedRouter(router[key], options);
+  for (const [key, child] of Object.entries(router)) {
+    enhanced[key] = augmentImplementedRouter(child, options);
   }
   return enhanced;
 }
@@ -177,8 +177,7 @@ function walkProcedureContractsSyncInternal(router, callback, path, lazyResults)
   if (!isTypescriptObject(router)) {
     return;
   }
-  for (const key in router) {
-    const value = router[key];
+  for (const [key, value] of Object.entries(router)) {
     path.push(key);
     if (value instanceof Lazy) {
       lazyResults.push({ router: value, path: path.slice() });
@@ -200,8 +199,7 @@ async function walkProcedureContractsAsync(router, callback, path = []) {
   if (!isTypescriptObject(router)) {
     return;
   }
-  for (const key in router) {
-    const value = router[key];
+  for (const [key, value] of Object.entries(router)) {
     if (value instanceof Lazy) {
       const { default: router2 } = await unlazy(value);
       await walkProcedureContractsAsync(router2, callback, [...path, key]);
@@ -218,7 +216,7 @@ async function unlazyRouter(router) {
     return router;
   }
   const unlazied = {};
-  for (const key in router) {
+  for (const key of Object.keys(router)) {
     const item = router[key];
     const { default: unlaziedRouter } = await unlazy(item);
     unlazied[key] = await unlazyRouter(unlaziedRouter);