@orpc/server 1.14.9 → 1.14.11

package/dist/adapters/message-port/index.d.mts

@@ -1,56 +1,71 @@
 import { SupportedMessagePort } from '@orpc/client/message-port';
 import { Value, Promisable, MaybeOptionalOptions } from '@orpc/shared';
-import { DecodedResponseMessage } from '@orpc/standard-server-peer';
-import { C as Context, R as Router } from '../../shared/server.qKsRrdxW.mjs';
-import { f as StandardHandler } from '../../shared/server.BqadksTP.mjs';
-import { HandleStandardServerPeerMessageOptions } from '../standard-peer/index.mjs';
-import { S as StandardRPCHandlerOptions } from '../../shared/server.ChUyt5-i.mjs';
+import { ServerPeer, EncodePeerMessageOptions, DecodePeerMessageOptions } from '@standardserver/peer';
+import { C as Context } from '../../shared/server.CcR4kgje.mjs';
+import { S as StandardHandler, a as StandardHandlerOptions } from '../../shared/server.DDFizwfU.mjs';
+import { StandardPeerRequestHandlerOptions } from '../standard-peer/index.mjs';
+import { R as Router } from '../../shared/server.15O7oC1p.mjs';
+import { R as RPCHandlerCodecOptions } from '../../shared/server.B4BnEWWm.mjs';
 import '@orpc/client';
 import '@orpc/contract';
-import '@orpc/standard-server';
-import '../../shared/server.B8gYOD5g.mjs';
-import '@orpc/client/standard';
-import '../../shared/server.C8_sRzQB.mjs';
+import '@standardserver/core';
 
+type DecodedResponseMessage = ConstructorParameters<typeof ServerPeer>[0] extends (message: infer TMessage) => unknown ? TMessage : never;
 interface MessagePortHandlerOptions<_T extends Context> {
     /**
-     * By default, oRPC serializes request/response messages to string/binary data before sending over message port.
-     * If needed, you can define the this option to utilize full power of [MessagePort: postMessage() method](https://developer.mozilla.org/en-US/docs/Web/API/MessagePort/postMessage),
-     * such as transferring ownership of objects to the other side or support unserializable objects like `OffscreenCanvas`.
+     * By default, oRPC encodes peer messages as strings or binary data before sending them over the message port.
+     * Use this option to bypass encoding and leverage the full capabilities of the
+     * [MessagePort: postMessage() method](https://developer.mozilla.org/en-US/docs/Web/API/MessagePort/postMessage),
+     * such as transferring object ownership or supporting non-serializable objects like `OffscreenCanvas` or improving performance.
      *
      * @remarks
-     * - return null | undefined to disable this feature
+     * - Returning `null` or `undefined` disables this feature.
      *
-     * @warning Make sure your message port supports `transfer` before using this feature.
-     * @example
-     * ```ts
-     * experimental_transfer: (message, port) => {
-     *   const transfer = deepFindTransferableObjects(message) // implement your own logic
-     *   return transfer.length ? transfer : null // only enable when needed
-     * }
-     * ```
-     *
-     * @see {@link https://orpc.dev/docs/adapters/message-port#transfer Message Port Transfer Docs}
+     * @warning Ensure your message port implementation supports `transferable` objects before enabling this.
      */
     experimental_transfer?: Value<Promisable<object[] | null | undefined>, [message: DecodedResponseMessage, port: SupportedMessagePort]>;
+    /**
+     * Options for encoding peer messages. such as `prefix` for distinguishing messages on the same channel..
+     */
+    encodePeerMessage?: EncodePeerMessageOptions | undefined;
+    /**
+     * Options for decoding peer messages. such as `prefix` for distinguishing messages on the same channel..
+     */
+    decodePeerMessage?: DecodePeerMessageOptions | undefined;
 }
 declare class MessagePortHandler<T extends Context> {
-    private readonly standardHandler;
+    private readonly handler;
+    private readonly peers;
     private readonly transfer;
-    constructor(standardHandler: StandardHandler<T>, options?: NoInfer<MessagePortHandlerOptions<T>>);
-    upgrade(port: SupportedMessagePort, ...rest: MaybeOptionalOptions<HandleStandardServerPeerMessageOptions<T>>): void;
+    private readonly encodePeerMessageOptions;
+    private readonly decodePeerMessageOptions;
+    constructor(handler: StandardHandler<T>, options?: NoInfer<MessagePortHandlerOptions<T>>);
+    /**
+     * Attaches message and close listeners to a message port.
+     *
+     * Prefer this over calling `.message()` and `.close()` manually.
+     */
+    upgrade(port: SupportedMessagePort, ...rest: MaybeOptionalOptions<StandardPeerRequestHandlerOptions<T>>): void;
+    /**
+     * Handles a single message received from a message port.
+     *
+     * @param port The message port instance. Use the same instance for all messages.
+     */
+    message(port: SupportedMessagePort, data: unknown, ...rest: MaybeOptionalOptions<StandardPeerRequestHandlerOptions<T>>): Promise<{
+        matched: boolean;
+    }>;
+    /**
+     * Cleans up peer state for a closed message port.
+     *
+     * @param port The same message port instance passed to `.message()`.
+     */
+    close(port: SupportedMessagePort): Promise<void>;
 }
 
-interface RPCHandlerOptions<T extends Context> extends StandardRPCHandlerOptions<T>, MessagePortHandlerOptions<T> {
+interface RPCHandlerOptions<T extends Context> extends StandardHandlerOptions<T>, RPCHandlerCodecOptions<T>, MessagePortHandlerOptions<T> {
 }
-/**
- * RPC Handler for common message port implementations.
- *
- * @see {@link https://orpc.dev/docs/rpc-handler RPC Handler Docs}
- * @see {@link https://orpc.dev/docs/adapters/message-port Message Port Adapter Docs}
- */
 declare class RPCHandler<T extends Context> extends MessagePortHandler<T> {
-    constructor(router: Router<any, T>, options?: NoInfer<RPCHandlerOptions<T>>);
+    constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
 }
 
 export { MessagePortHandler, RPCHandler };

package/dist/adapters/message-port/index.d.ts

@@ -1,56 +1,71 @@
 import { SupportedMessagePort } from '@orpc/client/message-port';
 import { Value, Promisable, MaybeOptionalOptions } from '@orpc/shared';
-import { DecodedResponseMessage } from '@orpc/standard-server-peer';
-import { C as Context, R as Router } from '../../shared/server.qKsRrdxW.js';
-import { f as StandardHandler } from '../../shared/server.7cEtMB30.js';
-import { HandleStandardServerPeerMessageOptions } from '../standard-peer/index.js';
-import { S as StandardRPCHandlerOptions } from '../../shared/server.yoEB3Fx4.js';
+import { ServerPeer, EncodePeerMessageOptions, DecodePeerMessageOptions } from '@standardserver/peer';
+import { C as Context } from '../../shared/server.CcR4kgje.js';
+import { S as StandardHandler, a as StandardHandlerOptions } from '../../shared/server.BhsVw7m7.js';
+import { StandardPeerRequestHandlerOptions } from '../standard-peer/index.js';
+import { R as Router } from '../../shared/server.m3szVJGU.js';
+import { R as RPCHandlerCodecOptions } from '../../shared/server.CnN50DHH.js';
 import '@orpc/client';
 import '@orpc/contract';
-import '@orpc/standard-server';
-import '../../shared/server.EfTOZ2Q7.js';
-import '@orpc/client/standard';
-import '../../shared/server.ChyoA9XY.js';
+import '@standardserver/core';
 
+type DecodedResponseMessage = ConstructorParameters<typeof ServerPeer>[0] extends (message: infer TMessage) => unknown ? TMessage : never;
 interface MessagePortHandlerOptions<_T extends Context> {
     /**
-     * By default, oRPC serializes request/response messages to string/binary data before sending over message port.
-     * If needed, you can define the this option to utilize full power of [MessagePort: postMessage() method](https://developer.mozilla.org/en-US/docs/Web/API/MessagePort/postMessage),
-     * such as transferring ownership of objects to the other side or support unserializable objects like `OffscreenCanvas`.
+     * By default, oRPC encodes peer messages as strings or binary data before sending them over the message port.
+     * Use this option to bypass encoding and leverage the full capabilities of the
+     * [MessagePort: postMessage() method](https://developer.mozilla.org/en-US/docs/Web/API/MessagePort/postMessage),
+     * such as transferring object ownership or supporting non-serializable objects like `OffscreenCanvas` or improving performance.
      *
      * @remarks
-     * - return null | undefined to disable this feature
+     * - Returning `null` or `undefined` disables this feature.
      *
-     * @warning Make sure your message port supports `transfer` before using this feature.
-     * @example
-     * ```ts
-     * experimental_transfer: (message, port) => {
-     *   const transfer = deepFindTransferableObjects(message) // implement your own logic
-     *   return transfer.length ? transfer : null // only enable when needed
-     * }
-     * ```
-     *
-     * @see {@link https://orpc.dev/docs/adapters/message-port#transfer Message Port Transfer Docs}
+     * @warning Ensure your message port implementation supports `transferable` objects before enabling this.
      */
     experimental_transfer?: Value<Promisable<object[] | null | undefined>, [message: DecodedResponseMessage, port: SupportedMessagePort]>;
+    /**
+     * Options for encoding peer messages. such as `prefix` for distinguishing messages on the same channel..
+     */
+    encodePeerMessage?: EncodePeerMessageOptions | undefined;
+    /**
+     * Options for decoding peer messages. such as `prefix` for distinguishing messages on the same channel..
+     */
+    decodePeerMessage?: DecodePeerMessageOptions | undefined;
 }
 declare class MessagePortHandler<T extends Context> {
-    private readonly standardHandler;
+    private readonly handler;
+    private readonly peers;
     private readonly transfer;
-    constructor(standardHandler: StandardHandler<T>, options?: NoInfer<MessagePortHandlerOptions<T>>);
-    upgrade(port: SupportedMessagePort, ...rest: MaybeOptionalOptions<HandleStandardServerPeerMessageOptions<T>>): void;
+    private readonly encodePeerMessageOptions;
+    private readonly decodePeerMessageOptions;
+    constructor(handler: StandardHandler<T>, options?: NoInfer<MessagePortHandlerOptions<T>>);
+    /**
+     * Attaches message and close listeners to a message port.
+     *
+     * Prefer this over calling `.message()` and `.close()` manually.
+     */
+    upgrade(port: SupportedMessagePort, ...rest: MaybeOptionalOptions<StandardPeerRequestHandlerOptions<T>>): void;
+    /**
+     * Handles a single message received from a message port.
+     *
+     * @param port The message port instance. Use the same instance for all messages.
+     */
+    message(port: SupportedMessagePort, data: unknown, ...rest: MaybeOptionalOptions<StandardPeerRequestHandlerOptions<T>>): Promise<{
+        matched: boolean;
+    }>;
+    /**
+     * Cleans up peer state for a closed message port.
+     *
+     * @param port The same message port instance passed to `.message()`.
+     */
+    close(port: SupportedMessagePort): Promise<void>;
 }
 
-interface RPCHandlerOptions<T extends Context> extends StandardRPCHandlerOptions<T>, MessagePortHandlerOptions<T> {
+interface RPCHandlerOptions<T extends Context> extends StandardHandlerOptions<T>, RPCHandlerCodecOptions<T>, MessagePortHandlerOptions<T> {
 }
-/**
- * RPC Handler for common message port implementations.
- *
- * @see {@link https://orpc.dev/docs/rpc-handler RPC Handler Docs}
- * @see {@link https://orpc.dev/docs/adapters/message-port Message Port Adapter Docs}
- */
 declare class RPCHandler<T extends Context> extends MessagePortHandler<T> {
-    constructor(router: Router<any, T>, options?: NoInfer<RPCHandlerOptions<T>>);
+    constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
 }
 
 export { MessagePortHandler, RPCHandler };

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

@@ -1,54 +1,85 @@
-import { postMessagePortMessage, onMessagePortMessage, onMessagePortClose } from '@orpc/client/message-port';
-import { value, resolveMaybeOptionalOptions, isObject } from '@orpc/shared';
-import { experimental_ServerPeerWithoutCodec, serializeResponseMessage, encodeResponseMessage, deserializeRequestMessage, decodeRequestMessage } from '@orpc/standard-server-peer';
-import { createServerPeerHandleRequestFn } from '../standard-peer/index.mjs';
-import { b as StandardRPCHandler } from '../../shared/server.ZxHCEN1h.mjs';
-import '../../shared/server.DZ5BIITo.mjs';
-import '@orpc/client/standard';
+import { onMessagePortMessage, onMessagePortClose, postMessagePortMessage } from '@orpc/client/message-port';
+import { value, resolveMaybeOptionalOptions } from '@orpc/shared';
+import { ServerPeer, encodePeerMessage, decodePeerMessage, isClientPeerSendMessage, isPeerMessage } from '@standardserver/peer';
+import { c as createStandardPeerRequestHandler } from '../../shared/server.CX4vUnDk.mjs';
+import { R as RPCHandlerCodec, S as StandardHandler } from '../../shared/server.COPVXhDG.mjs';
 import '@orpc/client';
-import '@orpc/standard-server';
-import '../../shared/server.DEBcqOjg.mjs';
+import '@standardserver/core';
+import '../../shared/server.DofEOwf-.mjs';
 import '@orpc/contract';
+import '../../shared/server.BoiFpNT7.mjs';
 
 class MessagePortHandler {
-  constructor(standardHandler, options = {}) {
-    this.standardHandler = standardHandler;
+  constructor(handler, options = {}) {
+    this.handler = handler;
     this.transfer = options.experimental_transfer;
+    this.encodePeerMessageOptions = options.encodePeerMessage;
+    this.decodePeerMessageOptions = options.decodePeerMessage;
   }
+  peers = /* @__PURE__ */ new WeakMap();
   transfer;
+  encodePeerMessageOptions;
+  decodePeerMessageOptions;
+  /**
+   * Attaches message and close listeners to a message port.
+   *
+   * Prefer this over calling `.message()` and `.close()` manually.
+   */
   upgrade(port, ...rest) {
-    const peer = new experimental_ServerPeerWithoutCodec(async (message) => {
-      const [id, type, payload] = message;
-      const transfer = await value(this.transfer, message, port);
-      if (transfer) {
-        postMessagePortMessage(port, serializeResponseMessage(id, type, payload), transfer);
-      } else {
-        postMessagePortMessage(port, await encodeResponseMessage(id, type, payload));
-      }
-    });
-    onMessagePortMessage(port, async (message) => {
-      const handleFn = createServerPeerHandleRequestFn(this.standardHandler, resolveMaybeOptionalOptions(rest));
-      if (isObject(message)) {
-        await peer.message(
-          deserializeRequestMessage(message),
-          handleFn
-        );
-      } else {
-        await peer.message(
-          await decodeRequestMessage(message),
-          handleFn
-        );
+    onMessagePortMessage(port, (message) => this.message(port, message, ...rest));
+    onMessagePortClose(port, () => this.close(port));
+  }
+  /**
+   * Handles a single message received from a message port.
+   *
+   * @param port The message port instance. Use the same instance for all messages.
+   */
+  async message(port, data, ...rest) {
+    let peer = this.peers.get(port);
+    if (!peer) {
+      this.peers.set(port, peer = new ServerPeer(async (message) => {
+        const transfer = await value(this.transfer, message, port);
+        if (transfer) {
+          postMessagePortMessage(port, message, transfer);
+        } else {
+          postMessagePortMessage(port, await encodePeerMessage(message, this.encodePeerMessageOptions));
+        }
+      }));
+    }
+    let peerMessage;
+    if (typeof data === "string" || data instanceof Uint8Array) {
+      const result = decodePeerMessage(data, this.decodePeerMessageOptions);
+      if (result.matched && isClientPeerSendMessage(result.message)) {
+        peerMessage = result.message;
       }
-    });
-    onMessagePortClose(port, () => {
-      peer.close();
-    });
+    } else if (isPeerMessage(data) && isClientPeerSendMessage(data)) {
+      peerMessage = data;
+    }
+    if (peerMessage === void 0) {
+      return { matched: false };
+    }
+    await peer.message(peerMessage, createStandardPeerRequestHandler(this.handler, resolveMaybeOptionalOptions(rest)));
+    return { matched: true };
+  }
+  /**
+   * Cleans up peer state for a closed message port.
+   *
+   * @param port The same message port instance passed to `.message()`.
+   */
+  async close(port) {
+    const peer = this.peers.get(port);
+    if (peer) {
+      this.peers.delete(port);
+      await peer.close();
+    }
   }
 }
 
 class RPCHandler extends MessagePortHandler {
   constructor(router, options = {}) {
-    super(new StandardRPCHandler(router, options), options);
+    const codec = new RPCHandlerCodec(router, options);
+    const handler = new StandardHandler(codec, options);
+    super(handler, options);
   }
 }
 

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

@@ -1,99 +1,91 @@
-import { C as Context, R as Router } from '../../shared/server.qKsRrdxW.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 compression from '@orpc/interop/compression';
-import { S as StandardRPCHandlerOptions } from '../../shared/server.ChUyt5-i.mjs';
+import { SendStandardResponseOptions, NodeHttpRequest, NodeHttpResponse } from '@standardserver/node';
+import { C as Context } from '../../shared/server.CcR4kgje.mjs';
+import { e as StandardHandlerPlugin, b as StandardHandlerHandleOptions, S as StandardHandler, a as StandardHandlerOptions } from '../../shared/server.DDFizwfU.mjs';
+import { FriendlyStandardHandlerHandleOptions } from '../standard/index.mjs';
+import { R as Router } from '../../shared/server.15O7oC1p.mjs';
+import { R as RPCHandlerCodecOptions } from '../../shared/server.B4BnEWWm.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;
-}
-interface NodeHttpHandlerOptions<T extends Context> extends SendStandardResponseOptions {
-    adapterInterceptors?: Interceptor<NodeHttpHandlerInterceptorOptions<T>, Promise<NodeHttpHandleResult>>[];
-    plugins?: NodeHttpHandlerPlugin<T>[];
-}
-declare class NodeHttpHandler<T extends Context> {
-    private readonly standardHandler;
-    private readonly sendStandardResponseOptions;
-    private readonly adapterInterceptors;
-    constructor(standardHandler: StandardHandler<T>, options?: NoInfer<NodeHttpHandlerOptions<T>>);
-    handle(request: NodeHttpRequest, response: NodeHttpResponse, ...rest: MaybeOptionalOptions<FriendlyStandardHandleOptions<T>>): Promise<NodeHttpHandleResult>;
+    sendStandardResponseOptions: SendStandardResponseOptions | undefined;
 }
-
-interface BodyLimitPluginOptions {
+type NodeHttpHandlerNodeHttpInterceptor<T extends Context> = Interceptor<NodeHttpHandlerNodeHttpInterceptorOptions<T>, Promise<NodeHttpHandlerHandleResult>>;
+interface NodeHttpHandlerOptions<T extends Context> {
     /**
-     * The maximum size of the body in bytes.
+     * Custom options for `sendStandardResponse`, used to send a `Standard Response`
      */
-    maxBodySize: number;
-}
-/**
- * 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;
-}
-
-interface CompressionPluginOptions extends compression.CompressionOptions {
+    sendStandardResponse?: SendStandardResponseOptions | undefined;
     /**
-     * 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.
+     * Interceptors that run before the mapping between the Standard API and Node HTTP API,
+     * useful for extending Node HTTP request/response before handling, ...
      */
-    filter?: (req: NodeHttpRequest, res: NodeHttpResponse) => boolean;
+    nodeHttpInterceptors?: NodeHttpHandlerNodeHttpInterceptor<T>[] | undefined;
+    plugins?: NodeHttpHandlerPlugin<T>[] | undefined;
 }
-/**
- * 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 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<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 { CompositeNodeHttpHandlerPlugin, NodeHttpHandler, RPCHandler };
+export type { NodeHttpHandlerHandleResult, NodeHttpHandlerNodeHttpInterceptor, NodeHttpHandlerNodeHttpInterceptorOptions, NodeHttpHandlerOptions, NodeHttpHandlerPlugin, RPCHandlerOptions };