@orpc/server 2.0.0-beta.3 → 2.0.0-beta.31

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

@@ -1,11 +1,11 @@
 import { MaybeOptionalOptions } from '@orpc/shared';
 import { EncodePeerMessageOptions, DecodePeerMessageOptions } from '@standardserver/peer';
 import { Message, Peer } from 'crossws';
-import { C as Context } from '../../shared/server.BL22TloH.mjs';
-import { S as StandardHandler, a as StandardHandlerOptions } from '../../shared/server.BB_Ik9Ph.mjs';
+import { Context } from '../../index.mjs';
+import { StandardHandler, StandardHandlerOptions } from '../standard/index.mjs';
 import { StandardPeerRequestHandlerOptions } from '../standard-peer/index.mjs';
-import { R as Router } from '../../shared/server.BsNNjG5J.mjs';
-import { R as RPCHandlerCodecOptions } from '../../shared/server.B_U9y00a.mjs';
+import { Router } from '../../index.mjs';
+import { RPCHandlerCodecOptions } from '../standard/index.mjs';
 import '@orpc/client';
 import '@orpc/contract';
 import '@standardserver/core';
@@ -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<{
         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.d.ts

@@ -1,11 +1,11 @@
 import { MaybeOptionalOptions } from '@orpc/shared';
 import { EncodePeerMessageOptions, DecodePeerMessageOptions } from '@standardserver/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.EOHJ3NJr.js';
+import { Context } from '../../index.js';
+import { StandardHandler, StandardHandlerOptions } from '../standard/index.js';
 import { StandardPeerRequestHandlerOptions } from '../standard-peer/index.js';
-import { R as Router } from '../../shared/server.Pa0F03f_.js';
-import { R as RPCHandlerCodecOptions } from '../../shared/server.T9F3bzZx.js';
+import { Router } from '../../index.js';
+import { RPCHandlerCodecOptions } from '../standard/index.js';
 import '@orpc/client';
 import '@orpc/contract';
 import '@standardserver/core';
@@ -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<{
         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,12 @@
 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 { R as RPCHandlerCodec, S as StandardHandler } from '../../shared/server.DpUGXBi2.mjs';
 import '@orpc/client';
 import '@standardserver/core';
-import '../../shared/server.CrlKQucM.mjs';
+import '../../shared/server.CkButhNT.mjs';
 import '@orpc/contract';
-import '../../shared/server.BwHnWUuN.mjs';
+import '../../shared/server.Dh77P3ii.mjs';
 
 class experimental_CrosswsHandler {
   constructor(handler, options = {}) {
@@ -18,9 +18,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 +43,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,85 @@
+import { Interceptor, MaybeOptionalOptions } from '@orpc/shared';
+import { SendStandardResponseOptions, AnyFastifyRequest, AnyFastifyReply } from '@standardserver/fastify';
+import { Context } from '../../index.mjs';
+import { StandardHandlerPlugin, StandardHandlerHandleOptions, 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 '@standardserver/core';
+
+interface FastifyHandlerPlugin<T extends Context> extends StandardHandlerPlugin<T> {
+    /**
+     * Initializes the plugin and returns new Fastify handler options.
+     * Called once per plugin instance during composition.
+     *
+     * This method allows plugins to wrap, extend, or transform Fastify handler options
+     * such as interceptors, or other configuration.
+     *
+     * @param options - The current handler options from previous plugins or base configuration
+     * @returns Transformed handler options with plugin's modifications applied
+     *
+     * @example
+     * ```ts
+     * initFastifyHandlerOptions(options) {
+     *   return {
+     *     ...options,
+     *     fastifyInterceptors: [...(options.fastifyInterceptors || []), myInterceptor]
+     *   }
+     * }
+     * ```
+     */
+    initFastifyHandlerOptions?(options: FastifyHandlerOptions<T>): FastifyHandlerOptions<T>;
+}
+declare class CompositeFastifyHandlerPlugin<T extends Context> implements FastifyHandlerPlugin<T> {
+    readonly name = "~composite/fastify";
+    protected readonly plugins: FastifyHandlerPlugin<T>[];
+    constructor(plugins?: FastifyHandlerPlugin<T>[]);
+    initFastifyHandlerOptions(options: FastifyHandlerOptions<T>): FastifyHandlerOptions<T>;
+}
+
+type FastifyHandlerHandleResult = {
+    matched: true;
+} | {
+    matched: false;
+};
+interface FastifyHandlerFastifyInterceptorOptions<T extends Context> extends StandardHandlerHandleOptions<T> {
+    request: AnyFastifyRequest;
+    reply: AnyFastifyReply;
+    sendStandardResponseOptions: SendStandardResponseOptions | undefined;
+}
+type FastifyHandlerFastifyInterceptor<T extends Context> = Interceptor<FastifyHandlerFastifyInterceptorOptions<T>, Promise<FastifyHandlerHandleResult>>;
+interface FastifyHandlerOptions<T extends Context> {
+    /**
+     * Custom options for `sendStandardResponse`, used to send a `Standard Response`
+     */
+    sendStandardResponse?: SendStandardResponseOptions | undefined;
+    /**
+     * Interceptors that run before the mapping between the Standard API and Fastify API,
+     * useful for extending the Fastify request/reply before handling, ...
+     */
+    fastifyInterceptors?: FastifyHandlerFastifyInterceptor<T>[] | undefined;
+    plugins?: FastifyHandlerPlugin<T>[] | undefined;
+}
+declare class FastifyHandler<T extends Context> {
+    private readonly standardHandler;
+    private readonly sendStandardResponseOptions;
+    private readonly fastifyInterceptors;
+    constructor(standardHandler: StandardHandler<T>, options?: NoInfer<FastifyHandlerOptions<T>>);
+    handle(request: AnyFastifyRequest, reply: AnyFastifyReply, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): Promise<FastifyHandlerHandleResult>;
+}
+
+interface RPCHandlerOptions<T extends Context> extends FastifyHandlerOptions<T>, Omit<StandardHandlerOptions<T>, 'plugins'>, RPCHandlerCodecOptions<T> {
+}
+/**
+ * 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 { CompositeFastifyHandlerPlugin, FastifyHandler, RPCHandler };
+export type { FastifyHandlerFastifyInterceptor, FastifyHandlerFastifyInterceptorOptions, FastifyHandlerHandleResult, FastifyHandlerOptions, FastifyHandlerPlugin, RPCHandlerOptions };

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

@@ -0,0 +1,85 @@
+import { Interceptor, MaybeOptionalOptions } from '@orpc/shared';
+import { SendStandardResponseOptions, AnyFastifyRequest, AnyFastifyReply } from '@standardserver/fastify';
+import { Context } from '../../index.js';
+import { StandardHandlerPlugin, StandardHandlerHandleOptions, 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';
+
+interface FastifyHandlerPlugin<T extends Context> extends StandardHandlerPlugin<T> {
+    /**
+     * Initializes the plugin and returns new Fastify handler options.
+     * Called once per plugin instance during composition.
+     *
+     * This method allows plugins to wrap, extend, or transform Fastify handler options
+     * such as interceptors, or other configuration.
+     *
+     * @param options - The current handler options from previous plugins or base configuration
+     * @returns Transformed handler options with plugin's modifications applied
+     *
+     * @example
+     * ```ts
+     * initFastifyHandlerOptions(options) {
+     *   return {
+     *     ...options,
+     *     fastifyInterceptors: [...(options.fastifyInterceptors || []), myInterceptor]
+     *   }
+     * }
+     * ```
+     */
+    initFastifyHandlerOptions?(options: FastifyHandlerOptions<T>): FastifyHandlerOptions<T>;
+}
+declare class CompositeFastifyHandlerPlugin<T extends Context> implements FastifyHandlerPlugin<T> {
+    readonly name = "~composite/fastify";
+    protected readonly plugins: FastifyHandlerPlugin<T>[];
+    constructor(plugins?: FastifyHandlerPlugin<T>[]);
+    initFastifyHandlerOptions(options: FastifyHandlerOptions<T>): FastifyHandlerOptions<T>;
+}
+
+type FastifyHandlerHandleResult = {
+    matched: true;
+} | {
+    matched: false;
+};
+interface FastifyHandlerFastifyInterceptorOptions<T extends Context> extends StandardHandlerHandleOptions<T> {
+    request: AnyFastifyRequest;
+    reply: AnyFastifyReply;
+    sendStandardResponseOptions: SendStandardResponseOptions | undefined;
+}
+type FastifyHandlerFastifyInterceptor<T extends Context> = Interceptor<FastifyHandlerFastifyInterceptorOptions<T>, Promise<FastifyHandlerHandleResult>>;
+interface FastifyHandlerOptions<T extends Context> {
+    /**
+     * Custom options for `sendStandardResponse`, used to send a `Standard Response`
+     */
+    sendStandardResponse?: SendStandardResponseOptions | undefined;
+    /**
+     * Interceptors that run before the mapping between the Standard API and Fastify API,
+     * useful for extending the Fastify request/reply before handling, ...
+     */
+    fastifyInterceptors?: FastifyHandlerFastifyInterceptor<T>[] | undefined;
+    plugins?: FastifyHandlerPlugin<T>[] | undefined;
+}
+declare class FastifyHandler<T extends Context> {
+    private readonly standardHandler;
+    private readonly sendStandardResponseOptions;
+    private readonly fastifyInterceptors;
+    constructor(standardHandler: StandardHandler<T>, options?: NoInfer<FastifyHandlerOptions<T>>);
+    handle(request: AnyFastifyRequest, reply: AnyFastifyReply, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): Promise<FastifyHandlerHandleResult>;
+}
+
+interface RPCHandlerOptions<T extends Context> extends FastifyHandlerOptions<T>, Omit<StandardHandlerOptions<T>, 'plugins'>, RPCHandlerCodecOptions<T> {
+}
+/**
+ * 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 { CompositeFastifyHandlerPlugin, FastifyHandler, RPCHandler };
+export type { FastifyHandlerFastifyInterceptor, FastifyHandlerFastifyInterceptorOptions, FastifyHandlerHandleResult, FastifyHandlerOptions, FastifyHandlerPlugin, RPCHandlerOptions };

package/dist/adapters/fastify/index.mjs

@@ -0,0 +1,66 @@
+import { sortPlugins, intercept, resolveMaybeOptionalOptions } from '@orpc/shared';
+import { toStandardLazyRequest, sendStandardResponse } from '@standardserver/fastify';
+import { r as resolveFriendlyStandardHandlerHandleOptions } from '../../shared/server.W91HSRkE.mjs';
+import { R as RPCHandlerCodec, S as StandardHandler } from '../../shared/server.DpUGXBi2.mjs';
+import '@orpc/client';
+import '@standardserver/core';
+import '../../shared/server.CkButhNT.mjs';
+import '@orpc/contract';
+import '../../shared/server.Dh77P3ii.mjs';
+
+class CompositeFastifyHandlerPlugin {
+  name = "~composite/fastify";
+  plugins;
+  constructor(plugins = []) {
+    this.plugins = sortPlugins(plugins);
+  }
+  initFastifyHandlerOptions(options) {
+    for (const plugin of this.plugins) {
+      if (plugin.initFastifyHandlerOptions) {
+        options = plugin.initFastifyHandlerOptions(options);
+      }
+    }
+    return options;
+  }
+}
+
+class FastifyHandler {
+  constructor(standardHandler, options = {}) {
+    this.standardHandler = standardHandler;
+    options = new CompositeFastifyHandlerPlugin(options.plugins).initFastifyHandlerOptions(options);
+    this.fastifyInterceptors = options.fastifyInterceptors;
+    this.sendStandardResponseOptions = options.sendStandardResponse;
+  }
+  sendStandardResponseOptions;
+  fastifyInterceptors;
+  async handle(request, reply, ...rest) {
+    return intercept(
+      this.fastifyInterceptors,
+      {
+        ...resolveFriendlyStandardHandlerHandleOptions(resolveMaybeOptionalOptions(rest)),
+        request,
+        reply,
+        sendStandardResponseOptions: this.sendStandardResponseOptions
+      },
+      async ({ request: request2, reply: reply2, sendStandardResponseOptions, ...options }) => {
+        const standardRequest = toStandardLazyRequest(request2, reply2);
+        const result = await this.standardHandler.handle(standardRequest, options);
+        if (!result.matched) {
+          return result;
+        }
+        await sendStandardResponse(reply2, result.response, sendStandardResponseOptions);
+        return result;
+      }
+    );
+  }
+}
+
+class RPCHandler extends FastifyHandler {
+  constructor(router, options = {}) {
+    const codec = new RPCHandlerCodec(router, options);
+    const handler = new StandardHandler(codec, options);
+    super(handler, options);
+  }
+}
+
+export { CompositeFastifyHandlerPlugin, FastifyHandler, RPCHandler };

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

@@ -1,10 +1,11 @@
-import { C as Context } from '../../shared/server.BL22TloH.mjs';
+export { R as BodyLimitPlugin } from '../../shared/server.D0Ipbmdv.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.BB_Ik9Ph.mjs';
+import { Context } from '../../index.mjs';
+import { StandardHandlerPlugin, StandardHandlerHandleOptions, 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.B_U9y00a.mjs';
+import { Router } from '../../index.mjs';
+import { RPCHandlerCodecOptions } from '../standard/index.mjs';
 import '@orpc/client';
 import '@orpc/contract';
 import '@standardserver/core';
@@ -33,7 +34,7 @@ interface FetchHandlerPlugin<T extends Context> extends StandardHandlerPlugin<T>
     initFetchHandlerOptions?(options: FetchHandlerOptions<T>): FetchHandlerOptions<T>;
 }
 declare class CompositeFetchHandlerPlugin<T extends Context> implements FetchHandlerPlugin<T> {
-    readonly name = "~composite/fetch-handler";
+    readonly name = "~composite/fetch";
     protected readonly plugins: FetchHandlerPlugin<T>[];
     constructor(plugins?: FetchHandlerPlugin<T>[]);
     initFetchHandlerOptions(options: FetchHandlerOptions<T>): FetchHandlerOptions<T>;
@@ -53,7 +54,7 @@ interface FetchHandlerFetchInterceptorOptions<T extends Context> extends Standar
 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 iterator options, etc.
+     * Options for how to convert the Fetch Response to a Standard Response, like event stream options, etc.
      */
     toFetchResponse?: undefined | ToFetchResponseOptions;
     /**
@@ -71,70 +72,18 @@ declare class FetchHandler<T extends Context> {
     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;
-    };
 }
+/**
+ * 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 { CompositeFetchHandlerPlugin, FetchHandler, RPCHandler };
+export type { FetchHandlerFetchInterceptor, FetchHandlerFetchInterceptorOptions, FetchHandlerHandleResult, FetchHandlerOptions, FetchHandlerPlugin, RPCHandlerOptions };

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

@@ -1,10 +1,11 @@
-import { C as Context } from '../../shared/server.BL22TloH.js';
+export { R as BodyLimitPlugin } from '../../shared/server.BhHrioCw.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.EOHJ3NJr.js';
+import { Context } from '../../index.js';
+import { StandardHandlerPlugin, StandardHandlerHandleOptions, 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.T9F3bzZx.js';
+import { Router } from '../../index.js';
+import { RPCHandlerCodecOptions } from '../standard/index.js';
 import '@orpc/client';
 import '@orpc/contract';
 import '@standardserver/core';
@@ -33,7 +34,7 @@ interface FetchHandlerPlugin<T extends Context> extends StandardHandlerPlugin<T>
     initFetchHandlerOptions?(options: FetchHandlerOptions<T>): FetchHandlerOptions<T>;
 }
 declare class CompositeFetchHandlerPlugin<T extends Context> implements FetchHandlerPlugin<T> {
-    readonly name = "~composite/fetch-handler";
+    readonly name = "~composite/fetch";
     protected readonly plugins: FetchHandlerPlugin<T>[];
     constructor(plugins?: FetchHandlerPlugin<T>[]);
     initFetchHandlerOptions(options: FetchHandlerOptions<T>): FetchHandlerOptions<T>;
@@ -53,7 +54,7 @@ interface FetchHandlerFetchInterceptorOptions<T extends Context> extends Standar
 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 iterator options, etc.
+     * Options for how to convert the Fetch Response to a Standard Response, like event stream options, etc.
      */
     toFetchResponse?: undefined | ToFetchResponseOptions;
     /**
@@ -71,70 +72,18 @@ declare class FetchHandler<T extends Context> {
     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;
-    };
 }
+/**
+ * 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 { CompositeFetchHandlerPlugin, FetchHandler, RPCHandler };
+export type { FetchHandlerFetchInterceptor, FetchHandlerFetchInterceptorOptions, FetchHandlerHandleResult, FetchHandlerOptions, FetchHandlerPlugin, RPCHandlerOptions };