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

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

@@ -1,14 +1,14 @@
 import { MaybeOptionalOptions } from '@orpc/shared';
-import { EncodePeerMessageOptions, DecodePeerMessageOptions } from '@standardserver/peer';
+import { EncodePeerMessageOptions, DecodePeerMessageOptions } from '@standard-server/peer';
 import { Message, Peer } from 'crossws';
-import { C as Context } from '../../shared/server.BL22TloH.js';
-import { S as StandardHandler, a as StandardHandlerOptions } from '../../shared/server.DBANIheG.js';
-import { StandardPeerRequestHandlerOptions } from '../standard-peer/index.js';
-import { R as Router } from '../../shared/server.Pa0F03f_.js';
-import { R as RPCHandlerCodecOptions } from '../../shared/server.d_2NS3g5.js';
+import { Context } from '../../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';
 import '@orpc/client';
 import '@orpc/contract';
-import '@standardserver/core';
+import '@standard-server/core';
 
 type CrosswsPeerLike = Pick<Peer, 'send'>;
 type CrosswsMessageLike = Pick<Message, 'rawData' | 'uint8Array'>;
@@ -29,23 +29,32 @@ declare class experimental_CrosswsHandler<T extends Context> {
     private readonly decodePeerMessageOptions;
     constructor(handler: StandardHandler<T>, options?: NoInfer<experimental_CrosswsHandlerOptions<T>>);
     /**
-     * Handles a single message received from a crossws Peer.
+     * Handles a single WebSocket message.
      *
-     * @param ws The crossws Peer instance, require consistent instance across messages for proper peer management
+     * Message order matters. Call this immediately after receiving a message,
+     * before any other async work, to preserve ordering.
+     *
+     * @param ws The crossws peer instance. Use the same instance for all messages.
      */
-    message(ws: CrosswsPeerLike, message: CrosswsMessageLike, ...rest: MaybeOptionalOptions<StandardPeerRequestHandlerOptions<T>>): Promise<{
+    message(ws: CrosswsPeerLike, message: CrosswsMessageLike, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): Promise<{
         matched: boolean;
     }>;
     /**
-     * Closes the peer connection and cleans up associated resources.
+     * Cleans up peer state for a closed WebSocket.
      *
-     * @param ws The crossws Peer instance to close, require consistent instance for proper peer management
+     * @param ws The same crossws peer instance passed to `.message()`.
      */
     close(ws: CrosswsPeerLike): Promise<void>;
 }
 
 interface experimental_RPCHandlerOptions<T extends Context> extends StandardHandlerOptions<T>, RPCHandlerCodecOptions<T>, experimental_CrosswsHandlerOptions<T> {
 }
+/**
+ * Serves an oRPC router over the RPC protocol on a WebSocket connection
+ * managed by [crossws](https://github.com/h3js/crossws).
+ *
+ * @see {@link https://orpc.dev/docs/adapters/websocket | WebSocket Adapters}
+ */
 declare class experimental_RPCHandler<T extends Context> extends experimental_CrosswsHandler<T> {
     constructor(router: Router<T>, options?: NoInfer<experimental_RPCHandlerOptions<T>>);
 }

package/dist/adapters/crossws/index.mjs

@@ -1,12 +1,13 @@
 import { resolveMaybeOptionalOptions } from '@orpc/shared';
-import { ServerPeer, encodePeerMessage, decodePeerMessage, isClientPeerSendMessage } from '@standardserver/peer';
-import { c as createStandardPeerRequestHandler } from '../../shared/server.CX4vUnDk.mjs';
-import { R as RPCHandlerCodec, S as StandardHandler } from '../../shared/server.GDpX6Df8.mjs';
+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.C0lFtoHU.mjs';
+import '../../shared/server.W91HSRkE.mjs';
 import '@orpc/client';
-import '@standardserver/core';
-import '../../shared/server.CrlKQucM.mjs';
+import '@standard-server/core';
+import '../../shared/server.Djb_ebJT.mjs';
 import '@orpc/contract';
-import '../../shared/server.BwHnWUuN.mjs';
+import '../../shared/server.BynNaBBA.mjs';
 
 class experimental_CrosswsHandler {
   constructor(handler, options = {}) {
@@ -18,9 +19,12 @@ class experimental_CrosswsHandler {
   encodePeerMessageOptions;
   decodePeerMessageOptions;
   /**
-   * Handles a single message received from a crossws Peer.
+   * Handles a single WebSocket message.
    *
-   * @param ws The crossws Peer instance, require consistent instance across messages for proper peer management
+   * Message order matters. Call this immediately after receiving a message,
+   * before any other async work, to preserve ordering.
+   *
+   * @param ws The crossws peer instance. Use the same instance for all messages.
    */
   async message(ws, message, ...rest) {
     let peer = this.peers.get(ws);
@@ -40,9 +44,9 @@ class experimental_CrosswsHandler {
     return result;
   }
   /**
-   * Closes the peer connection and cleans up associated resources.
+   * Cleans up peer state for a closed WebSocket.
    *
-   * @param ws The crossws Peer instance to close, require consistent instance for proper peer management
+   * @param ws The same crossws peer instance passed to `.message()`.
    */
   async close(ws) {
     const server = this.peers.get(ws);

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

@@ -0,0 +1,42 @@
+import { MaybeOptionalOptions } from '@orpc/shared';
+import { SendStandardResponseOptions, AnyFastifyRequest, AnyFastifyReply } from '@standard-server/fastify';
+import { Context } from '../../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';
+import '@orpc/client';
+import '@orpc/contract';
+import '@standard-server/core';
+
+type FastifyHandlerHandleResult = {
+    matched: true;
+} | {
+    matched: false;
+};
+interface FastifyHandlerOptions<_T extends Context> {
+    /**
+     * Custom options for `sendStandardResponse`, used to send a `Standard Response`
+     */
+    sendStandardResponse?: SendStandardResponseOptions | undefined;
+}
+declare class FastifyHandler<T extends Context> {
+    private readonly standardHandler;
+    private readonly sendStandardResponseOptions;
+    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>, StandardHandlerOptions<T>, RPCHandlerCodecOptions<T> {
+}
+/**
+ * Serves an oRPC router over the RPC protocol inside a Fastify server.
+ *
+ * @see {@link https://orpc.dev/docs/adapters/fastify | Fastify Adapter}
+ */
+declare class RPCHandler<T extends Context> extends FastifyHandler<T> {
+    constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
+}
+
+export { FastifyHandler, RPCHandler };
+export type { FastifyHandlerHandleResult, FastifyHandlerOptions, RPCHandlerOptions };

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

@@ -0,0 +1,42 @@
+import { MaybeOptionalOptions } from '@orpc/shared';
+import { SendStandardResponseOptions, AnyFastifyRequest, AnyFastifyReply } from '@standard-server/fastify';
+import { Context } from '../../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';
+import '@orpc/client';
+import '@orpc/contract';
+import '@standard-server/core';
+
+type FastifyHandlerHandleResult = {
+    matched: true;
+} | {
+    matched: false;
+};
+interface FastifyHandlerOptions<_T extends Context> {
+    /**
+     * Custom options for `sendStandardResponse`, used to send a `Standard Response`
+     */
+    sendStandardResponse?: SendStandardResponseOptions | undefined;
+}
+declare class FastifyHandler<T extends Context> {
+    private readonly standardHandler;
+    private readonly sendStandardResponseOptions;
+    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>, StandardHandlerOptions<T>, RPCHandlerCodecOptions<T> {
+}
+/**
+ * Serves an oRPC router over the RPC protocol inside a Fastify server.
+ *
+ * @see {@link https://orpc.dev/docs/adapters/fastify | Fastify Adapter}
+ */
+declare class RPCHandler<T extends Context> extends FastifyHandler<T> {
+    constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
+}
+
+export { FastifyHandler, RPCHandler };
+export type { FastifyHandlerHandleResult, FastifyHandlerOptions, RPCHandlerOptions };

package/dist/adapters/fastify/index.mjs

@@ -0,0 +1,39 @@
+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.C0lFtoHU.mjs';
+import '@orpc/client';
+import '@standard-server/core';
+import '../../shared/server.Djb_ebJT.mjs';
+import '@orpc/contract';
+import '../../shared/server.BynNaBBA.mjs';
+
+class FastifyHandler {
+  constructor(standardHandler, options = {}) {
+    this.standardHandler = standardHandler;
+    this.sendStandardResponseOptions = options.sendStandardResponse;
+  }
+  sendStandardResponseOptions;
+  async handle(request, reply, ...rest) {
+    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;
+  }
+}
+
+class RPCHandler extends FastifyHandler {
+  constructor(router, options = {}) {
+    const codec = new RPCHandlerCodec(router, options);
+    const handler = new StandardHandler(codec, options);
+    super(handler, options);
+  }
+}
+
+export { FastifyHandler, RPCHandler };

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

@@ -1,43 +1,14 @@
-import { C as Context } from '../../shared/server.BL22TloH.mjs';
-import { Interceptor, MaybeOptionalOptions } from '@orpc/shared';
-import { ToFetchResponseOptions } from '@standardserver/fetch';
-import { e as StandardHandlerPlugin, b as StandardHandlerHandleOptions, S as StandardHandler, a as StandardHandlerOptions } from '../../shared/server.DJIkub_t.mjs';
+export { R as BodyLimitPlugin } from '../../shared/server.C7xllBNN.mjs';
+import { MaybeOptionalOptions } from '@orpc/shared';
+import { ToFetchResponseOptions } from '@standard-server/fetch';
+import { Context } from '../../index.mjs';
+import { StandardHandler, StandardHandlerOptions } from '../standard/index.mjs';
 import { FriendlyStandardHandlerHandleOptions } from '../standard/index.mjs';
-import { R as Router } from '../../shared/server.BsNNjG5J.mjs';
-import { R as RPCHandlerCodecOptions } from '../../shared/server.Cj5lgPuG.mjs';
+import { Router } from '../../index.mjs';
+import { RPCHandlerCodecOptions } from '../standard/index.mjs';
 import '@orpc/client';
 import '@orpc/contract';
-import '@standardserver/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-handler";
-    protected readonly plugins: FetchHandlerPlugin<T>[];
-    constructor(plugins?: FetchHandlerPlugin<T>[]);
-    initFetchHandlerOptions(options: FetchHandlerOptions<T>): FetchHandlerOptions<T>;
-}
+import '@standard-server/core';
 
 type FetchHandlerHandleResult = {
     matched: true;
@@ -46,95 +17,31 @@ 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 iterator options, etc.
+     * 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>;
 }
 
-declare const ORDERED_SUPPORTED_ENCODINGS: readonly ["gzip", "deflate"];
-interface BodyCompressionHandlerPluginOptions {
-    /**
-     * The compression schemes to use for response compression.
-     * Schemes are prioritized by their order in this array and
-     * only applied if the client supports them.
-     *
-     * @default ['gzip', 'deflate']
-     */
-    encodings?: readonly (typeof ORDERED_SUPPORTED_ENCODINGS)[number][];
-    /**
-     * The minimum response size in bytes required to trigger compression.
-     * Responses smaller than this threshold will not be compressed to avoid overhead.
-     * If the response size cannot be determined, compression will still be applied.
-     *
-     * @default 1024 (1KB)
-     */
-    threshold?: number;
-    /**
-     * Override the default content-type filter used to determine which responses should be compressed.
-     *
-     * @warning Event stream responses are never compressed, regardless of this filter's return value.
-     * @default only responses with compressible content types are compressed.
-     */
-    filter?: (request: Request, response: Response) => boolean;
-}
-declare class BodyCompressionHandlerPlugin<T extends Context> implements FetchHandlerPlugin<T> {
-    name: string;
-    private readonly encodings;
-    private readonly threshold;
-    private readonly filter;
-    constructor(options?: BodyCompressionHandlerPluginOptions);
-    initFetchHandlerOptions(options: FetchHandlerOptions<T>): FetchHandlerOptions<T>;
-}
-
-interface BodyLimitHandlerPluginOptions {
-    /**
-     * The maximum size of the body in bytes.
-     */
-    maxBodySize: number;
-}
-declare class BodyLimitHandlerPlugin<T extends Context> implements FetchHandlerPlugin<T> {
-    name: string;
-    private readonly maxBodySize;
-    constructor(options: BodyLimitHandlerPluginOptions);
-    initFetchHandlerOptions(options: FetchHandlerOptions<T>): FetchHandlerOptions<T>;
-}
-
-interface RPCHandlerOptions<T extends Context> extends FetchHandlerOptions<T>, Omit<StandardHandlerOptions<T>, 'plugins'>, RPCHandlerCodecOptions<T> {
-    /**
-     * Configuration for {@link CSRFGuardHandlerPlugin}, which is enabled by default for `RPCHandler` over HTTP.
-     */
-    csrfGuardHandlerPlugin?: {
-        /**
-         * If `false`, this plugin is disabled.
-         *
-         * @default true
-         */
-        enabled?: boolean;
-    };
-}
+interface RPCHandlerOptions<T extends Context> extends FetchHandlerOptions<T>, StandardHandlerOptions<T>, RPCHandlerCodecOptions<T> {
+}
+/**
+ * Serves an oRPC router over the RPC protocol using the Fetch API
+ * (Request/Response), supported by modern runtimes like Deno, Bun,
+ * Cloudflare Workers, and browsers.
+ *
+ * @see {@link https://orpc.dev/docs/adapters/fetch-api | Fetch API Adapter}
+ */
 declare class RPCHandler<T extends Context> extends FetchHandler<T> {
     constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
 }
 
-export { BodyCompressionHandlerPlugin, BodyLimitHandlerPlugin, CompositeFetchHandlerPlugin, FetchHandler, RPCHandler };
-export type { BodyCompressionHandlerPluginOptions, BodyLimitHandlerPluginOptions, FetchHandlerFetchInterceptor, FetchHandlerFetchInterceptorOptions, FetchHandlerHandleResult, FetchHandlerOptions, FetchHandlerPlugin, RPCHandlerOptions };
+export { FetchHandler, RPCHandler };
+export type { FetchHandlerHandleResult, FetchHandlerOptions, RPCHandlerOptions };

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

@@ -1,43 +1,14 @@
-import { C as Context } from '../../shared/server.BL22TloH.js';
-import { Interceptor, MaybeOptionalOptions } from '@orpc/shared';
-import { ToFetchResponseOptions } from '@standardserver/fetch';
-import { e as StandardHandlerPlugin, b as StandardHandlerHandleOptions, S as StandardHandler, a as StandardHandlerOptions } from '../../shared/server.DBANIheG.js';
+export { R as BodyLimitPlugin } from '../../shared/server.D0dr-F8u.js';
+import { MaybeOptionalOptions } from '@orpc/shared';
+import { ToFetchResponseOptions } from '@standard-server/fetch';
+import { Context } from '../../index.js';
+import { StandardHandler, StandardHandlerOptions } from '../standard/index.js';
 import { FriendlyStandardHandlerHandleOptions } from '../standard/index.js';
-import { R as Router } from '../../shared/server.Pa0F03f_.js';
-import { R as RPCHandlerCodecOptions } from '../../shared/server.d_2NS3g5.js';
+import { Router } from '../../index.js';
+import { RPCHandlerCodecOptions } from '../standard/index.js';
 import '@orpc/client';
 import '@orpc/contract';
-import '@standardserver/core';
-
-interface 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-handler";
-    protected readonly plugins: FetchHandlerPlugin<T>[];
-    constructor(plugins?: FetchHandlerPlugin<T>[]);
-    initFetchHandlerOptions(options: FetchHandlerOptions<T>): FetchHandlerOptions<T>;
-}
+import '@standard-server/core';
 
 type FetchHandlerHandleResult = {
     matched: true;
@@ -46,95 +17,31 @@ 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 iterator options, etc.
+     * 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>;
 }
 
-declare const ORDERED_SUPPORTED_ENCODINGS: readonly ["gzip", "deflate"];
-interface BodyCompressionHandlerPluginOptions {
-    /**
-     * The compression schemes to use for response compression.
-     * Schemes are prioritized by their order in this array and
-     * only applied if the client supports them.
-     *
-     * @default ['gzip', 'deflate']
-     */
-    encodings?: readonly (typeof ORDERED_SUPPORTED_ENCODINGS)[number][];
-    /**
-     * The minimum response size in bytes required to trigger compression.
-     * Responses smaller than this threshold will not be compressed to avoid overhead.
-     * If the response size cannot be determined, compression will still be applied.
-     *
-     * @default 1024 (1KB)
-     */
-    threshold?: number;
-    /**
-     * Override the default content-type filter used to determine which responses should be compressed.
-     *
-     * @warning Event stream responses are never compressed, regardless of this filter's return value.
-     * @default only responses with compressible content types are compressed.
-     */
-    filter?: (request: Request, response: Response) => boolean;
-}
-declare class BodyCompressionHandlerPlugin<T extends Context> implements FetchHandlerPlugin<T> {
-    name: string;
-    private readonly encodings;
-    private readonly threshold;
-    private readonly filter;
-    constructor(options?: BodyCompressionHandlerPluginOptions);
-    initFetchHandlerOptions(options: FetchHandlerOptions<T>): FetchHandlerOptions<T>;
-}
-
-interface BodyLimitHandlerPluginOptions {
-    /**
-     * The maximum size of the body in bytes.
-     */
-    maxBodySize: number;
-}
-declare class BodyLimitHandlerPlugin<T extends Context> implements FetchHandlerPlugin<T> {
-    name: string;
-    private readonly maxBodySize;
-    constructor(options: BodyLimitHandlerPluginOptions);
-    initFetchHandlerOptions(options: FetchHandlerOptions<T>): FetchHandlerOptions<T>;
-}
-
-interface RPCHandlerOptions<T extends Context> extends FetchHandlerOptions<T>, Omit<StandardHandlerOptions<T>, 'plugins'>, RPCHandlerCodecOptions<T> {
-    /**
-     * Configuration for {@link CSRFGuardHandlerPlugin}, which is enabled by default for `RPCHandler` over HTTP.
-     */
-    csrfGuardHandlerPlugin?: {
-        /**
-         * If `false`, this plugin is disabled.
-         *
-         * @default true
-         */
-        enabled?: boolean;
-    };
-}
+interface RPCHandlerOptions<T extends Context> extends FetchHandlerOptions<T>, StandardHandlerOptions<T>, RPCHandlerCodecOptions<T> {
+}
+/**
+ * Serves an oRPC router over the RPC protocol using the Fetch API
+ * (Request/Response), supported by modern runtimes like Deno, Bun,
+ * Cloudflare Workers, and browsers.
+ *
+ * @see {@link https://orpc.dev/docs/adapters/fetch-api | Fetch API Adapter}
+ */
 declare class RPCHandler<T extends Context> extends FetchHandler<T> {
     constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
 }
 
-export { BodyCompressionHandlerPlugin, BodyLimitHandlerPlugin, CompositeFetchHandlerPlugin, FetchHandler, RPCHandler };
-export type { BodyCompressionHandlerPluginOptions, BodyLimitHandlerPluginOptions, FetchHandlerFetchInterceptor, FetchHandlerFetchInterceptorOptions, FetchHandlerHandleResult, FetchHandlerOptions, FetchHandlerPlugin, RPCHandlerOptions };
+export { FetchHandler, RPCHandler };
+export type { FetchHandlerHandleResult, FetchHandlerOptions, RPCHandlerOptions };