@orpc/server 2.0.0-beta.4 → 2.0.0-beta.40

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

@@ -1,121 +1,44 @@
-import { SendStandardResponseOptions, NodeHttpRequest, NodeHttpResponse } from '@standardserver/node';
-import { C as Context } from '../../shared/server.BL22TloH.js';
-import { Interceptor, MaybeOptionalOptions } from '@orpc/shared';
-import { e as StandardHandlerPlugin, b as StandardHandlerHandleOptions, S as StandardHandler, a as StandardHandlerOptions } from '../../shared/server.DBANIheG.js';
+export { R as BodyLimitPlugin } from '../../shared/server.D0dr-F8u.js';
+import { MaybeOptionalOptions } from '@orpc/shared';
+import { SendStandardResponseOptions, NodeHttpRequest, NodeHttpResponse } from '@standard-server/node';
+import { Context } from '../../index.js';
+import { StandardHandler, StandardHandlerOptions } from '../standard/index.js';
 import { FriendlyStandardHandlerHandleOptions } from '../standard/index.js';
-import compression from '@orpc/interop/compression';
-import { R as Router } from '../../shared/server.Pa0F03f_.js';
-import { R as RPCHandlerCodecOptions } from '../../shared/server.d_2NS3g5.js';
+import { Router } from '../../index.js';
+import { RPCHandlerCodecOptions } from '../standard/index.js';
 import '@orpc/client';
 import '@orpc/contract';
-import '@standardserver/core';
-
-interface NodeHttpHandlerPlugin<T extends Context> extends StandardHandlerPlugin<T> {
-    /**
-     * Initializes the plugin and returns new node HTTP handler options.
-     * Called once per plugin instance during composition.
-     *
-     * This method allows plugins to wrap, extend, or transform node HTTP handler options
-     * such as interceptors, or other configuration.
-     *
-     * @param options - The current handler options from previous plugins or base configuration
-     * @returns Transformed handler options with plugin's modifications applied
-     *
-     * @example
-     * ```ts
-     * initNodeHttpHandlerOptions(options) {
-     *   return {
-     *     ...options,
-     *     nodeHttpInterceptors: [...(options.nodeHttpInterceptors || []), myInterceptor]
-     *   }
-     * }
-     * ```
-     */
-    initNodeHttpHandlerOptions?(options: NodeHttpHandlerOptions<T>): NodeHttpHandlerOptions<T>;
-}
-declare class CompositeNodeHttpHandlerPlugin<T extends Context> implements NodeHttpHandlerPlugin<T> {
-    readonly name = "~composite/node-http-handler";
-    protected readonly plugins: NodeHttpHandlerPlugin<T>[];
-    constructor(plugins?: NodeHttpHandlerPlugin<T>[]);
-    initNodeHttpHandlerOptions(options: NodeHttpHandlerOptions<T>): NodeHttpHandlerOptions<T>;
-}
+import '@standard-server/core';
 
 type NodeHttpHandlerHandleResult = {
     matched: true;
 } | {
     matched: false;
 };
-interface NodeHttpHandlerNodeHttpInterceptorOptions<T extends Context> extends StandardHandlerHandleOptions<T> {
-    request: NodeHttpRequest;
-    response: NodeHttpResponse;
-    sendStandardResponseOptions: SendStandardResponseOptions | undefined;
-}
-type NodeHttpHandlerNodeHttpInterceptor<T extends Context> = Interceptor<NodeHttpHandlerNodeHttpInterceptorOptions<T>, Promise<NodeHttpHandlerHandleResult>>;
-interface NodeHttpHandlerOptions<T extends Context> {
+interface NodeHttpHandlerOptions<_T extends Context> {
     /**
      * Custom options for `sendStandardResponse`, used to send a `Standard Response`
      */
     sendStandardResponse?: SendStandardResponseOptions | undefined;
-    /**
-     * Interceptors that run before the mapping between the Standard API and Node HTTP API,
-     * useful for extending Node HTTP request/response before handling, ...
-     */
-    nodeHttpInterceptors?: NodeHttpHandlerNodeHttpInterceptor<T>[] | undefined;
-    plugins?: NodeHttpHandlerPlugin<T>[] | undefined;
 }
 declare class NodeHttpHandler<T extends Context> {
     private readonly standardHandler;
     private readonly sendStandardResponseOptions;
-    private readonly nodeHttpInterceptors;
     constructor(standardHandler: StandardHandler<T>, options?: NoInfer<NodeHttpHandlerOptions<T>>);
     handle(request: NodeHttpRequest, response: NodeHttpResponse, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): Promise<NodeHttpHandlerHandleResult>;
 }
 
-interface BodyCompressionHandlerPluginOptions extends compression.CompressionOptions {
-    /**
-     * Override the default content-type filter used to determine which responses should be compressed.
-     *
-     * @warning Event stream responses are never compressed, regardless of this filter's return value.
-     * @default only responses with compressible content types are compressed.
-     */
-    filter?: (request: NodeHttpRequest, response: NodeHttpResponse) => boolean;
-}
-declare class BodyCompressionHandlerPlugin<T extends Context> implements NodeHttpHandlerPlugin<T> {
-    name: string;
-    private readonly compressionHandler;
-    constructor(options?: BodyCompressionHandlerPluginOptions);
-    initNodeHttpHandlerOptions(options: NodeHttpHandlerOptions<T>): NodeHttpHandlerOptions<T>;
-}
-
-interface BodyLimitHandlerPluginOptions {
-    /**
-     * The maximum size of the body in bytes.
-     */
-    maxBodySize: number;
-}
-declare class BodyLimitHandlerPlugin<T extends Context> implements NodeHttpHandlerPlugin<T> {
-    name: string;
-    private readonly maxBodySize;
-    constructor(options: BodyLimitHandlerPluginOptions);
-    initNodeHttpHandlerOptions(options: NodeHttpHandlerOptions<T>): NodeHttpHandlerOptions<T>;
-}
-
-interface RPCHandlerOptions<T extends Context> extends NodeHttpHandlerOptions<T>, Omit<StandardHandlerOptions<T>, 'plugins'>, RPCHandlerCodecOptions<T> {
-    /**
-     * Configuration for {@link CSRFGuardHandlerPlugin}, which is enabled by default for `RPCHandler` over HTTP.
-     */
-    csrfGuardPlugin?: {
-        /**
-         * If `false`, this plugin is disabled.
-         *
-         * @default true
-         */
-        enabled?: boolean;
-    };
-}
+interface RPCHandlerOptions<T extends Context> extends NodeHttpHandlerOptions<T>, StandardHandlerOptions<T>, RPCHandlerCodecOptions<T> {
+}
+/**
+ * Serves an oRPC router over the RPC protocol using Node.js built-in
+ * HTTP request/response objects.
+ *
+ * @see {@link https://orpc.dev/docs/adapters/node-http | Node HTTP Adapter}
+ */
 declare class RPCHandler<T extends Context> extends NodeHttpHandler<T> {
     constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
 }
 
-export { BodyCompressionHandlerPlugin, BodyLimitHandlerPlugin, CompositeNodeHttpHandlerPlugin, NodeHttpHandler, RPCHandler };
-export type { BodyCompressionHandlerPluginOptions, BodyLimitHandlerPluginOptions, NodeHttpHandlerHandleResult, NodeHttpHandlerNodeHttpInterceptor, NodeHttpHandlerNodeHttpInterceptorOptions, NodeHttpHandlerOptions, NodeHttpHandlerPlugin, RPCHandlerOptions };
+export { NodeHttpHandler, RPCHandler };
+export type { NodeHttpHandlerHandleResult, NodeHttpHandlerOptions, RPCHandlerOptions };

package/dist/adapters/node/index.mjs

@@ -1,179 +1,41 @@
-import compression from '@orpc/interop/compression';
-import { toArray, sortPlugins, intercept, resolveMaybeOptionalOptions } from '@orpc/shared';
-import { ORPCError } from '@orpc/client';
-import { toStandardLazyRequest, sendStandardResponse } from '@standardserver/node';
+export { R as BodyLimitPlugin } from '../../shared/server.1ExWFMze.mjs';
+import { resolveMaybeOptionalOptions } from '@orpc/shared';
+import { toStandardLazyRequest, sendStandardResponse } from '@standard-server/node';
 import { r as resolveFriendlyStandardHandlerHandleOptions } from '../../shared/server.W91HSRkE.mjs';
-import { C as CSRFGuardHandlerPlugin } from '../../shared/server.D_QauotT.mjs';
-import { R as RPCHandlerCodec, S as StandardHandler } from '../../shared/server.GDpX6Df8.mjs';
-import '@standardserver/core';
-import '../../shared/server.CrlKQucM.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.BwHnWUuN.mjs';
-
-class BodyCompressionHandlerPlugin {
-  name = "~body-compression";
-  compressionHandler;
-  constructor(options = {}) {
-    this.compressionHandler = compression({
-      ...options,
-      filter: (request, response) => {
-        const hasContentDisposition = response.hasHeader("content-disposition");
-        const contentType = response.getHeader("content-type")?.toString();
-        if (!hasContentDisposition && contentType?.startsWith("text/event-stream")) {
-          return false;
-        }
-        return options.filter ? options.filter(request, response) : compression.filter(request, response);
-      }
-    });
-  }
-  initNodeHttpHandlerOptions(options) {
-    return {
-      ...options,
-      nodeHttpInterceptors: [
-        async (interceptorOptions) => {
-          let resolve;
-          let reject;
-          const promise = new Promise((res, rej) => {
-            resolve = res;
-            reject = rej;
-          });
-          const originalWrite = interceptorOptions.response.write;
-          const originalEnd = interceptorOptions.response.end;
-          const originalOn = interceptorOptions.response.on;
-          this.compressionHandler(
-            interceptorOptions.request,
-            interceptorOptions.response,
-            async (error) => {
-              if (error) {
-                reject(error);
-              } else {
-                try {
-                  resolve(await interceptorOptions.next(interceptorOptions));
-                } catch (nextError) {
-                  reject(nextError);
-                }
-              }
-            }
-          );
-          try {
-            return await promise;
-          } finally {
-            interceptorOptions.response.write = originalWrite;
-            interceptorOptions.response.end = originalEnd;
-            interceptorOptions.response.on = originalOn;
-          }
-        },
-        ...toArray(options.nodeHttpInterceptors)
-      ]
-    };
-  }
-}
-
-class BodyLimitHandlerPlugin {
-  name = "~body-limit";
-  maxBodySize;
-  constructor(options) {
-    this.maxBodySize = options.maxBodySize;
-  }
-  initNodeHttpHandlerOptions(options) {
-    return {
-      ...options,
-      nodeHttpInterceptors: [
-        async (interceptorOptions) => {
-          let isHeaderChecked = false;
-          const checkHeader = () => {
-            if (isHeaderChecked) {
-              return;
-            }
-            isHeaderChecked = true;
-            const contentLength = interceptorOptions.request.headers["content-length"];
-            if (contentLength && Number(contentLength) > this.maxBodySize) {
-              throw new ORPCError("PAYLOAD_TOO_LARGE");
-            }
-          };
-          const originalEmit = interceptorOptions.request.emit;
-          let currentBodySize = 0;
-          interceptorOptions.request.emit = (event, ...args) => {
-            if (event === "data") {
-              checkHeader();
-              currentBodySize += args[0]?.length ?? 0;
-              if (currentBodySize > this.maxBodySize) {
-                throw new ORPCError("PAYLOAD_TOO_LARGE");
-              }
-            }
-            return originalEmit.call(interceptorOptions.request, event, ...args);
-          };
-          try {
-            return await interceptorOptions.next(interceptorOptions);
-          } finally {
-            interceptorOptions.request.emit = originalEmit;
-          }
-        },
-        ...toArray(options.nodeHttpInterceptors)
-      ]
-    };
-  }
-}
-
-class CompositeNodeHttpHandlerPlugin {
-  name = "~composite/node-http-handler";
-  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;
   }
 }
 
 class RPCHandler extends NodeHttpHandler {
   constructor(router, options = {}) {
-    if (options.csrfGuardPlugin?.enabled !== false) {
-      options = {
-        ...options,
-        plugins: [...toArray(options.plugins), new CSRFGuardHandlerPlugin()]
-      };
-    }
     const codec = new RPCHandlerCodec(router, options);
     const handler = new StandardHandler(codec, options);
     super(handler, options);
   }
 }
 
-export { BodyCompressionHandlerPlugin, BodyLimitHandlerPlugin, CompositeNodeHttpHandlerPlugin, NodeHttpHandler, RPCHandler };
+export { NodeHttpHandler, RPCHandler };

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

@@ -1,19 +1,93 @@
-import { b as StandardHandlerHandleOptions } from '../../shared/server.DJIkub_t.mjs';
-export { C as CompositeStandardHandlerPlugin, O as OtelHandlerPlugin, S as StandardHandler, c as StandardHandlerCodec, d as StandardHandlerCodecResolvedProcedure, h as StandardHandlerHandleResult, i as StandardHandlerInterceptor, g as StandardHandlerInterceptorOptions, a as StandardHandlerOptions, e as StandardHandlerPlugin, j as StandardHandlerRoutingInterceptor, f as StandardHandlerRoutingInterceptorOptions } from '../../shared/server.DJIkub_t.mjs';
-export { a as RPCHandlerCodec, R as RPCHandlerCodecOptions, b as RPCMatcher, c as RPCMatcherOptions } from '../../shared/server.Cj5lgPuG.mjs';
-import { C as Context } from '../../shared/server.BL22TloH.mjs';
-export { StandardBody, StandardBodyHint, StandardHeaders, StandardLazyRequest, StandardLazyResponse, StandardMethod, StandardRequest, StandardResponse, StandardUrl } from '@standardserver/core';
-import '@orpc/client';
-import '@orpc/shared';
-import '@orpc/contract';
-import '../../shared/server.BsNNjG5J.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 { b as StandardHandlerHandleOptions } from '../../shared/server.DBANIheG.js';
-export { C as CompositeStandardHandlerPlugin, O as OtelHandlerPlugin, S as StandardHandler, c as StandardHandlerCodec, d as StandardHandlerCodecResolvedProcedure, h as StandardHandlerHandleResult, i as StandardHandlerInterceptor, g as StandardHandlerInterceptorOptions, a as StandardHandlerOptions, e as StandardHandlerPlugin, j as StandardHandlerRoutingInterceptor, f as StandardHandlerRoutingInterceptorOptions } from '../../shared/server.DBANIheG.js';
-export { a as RPCHandlerCodec, R as RPCHandlerCodecOptions, b as RPCMatcher, c as RPCMatcherOptions } from '../../shared/server.d_2NS3g5.js';
-import { C as Context } from '../../shared/server.BL22TloH.js';
-export { StandardBody, StandardBodyHint, StandardHeaders, StandardLazyRequest, StandardLazyResponse, StandardMethod, StandardRequest, StandardResponse, StandardUrl } from '@standardserver/core';
-import '@orpc/client';
-import '@orpc/shared';
-import '@orpc/contract';
-import '../../shared/server.Pa0F03f_.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, O as OtelHandlerPlugin, R as RPCHandlerCodec, a as RPCMatcher, S as StandardHandler } from '../../shared/server.GDpX6Df8.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 '@standardserver/core';
-import '../../shared/server.CrlKQucM.mjs';
+import '@standard-server/core';
+import '../../shared/server.Djb_ebJT.mjs';
 import '@orpc/contract';
-import '../../shared/server.BwHnWUuN.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 '@standardserver/core';
-import { C as Context } from '../../shared/server.BL22TloH.mjs';
-import { b as StandardHandlerHandleOptions, S as StandardHandler } from '../../shared/server.DJIkub_t.mjs';
+import { StandardLazyRequest, StandardResponse } from '@standard-server/core';
+import { Context } from '../../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 '@standardserver/core';
-import { C as Context } from '../../shared/server.BL22TloH.js';
-import { b as StandardHandlerHandleOptions, S as StandardHandler } from '../../shared/server.DBANIheG.js';
+import { StandardLazyRequest, StandardResponse } from '@standard-server/core';
+import { Context } from '../../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 };