@orpc/server 1.14.11 → 1.14.12

package/dist/adapters/crossws/index.mjs

@@ -1,56 +1,36 @@
 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.COPVXhDG.mjs';
+import { ServerPeer } from '@orpc/standard-server-peer';
+import { createServerPeerHandleRequestFn } from '../standard-peer/index.mjs';
+import { b as StandardRPCHandler } from '../../shared/server.CMf4nKky.mjs';
+import '../../shared/server.DZ5BIITo.mjs';
+import '@orpc/client/standard';
 import '@orpc/client';
-import '@standardserver/core';
-import '../../shared/server.DofEOwf-.mjs';
+import '@orpc/standard-server';
+import '../../shared/server.DEBcqOjg.mjs';
 import '@orpc/contract';
-import '../../shared/server.BoiFpNT7.mjs';
 
 class experimental_CrosswsHandler {
-  constructor(handler, options = {}) {
-    this.handler = handler;
-    this.encodePeerMessageOptions = options.encodePeerMessage;
-    this.decodePeerMessageOptions = options.decodePeerMessage;
+  constructor(standardHandler) {
+    this.standardHandler = standardHandler;
   }
   peers = /* @__PURE__ */ new WeakMap();
-  encodePeerMessageOptions;
-  decodePeerMessageOptions;
-  /**
-   * Handles a single WebSocket message.
-   *
-   * 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);
     if (!peer) {
-      this.peers.set(ws, peer = new ServerPeer(async (message2) => {
-        ws.send(await encodePeerMessage(message2, this.encodePeerMessageOptions));
+      this.peers.set(ws, peer = new ServerPeer((message2) => {
+        ws.send(message2);
       }));
     }
     const encodedMessage = typeof message.rawData === "string" ? message.rawData : message.uint8Array();
-    const result = decodePeerMessage(encodedMessage, this.decodePeerMessageOptions);
-    if (result.matched && isClientPeerSendMessage(result.message)) {
-      await peer.message(
-        result.message,
-        createStandardPeerRequestHandler(this.handler, resolveMaybeOptionalOptions(rest))
-      );
-    }
-    return result;
+    await peer.message(
+      encodedMessage,
+      createServerPeerHandleRequestFn(this.standardHandler, resolveMaybeOptionalOptions(rest))
+    );
   }
-  /**
-   * Cleans up peer state for a closed WebSocket.
-   *
-   * @param ws The same crossws peer instance passed to `.message()`.
-   */
-  async close(ws) {
+  close(ws) {
     const server = this.peers.get(ws);
     if (server) {
-      await server.close();
+      server.close();
       this.peers.delete(ws);
     }
   }
@@ -58,9 +38,7 @@ class experimental_CrosswsHandler {
 
 class experimental_RPCHandler extends experimental_CrosswsHandler {
   constructor(router, options = {}) {
-    const codec = new RPCHandlerCodec(router, options);
-    const handler = new StandardHandler(codec, options);
-    super(handler, options);
+    super(new StandardRPCHandler(router, options));
   }
 }
 

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

@@ -0,0 +1,53 @@
+import { Interceptor, MaybeOptionalOptions } from '@orpc/shared';
+import { FastifyRequest, FastifyReply, SendStandardResponseOptions } from '@orpc/standard-server-fastify';
+import { C as Context, R as Router } from '../../shared/server.qKsRrdxW.mjs';
+import { F as FriendlyStandardHandleOptions } from '../../shared/server.B8gYOD5g.mjs';
+import { b as StandardHandleOptions, f as StandardHandler } from '../../shared/server.BqadksTP.mjs';
+import { S as StandardRPCHandlerOptions } from '../../shared/server.DzE6WeuY.mjs';
+import '@orpc/client';
+import '@orpc/contract';
+import '@orpc/standard-server';
+import '@orpc/client/standard';
+import '../../shared/server.C8_sRzQB.mjs';
+
+type FastifyHandleResult = {
+    matched: true;
+} | {
+    matched: false;
+};
+interface FastifyInterceptorOptions<T extends Context> extends StandardHandleOptions<T> {
+    request: FastifyRequest;
+    reply: FastifyReply;
+    sendStandardResponseOptions: SendStandardResponseOptions;
+}
+interface FastifyHandlerOptions<T extends Context> extends SendStandardResponseOptions {
+    adapterInterceptors?: Interceptor<FastifyInterceptorOptions<T>, Promise<FastifyHandleResult>>[];
+}
+declare class FastifyHandler<T extends Context> {
+    private readonly standardHandler;
+    private readonly sendStandardResponseOptions;
+    private readonly adapterInterceptors;
+    constructor(standardHandler: StandardHandler<T>, options?: NoInfer<FastifyHandlerOptions<T>>);
+    handle(request: FastifyRequest, reply: FastifyReply, ...rest: MaybeOptionalOptions<FriendlyStandardHandleOptions<T>>): Promise<FastifyHandleResult>;
+}
+
+interface RPCHandlerOptions<T extends Context> extends FastifyHandlerOptions<T>, StandardRPCHandlerOptions<T> {
+    /**
+     * Enables or disables the StrictGetMethodPlugin.
+     *
+     * @default true
+     */
+    strictGetMethodPluginEnabled?: boolean;
+}
+/**
+ * RPC Handler for Fastify 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 FastifyHandler<T> {
+    constructor(router: Router<any, T>, options?: NoInfer<RPCHandlerOptions<T>>);
+}
+
+export { FastifyHandler, RPCHandler };
+export type { FastifyHandleResult, FastifyHandlerOptions, FastifyInterceptorOptions, RPCHandlerOptions };

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

@@ -0,0 +1,53 @@
+import { Interceptor, MaybeOptionalOptions } from '@orpc/shared';
+import { FastifyRequest, FastifyReply, SendStandardResponseOptions } from '@orpc/standard-server-fastify';
+import { C as Context, R as Router } from '../../shared/server.qKsRrdxW.js';
+import { F as FriendlyStandardHandleOptions } from '../../shared/server.EfTOZ2Q7.js';
+import { b as StandardHandleOptions, f as StandardHandler } from '../../shared/server.7cEtMB30.js';
+import { S as StandardRPCHandlerOptions } from '../../shared/server.D8IXzfqT.js';
+import '@orpc/client';
+import '@orpc/contract';
+import '@orpc/standard-server';
+import '@orpc/client/standard';
+import '../../shared/server.ChyoA9XY.js';
+
+type FastifyHandleResult = {
+    matched: true;
+} | {
+    matched: false;
+};
+interface FastifyInterceptorOptions<T extends Context> extends StandardHandleOptions<T> {
+    request: FastifyRequest;
+    reply: FastifyReply;
+    sendStandardResponseOptions: SendStandardResponseOptions;
+}
+interface FastifyHandlerOptions<T extends Context> extends SendStandardResponseOptions {
+    adapterInterceptors?: Interceptor<FastifyInterceptorOptions<T>, Promise<FastifyHandleResult>>[];
+}
+declare class FastifyHandler<T extends Context> {
+    private readonly standardHandler;
+    private readonly sendStandardResponseOptions;
+    private readonly adapterInterceptors;
+    constructor(standardHandler: StandardHandler<T>, options?: NoInfer<FastifyHandlerOptions<T>>);
+    handle(request: FastifyRequest, reply: FastifyReply, ...rest: MaybeOptionalOptions<FriendlyStandardHandleOptions<T>>): Promise<FastifyHandleResult>;
+}
+
+interface RPCHandlerOptions<T extends Context> extends FastifyHandlerOptions<T>, StandardRPCHandlerOptions<T> {
+    /**
+     * Enables or disables the StrictGetMethodPlugin.
+     *
+     * @default true
+     */
+    strictGetMethodPluginEnabled?: boolean;
+}
+/**
+ * RPC Handler for Fastify 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 FastifyHandler<T> {
+    constructor(router: Router<any, T>, options?: NoInfer<RPCHandlerOptions<T>>);
+}
+
+export { FastifyHandler, RPCHandler };
+export type { FastifyHandleResult, FastifyHandlerOptions, FastifyInterceptorOptions, RPCHandlerOptions };

package/dist/adapters/fastify/index.mjs

@@ -0,0 +1,52 @@
+import { toArray, intercept, resolveMaybeOptionalOptions } from '@orpc/shared';
+import { toStandardLazyRequest, sendStandardResponse } from '@orpc/standard-server-fastify';
+import { r as resolveFriendlyStandardHandleOptions } from '../../shared/server.DZ5BIITo.mjs';
+import { S as StrictGetMethodPlugin } from '../../shared/server.TEVCLCFC.mjs';
+import { b as StandardRPCHandler } from '../../shared/server.CMf4nKky.mjs';
+import '@orpc/contract';
+import '@orpc/client/standard';
+import '@orpc/client';
+import '@orpc/standard-server';
+import '../../shared/server.DEBcqOjg.mjs';
+
+class FastifyHandler {
+  constructor(standardHandler, options = {}) {
+    this.standardHandler = standardHandler;
+    this.adapterInterceptors = toArray(options.adapterInterceptors);
+    this.sendStandardResponseOptions = options;
+  }
+  sendStandardResponseOptions;
+  adapterInterceptors;
+  async handle(request, reply, ...rest) {
+    return intercept(
+      this.adapterInterceptors,
+      {
+        ...resolveFriendlyStandardHandleOptions(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 { matched: false };
+        }
+        await sendStandardResponse(reply2, result.response, sendStandardResponseOptions);
+        return { matched: true };
+      }
+    );
+  }
+}
+
+class RPCHandler extends FastifyHandler {
+  constructor(router, options = {}) {
+    if (options.strictGetMethodPluginEnabled ?? true) {
+      options.plugins ??= [];
+      options.plugins.push(new StrictGetMethodPlugin());
+    }
+    super(new StandardRPCHandler(router, options), options);
+  }
+}
+
+export { FastifyHandler, RPCHandler };

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

@@ -1,92 +1,124 @@
+import { C as Context, R as Router } from '../../shared/server.qKsRrdxW.mjs';
 import { Interceptor, MaybeOptionalOptions } from '@orpc/shared';
-import { ToFetchResponseOptions } from '@standardserver/fetch';
-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 { ToFetchResponseOptions } from '@orpc/standard-server-fetch';
+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 { S as StandardRPCHandlerOptions } from '../../shared/server.DzE6WeuY.mjs';
 import '@orpc/client';
 import '@orpc/contract';
-import '@standardserver/core';
+import '@orpc/standard-server';
+import '@orpc/client/standard';
+import '../../shared/server.C8_sRzQB.mjs';
 
 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>;
+    initRuntimeAdapter?(options: FetchHandlerOptions<T>): void;
 }
-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>;
+declare class CompositeFetchHandlerPlugin<T extends Context, TPlugin extends FetchHandlerPlugin<T>> extends CompositeStandardHandlerPlugin<T, TPlugin> implements FetchHandlerPlugin<T> {
+    initRuntimeAdapter(options: FetchHandlerOptions<T>): void;
 }
 
-type FetchHandlerHandleResult = {
+type FetchHandleResult = {
     matched: true;
     response: Response;
 } | {
     matched: false;
-    response?: undefined;
+    response: undefined;
 };
-interface FetchHandlerFetchInterceptorOptions<T extends Context> extends StandardHandlerHandleOptions<T> {
+interface FetchHandlerInterceptorOptions<T extends Context> extends StandardHandleOptions<T> {
     request: Request;
-    toFetchResponseOptions: ToFetchResponseOptions | undefined;
+    toFetchResponseOptions: ToFetchResponseOptions;
 }
-type FetchHandlerFetchInterceptor<T extends Context> = Interceptor<FetchHandlerFetchInterceptorOptions<T>, Promise<FetchHandlerHandleResult>>;
-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;
+interface FetchHandlerOptions<T extends Context> extends ToFetchResponseOptions {
+    adapterInterceptors?: Interceptor<FetchHandlerInterceptorOptions<T>, Promise<FetchHandleResult>>[];
+    plugins?: FetchHandlerPlugin<T>[];
 }
 declare class FetchHandler<T extends Context> {
     private readonly standardHandler;
     private readonly toFetchResponseOptions;
-    private readonly fetchInterceptors;
+    private readonly adapterInterceptors;
     constructor(standardHandler: StandardHandler<T>, options?: NoInfer<FetchHandlerOptions<T>>);
-    handle(request: Request, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): Promise<FetchHandlerHandleResult>;
+    handle(request: Request, ...rest: MaybeOptionalOptions<FriendlyStandardHandleOptions<T>>): Promise<FetchHandleResult>;
+}
+
+interface BodyLimitPluginOptions {
+    /**
+     * The maximum size of the body in bytes.
+     */
+    maxBodySize: number;
+}
+/**
+ * The Body Limit Plugin restricts the size of the request body for the Fetch Server.
+ *
+ * @see {@link https://orpc.dev/docs/plugins/body-limit Body Limit Plugin Docs}
+ */
+declare class BodyLimitPlugin<T extends Context> implements FetchHandlerPlugin<T> {
+    private readonly maxBodySize;
+    constructor(options: BodyLimitPluginOptions);
+    initRuntimeAdapter(options: FetchHandlerOptions<T>): void;
 }
 
-interface RPCHandlerOptions<T extends Context> extends FetchHandlerOptions<T>, Omit<StandardHandlerOptions<T>, 'plugins'>, RPCHandlerCodecOptions<T> {
+/**
+ * This plugin is heavily inspired by the [Hono Compression Plugin](https://github.com/honojs/hono/blob/1.x/src/middleware/compress/index.ts)
+ */
+
+declare const ORDERED_SUPPORTED_ENCODINGS: readonly ["gzip", "deflate"];
+interface CompressionPluginOptions {
+    /**
+     * 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;
     /**
-     * Configuration for {@link CSRFGuardHandlerPlugin}, which is enabled by default for `RPCHandler` over HTTP.
+     * 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.
+     */
+    filter?: (request: Request, response: Response) => boolean;
+}
+/**
+ * The Compression Plugin adds response compression to the Fetch Server.
+ * Build on top of [CompressionStream](https://developer.mozilla.org/en-US/docs/Web/API/CompressionStream)
+ * You might need to polyfill it if your environment does not support it.
+ *
+ * @see {@link https://orpc.dev/docs/plugins/compression Compression Plugin Docs}
+ */
+declare class CompressionPlugin<T extends Context> implements FetchHandlerPlugin<T> {
+    private readonly encodings;
+    private readonly threshold;
+    private readonly filter;
+    constructor(options?: CompressionPluginOptions);
+    initRuntimeAdapter(options: FetchHandlerOptions<T>): void;
+}
+
+interface RPCHandlerOptions<T extends Context> extends FetchHandlerOptions<T>, Omit<StandardRPCHandlerOptions<T>, 'plugins'> {
+    /**
+     * Enables or disables the StrictGetMethodPlugin.
+     *
+     * @default true
      */
-    csrfGuardHandlerPlugin?: {
-        /**
-         * If `false`, this plugin is disabled.
-         *
-         * @default true
-         */
-        enabled?: boolean;
-    };
+    strictGetMethodPluginEnabled?: boolean;
 }
+/**
+ * RPC Handler for Fetch 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 FetchHandler<T> {
-    constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
+    constructor(router: Router<any, T>, options?: NoInfer<RPCHandlerOptions<T>>);
 }
 
-export { CompositeFetchHandlerPlugin, FetchHandler, RPCHandler };
-export type { FetchHandlerFetchInterceptor, FetchHandlerFetchInterceptorOptions, FetchHandlerHandleResult, FetchHandlerOptions, FetchHandlerPlugin, RPCHandlerOptions };
+export { BodyLimitPlugin, CompositeFetchHandlerPlugin, CompressionPlugin, FetchHandler, RPCHandler };
+export type { BodyLimitPluginOptions, CompressionPluginOptions, FetchHandleResult, FetchHandlerInterceptorOptions, FetchHandlerOptions, FetchHandlerPlugin, RPCHandlerOptions };

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

@@ -1,92 +1,124 @@
+import { C as Context, R as Router } from '../../shared/server.qKsRrdxW.js';
 import { Interceptor, MaybeOptionalOptions } from '@orpc/shared';
-import { ToFetchResponseOptions } from '@standardserver/fetch';
-import { C as Context } from '../../shared/server.CcR4kgje.js';
-import { e as StandardHandlerPlugin, b as StandardHandlerHandleOptions, S as StandardHandler, a as StandardHandlerOptions } from '../../shared/server.BhsVw7m7.js';
-import { FriendlyStandardHandlerHandleOptions } from '../standard/index.js';
-import { R as Router } from '../../shared/server.m3szVJGU.js';
-import { R as RPCHandlerCodecOptions } from '../../shared/server.CnN50DHH.js';
+import { ToFetchResponseOptions } from '@orpc/standard-server-fetch';
+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 { S as StandardRPCHandlerOptions } from '../../shared/server.D8IXzfqT.js';
 import '@orpc/client';
 import '@orpc/contract';
-import '@standardserver/core';
+import '@orpc/standard-server';
+import '@orpc/client/standard';
+import '../../shared/server.ChyoA9XY.js';
 
 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>;
+    initRuntimeAdapter?(options: FetchHandlerOptions<T>): void;
 }
-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>;
+declare class CompositeFetchHandlerPlugin<T extends Context, TPlugin extends FetchHandlerPlugin<T>> extends CompositeStandardHandlerPlugin<T, TPlugin> implements FetchHandlerPlugin<T> {
+    initRuntimeAdapter(options: FetchHandlerOptions<T>): void;
 }
 
-type FetchHandlerHandleResult = {
+type FetchHandleResult = {
     matched: true;
     response: Response;
 } | {
     matched: false;
-    response?: undefined;
+    response: undefined;
 };
-interface FetchHandlerFetchInterceptorOptions<T extends Context> extends StandardHandlerHandleOptions<T> {
+interface FetchHandlerInterceptorOptions<T extends Context> extends StandardHandleOptions<T> {
     request: Request;
-    toFetchResponseOptions: ToFetchResponseOptions | undefined;
+    toFetchResponseOptions: ToFetchResponseOptions;
 }
-type FetchHandlerFetchInterceptor<T extends Context> = Interceptor<FetchHandlerFetchInterceptorOptions<T>, Promise<FetchHandlerHandleResult>>;
-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;
+interface FetchHandlerOptions<T extends Context> extends ToFetchResponseOptions {
+    adapterInterceptors?: Interceptor<FetchHandlerInterceptorOptions<T>, Promise<FetchHandleResult>>[];
+    plugins?: FetchHandlerPlugin<T>[];
 }
 declare class FetchHandler<T extends Context> {
     private readonly standardHandler;
     private readonly toFetchResponseOptions;
-    private readonly fetchInterceptors;
+    private readonly adapterInterceptors;
     constructor(standardHandler: StandardHandler<T>, options?: NoInfer<FetchHandlerOptions<T>>);
-    handle(request: Request, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): Promise<FetchHandlerHandleResult>;
+    handle(request: Request, ...rest: MaybeOptionalOptions<FriendlyStandardHandleOptions<T>>): Promise<FetchHandleResult>;
+}
+
+interface BodyLimitPluginOptions {
+    /**
+     * The maximum size of the body in bytes.
+     */
+    maxBodySize: number;
+}
+/**
+ * The Body Limit Plugin restricts the size of the request body for the Fetch Server.
+ *
+ * @see {@link https://orpc.dev/docs/plugins/body-limit Body Limit Plugin Docs}
+ */
+declare class BodyLimitPlugin<T extends Context> implements FetchHandlerPlugin<T> {
+    private readonly maxBodySize;
+    constructor(options: BodyLimitPluginOptions);
+    initRuntimeAdapter(options: FetchHandlerOptions<T>): void;
 }
 
-interface RPCHandlerOptions<T extends Context> extends FetchHandlerOptions<T>, Omit<StandardHandlerOptions<T>, 'plugins'>, RPCHandlerCodecOptions<T> {
+/**
+ * This plugin is heavily inspired by the [Hono Compression Plugin](https://github.com/honojs/hono/blob/1.x/src/middleware/compress/index.ts)
+ */
+
+declare const ORDERED_SUPPORTED_ENCODINGS: readonly ["gzip", "deflate"];
+interface CompressionPluginOptions {
+    /**
+     * 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;
     /**
-     * Configuration for {@link CSRFGuardHandlerPlugin}, which is enabled by default for `RPCHandler` over HTTP.
+     * 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.
+     */
+    filter?: (request: Request, response: Response) => boolean;
+}
+/**
+ * The Compression Plugin adds response compression to the Fetch Server.
+ * Build on top of [CompressionStream](https://developer.mozilla.org/en-US/docs/Web/API/CompressionStream)
+ * You might need to polyfill it if your environment does not support it.
+ *
+ * @see {@link https://orpc.dev/docs/plugins/compression Compression Plugin Docs}
+ */
+declare class CompressionPlugin<T extends Context> implements FetchHandlerPlugin<T> {
+    private readonly encodings;
+    private readonly threshold;
+    private readonly filter;
+    constructor(options?: CompressionPluginOptions);
+    initRuntimeAdapter(options: FetchHandlerOptions<T>): void;
+}
+
+interface RPCHandlerOptions<T extends Context> extends FetchHandlerOptions<T>, Omit<StandardRPCHandlerOptions<T>, 'plugins'> {
+    /**
+     * Enables or disables the StrictGetMethodPlugin.
+     *
+     * @default true
      */
-    csrfGuardHandlerPlugin?: {
-        /**
-         * If `false`, this plugin is disabled.
-         *
-         * @default true
-         */
-        enabled?: boolean;
-    };
+    strictGetMethodPluginEnabled?: boolean;
 }
+/**
+ * RPC Handler for Fetch 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 FetchHandler<T> {
-    constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
+    constructor(router: Router<any, T>, options?: NoInfer<RPCHandlerOptions<T>>);
 }
 
-export { CompositeFetchHandlerPlugin, FetchHandler, RPCHandler };
-export type { FetchHandlerFetchInterceptor, FetchHandlerFetchInterceptorOptions, FetchHandlerHandleResult, FetchHandlerOptions, FetchHandlerPlugin, RPCHandlerOptions };
+export { BodyLimitPlugin, CompositeFetchHandlerPlugin, CompressionPlugin, FetchHandler, RPCHandler };
+export type { BodyLimitPluginOptions, CompressionPluginOptions, FetchHandleResult, FetchHandlerInterceptorOptions, FetchHandlerOptions, FetchHandlerPlugin, RPCHandlerOptions };