@orpc/server 0.0.0-next.85cc28f → 0.0.0-next.85cf38b

package/README.md

@@ -21,28 +21,24 @@
 
 <h3 align="center">Typesafe APIs Made Simple 🪄</h3>
 
-**oRPC is a powerful combination of RPC and OpenAPI**, makes it easy to build APIs that are end-to-end type-safe and adhere to OpenAPI standards, ensuring a smooth and enjoyable developer experience.
+**oRPC is a powerful combination of RPC and OpenAPI**, makes it easy to build APIs that are end-to-end type-safe and adhere to OpenAPI standards
 
 ---
 
 ## Highlights
 
-- **End-to-End Type Safety 🔒**: Ensure complete type safety from inputs to outputs and errors, bridging server and client seamlessly.
-- **First-Class OpenAPI 📄**: Adheres to the OpenAPI standard out of the box, ensuring seamless integration and comprehensive API documentation.
-- **Contract-First Development 📜**: (Optional) Define your API contract upfront and implement it with confidence.
-- **Exceptional Developer Experience ✨**: Enjoy a streamlined workflow with robust typing and clear, in-code documentation.
-- **Multi-Runtime Support 🌍**: Run your code seamlessly on Cloudflare, Deno, Bun, Node.js, and more.
-- **Framework Integrations 🧩**: Supports Tanstack Query (React, Vue, Solid, Svelte), Pinia Colada, and more.
-- **Server Actions ⚡️**: Fully compatible with React Server Actions on Next.js, TanStack Start, and more.
-- **Standard Schema Support 🗂️**: Effortlessly work with Zod, Valibot, ArkType, and others right out of the box.
-- **Fast & Lightweight 💨**: Built on native APIs across all runtimes – optimized for speed and efficiency.
-- **Native Types 📦**: Enjoy built-in support for Date, File, Blob, BigInt, URL and more with no extra setup.
-- **Lazy Router ⏱️**: Improve cold start times with our lazy routing feature.
-- **SSE & Streaming 📡**: Provides SSE and streaming features – perfect for real-time notifications and AI-powered streaming responses.
-- **Reusability 🔄**: Write once and reuse your code across multiple purposes effortlessly.
-- **Extendability 🔌**: Easily enhance oRPC with plugins, middleware, and interceptors.
-- **Reliability 🛡️**: Well-tested, fully TypeScript, production-ready, and MIT licensed for peace of mind.
-- **Simplicity 💡**: Enjoy straightforward, clean code with no hidden magic.
+- **🔗 End-to-End Type Safety**: Ensure type-safe inputs, outputs, and errors from client to server.
+- **📘 First-Class OpenAPI**: Built-in support that fully adheres to the OpenAPI standard.
+- **📝 Contract-First Development**: Optionally define your API contract before implementation.
+- **🔍 First-Class OpenTelemetry**: Seamlessly integrate with OpenTelemetry for observability.
+- **⚙️ Framework Integrations**: Seamlessly integrate with TanStack Query (React, Vue, Solid, Svelte, Angular), Pinia Colada, and more.
+- **🚀 Server Actions**: Fully compatible with React Server Actions on Next.js, TanStack Start, and other platforms.
+- **🔠 Standard Schema Support**: Works out of the box with Zod, Valibot, ArkType, and other schema validators.
+- **🗃️ Native Types**: Supports native types like Date, File, Blob, BigInt, URL, and more.
+- **⏱️ Lazy Router**: Enhance cold start times with our lazy routing feature.
+- **📡 SSE & Streaming**: Enjoy full type-safe support for SSE and streaming.
+- **🌍 Multi-Runtime Support**: Fast and lightweight on Cloudflare, Deno, Bun, Node.js, and beyond.
+- **🔌 Extendability**: Easily extend functionality with plugins, middleware, and interceptors.
 
 ## Documentation
 
@@ -53,13 +49,13 @@ You can find the full documentation [here](https://orpc.unnoq.com).
 - [@orpc/contract](https://www.npmjs.com/package/@orpc/contract): Build your API contract.
 - [@orpc/server](https://www.npmjs.com/package/@orpc/server): Build your API or implement API contract.
 - [@orpc/client](https://www.npmjs.com/package/@orpc/client): Consume your API on the client with type-safety.
+- [@orpc/openapi](https://www.npmjs.com/package/@orpc/openapi): Generate OpenAPI specs and handle OpenAPI requests.
+- [@orpc/otel](https://www.npmjs.com/package/@orpc/otel): [OpenTelemetry](https://opentelemetry.io/) integration for observability.
+- [@orpc/nest](https://www.npmjs.com/package/@orpc/nest): Deeply integrate oRPC with [NestJS](https://nestjs.com/).
 - [@orpc/react](https://www.npmjs.com/package/@orpc/react): Utilities for integrating oRPC with React and React Server Actions.
-- [@orpc/react-query](https://www.npmjs.com/package/@orpc/react-query): Integration with [React Query](https://tanstack.com/query/latest/docs/framework/react/overview).
-- [@orpc/vue-query](https://www.npmjs.com/package/@orpc/vue-query): Integration with [Vue Query](https://tanstack.com/query/latest/docs/framework/vue/overview).
-- [@orpc/solid-query](https://www.npmjs.com/package/@orpc/solid-query): Integration with [Solid Query](https://tanstack.com/query/latest/docs/framework/solid/overview).
-- [@orpc/svelte-query](https://www.npmjs.com/package/@orpc/svelte-query): Integration with [Svelte Query](https://tanstack.com/query/latest/docs/framework/svelte/overview).
+- [@orpc/tanstack-query](https://www.npmjs.com/package/@orpc/tanstack-query): [TanStack Query](https://tanstack.com/query/latest) integration.
 - [@orpc/vue-colada](https://www.npmjs.com/package/@orpc/vue-colada): Integration with [Pinia Colada](https://pinia-colada.esm.dev/).
-- [@orpc/openapi](https://www.npmjs.com/package/@orpc/openapi): Generate OpenAPI specs and handle OpenAPI requests.
+- [@orpc/hey-api](https://www.npmjs.com/package/@orpc/hey-api): [Hey API](https://heyapi.dev/) integration.
 - [@orpc/zod](https://www.npmjs.com/package/@orpc/zod): More schemas that [Zod](https://zod.dev/) doesn't support yet.
 - [@orpc/valibot](https://www.npmjs.com/package/@orpc/valibot): OpenAPI spec generation from [Valibot](https://valibot.dev/).
 - [@orpc/arktype](https://www.npmjs.com/package/@orpc/arktype): OpenAPI spec generation from [ArkType](https://arktype.io/).
@@ -71,7 +67,7 @@ Build your API or implement API contract. Read the [documentation](https://orpc.
 ```ts
 import type { IncomingHttpHeaders } from 'node:http'
 import { ORPCError, os } from '@orpc/server'
-import { z } from 'zod'
+import * as z from 'zod'
 
 const PlanetSchema = z.object({
   id: z.number().int().min(1),

package/dist/adapters/aws-lambda/index.d.mts

@@ -0,0 +1,46 @@
+import { MaybeOptionalOptions } from '@orpc/shared';
+import { SendStandardResponseOptions, APIGatewayProxyEventV2, ResponseStream } from '@orpc/standard-server-aws-lambda';
+import { C as Context, R as Router } from '../../shared/server.CYNGeoCm.mjs';
+import { f as StandardHandler } from '../../shared/server.gqRxT-yN.mjs';
+import { F as FriendlyStandardHandleOptions } from '../../shared/server.BEFBl-Cb.mjs';
+import { S as StandardRPCHandlerOptions } from '../../shared/server.BU4WI18A.mjs';
+import '@orpc/client';
+import '@orpc/contract';
+import '@orpc/standard-server';
+import '@orpc/client/standard';
+import '../../shared/server.DhJj-1X9.mjs';
+
+interface AwsLambdaHandlerOptions extends SendStandardResponseOptions {
+}
+type AwsLambdaHandleResult = {
+    matched: true;
+} | {
+    matched: false;
+};
+declare class AwsLambdaHandler<T extends Context> {
+    private readonly standardHandler;
+    private readonly sendStandardResponseOptions;
+    constructor(standardHandler: StandardHandler<T>, options?: AwsLambdaHandlerOptions);
+    handle(event: APIGatewayProxyEventV2, responseStream: ResponseStream, ...rest: MaybeOptionalOptions<FriendlyStandardHandleOptions<T>>): Promise<AwsLambdaHandleResult>;
+}
+
+type RPCHandlerOptions<T extends Context> = AwsLambdaHandlerOptions & StandardRPCHandlerOptions<T> & {
+    /**
+     * Enables or disables the StrictGetMethodPlugin.
+     *
+     * @default true
+     */
+    strictGetMethodPluginEnabled?: boolean;
+};
+/**
+ * RPC Handler for AWS Lambda.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/rpc-handler RPC Handler Docs}
+ * @see {@link https://orpc.unnoq.com/docs/adapters/http HTTP Adapter Docs}
+ */
+declare class RPCHandler<T extends Context> extends AwsLambdaHandler<T> {
+    constructor(router: Router<any, T>, options?: NoInfer<RPCHandlerOptions<T>>);
+}
+
+export { AwsLambdaHandler, RPCHandler };
+export type { AwsLambdaHandleResult, AwsLambdaHandlerOptions, RPCHandlerOptions };

package/dist/adapters/aws-lambda/index.d.ts

@@ -0,0 +1,46 @@
+import { MaybeOptionalOptions } from '@orpc/shared';
+import { SendStandardResponseOptions, APIGatewayProxyEventV2, ResponseStream } from '@orpc/standard-server-aws-lambda';
+import { C as Context, R as Router } from '../../shared/server.CYNGeoCm.js';
+import { f as StandardHandler } from '../../shared/server.Bmh5xd4n.js';
+import { F as FriendlyStandardHandleOptions } from '../../shared/server.B7b2w3_i.js';
+import { S as StandardRPCHandlerOptions } from '../../shared/server.D0H-iaY3.js';
+import '@orpc/client';
+import '@orpc/contract';
+import '@orpc/standard-server';
+import '@orpc/client/standard';
+import '../../shared/server.jMTkVNIb.js';
+
+interface AwsLambdaHandlerOptions extends SendStandardResponseOptions {
+}
+type AwsLambdaHandleResult = {
+    matched: true;
+} | {
+    matched: false;
+};
+declare class AwsLambdaHandler<T extends Context> {
+    private readonly standardHandler;
+    private readonly sendStandardResponseOptions;
+    constructor(standardHandler: StandardHandler<T>, options?: AwsLambdaHandlerOptions);
+    handle(event: APIGatewayProxyEventV2, responseStream: ResponseStream, ...rest: MaybeOptionalOptions<FriendlyStandardHandleOptions<T>>): Promise<AwsLambdaHandleResult>;
+}
+
+type RPCHandlerOptions<T extends Context> = AwsLambdaHandlerOptions & StandardRPCHandlerOptions<T> & {
+    /**
+     * Enables or disables the StrictGetMethodPlugin.
+     *
+     * @default true
+     */
+    strictGetMethodPluginEnabled?: boolean;
+};
+/**
+ * RPC Handler for AWS Lambda.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/rpc-handler RPC Handler Docs}
+ * @see {@link https://orpc.unnoq.com/docs/adapters/http HTTP Adapter Docs}
+ */
+declare class RPCHandler<T extends Context> extends AwsLambdaHandler<T> {
+    constructor(router: Router<any, T>, options?: NoInfer<RPCHandlerOptions<T>>);
+}
+
+export { AwsLambdaHandler, RPCHandler };
+export type { AwsLambdaHandleResult, AwsLambdaHandlerOptions, RPCHandlerOptions };

package/dist/adapters/aws-lambda/index.mjs

@@ -0,0 +1,42 @@
+import { resolveMaybeOptionalOptions } from '@orpc/shared';
+import { toStandardLazyRequest, sendStandardResponse } from '@orpc/standard-server-aws-lambda';
+import { r as resolveFriendlyStandardHandleOptions } from '../../shared/server.DZ5BIITo.mjs';
+import '@orpc/standard-server';
+import '@orpc/standard-server/batch';
+import '@orpc/standard-server-fetch';
+import '@orpc/client';
+import { S as StrictGetMethodPlugin } from '../../shared/server.BW-nUGgA.mjs';
+import '@orpc/contract';
+import { b as StandardRPCHandler } from '../../shared/server.CYRYFTxo.mjs';
+import '@orpc/client/standard';
+import '../../shared/server.B_fj3X5m.mjs';
+
+class AwsLambdaHandler {
+  constructor(standardHandler, options = {}) {
+    this.standardHandler = standardHandler;
+    this.sendStandardResponseOptions = options;
+  }
+  sendStandardResponseOptions;
+  async handle(event, responseStream, ...rest) {
+    const standardRequest = toStandardLazyRequest(event, responseStream);
+    const options = resolveFriendlyStandardHandleOptions(resolveMaybeOptionalOptions(rest));
+    const result = await this.standardHandler.handle(standardRequest, options);
+    if (!result.matched) {
+      return { matched: false };
+    }
+    await sendStandardResponse(responseStream, result.response, this.sendStandardResponseOptions);
+    return { matched: true };
+  }
+}
+
+class RPCHandler extends AwsLambdaHandler {
+  constructor(router, options = {}) {
+    if (options.strictGetMethodPluginEnabled ?? true) {
+      options.plugins ??= [];
+      options.plugins.push(new StrictGetMethodPlugin());
+    }
+    super(new StandardRPCHandler(router, options), options);
+  }
+}
+
+export { AwsLambdaHandler, RPCHandler };

package/dist/adapters/bun-ws/index.d.mts

@@ -0,0 +1,36 @@
+import { MaybeOptionalOptions } from '@orpc/shared';
+import { C as Context, R as Router } from '../../shared/server.CYNGeoCm.mjs';
+import { f as StandardHandler } from '../../shared/server.gqRxT-yN.mjs';
+import { HandleStandardServerPeerMessageOptions } from '../standard-peer/index.mjs';
+import { S as StandardRPCHandlerOptions } from '../../shared/server.BU4WI18A.mjs';
+import '@orpc/client';
+import '@orpc/contract';
+import '@orpc/standard-server';
+import '@orpc/standard-server-peer';
+import '../../shared/server.BEFBl-Cb.mjs';
+import '@orpc/client/standard';
+import '../../shared/server.DhJj-1X9.mjs';
+
+interface ServerWebSocket {
+    send(message: string | ArrayBufferLike | Uint8Array): number;
+}
+declare class BunWsHandler<T extends Context> {
+    private readonly standardHandler;
+    private readonly peers;
+    constructor(standardHandler: StandardHandler<T>);
+    message(ws: ServerWebSocket, message: string | ArrayBufferView, ...rest: MaybeOptionalOptions<HandleStandardServerPeerMessageOptions<T>>): Promise<void>;
+    close(ws: ServerWebSocket): void;
+}
+
+/**
+ * RPC Handler for Bun WS adapter
+ *
+ * @see {@link https://orpc.unnoq.com/docs/rpc-handler RPC Handler Docs}
+ * @see {@link https://orpc.unnoq.com/docs/adapters/websocket Websocket Adapter Docs}
+ */
+declare class RPCHandler<T extends Context> extends BunWsHandler<T> {
+    constructor(router: Router<any, T>, options?: NoInfer<StandardRPCHandlerOptions<T>>);
+}
+
+export { BunWsHandler, RPCHandler };
+export type { ServerWebSocket };

package/dist/adapters/bun-ws/index.d.ts

@@ -0,0 +1,36 @@
+import { MaybeOptionalOptions } from '@orpc/shared';
+import { C as Context, R as Router } from '../../shared/server.CYNGeoCm.js';
+import { f as StandardHandler } from '../../shared/server.Bmh5xd4n.js';
+import { HandleStandardServerPeerMessageOptions } from '../standard-peer/index.js';
+import { S as StandardRPCHandlerOptions } from '../../shared/server.D0H-iaY3.js';
+import '@orpc/client';
+import '@orpc/contract';
+import '@orpc/standard-server';
+import '@orpc/standard-server-peer';
+import '../../shared/server.B7b2w3_i.js';
+import '@orpc/client/standard';
+import '../../shared/server.jMTkVNIb.js';
+
+interface ServerWebSocket {
+    send(message: string | ArrayBufferLike | Uint8Array): number;
+}
+declare class BunWsHandler<T extends Context> {
+    private readonly standardHandler;
+    private readonly peers;
+    constructor(standardHandler: StandardHandler<T>);
+    message(ws: ServerWebSocket, message: string | ArrayBufferView, ...rest: MaybeOptionalOptions<HandleStandardServerPeerMessageOptions<T>>): Promise<void>;
+    close(ws: ServerWebSocket): void;
+}
+
+/**
+ * RPC Handler for Bun WS adapter
+ *
+ * @see {@link https://orpc.unnoq.com/docs/rpc-handler RPC Handler Docs}
+ * @see {@link https://orpc.unnoq.com/docs/adapters/websocket Websocket Adapter Docs}
+ */
+declare class RPCHandler<T extends Context> extends BunWsHandler<T> {
+    constructor(router: Router<any, T>, options?: NoInfer<StandardRPCHandlerOptions<T>>);
+}
+
+export { BunWsHandler, RPCHandler };
+export type { ServerWebSocket };

package/dist/adapters/bun-ws/index.mjs

@@ -0,0 +1,47 @@
+import { resolveMaybeOptionalOptions } from '@orpc/shared';
+import { ServerPeer } from '@orpc/standard-server-peer';
+import { c as createServerPeerHandleRequestFn } from '../../shared/server.UVMTOWrk.mjs';
+import '@orpc/client';
+import '@orpc/standard-server';
+import '@orpc/contract';
+import { b as StandardRPCHandler } from '../../shared/server.CYRYFTxo.mjs';
+import '@orpc/client/standard';
+import '../../shared/server.DZ5BIITo.mjs';
+import '../../shared/server.B_fj3X5m.mjs';
+
+class BunWsHandler {
+  constructor(standardHandler) {
+    this.standardHandler = standardHandler;
+  }
+  peers = /* @__PURE__ */ new WeakMap();
+  async message(ws, message, ...rest) {
+    let peer = this.peers.get(ws);
+    if (!peer) {
+      this.peers.set(ws, peer = new ServerPeer(
+        (message2) => {
+          ws.send(message2);
+        }
+      ));
+    }
+    const encodedMessage = typeof message === "string" ? message : new Uint8Array(message.buffer, message.byteOffset, message.byteLength);
+    await peer.message(
+      encodedMessage,
+      createServerPeerHandleRequestFn(this.standardHandler, resolveMaybeOptionalOptions(rest))
+    );
+  }
+  close(ws) {
+    const server = this.peers.get(ws);
+    if (server) {
+      server.close();
+      this.peers.delete(ws);
+    }
+  }
+}
+
+class RPCHandler extends BunWsHandler {
+  constructor(router, options = {}) {
+    super(new StandardRPCHandler(router, options));
+  }
+}
+
+export { BunWsHandler, RPCHandler };

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

@@ -0,0 +1,33 @@
+import { MaybeOptionalOptions } from '@orpc/shared';
+import { Peer, Message } from 'crossws';
+import { C as Context, R as Router } from '../../shared/server.CYNGeoCm.mjs';
+import { f as StandardHandler } from '../../shared/server.gqRxT-yN.mjs';
+import { HandleStandardServerPeerMessageOptions } from '../standard-peer/index.mjs';
+import { S as StandardRPCHandlerOptions } from '../../shared/server.BU4WI18A.mjs';
+import '@orpc/client';
+import '@orpc/contract';
+import '@orpc/standard-server';
+import '@orpc/standard-server-peer';
+import '../../shared/server.BEFBl-Cb.mjs';
+import '@orpc/client/standard';
+import '../../shared/server.DhJj-1X9.mjs';
+
+declare class experimental_CrosswsHandler<T extends Context> {
+    private readonly standardHandler;
+    private readonly peers;
+    constructor(standardHandler: StandardHandler<T>);
+    message(ws: Pick<Peer, 'send'>, message: Pick<Message, 'rawData' | 'uint8Array'>, ...rest: MaybeOptionalOptions<HandleStandardServerPeerMessageOptions<T>>): Promise<void>;
+    close(ws: Pick<Peer, 'send'>): void;
+}
+
+/**
+ * RPC Handler for Crossws adapter
+ *
+ * @see {@link https://orpc.unnoq.com/docs/rpc-handler RPC Handler Docs}
+ * @see {@link https://orpc.unnoq.com/docs/adapters/websocket Websocket Adapter Docs}
+ */
+declare class experimental_RPCHandler<T extends Context> extends experimental_CrosswsHandler<T> {
+    constructor(router: Router<any, T>, options?: NoInfer<StandardRPCHandlerOptions<T>>);
+}
+
+export { experimental_CrosswsHandler, experimental_RPCHandler };

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

@@ -0,0 +1,33 @@
+import { MaybeOptionalOptions } from '@orpc/shared';
+import { Peer, Message } from 'crossws';
+import { C as Context, R as Router } from '../../shared/server.CYNGeoCm.js';
+import { f as StandardHandler } from '../../shared/server.Bmh5xd4n.js';
+import { HandleStandardServerPeerMessageOptions } from '../standard-peer/index.js';
+import { S as StandardRPCHandlerOptions } from '../../shared/server.D0H-iaY3.js';
+import '@orpc/client';
+import '@orpc/contract';
+import '@orpc/standard-server';
+import '@orpc/standard-server-peer';
+import '../../shared/server.B7b2w3_i.js';
+import '@orpc/client/standard';
+import '../../shared/server.jMTkVNIb.js';
+
+declare class experimental_CrosswsHandler<T extends Context> {
+    private readonly standardHandler;
+    private readonly peers;
+    constructor(standardHandler: StandardHandler<T>);
+    message(ws: Pick<Peer, 'send'>, message: Pick<Message, 'rawData' | 'uint8Array'>, ...rest: MaybeOptionalOptions<HandleStandardServerPeerMessageOptions<T>>): Promise<void>;
+    close(ws: Pick<Peer, 'send'>): void;
+}
+
+/**
+ * RPC Handler for Crossws adapter
+ *
+ * @see {@link https://orpc.unnoq.com/docs/rpc-handler RPC Handler Docs}
+ * @see {@link https://orpc.unnoq.com/docs/adapters/websocket Websocket Adapter Docs}
+ */
+declare class experimental_RPCHandler<T extends Context> extends experimental_CrosswsHandler<T> {
+    constructor(router: Router<any, T>, options?: NoInfer<StandardRPCHandlerOptions<T>>);
+}
+
+export { experimental_CrosswsHandler, experimental_RPCHandler };

package/dist/adapters/crossws/index.mjs

@@ -0,0 +1,45 @@
+import { resolveMaybeOptionalOptions } from '@orpc/shared';
+import { ServerPeer } from '@orpc/standard-server-peer';
+import { c as createServerPeerHandleRequestFn } from '../../shared/server.UVMTOWrk.mjs';
+import '@orpc/client';
+import '@orpc/standard-server';
+import '@orpc/contract';
+import { b as StandardRPCHandler } from '../../shared/server.CYRYFTxo.mjs';
+import '@orpc/client/standard';
+import '../../shared/server.DZ5BIITo.mjs';
+import '../../shared/server.B_fj3X5m.mjs';
+
+class experimental_CrosswsHandler {
+  constructor(standardHandler) {
+    this.standardHandler = standardHandler;
+  }
+  peers = /* @__PURE__ */ new WeakMap();
+  async message(ws, message, ...rest) {
+    let peer = this.peers.get(ws);
+    if (!peer) {
+      this.peers.set(ws, peer = new ServerPeer((message2) => {
+        ws.send(message2);
+      }));
+    }
+    const encodedMessage = typeof message.rawData === "string" ? message.rawData : message.uint8Array();
+    await peer.message(
+      encodedMessage,
+      createServerPeerHandleRequestFn(this.standardHandler, resolveMaybeOptionalOptions(rest))
+    );
+  }
+  close(ws) {
+    const server = this.peers.get(ws);
+    if (server) {
+      server.close();
+      this.peers.delete(ws);
+    }
+  }
+}
+
+class experimental_RPCHandler extends experimental_CrosswsHandler {
+  constructor(router, options = {}) {
+    super(new StandardRPCHandler(router, options));
+  }
+}
+
+export { experimental_CrosswsHandler, experimental_RPCHandler };

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

@@ -1,13 +1,21 @@
-import { C as Context, R as Router } from '../../shared/server.DLt5njUb.mjs';
-import { Interceptor, ThrowableError, MaybeOptionalOptions } from '@orpc/shared';
-import { c as StandardHandlerPlugin, S as StandardHandleOptions, i as StandardHandler } from '../../shared/server.CzxlqYZL.mjs';
-import { F as FriendlyStandardHandleOptions } from '../../shared/server.DGnN7q3R.mjs';
+import { C as Context, R as Router } from '../../shared/server.CYNGeoCm.mjs';
+import { Interceptor, MaybeOptionalOptions } from '@orpc/shared';
 import { ToFetchResponseOptions } from '@orpc/standard-server-fetch';
-import { S as StandardRPCHandlerOptions } from '../../shared/server.B77ImKAP.mjs';
+import { g as StandardHandlerPlugin, C as CompositeStandardHandlerPlugin, b as StandardHandleOptions, f as StandardHandler } from '../../shared/server.gqRxT-yN.mjs';
+import { F as FriendlyStandardHandleOptions } from '../../shared/server.BEFBl-Cb.mjs';
+import { S as StandardRPCHandlerOptions } from '../../shared/server.BU4WI18A.mjs';
 import '@orpc/client';
 import '@orpc/contract';
 import '@orpc/standard-server';
 import '@orpc/client/standard';
+import '../../shared/server.DhJj-1X9.mjs';
+
+interface FetchHandlerPlugin<T extends Context> extends StandardHandlerPlugin<T> {
+    initRuntimeAdapter?(options: FetchHandlerOptions<T>): void;
+}
+declare class CompositeFetchHandlerPlugin<T extends Context, TPlugin extends FetchHandlerPlugin<T>> extends CompositeStandardHandlerPlugin<T, TPlugin> implements FetchHandlerPlugin<T> {
+    initRuntimeAdapter(options: FetchHandlerOptions<T>): void;
+}
 
 type FetchHandleResult = {
     matched: true;
@@ -16,15 +24,12 @@ type FetchHandleResult = {
     matched: false;
     response: undefined;
 };
-interface FetchHandlerPlugin<T extends Context> extends StandardHandlerPlugin<T> {
-    initRuntimeAdapter?(options: FetchHandlerOptions<T>): void;
-}
 interface FetchHandlerInterceptorOptions<T extends Context> extends StandardHandleOptions<T> {
     request: Request;
     toFetchResponseOptions: ToFetchResponseOptions;
 }
 interface FetchHandlerOptions<T extends Context> extends ToFetchResponseOptions {
-    adapterInterceptors?: Interceptor<FetchHandlerInterceptorOptions<T>, FetchHandleResult, ThrowableError>[];
+    adapterInterceptors?: Interceptor<FetchHandlerInterceptorOptions<T>, Promise<FetchHandleResult>>[];
     plugins?: FetchHandlerPlugin<T>[];
 }
 declare class FetchHandler<T extends Context> {
@@ -41,14 +46,78 @@ interface BodyLimitPluginOptions {
      */
     maxBodySize: number;
 }
+/**
+ * The Body Limit Plugin restricts the size of the request body for the Fetch Server.
+ *
+ * @see {@link https://orpc.unnoq.com/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;
 }
 
+/**
+ * This plugin is heavily inspired by the [Hono Compression Plugin](https://github.com/honojs/hono/blob/main/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;
+    /**
+     * A filter function to determine if a response should be compressed.
+     * This function is called in addition to the default compression checks
+     * and allows for custom compression logic based on the request and response.
+     */
+    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.unnoq.com/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;
+}
+
+type RPCHandlerOptions<T extends Context> = FetchHandlerOptions<T> & StandardRPCHandlerOptions<T> & {
+    /**
+     * Enables or disables the StrictGetMethodPlugin.
+     *
+     * @default true
+     */
+    strictGetMethodPluginEnabled?: boolean;
+};
+/**
+ * RPC Handler for Fetch Server
+ *
+ * @see {@link https://orpc.unnoq.com/docs/rpc-handler RPC Handler Docs}
+ * @see {@link https://orpc.unnoq.com/docs/adapters/http HTTP Adapter Docs}
+ */
 declare class RPCHandler<T extends Context> extends FetchHandler<T> {
-    constructor(router: Router<any, T>, options?: NoInfer<FetchHandlerOptions<T> & StandardRPCHandlerOptions<T>>);
+    constructor(router: Router<any, T>, options?: NoInfer<RPCHandlerOptions<T>>);
 }
 
-export { BodyLimitPlugin, type BodyLimitPluginOptions, type FetchHandleResult, FetchHandler, type FetchHandlerInterceptorOptions, type FetchHandlerOptions, type FetchHandlerPlugin, RPCHandler };
+export { BodyLimitPlugin, CompositeFetchHandlerPlugin, CompressionPlugin, FetchHandler, RPCHandler };
+export type { BodyLimitPluginOptions, CompressionPluginOptions, FetchHandleResult, FetchHandlerInterceptorOptions, FetchHandlerOptions, FetchHandlerPlugin, RPCHandlerOptions };