@orpc/server 1.14.5 → 2.0.0-beta.1

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

@@ -1,99 +1,121 @@
-import { C as Context, R as Router } from '../../shared/server.qKsRrdxW.mjs';
+import { SendStandardResponseOptions, NodeHttpRequest, NodeHttpResponse } from '@standardserver/node';
+import { C as Context } from '../../shared/server.BL22TloH.mjs';
 import { Interceptor, MaybeOptionalOptions } from '@orpc/shared';
-import { SendStandardResponseOptions, NodeHttpRequest, NodeHttpResponse } from '@orpc/standard-server-node';
-import { F as FriendlyStandardHandleOptions } from '../../shared/server.B8gYOD5g.mjs';
-import { g as StandardHandlerPlugin, C as CompositeStandardHandlerPlugin, b as StandardHandleOptions, f as StandardHandler } from '../../shared/server.BqadksTP.mjs';
+import { e as StandardHandlerPlugin, b as StandardHandlerHandleOptions, S as StandardHandler, a as StandardHandlerOptions } from '../../shared/server.BB_Ik9Ph.mjs';
+import { FriendlyStandardHandlerHandleOptions } from '../standard/index.mjs';
 import compression from '@orpc/interop/compression';
-import { S as StandardRPCHandlerOptions } from '../../shared/server.ChUyt5-i.mjs';
+import { R as Router } from '../../shared/server.BsNNjG5J.mjs';
+import { R as RPCHandlerCodecOptions } from '../../shared/server.B_U9y00a.mjs';
 import '@orpc/client';
 import '@orpc/contract';
-import '@orpc/standard-server';
-import '@orpc/client/standard';
-import '../../shared/server.C8_sRzQB.mjs';
+import '@standardserver/core';
 
 interface NodeHttpHandlerPlugin<T extends Context> extends StandardHandlerPlugin<T> {
-    initRuntimeAdapter?(options: NodeHttpHandlerOptions<T>): void;
+    /**
+     * 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, TPlugin extends NodeHttpHandlerPlugin<T>> extends CompositeStandardHandlerPlugin<T, TPlugin> implements NodeHttpHandlerPlugin<T> {
-    initRuntimeAdapter(options: NodeHttpHandlerOptions<T>): void;
+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>;
 }
 
-type NodeHttpHandleResult = {
+type NodeHttpHandlerHandleResult = {
     matched: true;
 } | {
     matched: false;
 };
-interface NodeHttpHandlerInterceptorOptions<T extends Context> extends StandardHandleOptions<T> {
+interface NodeHttpHandlerNodeHttpInterceptorOptions<T extends Context> extends StandardHandlerHandleOptions<T> {
     request: NodeHttpRequest;
     response: NodeHttpResponse;
-    sendStandardResponseOptions: SendStandardResponseOptions;
+    sendStandardResponseOptions: SendStandardResponseOptions | undefined;
 }
-interface NodeHttpHandlerOptions<T extends Context> extends SendStandardResponseOptions {
-    adapterInterceptors?: Interceptor<NodeHttpHandlerInterceptorOptions<T>, Promise<NodeHttpHandleResult>>[];
-    plugins?: NodeHttpHandlerPlugin<T>[];
+type NodeHttpHandlerNodeHttpInterceptor<T extends Context> = Interceptor<NodeHttpHandlerNodeHttpInterceptorOptions<T>, Promise<NodeHttpHandlerHandleResult>>;
+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 adapterInterceptors;
+    private readonly nodeHttpInterceptors;
     constructor(standardHandler: StandardHandler<T>, options?: NoInfer<NodeHttpHandlerOptions<T>>);
-    handle(request: NodeHttpRequest, response: NodeHttpResponse, ...rest: MaybeOptionalOptions<FriendlyStandardHandleOptions<T>>): Promise<NodeHttpHandleResult>;
+    handle(request: NodeHttpRequest, response: NodeHttpResponse, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): Promise<NodeHttpHandlerHandleResult>;
 }
 
-interface BodyLimitPluginOptions {
+interface BodyCompressionHandlerPluginOptions extends compression.CompressionOptions {
     /**
-     * The maximum size of the body in bytes.
+     * 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.
      */
-    maxBodySize: number;
+    filter?: (request: NodeHttpRequest, response: NodeHttpResponse) => boolean;
 }
-/**
- * The Body Limit Plugin restricts the size of the request body for the Node.js HTTP Server.
- *
- * @see {@link https://orpc.dev/docs/plugins/body-limit Body Limit Plugin Docs}
- */
-declare class BodyLimitPlugin<T extends Context> implements NodeHttpHandlerPlugin<T> {
-    private readonly maxBodySize;
-    constructor(options: BodyLimitPluginOptions);
-    initRuntimeAdapter(options: NodeHttpHandlerOptions<T>): void;
+declare class BodyCompressionHandlerPlugin<T extends Context> implements NodeHttpHandlerPlugin<T> {
+    name: string;
+    private readonly compressionHandler;
+    constructor(options?: BodyCompressionHandlerPluginOptions);
+    initNodeHttpHandlerOptions(options: NodeHttpHandlerOptions<T>): NodeHttpHandlerOptions<T>;
 }
 
-interface CompressionPluginOptions extends compression.CompressionOptions {
+interface BodyLimitHandlerPluginOptions {
     /**
-     * Override the default content-type filter used to determine which responses should be compressed.
-     *
-     * @warning [Event Iterator](https://orpc.dev/docs/event-iterator) responses are never compressed, regardless of this filter's return value.
-     * @default only responses with compressible content types are compressed.
+     * The maximum size of the body in bytes.
      */
-    filter?: (req: NodeHttpRequest, res: NodeHttpResponse) => boolean;
+    maxBodySize: number;
 }
-/**
- * The Compression Plugin adds response compression to the Node.js HTTP Server.
- *
- * @see {@link https://orpc.dev/docs/plugins/compression Compression Plugin Docs}
- */
-declare class CompressionPlugin<T extends Context> implements NodeHttpHandlerPlugin<T> {
-    private readonly compressionHandler;
-    constructor(options?: CompressionPluginOptions);
-    initRuntimeAdapter(options: NodeHttpHandlerOptions<T>): void;
+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<StandardRPCHandlerOptions<T>, 'plugins'> {
+interface RPCHandlerOptions<T extends Context> extends NodeHttpHandlerOptions<T>, Omit<StandardHandlerOptions<T>, 'plugins'>, RPCHandlerCodecOptions<T> {
     /**
-     * Enables or disables the StrictGetMethodPlugin.
-     *
-     * @default true
+     * Configuration for {@link CSRFGuardHandlerPlugin}, which is enabled by default for `RPCHandler` over HTTP.
      */
-    strictGetMethodPluginEnabled?: boolean;
+    csrfGuardPlugin?: {
+        /**
+         * If `false`, this plugin is disabled.
+         *
+         * @default true
+         */
+        enabled?: boolean;
+    };
 }
-/**
- * RPC Handler for Node.js HTTP Server
- *
- * @see {@link https://orpc.dev/docs/rpc-handler RPC Handler Docs}
- * @see {@link https://orpc.dev/docs/adapters/http HTTP Adapter Docs}
- */
 declare class RPCHandler<T extends Context> extends NodeHttpHandler<T> {
-    constructor(router: Router<any, T>, options?: NoInfer<RPCHandlerOptions<T>>);
+    constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
 }
 
-export { BodyLimitPlugin, CompositeNodeHttpHandlerPlugin, CompressionPlugin, NodeHttpHandler, RPCHandler };
-export type { BodyLimitPluginOptions, CompressionPluginOptions, NodeHttpHandleResult, NodeHttpHandlerInterceptorOptions, NodeHttpHandlerOptions, NodeHttpHandlerPlugin, RPCHandlerOptions };
+export { BodyCompressionHandlerPlugin, BodyLimitHandlerPlugin, CompositeNodeHttpHandlerPlugin, NodeHttpHandler, RPCHandler };
+export type { BodyCompressionHandlerPluginOptions, BodyLimitHandlerPluginOptions, NodeHttpHandlerHandleResult, NodeHttpHandlerNodeHttpInterceptor, NodeHttpHandlerNodeHttpInterceptorOptions, NodeHttpHandlerOptions, NodeHttpHandlerPlugin, RPCHandlerOptions };

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

@@ -1,99 +1,121 @@
-import { C as Context, R as Router } from '../../shared/server.qKsRrdxW.js';
+import { SendStandardResponseOptions, NodeHttpRequest, NodeHttpResponse } from '@standardserver/node';
+import { C as Context } from '../../shared/server.BL22TloH.js';
 import { Interceptor, MaybeOptionalOptions } from '@orpc/shared';
-import { SendStandardResponseOptions, NodeHttpRequest, NodeHttpResponse } from '@orpc/standard-server-node';
-import { F as FriendlyStandardHandleOptions } from '../../shared/server.EfTOZ2Q7.js';
-import { g as StandardHandlerPlugin, C as CompositeStandardHandlerPlugin, b as StandardHandleOptions, f as StandardHandler } from '../../shared/server.7cEtMB30.js';
+import { e as StandardHandlerPlugin, b as StandardHandlerHandleOptions, S as StandardHandler, a as StandardHandlerOptions } from '../../shared/server.EOHJ3NJr.js';
+import { FriendlyStandardHandlerHandleOptions } from '../standard/index.js';
 import compression from '@orpc/interop/compression';
-import { S as StandardRPCHandlerOptions } from '../../shared/server.yoEB3Fx4.js';
+import { R as Router } from '../../shared/server.Pa0F03f_.js';
+import { R as RPCHandlerCodecOptions } from '../../shared/server.T9F3bzZx.js';
 import '@orpc/client';
 import '@orpc/contract';
-import '@orpc/standard-server';
-import '@orpc/client/standard';
-import '../../shared/server.ChyoA9XY.js';
+import '@standardserver/core';
 
 interface NodeHttpHandlerPlugin<T extends Context> extends StandardHandlerPlugin<T> {
-    initRuntimeAdapter?(options: NodeHttpHandlerOptions<T>): void;
+    /**
+     * 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, TPlugin extends NodeHttpHandlerPlugin<T>> extends CompositeStandardHandlerPlugin<T, TPlugin> implements NodeHttpHandlerPlugin<T> {
-    initRuntimeAdapter(options: NodeHttpHandlerOptions<T>): void;
+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>;
 }
 
-type NodeHttpHandleResult = {
+type NodeHttpHandlerHandleResult = {
     matched: true;
 } | {
     matched: false;
 };
-interface NodeHttpHandlerInterceptorOptions<T extends Context> extends StandardHandleOptions<T> {
+interface NodeHttpHandlerNodeHttpInterceptorOptions<T extends Context> extends StandardHandlerHandleOptions<T> {
     request: NodeHttpRequest;
     response: NodeHttpResponse;
-    sendStandardResponseOptions: SendStandardResponseOptions;
+    sendStandardResponseOptions: SendStandardResponseOptions | undefined;
 }
-interface NodeHttpHandlerOptions<T extends Context> extends SendStandardResponseOptions {
-    adapterInterceptors?: Interceptor<NodeHttpHandlerInterceptorOptions<T>, Promise<NodeHttpHandleResult>>[];
-    plugins?: NodeHttpHandlerPlugin<T>[];
+type NodeHttpHandlerNodeHttpInterceptor<T extends Context> = Interceptor<NodeHttpHandlerNodeHttpInterceptorOptions<T>, Promise<NodeHttpHandlerHandleResult>>;
+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 adapterInterceptors;
+    private readonly nodeHttpInterceptors;
     constructor(standardHandler: StandardHandler<T>, options?: NoInfer<NodeHttpHandlerOptions<T>>);
-    handle(request: NodeHttpRequest, response: NodeHttpResponse, ...rest: MaybeOptionalOptions<FriendlyStandardHandleOptions<T>>): Promise<NodeHttpHandleResult>;
+    handle(request: NodeHttpRequest, response: NodeHttpResponse, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): Promise<NodeHttpHandlerHandleResult>;
 }
 
-interface BodyLimitPluginOptions {
+interface BodyCompressionHandlerPluginOptions extends compression.CompressionOptions {
     /**
-     * The maximum size of the body in bytes.
+     * 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.
      */
-    maxBodySize: number;
+    filter?: (request: NodeHttpRequest, response: NodeHttpResponse) => boolean;
 }
-/**
- * The Body Limit Plugin restricts the size of the request body for the Node.js HTTP Server.
- *
- * @see {@link https://orpc.dev/docs/plugins/body-limit Body Limit Plugin Docs}
- */
-declare class BodyLimitPlugin<T extends Context> implements NodeHttpHandlerPlugin<T> {
-    private readonly maxBodySize;
-    constructor(options: BodyLimitPluginOptions);
-    initRuntimeAdapter(options: NodeHttpHandlerOptions<T>): void;
+declare class BodyCompressionHandlerPlugin<T extends Context> implements NodeHttpHandlerPlugin<T> {
+    name: string;
+    private readonly compressionHandler;
+    constructor(options?: BodyCompressionHandlerPluginOptions);
+    initNodeHttpHandlerOptions(options: NodeHttpHandlerOptions<T>): NodeHttpHandlerOptions<T>;
 }
 
-interface CompressionPluginOptions extends compression.CompressionOptions {
+interface BodyLimitHandlerPluginOptions {
     /**
-     * Override the default content-type filter used to determine which responses should be compressed.
-     *
-     * @warning [Event Iterator](https://orpc.dev/docs/event-iterator) responses are never compressed, regardless of this filter's return value.
-     * @default only responses with compressible content types are compressed.
+     * The maximum size of the body in bytes.
      */
-    filter?: (req: NodeHttpRequest, res: NodeHttpResponse) => boolean;
+    maxBodySize: number;
 }
-/**
- * The Compression Plugin adds response compression to the Node.js HTTP Server.
- *
- * @see {@link https://orpc.dev/docs/plugins/compression Compression Plugin Docs}
- */
-declare class CompressionPlugin<T extends Context> implements NodeHttpHandlerPlugin<T> {
-    private readonly compressionHandler;
-    constructor(options?: CompressionPluginOptions);
-    initRuntimeAdapter(options: NodeHttpHandlerOptions<T>): void;
+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<StandardRPCHandlerOptions<T>, 'plugins'> {
+interface RPCHandlerOptions<T extends Context> extends NodeHttpHandlerOptions<T>, Omit<StandardHandlerOptions<T>, 'plugins'>, RPCHandlerCodecOptions<T> {
     /**
-     * Enables or disables the StrictGetMethodPlugin.
-     *
-     * @default true
+     * Configuration for {@link CSRFGuardHandlerPlugin}, which is enabled by default for `RPCHandler` over HTTP.
      */
-    strictGetMethodPluginEnabled?: boolean;
+    csrfGuardPlugin?: {
+        /**
+         * If `false`, this plugin is disabled.
+         *
+         * @default true
+         */
+        enabled?: boolean;
+    };
 }
-/**
- * RPC Handler for Node.js HTTP Server
- *
- * @see {@link https://orpc.dev/docs/rpc-handler RPC Handler Docs}
- * @see {@link https://orpc.dev/docs/adapters/http HTTP Adapter Docs}
- */
 declare class RPCHandler<T extends Context> extends NodeHttpHandler<T> {
-    constructor(router: Router<any, T>, options?: NoInfer<RPCHandlerOptions<T>>);
+    constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
 }
 
-export { BodyLimitPlugin, CompositeNodeHttpHandlerPlugin, CompressionPlugin, NodeHttpHandler, RPCHandler };
-export type { BodyLimitPluginOptions, CompressionPluginOptions, NodeHttpHandleResult, NodeHttpHandlerInterceptorOptions, NodeHttpHandlerOptions, NodeHttpHandlerPlugin, RPCHandlerOptions };
+export { BodyCompressionHandlerPlugin, BodyLimitHandlerPlugin, CompositeNodeHttpHandlerPlugin, NodeHttpHandler, RPCHandler };
+export type { BodyCompressionHandlerPluginOptions, BodyLimitHandlerPluginOptions, NodeHttpHandlerHandleResult, NodeHttpHandlerNodeHttpInterceptor, NodeHttpHandlerNodeHttpInterceptorOptions, NodeHttpHandlerOptions, NodeHttpHandlerPlugin, RPCHandlerOptions };

package/dist/adapters/node/index.mjs

@@ -1,125 +1,150 @@
-import { ORPCError } from '@orpc/client';
-import { once, toArray, intercept, resolveMaybeOptionalOptions } from '@orpc/shared';
 import compression from '@orpc/interop/compression';
-import { toStandardLazyRequest, sendStandardResponse } from '@orpc/standard-server-node';
-import { r as resolveFriendlyStandardHandleOptions } from '../../shared/server.DZ5BIITo.mjs';
-import { C as CompositeStandardHandlerPlugin, b as StandardRPCHandler } from '../../shared/server.ZxHCEN1h.mjs';
-import { S as StrictGetMethodPlugin } from '../../shared/server.TEVCLCFC.mjs';
-import '@orpc/client/standard';
-import '@orpc/standard-server';
-import '../../shared/server.DEBcqOjg.mjs';
+import { toArray, sortPlugins, intercept, resolveMaybeOptionalOptions } from '@orpc/shared';
+import { ORPCError } from '@orpc/client';
+import { toStandardLazyRequest, sendStandardResponse } from '@standardserver/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 '@orpc/contract';
+import '../../shared/server.BwHnWUuN.mjs';
 
-class BodyLimitPlugin {
-  maxBodySize;
-  constructor(options) {
-    this.maxBodySize = options.maxBodySize;
-  }
-  initRuntimeAdapter(options) {
-    options.adapterInterceptors ??= [];
-    options.adapterInterceptors.push(async (options2) => {
-      const checkHeader = once(() => {
-        if (Number(options2.request.headers["content-length"]) > this.maxBodySize) {
-          throw new ORPCError("PAYLOAD_TOO_LARGE");
-        }
-      });
-      const originalEmit = options2.request.emit;
-      let currentBodySize = 0;
-      options2.request.emit = (event, ...args) => {
-        if (event === "data") {
-          checkHeader();
-          currentBodySize += args[0].length;
-          if (currentBodySize > this.maxBodySize) {
-            throw new ORPCError("PAYLOAD_TOO_LARGE");
-          }
-        }
-        return originalEmit.call(options2.request, event, ...args);
-      };
-      try {
-        return await options2.next(options2);
-      } finally {
-        options2.request.emit = originalEmit;
-      }
-    });
-  }
-}
-
-class CompressionPlugin {
+class BodyCompressionHandlerPlugin {
+  name = "~body-compression";
   compressionHandler;
   constructor(options = {}) {
     this.compressionHandler = compression({
       ...options,
-      filter: (req, res) => {
-        const hasContentDisposition = res.hasHeader("content-disposition");
-        const contentType = res.getHeader("content-type")?.toString();
+      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(req, res) : compression.filter(req, res);
+        return options.filter ? options.filter(request, response) : compression.filter(request, response);
       }
     });
   }
-  initRuntimeAdapter(options) {
-    options.adapterInterceptors ??= [];
-    options.adapterInterceptors.unshift(async (options2) => {
-      let resolve;
-      let reject;
-      const promise = new Promise((res, rej) => {
-        resolve = res;
-        reject = rej;
-      });
-      const originalWrite = options2.response.write;
-      const originalEnd = options2.response.end;
-      const originalOn = options2.response.on;
-      this.compressionHandler(
-        options2.request,
-        options2.response,
-        async (err) => {
-          if (err) {
-            reject(err);
-          } else {
-            try {
-              resolve(await options2.next());
-            } catch (error) {
-              reject(error);
+  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;
           }
-        }
-      );
-      try {
-        return await promise;
-      } finally {
-        options2.response.write = originalWrite;
-        options2.response.end = originalEnd;
-        options2.response.on = originalOn;
-      }
-    });
+        },
+        ...toArray(options.nodeHttpInterceptors)
+      ]
+    };
   }
 }
 
-class CompositeNodeHttpHandlerPlugin extends CompositeStandardHandlerPlugin {
-  initRuntimeAdapter(options) {
+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) {
-      plugin.initRuntimeAdapter?.(options);
+      if (plugin.initNodeHttpHandlerOptions) {
+        options = plugin.initNodeHttpHandlerOptions(options);
+      }
     }
+    return options;
   }
 }
 
 class NodeHttpHandler {
   constructor(standardHandler, options = {}) {
     this.standardHandler = standardHandler;
-    const plugin = new CompositeNodeHttpHandlerPlugin(options.plugins);
-    plugin.initRuntimeAdapter(options);
-    this.adapterInterceptors = toArray(options.adapterInterceptors);
-    this.sendStandardResponseOptions = options;
+    options = new CompositeNodeHttpHandlerPlugin(options.plugins).initNodeHttpHandlerOptions(options);
+    this.nodeHttpInterceptors = options.nodeHttpInterceptors;
+    this.sendStandardResponseOptions = options.sendStandardResponse;
   }
   sendStandardResponseOptions;
-  adapterInterceptors;
+  nodeHttpInterceptors;
   async handle(request, response, ...rest) {
     return intercept(
-      this.adapterInterceptors,
+      this.nodeHttpInterceptors,
       {
-        ...resolveFriendlyStandardHandleOptions(resolveMaybeOptionalOptions(rest)),
+        ...resolveFriendlyStandardHandlerHandleOptions(resolveMaybeOptionalOptions(rest)),
         request,
         response,
         sendStandardResponseOptions: this.sendStandardResponseOptions
@@ -128,10 +153,10 @@ class NodeHttpHandler {
         const standardRequest = toStandardLazyRequest(request2, response2);
         const result = await this.standardHandler.handle(standardRequest, options);
         if (!result.matched) {
-          return { matched: false };
+          return result;
         }
         await sendStandardResponse(response2, result.response, sendStandardResponseOptions);
-        return { matched: true };
+        return result;
       }
     );
   }
@@ -139,12 +164,16 @@ class NodeHttpHandler {
 
 class RPCHandler extends NodeHttpHandler {
   constructor(router, options = {}) {
-    if (options.strictGetMethodPluginEnabled ?? true) {
-      options.plugins ??= [];
-      options.plugins.push(new StrictGetMethodPlugin());
+    if (options.csrfGuardPlugin?.enabled !== false) {
+      options = {
+        ...options,
+        plugins: [...toArray(options.plugins), new CSRFGuardHandlerPlugin()]
+      };
     }
-    super(new StandardRPCHandler(router, options), options);
+    const codec = new RPCHandlerCodec(router, options);
+    const handler = new StandardHandler(codec, options);
+    super(handler, options);
   }
 }
 
-export { BodyLimitPlugin, CompositeNodeHttpHandlerPlugin, CompressionPlugin, NodeHttpHandler, RPCHandler };
+export { BodyCompressionHandlerPlugin, BodyLimitHandlerPlugin, CompositeNodeHttpHandlerPlugin, NodeHttpHandler, RPCHandler };