@orpc/server 2.0.0-beta.36 → 2.0.0-beta.38

package/README.md

@@ -38,11 +38,11 @@ You can read the documentation [here](https://orpc.dev).
 
 **Schema validation**
 
-| Package                                                      | Purpose                                         | Docs                                                  |
-| ------------------------------------------------------------ | ----------------------------------------------- | ----------------------------------------------------- |
-| [@orpc/zod](https://www.npmjs.com/package/@orpc/zod)         | Integrate with [Zod](https://zod.dev/).         | [Zod](https://orpc.dev/docs/integrations/zod)         |
-| [@orpc/valibot](https://www.npmjs.com/package/@orpc/valibot) | Integrate with [Valibot](https://valibot.dev/). | [Valibot](https://orpc.dev/docs/integrations/valibot) |
-| [@orpc/arktype](https://www.npmjs.com/package/@orpc/arktype) | Integrate with [ArkType](https://arktype.io/).  | [ArkType](https://orpc.dev/docs/integrations/arktype) |
+| Package                                                      | Purpose                                                    | Docs                                                  |
+| ------------------------------------------------------------ | ---------------------------------------------------------- | ----------------------------------------------------- |
+| [@orpc/zod](https://www.npmjs.com/package/@orpc/zod)         | JSON Schema converter for [Zod](https://zod.dev/).         | [Zod](https://orpc.dev/docs/integrations/zod)         |
+| [@orpc/valibot](https://www.npmjs.com/package/@orpc/valibot) | JSON Schema converter for [Valibot](https://valibot.dev/). | [Valibot](https://orpc.dev/docs/integrations/valibot) |
+| [@orpc/arktype](https://www.npmjs.com/package/@orpc/arktype) | JSON Schema converter for [ArkType](https://arktype.io/).  | [ArkType](https://orpc.dev/docs/integrations/arktype) |
 
 **Built-in features**
 

package/dist/adapters/aws-lambda/index.d.mts

@@ -1,7 +1,7 @@
-import { Interceptor, MaybeOptionalOptions } from '@orpc/shared';
+import { MaybeOptionalOptions } from '@orpc/shared';
 import { SendStandardResponseOptions, AnyAPIGatewayProxyEvent, HttpResponseStream } from '@standard-server/aws-lambda';
 import { Context } from '../../index.mjs';
-import { StandardHandlerPlugin, StandardHandler, StandardHandlerHandleOptions, StandardHandlerOptions } from '../standard/index.mjs';
+import { StandardHandler, StandardHandlerOptions } from '../standard/index.mjs';
 import { FriendlyStandardHandlerHandleOptions } from '../standard/index.mjs';
 import { Router } from '../../index.mjs';
 import { RPCHandlerCodecOptions } from '../standard/index.mjs';
@@ -9,58 +9,16 @@ import '@orpc/client';
 import '@orpc/contract';
 import '@standard-server/core';
 
-interface AwsLambdaHandlerPlugin<T extends Context> extends StandardHandlerPlugin<T> {
-    /**
-     * Initializes the plugin and returns new AWS Lambda handler options.
-     * Called once per plugin instance during composition.
-     *
-     * This method allows plugins to wrap, extend, or transform AWS Lambda 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
-     * initAwsLambdaHandlerOptions(options) {
-     *   return {
-     *     ...options,
-     *     awsLambdaInterceptors: [...(options.awsLambdaInterceptors || []), myInterceptor]
-     *   }
-     * }
-     * ```
-     */
-    initAwsLambdaHandlerOptions?(options: AwsLambdaHandlerOptions<T>): AwsLambdaHandlerOptions<T>;
-}
-declare class CompositeAwsLambdaHandlerPlugin<T extends Context> implements AwsLambdaHandlerPlugin<T> {
-    readonly name = "~composite/aws-lambda";
-    protected readonly plugins: AwsLambdaHandlerPlugin<T>[];
-    constructor(plugins?: AwsLambdaHandlerPlugin<T>[]);
-    initAwsLambdaHandlerOptions(options: AwsLambdaHandlerOptions<T>): AwsLambdaHandlerOptions<T>;
-}
-
 type AwsLambdaHandlerHandleResult = {
     matched: true;
 } | {
     matched: false;
 };
-interface AwsLambdaHandlerAwsLambdaInterceptorOptions<T extends Context> extends StandardHandlerHandleOptions<T> {
-    event: AnyAPIGatewayProxyEvent;
-    responseStream: HttpResponseStream;
-    sendStandardResponseOptions: SendStandardResponseOptions | undefined;
-}
-type AwsLambdaHandlerAwsLambdaInterceptor<T extends Context> = Interceptor<AwsLambdaHandlerAwsLambdaInterceptorOptions<T>, Promise<AwsLambdaHandlerHandleResult>>;
-interface AwsLambdaHandlerOptions<T extends Context> {
+interface AwsLambdaHandlerOptions<_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 AWS Lambda API,
-     * useful for extending the AWS Lambda event/response stream before handling, ...
-     */
-    awsLambdaInterceptors?: AwsLambdaHandlerAwsLambdaInterceptor<T>[] | undefined;
-    plugins?: AwsLambdaHandlerPlugin<T>[] | undefined;
 }
 /**
  * Requires the AWS Lambda Node.js runtime with response streaming enabled,
@@ -69,12 +27,11 @@ interface AwsLambdaHandlerOptions<T extends Context> {
 declare class AwsLambdaHandler<T extends Context> {
     private readonly standardHandler;
     private readonly sendStandardResponseOptions;
-    private readonly awsLambdaInterceptors;
     constructor(standardHandler: StandardHandler<T>, options?: NoInfer<AwsLambdaHandlerOptions<T>>);
     handle(event: AnyAPIGatewayProxyEvent, responseStream: HttpResponseStream, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): Promise<AwsLambdaHandlerHandleResult>;
 }
 
-interface RPCHandlerOptions<T extends Context> extends AwsLambdaHandlerOptions<T>, Omit<StandardHandlerOptions<T>, 'plugins'>, RPCHandlerCodecOptions<T> {
+interface RPCHandlerOptions<T extends Context> extends AwsLambdaHandlerOptions<T>, StandardHandlerOptions<T>, RPCHandlerCodecOptions<T> {
 }
 /**
  * Serves an oRPC router over the RPC protocol on AWS Lambda,
@@ -89,5 +46,5 @@ declare class RPCHandler<T extends Context> extends AwsLambdaHandler<T> {
     constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
 }
 
-export { AwsLambdaHandler, CompositeAwsLambdaHandlerPlugin, RPCHandler };
-export type { AwsLambdaHandlerAwsLambdaInterceptor, AwsLambdaHandlerAwsLambdaInterceptorOptions, AwsLambdaHandlerHandleResult, AwsLambdaHandlerOptions, AwsLambdaHandlerPlugin, RPCHandlerOptions };
+export { AwsLambdaHandler, RPCHandler };
+export type { AwsLambdaHandlerHandleResult, AwsLambdaHandlerOptions, RPCHandlerOptions };

package/dist/adapters/aws-lambda/index.d.ts

@@ -1,7 +1,7 @@
-import { Interceptor, MaybeOptionalOptions } from '@orpc/shared';
+import { MaybeOptionalOptions } from '@orpc/shared';
 import { SendStandardResponseOptions, AnyAPIGatewayProxyEvent, HttpResponseStream } from '@standard-server/aws-lambda';
 import { Context } from '../../index.js';
-import { StandardHandlerPlugin, StandardHandler, StandardHandlerHandleOptions, StandardHandlerOptions } from '../standard/index.js';
+import { StandardHandler, StandardHandlerOptions } from '../standard/index.js';
 import { FriendlyStandardHandlerHandleOptions } from '../standard/index.js';
 import { Router } from '../../index.js';
 import { RPCHandlerCodecOptions } from '../standard/index.js';
@@ -9,58 +9,16 @@ import '@orpc/client';
 import '@orpc/contract';
 import '@standard-server/core';
 
-interface AwsLambdaHandlerPlugin<T extends Context> extends StandardHandlerPlugin<T> {
-    /**
-     * Initializes the plugin and returns new AWS Lambda handler options.
-     * Called once per plugin instance during composition.
-     *
-     * This method allows plugins to wrap, extend, or transform AWS Lambda 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
-     * initAwsLambdaHandlerOptions(options) {
-     *   return {
-     *     ...options,
-     *     awsLambdaInterceptors: [...(options.awsLambdaInterceptors || []), myInterceptor]
-     *   }
-     * }
-     * ```
-     */
-    initAwsLambdaHandlerOptions?(options: AwsLambdaHandlerOptions<T>): AwsLambdaHandlerOptions<T>;
-}
-declare class CompositeAwsLambdaHandlerPlugin<T extends Context> implements AwsLambdaHandlerPlugin<T> {
-    readonly name = "~composite/aws-lambda";
-    protected readonly plugins: AwsLambdaHandlerPlugin<T>[];
-    constructor(plugins?: AwsLambdaHandlerPlugin<T>[]);
-    initAwsLambdaHandlerOptions(options: AwsLambdaHandlerOptions<T>): AwsLambdaHandlerOptions<T>;
-}
-
 type AwsLambdaHandlerHandleResult = {
     matched: true;
 } | {
     matched: false;
 };
-interface AwsLambdaHandlerAwsLambdaInterceptorOptions<T extends Context> extends StandardHandlerHandleOptions<T> {
-    event: AnyAPIGatewayProxyEvent;
-    responseStream: HttpResponseStream;
-    sendStandardResponseOptions: SendStandardResponseOptions | undefined;
-}
-type AwsLambdaHandlerAwsLambdaInterceptor<T extends Context> = Interceptor<AwsLambdaHandlerAwsLambdaInterceptorOptions<T>, Promise<AwsLambdaHandlerHandleResult>>;
-interface AwsLambdaHandlerOptions<T extends Context> {
+interface AwsLambdaHandlerOptions<_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 AWS Lambda API,
-     * useful for extending the AWS Lambda event/response stream before handling, ...
-     */
-    awsLambdaInterceptors?: AwsLambdaHandlerAwsLambdaInterceptor<T>[] | undefined;
-    plugins?: AwsLambdaHandlerPlugin<T>[] | undefined;
 }
 /**
  * Requires the AWS Lambda Node.js runtime with response streaming enabled,
@@ -69,12 +27,11 @@ interface AwsLambdaHandlerOptions<T extends Context> {
 declare class AwsLambdaHandler<T extends Context> {
     private readonly standardHandler;
     private readonly sendStandardResponseOptions;
-    private readonly awsLambdaInterceptors;
     constructor(standardHandler: StandardHandler<T>, options?: NoInfer<AwsLambdaHandlerOptions<T>>);
     handle(event: AnyAPIGatewayProxyEvent, responseStream: HttpResponseStream, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): Promise<AwsLambdaHandlerHandleResult>;
 }
 
-interface RPCHandlerOptions<T extends Context> extends AwsLambdaHandlerOptions<T>, Omit<StandardHandlerOptions<T>, 'plugins'>, RPCHandlerCodecOptions<T> {
+interface RPCHandlerOptions<T extends Context> extends AwsLambdaHandlerOptions<T>, StandardHandlerOptions<T>, RPCHandlerCodecOptions<T> {
 }
 /**
  * Serves an oRPC router over the RPC protocol on AWS Lambda,
@@ -89,5 +46,5 @@ declare class RPCHandler<T extends Context> extends AwsLambdaHandler<T> {
     constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
 }
 
-export { AwsLambdaHandler, CompositeAwsLambdaHandlerPlugin, RPCHandler };
-export type { AwsLambdaHandlerAwsLambdaInterceptor, AwsLambdaHandlerAwsLambdaInterceptorOptions, AwsLambdaHandlerHandleResult, AwsLambdaHandlerOptions, AwsLambdaHandlerPlugin, RPCHandlerOptions };
+export { AwsLambdaHandler, RPCHandler };
+export type { AwsLambdaHandlerHandleResult, AwsLambdaHandlerOptions, RPCHandlerOptions };

package/dist/adapters/aws-lambda/index.mjs

@@ -1,57 +1,30 @@
-import { sortPlugins, intercept, resolveMaybeOptionalOptions } from '@orpc/shared';
+import { resolveMaybeOptionalOptions } from '@orpc/shared';
 import { toStandardLazyRequest, sendStandardResponse } from '@standard-server/aws-lambda';
 import { r as resolveFriendlyStandardHandlerHandleOptions } from '../../shared/server.W91HSRkE.mjs';
-import { R as RPCHandlerCodec, S as StandardHandler } from '../../shared/server.vUIzQiOP.mjs';
+import { R as RPCHandlerCodec, S as StandardHandler } from '../../shared/server.C0lFtoHU.mjs';
 import '@orpc/client';
 import '@standard-server/core';
 import '../../shared/server.Djb_ebJT.mjs';
 import '@orpc/contract';
 import '../../shared/server.BynNaBBA.mjs';
 
-class CompositeAwsLambdaHandlerPlugin {
-  name = "~composite/aws-lambda";
-  plugins;
-  constructor(plugins = []) {
-    this.plugins = sortPlugins(plugins);
-  }
-  initAwsLambdaHandlerOptions(options) {
-    for (const plugin of this.plugins) {
-      if (plugin.initAwsLambdaHandlerOptions) {
-        options = plugin.initAwsLambdaHandlerOptions(options);
-      }
-    }
-    return options;
-  }
-}
-
 class AwsLambdaHandler {
   constructor(standardHandler, options = {}) {
     this.standardHandler = standardHandler;
-    options = new CompositeAwsLambdaHandlerPlugin(options.plugins).initAwsLambdaHandlerOptions(options);
-    this.awsLambdaInterceptors = options.awsLambdaInterceptors;
     this.sendStandardResponseOptions = options.sendStandardResponse;
   }
   sendStandardResponseOptions;
-  awsLambdaInterceptors;
   async handle(event, responseStream, ...rest) {
-    return intercept(
-      this.awsLambdaInterceptors,
-      {
-        ...resolveFriendlyStandardHandlerHandleOptions(resolveMaybeOptionalOptions(rest)),
-        event,
-        responseStream,
-        sendStandardResponseOptions: this.sendStandardResponseOptions
-      },
-      async ({ event: event2, responseStream: responseStream2, sendStandardResponseOptions, ...options }) => {
-        const standardRequest = toStandardLazyRequest(event2, responseStream2);
-        const result = await this.standardHandler.handle(standardRequest, options);
-        if (!result.matched) {
-          return result;
-        }
-        await sendStandardResponse(responseStream2, result.response, sendStandardResponseOptions);
-        return result;
-      }
+    const standardRequest = toStandardLazyRequest(event, responseStream);
+    const result = await this.standardHandler.handle(
+      standardRequest,
+      resolveFriendlyStandardHandlerHandleOptions(resolveMaybeOptionalOptions(rest))
     );
+    if (!result.matched) {
+      return result;
+    }
+    await sendStandardResponse(responseStream, result.response, this.sendStandardResponseOptions);
+    return result;
   }
 }
 
@@ -63,4 +36,4 @@ class RPCHandler extends AwsLambdaHandler {
   }
 }
 
-export { AwsLambdaHandler, CompositeAwsLambdaHandlerPlugin, RPCHandler };
+export { AwsLambdaHandler, RPCHandler };

package/dist/adapters/crossws/index.mjs

@@ -1,7 +1,7 @@
 import { resolveMaybeOptionalOptions } from '@orpc/shared';
 import { ServerPeer, encodePeerMessage, decodePeerMessage, isClientPeerSendMessage } from '@standard-server/peer';
 import { createStandardPeerRequestHandler } from '../standard-peer/index.mjs';
-import { R as RPCHandlerCodec, S as StandardHandler } from '../../shared/server.vUIzQiOP.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';

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

@@ -1,7 +1,7 @@
-import { Interceptor, MaybeOptionalOptions } from '@orpc/shared';
+import { MaybeOptionalOptions } from '@orpc/shared';
 import { SendStandardResponseOptions, AnyFastifyRequest, AnyFastifyReply } from '@standard-server/fastify';
 import { Context } from '../../index.mjs';
-import { StandardHandlerPlugin, StandardHandlerHandleOptions, StandardHandler, StandardHandlerOptions } from '../standard/index.mjs';
+import { StandardHandler, StandardHandlerOptions } from '../standard/index.mjs';
 import { FriendlyStandardHandlerHandleOptions } from '../standard/index.mjs';
 import { Router } from '../../index.mjs';
 import { RPCHandlerCodecOptions } from '../standard/index.mjs';
@@ -9,68 +9,25 @@ import '@orpc/client';
 import '@orpc/contract';
 import '@standard-server/core';
 
-interface FastifyHandlerPlugin<T extends Context> extends StandardHandlerPlugin<T> {
-    /**
-     * Initializes the plugin and returns new Fastify handler options.
-     * Called once per plugin instance during composition.
-     *
-     * This method allows plugins to wrap, extend, or transform Fastify 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
-     * initFastifyHandlerOptions(options) {
-     *   return {
-     *     ...options,
-     *     fastifyInterceptors: [...(options.fastifyInterceptors || []), myInterceptor]
-     *   }
-     * }
-     * ```
-     */
-    initFastifyHandlerOptions?(options: FastifyHandlerOptions<T>): FastifyHandlerOptions<T>;
-}
-declare class CompositeFastifyHandlerPlugin<T extends Context> implements FastifyHandlerPlugin<T> {
-    readonly name = "~composite/fastify";
-    protected readonly plugins: FastifyHandlerPlugin<T>[];
-    constructor(plugins?: FastifyHandlerPlugin<T>[]);
-    initFastifyHandlerOptions(options: FastifyHandlerOptions<T>): FastifyHandlerOptions<T>;
-}
-
 type FastifyHandlerHandleResult = {
     matched: true;
 } | {
     matched: false;
 };
-interface FastifyHandlerFastifyInterceptorOptions<T extends Context> extends StandardHandlerHandleOptions<T> {
-    request: AnyFastifyRequest;
-    reply: AnyFastifyReply;
-    sendStandardResponseOptions: SendStandardResponseOptions | undefined;
-}
-type FastifyHandlerFastifyInterceptor<T extends Context> = Interceptor<FastifyHandlerFastifyInterceptorOptions<T>, Promise<FastifyHandlerHandleResult>>;
-interface FastifyHandlerOptions<T extends Context> {
+interface FastifyHandlerOptions<_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 Fastify API,
-     * useful for extending the Fastify request/reply before handling, ...
-     */
-    fastifyInterceptors?: FastifyHandlerFastifyInterceptor<T>[] | undefined;
-    plugins?: FastifyHandlerPlugin<T>[] | undefined;
 }
 declare class FastifyHandler<T extends Context> {
     private readonly standardHandler;
     private readonly sendStandardResponseOptions;
-    private readonly fastifyInterceptors;
     constructor(standardHandler: StandardHandler<T>, options?: NoInfer<FastifyHandlerOptions<T>>);
     handle(request: AnyFastifyRequest, reply: AnyFastifyReply, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): Promise<FastifyHandlerHandleResult>;
 }
 
-interface RPCHandlerOptions<T extends Context> extends FastifyHandlerOptions<T>, Omit<StandardHandlerOptions<T>, 'plugins'>, RPCHandlerCodecOptions<T> {
+interface RPCHandlerOptions<T extends Context> extends FastifyHandlerOptions<T>, StandardHandlerOptions<T>, RPCHandlerCodecOptions<T> {
 }
 /**
  * Serves an oRPC router over the RPC protocol inside a Fastify server.
@@ -81,5 +38,5 @@ declare class RPCHandler<T extends Context> extends FastifyHandler<T> {
     constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
 }
 
-export { CompositeFastifyHandlerPlugin, FastifyHandler, RPCHandler };
-export type { FastifyHandlerFastifyInterceptor, FastifyHandlerFastifyInterceptorOptions, FastifyHandlerHandleResult, FastifyHandlerOptions, FastifyHandlerPlugin, RPCHandlerOptions };
+export { FastifyHandler, RPCHandler };
+export type { FastifyHandlerHandleResult, FastifyHandlerOptions, RPCHandlerOptions };

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

@@ -1,7 +1,7 @@
-import { Interceptor, MaybeOptionalOptions } from '@orpc/shared';
+import { MaybeOptionalOptions } from '@orpc/shared';
 import { SendStandardResponseOptions, AnyFastifyRequest, AnyFastifyReply } from '@standard-server/fastify';
 import { Context } from '../../index.js';
-import { StandardHandlerPlugin, StandardHandlerHandleOptions, StandardHandler, StandardHandlerOptions } from '../standard/index.js';
+import { StandardHandler, StandardHandlerOptions } from '../standard/index.js';
 import { FriendlyStandardHandlerHandleOptions } from '../standard/index.js';
 import { Router } from '../../index.js';
 import { RPCHandlerCodecOptions } from '../standard/index.js';
@@ -9,68 +9,25 @@ import '@orpc/client';
 import '@orpc/contract';
 import '@standard-server/core';
 
-interface FastifyHandlerPlugin<T extends Context> extends StandardHandlerPlugin<T> {
-    /**
-     * Initializes the plugin and returns new Fastify handler options.
-     * Called once per plugin instance during composition.
-     *
-     * This method allows plugins to wrap, extend, or transform Fastify 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
-     * initFastifyHandlerOptions(options) {
-     *   return {
-     *     ...options,
-     *     fastifyInterceptors: [...(options.fastifyInterceptors || []), myInterceptor]
-     *   }
-     * }
-     * ```
-     */
-    initFastifyHandlerOptions?(options: FastifyHandlerOptions<T>): FastifyHandlerOptions<T>;
-}
-declare class CompositeFastifyHandlerPlugin<T extends Context> implements FastifyHandlerPlugin<T> {
-    readonly name = "~composite/fastify";
-    protected readonly plugins: FastifyHandlerPlugin<T>[];
-    constructor(plugins?: FastifyHandlerPlugin<T>[]);
-    initFastifyHandlerOptions(options: FastifyHandlerOptions<T>): FastifyHandlerOptions<T>;
-}
-
 type FastifyHandlerHandleResult = {
     matched: true;
 } | {
     matched: false;
 };
-interface FastifyHandlerFastifyInterceptorOptions<T extends Context> extends StandardHandlerHandleOptions<T> {
-    request: AnyFastifyRequest;
-    reply: AnyFastifyReply;
-    sendStandardResponseOptions: SendStandardResponseOptions | undefined;
-}
-type FastifyHandlerFastifyInterceptor<T extends Context> = Interceptor<FastifyHandlerFastifyInterceptorOptions<T>, Promise<FastifyHandlerHandleResult>>;
-interface FastifyHandlerOptions<T extends Context> {
+interface FastifyHandlerOptions<_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 Fastify API,
-     * useful for extending the Fastify request/reply before handling, ...
-     */
-    fastifyInterceptors?: FastifyHandlerFastifyInterceptor<T>[] | undefined;
-    plugins?: FastifyHandlerPlugin<T>[] | undefined;
 }
 declare class FastifyHandler<T extends Context> {
     private readonly standardHandler;
     private readonly sendStandardResponseOptions;
-    private readonly fastifyInterceptors;
     constructor(standardHandler: StandardHandler<T>, options?: NoInfer<FastifyHandlerOptions<T>>);
     handle(request: AnyFastifyRequest, reply: AnyFastifyReply, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): Promise<FastifyHandlerHandleResult>;
 }
 
-interface RPCHandlerOptions<T extends Context> extends FastifyHandlerOptions<T>, Omit<StandardHandlerOptions<T>, 'plugins'>, RPCHandlerCodecOptions<T> {
+interface RPCHandlerOptions<T extends Context> extends FastifyHandlerOptions<T>, StandardHandlerOptions<T>, RPCHandlerCodecOptions<T> {
 }
 /**
  * Serves an oRPC router over the RPC protocol inside a Fastify server.
@@ -81,5 +38,5 @@ declare class RPCHandler<T extends Context> extends FastifyHandler<T> {
     constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
 }
 
-export { CompositeFastifyHandlerPlugin, FastifyHandler, RPCHandler };
-export type { FastifyHandlerFastifyInterceptor, FastifyHandlerFastifyInterceptorOptions, FastifyHandlerHandleResult, FastifyHandlerOptions, FastifyHandlerPlugin, RPCHandlerOptions };
+export { FastifyHandler, RPCHandler };
+export type { FastifyHandlerHandleResult, FastifyHandlerOptions, RPCHandlerOptions };

package/dist/adapters/fastify/index.mjs

@@ -1,57 +1,30 @@
-import { sortPlugins, intercept, resolveMaybeOptionalOptions } from '@orpc/shared';
+import { resolveMaybeOptionalOptions } from '@orpc/shared';
 import { toStandardLazyRequest, sendStandardResponse } from '@standard-server/fastify';
 import { r as resolveFriendlyStandardHandlerHandleOptions } from '../../shared/server.W91HSRkE.mjs';
-import { R as RPCHandlerCodec, S as StandardHandler } from '../../shared/server.vUIzQiOP.mjs';
+import { R as RPCHandlerCodec, S as StandardHandler } from '../../shared/server.C0lFtoHU.mjs';
 import '@orpc/client';
 import '@standard-server/core';
 import '../../shared/server.Djb_ebJT.mjs';
 import '@orpc/contract';
 import '../../shared/server.BynNaBBA.mjs';
 
-class CompositeFastifyHandlerPlugin {
-  name = "~composite/fastify";
-  plugins;
-  constructor(plugins = []) {
-    this.plugins = sortPlugins(plugins);
-  }
-  initFastifyHandlerOptions(options) {
-    for (const plugin of this.plugins) {
-      if (plugin.initFastifyHandlerOptions) {
-        options = plugin.initFastifyHandlerOptions(options);
-      }
-    }
-    return options;
-  }
-}
-
 class FastifyHandler {
   constructor(standardHandler, options = {}) {
     this.standardHandler = standardHandler;
-    options = new CompositeFastifyHandlerPlugin(options.plugins).initFastifyHandlerOptions(options);
-    this.fastifyInterceptors = options.fastifyInterceptors;
     this.sendStandardResponseOptions = options.sendStandardResponse;
   }
   sendStandardResponseOptions;
-  fastifyInterceptors;
   async handle(request, reply, ...rest) {
-    return intercept(
-      this.fastifyInterceptors,
-      {
-        ...resolveFriendlyStandardHandlerHandleOptions(resolveMaybeOptionalOptions(rest)),
-        request,
-        reply,
-        sendStandardResponseOptions: this.sendStandardResponseOptions
-      },
-      async ({ request: request2, reply: reply2, sendStandardResponseOptions, ...options }) => {
-        const standardRequest = toStandardLazyRequest(request2, reply2);
-        const result = await this.standardHandler.handle(standardRequest, options);
-        if (!result.matched) {
-          return result;
-        }
-        await sendStandardResponse(reply2, result.response, sendStandardResponseOptions);
-        return result;
-      }
+    const standardRequest = toStandardLazyRequest(request, reply);
+    const result = await this.standardHandler.handle(
+      standardRequest,
+      resolveFriendlyStandardHandlerHandleOptions(resolveMaybeOptionalOptions(rest))
     );
+    if (!result.matched) {
+      return result;
+    }
+    await sendStandardResponse(reply, result.response, this.sendStandardResponseOptions);
+    return result;
   }
 }
 
@@ -63,4 +36,4 @@ class RPCHandler extends FastifyHandler {
   }
 }
 
-export { CompositeFastifyHandlerPlugin, FastifyHandler, RPCHandler };
+export { FastifyHandler, RPCHandler };

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

@@ -1,8 +1,8 @@
 export { R as BodyLimitPlugin } from '../../shared/server.C7xllBNN.mjs';
-import { Interceptor, MaybeOptionalOptions } from '@orpc/shared';
+import { MaybeOptionalOptions } from '@orpc/shared';
 import { ToFetchResponseOptions } from '@standard-server/fetch';
 import { Context } from '../../index.mjs';
-import { StandardHandlerPlugin, StandardHandlerHandleOptions, StandardHandler, StandardHandlerOptions } from '../standard/index.mjs';
+import { StandardHandler, StandardHandlerOptions } from '../standard/index.mjs';
 import { FriendlyStandardHandlerHandleOptions } from '../standard/index.mjs';
 import { Router } from '../../index.mjs';
 import { RPCHandlerCodecOptions } from '../standard/index.mjs';
@@ -10,36 +10,6 @@ import '@orpc/client';
 import '@orpc/contract';
 import '@standard-server/core';
 
-interface FetchHandlerPlugin<T extends Context> extends StandardHandlerPlugin<T> {
-    /**
-     * Initializes the plugin and returns new fetch handler options.
-     * Called once per plugin instance during composition.
-     *
-     * This method allows plugins to wrap, extend, or transform fetch handler options
-     * such as fetch interceptors, or fetch configuration.
-     *
-     * @param options - The current handler options from previous plugins or base configuration
-     * @returns Transformed handler options with plugin's modifications applied
-     *
-     * @example
-     * ```ts
-     * initFetchHandlerOptions(options) {
-     *   return {
-     *     ...options,
-     *     interceptors: [...(options.interceptors || []), myInterceptor]
-     *   }
-     * }
-     * ```
-     */
-    initFetchHandlerOptions?(options: FetchHandlerOptions<T>): FetchHandlerOptions<T>;
-}
-declare class CompositeFetchHandlerPlugin<T extends Context> implements FetchHandlerPlugin<T> {
-    readonly name = "~composite/fetch";
-    protected readonly plugins: FetchHandlerPlugin<T>[];
-    constructor(plugins?: FetchHandlerPlugin<T>[]);
-    initFetchHandlerOptions(options: FetchHandlerOptions<T>): FetchHandlerOptions<T>;
-}
-
 type FetchHandlerHandleResult = {
     matched: true;
     response: Response;
@@ -47,32 +17,20 @@ type FetchHandlerHandleResult = {
     matched: false;
     response?: undefined;
 };
-interface FetchHandlerFetchInterceptorOptions<T extends Context> extends StandardHandlerHandleOptions<T> {
-    request: Request;
-    toFetchResponseOptions: ToFetchResponseOptions | undefined;
-}
-type FetchHandlerFetchInterceptor<T extends Context> = Interceptor<FetchHandlerFetchInterceptorOptions<T>, Promise<FetchHandlerHandleResult>>;
-interface FetchHandlerOptions<T extends Context> {
+interface FetchHandlerOptions<_T extends Context> {
     /**
      * Options for how to convert the Fetch Response to a Standard Response, like event stream options, etc.
      */
     toFetchResponse?: undefined | ToFetchResponseOptions;
-    /**
-     * Interceptors that run before the mapping between the Standard API and Fetch API,
-     * useful for customizing the mapping behavior (e.g. extending the body parser).
-     */
-    fetchInterceptors?: FetchHandlerFetchInterceptor<T>[] | undefined;
-    plugins?: FetchHandlerPlugin<T>[] | undefined;
 }
 declare class FetchHandler<T extends Context> {
     private readonly standardHandler;
     private readonly toFetchResponseOptions;
-    private readonly fetchInterceptors;
     constructor(standardHandler: StandardHandler<T>, options?: NoInfer<FetchHandlerOptions<T>>);
     handle(request: Request, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): Promise<FetchHandlerHandleResult>;
 }
 
-interface RPCHandlerOptions<T extends Context> extends FetchHandlerOptions<T>, Omit<StandardHandlerOptions<T>, 'plugins'>, RPCHandlerCodecOptions<T> {
+interface RPCHandlerOptions<T extends Context> extends FetchHandlerOptions<T>, StandardHandlerOptions<T>, RPCHandlerCodecOptions<T> {
 }
 /**
  * Serves an oRPC router over the RPC protocol using the Fetch API
@@ -85,5 +43,5 @@ declare class RPCHandler<T extends Context> extends FetchHandler<T> {
     constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
 }
 
-export { CompositeFetchHandlerPlugin, FetchHandler, RPCHandler };
-export type { FetchHandlerFetchInterceptor, FetchHandlerFetchInterceptorOptions, FetchHandlerHandleResult, FetchHandlerOptions, FetchHandlerPlugin, RPCHandlerOptions };
+export { FetchHandler, RPCHandler };
+export type { FetchHandlerHandleResult, FetchHandlerOptions, RPCHandlerOptions };

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

@@ -1,8 +1,8 @@
 export { R as BodyLimitPlugin } from '../../shared/server.D0dr-F8u.js';
-import { Interceptor, MaybeOptionalOptions } from '@orpc/shared';
+import { MaybeOptionalOptions } from '@orpc/shared';
 import { ToFetchResponseOptions } from '@standard-server/fetch';
 import { Context } from '../../index.js';
-import { StandardHandlerPlugin, StandardHandlerHandleOptions, StandardHandler, StandardHandlerOptions } from '../standard/index.js';
+import { StandardHandler, StandardHandlerOptions } from '../standard/index.js';
 import { FriendlyStandardHandlerHandleOptions } from '../standard/index.js';
 import { Router } from '../../index.js';
 import { RPCHandlerCodecOptions } from '../standard/index.js';
@@ -10,36 +10,6 @@ import '@orpc/client';
 import '@orpc/contract';
 import '@standard-server/core';
 
-interface FetchHandlerPlugin<T extends Context> extends StandardHandlerPlugin<T> {
-    /**
-     * Initializes the plugin and returns new fetch handler options.
-     * Called once per plugin instance during composition.
-     *
-     * This method allows plugins to wrap, extend, or transform fetch handler options
-     * such as fetch interceptors, or fetch configuration.
-     *
-     * @param options - The current handler options from previous plugins or base configuration
-     * @returns Transformed handler options with plugin's modifications applied
-     *
-     * @example
-     * ```ts
-     * initFetchHandlerOptions(options) {
-     *   return {
-     *     ...options,
-     *     interceptors: [...(options.interceptors || []), myInterceptor]
-     *   }
-     * }
-     * ```
-     */
-    initFetchHandlerOptions?(options: FetchHandlerOptions<T>): FetchHandlerOptions<T>;
-}
-declare class CompositeFetchHandlerPlugin<T extends Context> implements FetchHandlerPlugin<T> {
-    readonly name = "~composite/fetch";
-    protected readonly plugins: FetchHandlerPlugin<T>[];
-    constructor(plugins?: FetchHandlerPlugin<T>[]);
-    initFetchHandlerOptions(options: FetchHandlerOptions<T>): FetchHandlerOptions<T>;
-}
-
 type FetchHandlerHandleResult = {
     matched: true;
     response: Response;
@@ -47,32 +17,20 @@ type FetchHandlerHandleResult = {
     matched: false;
     response?: undefined;
 };
-interface FetchHandlerFetchInterceptorOptions<T extends Context> extends StandardHandlerHandleOptions<T> {
-    request: Request;
-    toFetchResponseOptions: ToFetchResponseOptions | undefined;
-}
-type FetchHandlerFetchInterceptor<T extends Context> = Interceptor<FetchHandlerFetchInterceptorOptions<T>, Promise<FetchHandlerHandleResult>>;
-interface FetchHandlerOptions<T extends Context> {
+interface FetchHandlerOptions<_T extends Context> {
     /**
      * Options for how to convert the Fetch Response to a Standard Response, like event stream options, etc.
      */
     toFetchResponse?: undefined | ToFetchResponseOptions;
-    /**
-     * Interceptors that run before the mapping between the Standard API and Fetch API,
-     * useful for customizing the mapping behavior (e.g. extending the body parser).
-     */
-    fetchInterceptors?: FetchHandlerFetchInterceptor<T>[] | undefined;
-    plugins?: FetchHandlerPlugin<T>[] | undefined;
 }
 declare class FetchHandler<T extends Context> {
     private readonly standardHandler;
     private readonly toFetchResponseOptions;
-    private readonly fetchInterceptors;
     constructor(standardHandler: StandardHandler<T>, options?: NoInfer<FetchHandlerOptions<T>>);
     handle(request: Request, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): Promise<FetchHandlerHandleResult>;
 }
 
-interface RPCHandlerOptions<T extends Context> extends FetchHandlerOptions<T>, Omit<StandardHandlerOptions<T>, 'plugins'>, RPCHandlerCodecOptions<T> {
+interface RPCHandlerOptions<T extends Context> extends FetchHandlerOptions<T>, StandardHandlerOptions<T>, RPCHandlerCodecOptions<T> {
 }
 /**
  * Serves an oRPC router over the RPC protocol using the Fetch API
@@ -85,5 +43,5 @@ declare class RPCHandler<T extends Context> extends FetchHandler<T> {
     constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
 }
 
-export { CompositeFetchHandlerPlugin, FetchHandler, RPCHandler };
-export type { FetchHandlerFetchInterceptor, FetchHandlerFetchInterceptorOptions, FetchHandlerHandleResult, FetchHandlerOptions, FetchHandlerPlugin, RPCHandlerOptions };
+export { FetchHandler, RPCHandler };
+export type { FetchHandlerHandleResult, FetchHandlerOptions, RPCHandlerOptions };

package/dist/adapters/fetch/index.mjs

@@ -1,59 +1,33 @@
 export { R as BodyLimitPlugin } from '../../shared/server.1ExWFMze.mjs';
-import { sortPlugins, intercept, resolveMaybeOptionalOptions } from '@orpc/shared';
+import { resolveMaybeOptionalOptions } from '@orpc/shared';
 import { toStandardLazyRequest, toFetchResponse } from '@standard-server/fetch';
 import { r as resolveFriendlyStandardHandlerHandleOptions } from '../../shared/server.W91HSRkE.mjs';
-import { R as RPCHandlerCodec, S as StandardHandler } from '../../shared/server.vUIzQiOP.mjs';
+import { R as RPCHandlerCodec, S as StandardHandler } from '../../shared/server.C0lFtoHU.mjs';
 import '@orpc/client';
 import '@standard-server/core';
 import '../../shared/server.Djb_ebJT.mjs';
 import '@orpc/contract';
 import '../../shared/server.BynNaBBA.mjs';
 
-class CompositeFetchHandlerPlugin {
-  name = "~composite/fetch";
-  plugins;
-  constructor(plugins = []) {
-    this.plugins = sortPlugins(plugins);
-  }
-  initFetchHandlerOptions(options) {
-    for (const plugin of this.plugins) {
-      if (plugin.initFetchHandlerOptions) {
-        options = plugin.initFetchHandlerOptions(options);
-      }
-    }
-    return options;
-  }
-}
-
 class FetchHandler {
   constructor(standardHandler, options = {}) {
     this.standardHandler = standardHandler;
-    options = new CompositeFetchHandlerPlugin(options.plugins).initFetchHandlerOptions(options);
-    this.fetchInterceptors = options.fetchInterceptors;
     this.toFetchResponseOptions = options.toFetchResponse;
   }
   toFetchResponseOptions;
-  fetchInterceptors;
   async handle(request, ...rest) {
-    return intercept(
-      this.fetchInterceptors,
-      {
-        ...resolveFriendlyStandardHandlerHandleOptions(resolveMaybeOptionalOptions(rest)),
-        request,
-        toFetchResponseOptions: this.toFetchResponseOptions
-      },
-      async ({ request: request2, toFetchResponseOptions, ...options }) => {
-        const standardRequest = toStandardLazyRequest(request2);
-        const result = await this.standardHandler.handle(standardRequest, options);
-        if (!result.matched) {
-          return result;
-        }
-        return {
-          matched: true,
-          response: toFetchResponse(result.response, toFetchResponseOptions)
-        };
-      }
+    const standardRequest = toStandardLazyRequest(request);
+    const result = await this.standardHandler.handle(
+      standardRequest,
+      resolveFriendlyStandardHandlerHandleOptions(resolveMaybeOptionalOptions(rest))
     );
+    if (!result.matched) {
+      return result;
+    }
+    return {
+      matched: true,
+      response: toFetchResponse(result.response, this.toFetchResponseOptions)
+    };
   }
 }
 
@@ -65,4 +39,4 @@ class RPCHandler extends FetchHandler {
   }
 }
 
-export { CompositeFetchHandlerPlugin, FetchHandler, RPCHandler };
+export { FetchHandler, RPCHandler };

package/dist/adapters/message-port/index.mjs

@@ -2,7 +2,7 @@ import { onMessagePortMessage, onMessagePortClose, postMessagePortMessage } from
 import { value, resolveMaybeOptionalOptions } from '@orpc/shared';
 import { ServerPeer, encodePeerMessage, decodePeerMessage, isClientPeerSendMessage, isPeerMessage } from '@standard-server/peer';
 import { createStandardPeerRequestHandler } from '../standard-peer/index.mjs';
-import { R as RPCHandlerCodec, S as StandardHandler } from '../../shared/server.vUIzQiOP.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';

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

@@ -1,8 +1,8 @@
 export { R as BodyLimitPlugin } from '../../shared/server.C7xllBNN.mjs';
-import { Interceptor, MaybeOptionalOptions } from '@orpc/shared';
+import { MaybeOptionalOptions } from '@orpc/shared';
 import { SendStandardResponseOptions, NodeHttpRequest, NodeHttpResponse } from '@standard-server/node';
 import { Context } from '../../index.mjs';
-import { StandardHandlerPlugin, StandardHandlerHandleOptions, StandardHandler, StandardHandlerOptions } from '../standard/index.mjs';
+import { StandardHandler, StandardHandlerOptions } from '../standard/index.mjs';
 import { FriendlyStandardHandlerHandleOptions } from '../standard/index.mjs';
 import { Router } from '../../index.mjs';
 import { RPCHandlerCodecOptions } from '../standard/index.mjs';
@@ -10,68 +10,25 @@ import '@orpc/client';
 import '@orpc/contract';
 import '@standard-server/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";
-    protected readonly plugins: NodeHttpHandlerPlugin<T>[];
-    constructor(plugins?: NodeHttpHandlerPlugin<T>[]);
-    initNodeHttpHandlerOptions(options: NodeHttpHandlerOptions<T>): NodeHttpHandlerOptions<T>;
-}
-
 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 RPCHandlerOptions<T extends Context> extends NodeHttpHandlerOptions<T>, Omit<StandardHandlerOptions<T>, 'plugins'>, RPCHandlerCodecOptions<T> {
+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
@@ -83,5 +40,5 @@ declare class RPCHandler<T extends Context> extends NodeHttpHandler<T> {
     constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
 }
 
-export { CompositeNodeHttpHandlerPlugin, NodeHttpHandler, RPCHandler };
-export type { NodeHttpHandlerHandleResult, NodeHttpHandlerNodeHttpInterceptor, NodeHttpHandlerNodeHttpInterceptorOptions, NodeHttpHandlerOptions, NodeHttpHandlerPlugin, RPCHandlerOptions };
+export { NodeHttpHandler, RPCHandler };
+export type { NodeHttpHandlerHandleResult, NodeHttpHandlerOptions, RPCHandlerOptions };

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

@@ -1,8 +1,8 @@
 export { R as BodyLimitPlugin } from '../../shared/server.D0dr-F8u.js';
-import { Interceptor, MaybeOptionalOptions } from '@orpc/shared';
+import { MaybeOptionalOptions } from '@orpc/shared';
 import { SendStandardResponseOptions, NodeHttpRequest, NodeHttpResponse } from '@standard-server/node';
 import { Context } from '../../index.js';
-import { StandardHandlerPlugin, StandardHandlerHandleOptions, StandardHandler, StandardHandlerOptions } from '../standard/index.js';
+import { StandardHandler, StandardHandlerOptions } from '../standard/index.js';
 import { FriendlyStandardHandlerHandleOptions } from '../standard/index.js';
 import { Router } from '../../index.js';
 import { RPCHandlerCodecOptions } from '../standard/index.js';
@@ -10,68 +10,25 @@ import '@orpc/client';
 import '@orpc/contract';
 import '@standard-server/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";
-    protected readonly plugins: NodeHttpHandlerPlugin<T>[];
-    constructor(plugins?: NodeHttpHandlerPlugin<T>[]);
-    initNodeHttpHandlerOptions(options: NodeHttpHandlerOptions<T>): NodeHttpHandlerOptions<T>;
-}
-
 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 RPCHandlerOptions<T extends Context> extends NodeHttpHandlerOptions<T>, Omit<StandardHandlerOptions<T>, 'plugins'>, RPCHandlerCodecOptions<T> {
+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
@@ -83,5 +40,5 @@ declare class RPCHandler<T extends Context> extends NodeHttpHandler<T> {
     constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
 }
 
-export { CompositeNodeHttpHandlerPlugin, NodeHttpHandler, RPCHandler };
-export type { NodeHttpHandlerHandleResult, NodeHttpHandlerNodeHttpInterceptor, NodeHttpHandlerNodeHttpInterceptorOptions, NodeHttpHandlerOptions, NodeHttpHandlerPlugin, RPCHandlerOptions };
+export { NodeHttpHandler, RPCHandler };
+export type { NodeHttpHandlerHandleResult, NodeHttpHandlerOptions, RPCHandlerOptions };

package/dist/adapters/node/index.mjs

@@ -1,8 +1,8 @@
 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.vUIzQiOP.mjs';
+import { R as RPCHandlerCodec, S as StandardHandler } from '../../shared/server.C0lFtoHU.mjs';
 import '@orpc/client';
 import '@standard-server/core';
 import '@standard-server/fetch';
@@ -10,50 +10,23 @@ import '../../shared/server.Djb_ebJT.mjs';
 import '@orpc/contract';
 import '../../shared/server.BynNaBBA.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;
-  }
-}
-
 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.mjs

@@ -1,4 +1,4 @@
-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.vUIzQiOP.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';

package/dist/adapters/websocket/index.mjs

@@ -1,7 +1,7 @@
 import { toStringOrBytes, resolveMaybeOptionalOptions, sequential, loadBytes } from '@orpc/shared';
 import { ServerPeer, encodePeerMessage, decodePeerMessage, isClientPeerSendMessage } from '@standard-server/peer';
 import { createStandardPeerRequestHandler } from '../standard-peer/index.mjs';
-import { R as RPCHandlerCodec, S as StandardHandler } from '../../shared/server.vUIzQiOP.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';

package/dist/shared/{server.vUIzQiOP.mjs → server.C0lFtoHU.mjs}

@@ -1,5 +1,5 @@
 import { ORPCError, toORPCError, RPCSerializer, COMMON_ERROR_STATUS_MAP } from '@orpc/client';
-import { sortPlugins, toArray, matchesHttpPathPrefix, value, intercept, getTracer, runWithSpan, ORPC_NAME, isAsyncIteratorObject, override, traceAsyncIterator, traceReadableStream, recordSpanError, toTracingException, wrapAsyncIterator, wrapReadableStream, pathToHttpPath, normalizeHttpPath, parseEmptyableJSON, getOwn } from '@orpc/shared';
+import { sortPlugins, toArray, matchesHttpPathPrefix, value, intercept, getTracer, runWithSpan, ORPC_NAME, isAsyncIteratorObject, override, traceAsyncIterator, traceReadableStream, recordSpanError, wrapAsyncIterator, toTracingException, wrapReadableStream, pathToHttpPath, normalizeHttpPath, parseEmptyableJSON, getOwn } from '@orpc/shared';
 import { flattenStandardHeader, parseStandardUrl, ErrorEvent } from '@standard-server/core';
 import { c as createProcedureClient, u as unlazy, P as Procedure } from './server.Djb_ebJT.mjs';
 import { w as walkProcedureContractsSync, g as getRouter, c as createContractProcedure, D as DEFAULT_SUCCESS_STATUS, a as DEFAULT_ERROR_STATUS } from './server.BynNaBBA.mjs';
@@ -115,66 +115,66 @@ class TracingHandlerPlugin {
           }
           const parent = tracer.extract?.(request.headers);
           const [pathname] = parseStandardUrl(request.url);
-          const span = tracer.startSpan(`${request.method} ${pathname}`, parent);
-          let result;
-          try {
-            result = await tracer.withActiveSpan(span, next);
-          } catch (e) {
-            span.recordException("error", toTracingException(e));
-            span.end();
-            throw e;
-          }
-          if (!result.matched) {
-            span.end();
-            return result;
-          }
-          const body = result.response.body;
-          if (isAsyncIteratorObject(body)) {
-            return {
-              ...result,
-              response: {
-                ...result.response,
-                /**
-                 * @remarks
-                 * **Warning**: Remember use `override` for remaining special properties
-                 */
-                body: override(body, wrapAsyncIterator(body, {
-                  runWith: (fn) => tracer.withActiveSpan(span, fn),
-                  onError(error) {
-                    if (!(error instanceof ErrorEvent)) {
-                      span.recordException("error", toTracingException(error));
-                    }
-                  },
-                  onFinish() {
-                    span.end();
+          return tracer.startActiveSpan(`${request.method} ${pathname}`, parent, async (span) => {
+            try {
+              const result = await next();
+              if (!result.matched) {
+                span.end();
+                return result;
+              }
+              const body = result.response.body;
+              if (isAsyncIteratorObject(body)) {
+                return {
+                  ...result,
+                  response: {
+                    ...result.response,
+                    /**
+                     * @remarks
+                     * **Warning**: Remember use `override` for remaining special properties
+                     */
+                    body: override(body, wrapAsyncIterator(body, {
+                      runWith: (fn) => tracer.withActiveSpan(span, fn),
+                      onError(error) {
+                        if (!(error instanceof ErrorEvent)) {
+                          span.recordException("error", toTracingException(error));
+                        }
+                      },
+                      onFinish() {
+                        span.end();
+                      }
+                    }))
                   }
-                }))
+                };
               }
-            };
-          }
-          if (body instanceof ReadableStream) {
-            return {
-              ...result,
-              response: {
-                ...result.response,
-                /**
-                 * @remarks
-                 * **Warning**: Remember use `override` for remaining special properties
-                 */
-                body: override(body, wrapReadableStream(body, {
-                  runWith: (fn) => tracer.withActiveSpan(span, fn),
-                  onError(error) {
-                    span.recordException("error", toTracingException(error));
-                  },
-                  onFinish() {
-                    span.end();
+              if (body instanceof ReadableStream) {
+                return {
+                  ...result,
+                  response: {
+                    ...result.response,
+                    /**
+                     * @remarks
+                     * **Warning**: Remember use `override` for remaining special properties
+                     */
+                    body: override(body, wrapReadableStream(body, {
+                      runWith: (fn) => tracer.withActiveSpan(span, fn),
+                      onError(error) {
+                        span.recordException("error", toTracingException(error));
+                      },
+                      onFinish() {
+                        span.end();
+                      }
+                    }))
                   }
-                }))
+                };
               }
-            };
-          }
-          span.end();
-          return result;
+              span.end();
+              return result;
+            } catch (e) {
+              span.recordException("error", toTracingException(e));
+              span.end();
+              throw e;
+            }
+          });
         },
         ...toArray(options.routingInterceptors)
       ]

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/server",
   "type": "module",
-  "version": "2.0.0-beta.36",
+  "version": "2.0.0-beta.38",
   "description": "Build typesafe APIs with oRPC: RPC and OpenAPI support, middleware, and adapters for Node.js, Bun, Deno, Fetch, Fastify, WebSocket, AWS Lambda, and more",
   "license": "MIT",
   "funding": [
@@ -117,15 +117,15 @@
     }
   },
   "dependencies": {
-    "@orpc/client": "2.0.0-beta.36",
-    "@orpc/contract": "2.0.0-beta.36",
-    "@orpc/shared": "2.0.0-beta.36",
-    "@standard-server/aws-lambda": "~0.9.0",
-    "@standard-server/core": "~0.9.0",
-    "@standard-server/fastify": "~0.9.0",
-    "@standard-server/fetch": "~0.9.0",
-    "@standard-server/node": "~0.9.0",
-    "@standard-server/peer": "~0.9.0",
+    "@orpc/client": "2.0.0-beta.38",
+    "@orpc/contract": "2.0.0-beta.38",
+    "@orpc/shared": "2.0.0-beta.38",
+    "@standard-server/aws-lambda": "~0.9.2",
+    "@standard-server/core": "~0.9.2",
+    "@standard-server/fastify": "~0.9.2",
+    "@standard-server/fetch": "~0.9.2",
+    "@standard-server/node": "~0.9.2",
+    "@standard-server/peer": "~0.9.2",
     "cookie": "^2.0.1"
   },
   "devDependencies": {