@orpc/server 2.0.0-beta.15 → 2.0.0-beta.17

package/README.md

@@ -175,7 +175,7 @@ Like what we build over at [middleapi](https://github.com/middleapi)? You can he
   <a href="https://github.com/illarionvk?ref=orpc" target="_blank" rel="noopener" title="Illarion Koperski"><img src="https://avatars.githubusercontent.com/u/5012724?u=7cfa13652f7ac5fb3c56d880e3eb3fbe40c3ea34&amp;v=4" width="32" height="32" alt="Illarion Koperski" /></a>
   <a href="https://github.com/steelbrain?ref=orpc" target="_blank" rel="noopener" title="Anees Iqbal"><img src="https://avatars.githubusercontent.com/u/4278113?u=22b80b5399eed68ac76cd58b02961b0481f1db11&amp;v=4" width="32" height="32" alt="Anees Iqbal" /></a>
   <a href="https://github.com/Scrumplex?ref=orpc" target="_blank" rel="noopener" title="Sefa Eyeoglu"><img src="https://avatars.githubusercontent.com/u/11587657?u=ab503582165c0bbff0cca47ce31c9450bb1553c9&amp;v=4" width="32" height="32" alt="Sefa Eyeoglu" /></a>
-  <a href="https://github.com/nattstack?ref=orpc" target="_blank" rel="noopener" title="Natt"><img src="https://avatars.githubusercontent.com/u/31426677?u=fa9dbb8b3e66eb0ea3c88db5dc07f31c8c5418fe&amp;v=4" width="32" height="32" alt="Natt" /></a>
+  <a href="https://github.com/nattstack?ref=orpc" target="_blank" rel="noopener" title="natt"><img src="https://avatars.githubusercontent.com/u/31426677?u=fa9dbb8b3e66eb0ea3c88db5dc07f31c8c5418fe&amp;v=4" width="32" height="32" alt="natt" /></a>
   <a href="https://github.com/ChromeGG?ref=orpc" target="_blank" rel="noopener" title="Adam Tkaczyk"><img src="https://avatars.githubusercontent.com/u/39050595?u=a58ca6042a6950e94e6e92442db76ef584279bc0&amp;v=4" width="32" height="32" alt="Adam Tkaczyk" /></a>
   <a href="https://github.com/plancraft?ref=orpc" target="_blank" rel="noopener" title="plancraft"><img src="https://avatars.githubusercontent.com/u/46482287?v=4" width="32" height="32" alt="plancraft" /></a>
 </p>

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

@@ -1,6 +1,6 @@
-import { C as Context } from '../../shared/server.BL22TloH.mjs';
 import { Interceptor, MaybeOptionalOptions } from '@orpc/shared';
 import { ToFetchResponseOptions } from '@standardserver/fetch';
+import { C as Context } from '../../shared/server.BL22TloH.mjs';
 import { e as StandardHandlerPlugin, b as StandardHandlerHandleOptions, S as StandardHandler, a as StandardHandlerOptions } from '../../shared/server.DJIkub_t.mjs';
 import { FriendlyStandardHandlerHandleOptions } from '../standard/index.mjs';
 import { R as Router } from '../../shared/server.BsNNjG5J.mjs';
@@ -71,54 +71,6 @@ 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.
@@ -136,5 +88,5 @@ 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,6 +1,6 @@
-import { C as Context } from '../../shared/server.BL22TloH.js';
 import { Interceptor, MaybeOptionalOptions } from '@orpc/shared';
 import { ToFetchResponseOptions } from '@standardserver/fetch';
+import { C as Context } from '../../shared/server.BL22TloH.js';
 import { e as StandardHandlerPlugin, b as StandardHandlerHandleOptions, S as StandardHandler, a as StandardHandlerOptions } from '../../shared/server.DBANIheG.js';
 import { FriendlyStandardHandlerHandleOptions } from '../standard/index.js';
 import { R as Router } from '../../shared/server.Pa0F03f_.js';
@@ -71,54 +71,6 @@ 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.
@@ -136,5 +88,5 @@ 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.mjs

@@ -1,144 +1,14 @@
-import { toArray, sortPlugins, intercept, resolveMaybeOptionalOptions } from '@orpc/shared';
-import { ORPCError } from '@orpc/client';
+import { sortPlugins, intercept, resolveMaybeOptionalOptions, toArray } from '@orpc/shared';
 import { toStandardLazyRequest, toFetchResponse } from '@standardserver/fetch';
 import { r as resolveFriendlyStandardHandlerHandleOptions } from '../../shared/server.W91HSRkE.mjs';
 import { C as CSRFGuardHandlerPlugin } from '../../shared/server.D_QauotT.mjs';
 import { R as RPCHandlerCodec, S as StandardHandler } from '../../shared/server.DZEvIn7o.mjs';
+import '@orpc/client';
 import '@standardserver/core';
 import '../../shared/server.BDeup7Ky.mjs';
 import '@orpc/contract';
 import '../../shared/server.C_osSBcd.mjs';
 
-const ORDERED_SUPPORTED_ENCODINGS = ["gzip", "deflate"];
-class BodyCompressionHandlerPlugin {
-  name = "~body-compression";
-  encodings;
-  threshold;
-  filter;
-  constructor(options = {}) {
-    this.encodings = options.encodings ?? ORDERED_SUPPORTED_ENCODINGS;
-    this.threshold = options.threshold ?? 1024;
-    this.filter = (request, response) => {
-      const hasContentDisposition = response.headers.has("content-disposition");
-      const contentType = response.headers.get("content-type");
-      if (!hasContentDisposition && contentType?.startsWith("text/event-stream")) {
-        return false;
-      }
-      return options.filter ? options.filter(request, response) : isCompressibleContentType(contentType);
-    };
-  }
-  initFetchHandlerOptions(options) {
-    return {
-      ...options,
-      fetchInterceptors: [
-        async (interceptorOptions) => {
-          const result = await interceptorOptions.next();
-          if (!result.matched) {
-            return result;
-          }
-          const response = result.response;
-          if (response.headers.has("content-encoding") || response.headers.has("transfer-encoding") || isNoTransformCacheControl(response.headers.get("cache-control"))) {
-            return result;
-          }
-          const contentLength = response.headers.get("content-length");
-          if (contentLength && Number(contentLength) < this.threshold) {
-            return result;
-          }
-          const acceptEncoding = interceptorOptions.request.headers.get("accept-encoding")?.split(",").map((enc) => enc.trim().split(";")[0]);
-          const encoding = this.encodings.find((enc) => acceptEncoding?.includes(enc));
-          if (!response.body || encoding === void 0) {
-            return result;
-          }
-          if (!this.filter(interceptorOptions.request, response)) {
-            return result;
-          }
-          const compressedBody = response.body.pipeThrough(new CompressionStream(encoding));
-          const compressedHeaders = new Headers(response.headers);
-          compressedHeaders.delete("content-length");
-          compressedHeaders.set("content-encoding", encoding);
-          return {
-            ...result,
-            response: new Response(compressedBody, {
-              status: response.status,
-              statusText: response.statusText,
-              headers: compressedHeaders
-            })
-          };
-        },
-        ...toArray(options.fetchInterceptors)
-      ]
-    };
-  }
-}
-const COMPRESSIBLE_CONTENT_TYPE_REGEX = /^\s*(?:text\/(?!event-stream(?:[;\s]|$))[^;\s]+|application\/(?:javascript|json|xml|xml-dtd|ecmascript|dart|postscript|rtf|tar|toml|vnd\.dart|vnd\.ms-fontobject|vnd\.ms-opentype|wasm|x-httpd-php|x-javascript|x-ns-proxy-autoconfig|x-sh|x-tar|x-virtualbox-hdd|x-virtualbox-ova|x-virtualbox-ovf|x-virtualbox-vbox|x-virtualbox-vdi|x-virtualbox-vhd|x-virtualbox-vmdk|x-www-form-urlencoded)|font\/(?:otf|ttf)|image\/(?:bmp|vnd\.adobe\.photoshop|vnd\.microsoft\.icon|vnd\.ms-dds|x-icon|x-ms-bmp)|message\/rfc822|model\/gltf-binary|x-shader\/x-fragment|x-shader\/x-vertex|[^;\s]+?\+(?:json|text|xml|yaml))(?:[;\s]|$)/i;
-function isCompressibleContentType(contentType) {
-  if (contentType === null) {
-    return false;
-  }
-  return COMPRESSIBLE_CONTENT_TYPE_REGEX.test(contentType);
-}
-const CACHE_CONTROL_NO_TRANSFORM_REGEX = /(?:^|,)\s*no-transform\s*(?:,|$)/i;
-function isNoTransformCacheControl(cacheControl) {
-  if (cacheControl === null) {
-    return false;
-  }
-  return CACHE_CONTROL_NO_TRANSFORM_REGEX.test(cacheControl);
-}
-
-class BodyLimitHandlerPlugin {
-  name = "~body-limit";
-  maxBodySize;
-  constructor(options) {
-    this.maxBodySize = options.maxBodySize;
-  }
-  initFetchHandlerOptions(options) {
-    return {
-      ...options,
-      fetchInterceptors: [
-        async (interceptorOptions) => {
-          if (!interceptorOptions.request.body) {
-            return interceptorOptions.next();
-          }
-          let currentBodySize = 0;
-          const rawReader = interceptorOptions.request.body.getReader();
-          const body = new ReadableStream({
-            start: async (controller) => {
-              const reject = async (error) => {
-                controller.error(error);
-                await rawReader.cancel(error);
-              };
-              const contentLength = interceptorOptions.request.headers.get("content-length");
-              if (contentLength && Number(contentLength) > this.maxBodySize) {
-                await reject(new ORPCError("PAYLOAD_TOO_LARGE"));
-                return;
-              }
-              while (true) {
-                const { done, value } = await rawReader.read();
-                if (done) {
-                  controller.close();
-                  return;
-                }
-                currentBodySize += value.length;
-                if (currentBodySize > this.maxBodySize) {
-                  await reject(new ORPCError("PAYLOAD_TOO_LARGE"));
-                  return;
-                }
-                controller.enqueue(value);
-              }
-            }
-          });
-          const requestInit = { body, duplex: "half" };
-          return interceptorOptions.next({
-            ...interceptorOptions,
-            request: new Request(interceptorOptions.request, requestInit)
-          });
-        },
-        ...toArray(options.fetchInterceptors)
-      ]
-    };
-  }
-}
-
 class CompositeFetchHandlerPlugin {
   name = "~composite/fetch-handler";
   plugins;
@@ -201,4 +71,4 @@ class RPCHandler extends FetchHandler {
   }
 }
 
-export { BodyCompressionHandlerPlugin, BodyLimitHandlerPlugin, CompositeFetchHandlerPlugin, FetchHandler, RPCHandler };
+export { CompositeFetchHandlerPlugin, FetchHandler, RPCHandler };

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

@@ -1,9 +1,8 @@
+import { Interceptor, MaybeOptionalOptions } from '@orpc/shared';
 import { SendStandardResponseOptions, NodeHttpRequest, NodeHttpResponse } from '@standardserver/node';
 import { C as Context } from '../../shared/server.BL22TloH.mjs';
-import { Interceptor, MaybeOptionalOptions } from '@orpc/shared';
 import { e as StandardHandlerPlugin, b as StandardHandlerHandleOptions, S as StandardHandler, a as StandardHandlerOptions } from '../../shared/server.DJIkub_t.mjs';
 import { FriendlyStandardHandlerHandleOptions } from '../standard/index.mjs';
-import compression from '@orpc/interop/compression';
 import { R as Router } from '../../shared/server.BsNNjG5J.mjs';
 import { R as RPCHandlerCodecOptions } from '../../shared/server.D8cib80w.mjs';
 import '@orpc/client';
@@ -71,35 +70,6 @@ declare class NodeHttpHandler<T extends Context> {
     handle(request: NodeHttpRequest, response: NodeHttpResponse, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): Promise<NodeHttpHandlerHandleResult>;
 }
 
-interface BodyCompressionHandlerPluginOptions extends compression.CompressionOptions {
-    /**
-     * 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: NodeHttpRequest, response: NodeHttpResponse) => boolean;
-}
-declare class BodyCompressionHandlerPlugin<T extends Context> implements NodeHttpHandlerPlugin<T> {
-    name: string;
-    private readonly compressionHandler;
-    constructor(options?: BodyCompressionHandlerPluginOptions);
-    initNodeHttpHandlerOptions(options: NodeHttpHandlerOptions<T>): NodeHttpHandlerOptions<T>;
-}
-
-interface BodyLimitHandlerPluginOptions {
-    /**
-     * The maximum size of the body in bytes.
-     */
-    maxBodySize: number;
-}
-declare class BodyLimitHandlerPlugin<T extends Context> implements NodeHttpHandlerPlugin<T> {
-    name: string;
-    private readonly maxBodySize;
-    constructor(options: BodyLimitHandlerPluginOptions);
-    initNodeHttpHandlerOptions(options: NodeHttpHandlerOptions<T>): NodeHttpHandlerOptions<T>;
-}
-
 interface RPCHandlerOptions<T extends Context> extends NodeHttpHandlerOptions<T>, Omit<StandardHandlerOptions<T>, 'plugins'>, RPCHandlerCodecOptions<T> {
     /**
      * Configuration for {@link CSRFGuardHandlerPlugin}, which is enabled by default for `RPCHandler` over HTTP.
@@ -117,5 +87,5 @@ declare class RPCHandler<T extends Context> extends NodeHttpHandler<T> {
     constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
 }
 
-export { BodyCompressionHandlerPlugin, BodyLimitHandlerPlugin, CompositeNodeHttpHandlerPlugin, NodeHttpHandler, RPCHandler };
-export type { BodyCompressionHandlerPluginOptions, BodyLimitHandlerPluginOptions, NodeHttpHandlerHandleResult, NodeHttpHandlerNodeHttpInterceptor, NodeHttpHandlerNodeHttpInterceptorOptions, NodeHttpHandlerOptions, NodeHttpHandlerPlugin, RPCHandlerOptions };
+export { CompositeNodeHttpHandlerPlugin, NodeHttpHandler, RPCHandler };
+export type { NodeHttpHandlerHandleResult, NodeHttpHandlerNodeHttpInterceptor, NodeHttpHandlerNodeHttpInterceptorOptions, NodeHttpHandlerOptions, NodeHttpHandlerPlugin, RPCHandlerOptions };

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

@@ -1,9 +1,8 @@
+import { Interceptor, MaybeOptionalOptions } from '@orpc/shared';
 import { SendStandardResponseOptions, NodeHttpRequest, NodeHttpResponse } from '@standardserver/node';
 import { C as Context } from '../../shared/server.BL22TloH.js';
-import { Interceptor, MaybeOptionalOptions } from '@orpc/shared';
 import { e as StandardHandlerPlugin, b as StandardHandlerHandleOptions, S as StandardHandler, a as StandardHandlerOptions } from '../../shared/server.DBANIheG.js';
 import { FriendlyStandardHandlerHandleOptions } from '../standard/index.js';
-import compression from '@orpc/interop/compression';
 import { R as Router } from '../../shared/server.Pa0F03f_.js';
 import { R as RPCHandlerCodecOptions } from '../../shared/server.D0WUu0EH.js';
 import '@orpc/client';
@@ -71,35 +70,6 @@ declare class NodeHttpHandler<T extends Context> {
     handle(request: NodeHttpRequest, response: NodeHttpResponse, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): Promise<NodeHttpHandlerHandleResult>;
 }
 
-interface BodyCompressionHandlerPluginOptions extends compression.CompressionOptions {
-    /**
-     * 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: NodeHttpRequest, response: NodeHttpResponse) => boolean;
-}
-declare class BodyCompressionHandlerPlugin<T extends Context> implements NodeHttpHandlerPlugin<T> {
-    name: string;
-    private readonly compressionHandler;
-    constructor(options?: BodyCompressionHandlerPluginOptions);
-    initNodeHttpHandlerOptions(options: NodeHttpHandlerOptions<T>): NodeHttpHandlerOptions<T>;
-}
-
-interface BodyLimitHandlerPluginOptions {
-    /**
-     * The maximum size of the body in bytes.
-     */
-    maxBodySize: number;
-}
-declare class BodyLimitHandlerPlugin<T extends Context> implements NodeHttpHandlerPlugin<T> {
-    name: string;
-    private readonly maxBodySize;
-    constructor(options: BodyLimitHandlerPluginOptions);
-    initNodeHttpHandlerOptions(options: NodeHttpHandlerOptions<T>): NodeHttpHandlerOptions<T>;
-}
-
 interface RPCHandlerOptions<T extends Context> extends NodeHttpHandlerOptions<T>, Omit<StandardHandlerOptions<T>, 'plugins'>, RPCHandlerCodecOptions<T> {
     /**
      * Configuration for {@link CSRFGuardHandlerPlugin}, which is enabled by default for `RPCHandler` over HTTP.
@@ -117,5 +87,5 @@ declare class RPCHandler<T extends Context> extends NodeHttpHandler<T> {
     constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
 }
 
-export { BodyCompressionHandlerPlugin, BodyLimitHandlerPlugin, CompositeNodeHttpHandlerPlugin, NodeHttpHandler, RPCHandler };
-export type { BodyCompressionHandlerPluginOptions, BodyLimitHandlerPluginOptions, NodeHttpHandlerHandleResult, NodeHttpHandlerNodeHttpInterceptor, NodeHttpHandlerNodeHttpInterceptorOptions, NodeHttpHandlerOptions, NodeHttpHandlerPlugin, RPCHandlerOptions };
+export { CompositeNodeHttpHandlerPlugin, NodeHttpHandler, RPCHandler };
+export type { NodeHttpHandlerHandleResult, NodeHttpHandlerNodeHttpInterceptor, NodeHttpHandlerNodeHttpInterceptorOptions, NodeHttpHandlerOptions, NodeHttpHandlerPlugin, RPCHandlerOptions };

package/dist/adapters/node/index.mjs

@@ -1,120 +1,14 @@
-import compression from '@orpc/interop/compression';
-import { toArray, sortPlugins, intercept, resolveMaybeOptionalOptions } from '@orpc/shared';
-import { ORPCError } from '@orpc/client';
+import { sortPlugins, intercept, resolveMaybeOptionalOptions, toArray } from '@orpc/shared';
 import { toStandardLazyRequest, sendStandardResponse } from '@standardserver/node';
 import { r as resolveFriendlyStandardHandlerHandleOptions } from '../../shared/server.W91HSRkE.mjs';
 import { C as CSRFGuardHandlerPlugin } from '../../shared/server.D_QauotT.mjs';
 import { R as RPCHandlerCodec, S as StandardHandler } from '../../shared/server.DZEvIn7o.mjs';
+import '@orpc/client';
 import '@standardserver/core';
 import '../../shared/server.BDeup7Ky.mjs';
 import '@orpc/contract';
 import '../../shared/server.C_osSBcd.mjs';
 
-class BodyCompressionHandlerPlugin {
-  name = "~body-compression";
-  compressionHandler;
-  constructor(options = {}) {
-    this.compressionHandler = compression({
-      ...options,
-      filter: (request, response) => {
-        const hasContentDisposition = response.hasHeader("content-disposition");
-        const contentType = response.getHeader("content-type")?.toString();
-        if (!hasContentDisposition && contentType?.startsWith("text/event-stream")) {
-          return false;
-        }
-        return options.filter ? options.filter(request, response) : compression.filter(request, response);
-      }
-    });
-  }
-  initNodeHttpHandlerOptions(options) {
-    return {
-      ...options,
-      nodeHttpInterceptors: [
-        async (interceptorOptions) => {
-          let resolve;
-          let reject;
-          const promise = new Promise((res, rej) => {
-            resolve = res;
-            reject = rej;
-          });
-          const originalWrite = interceptorOptions.response.write;
-          const originalEnd = interceptorOptions.response.end;
-          const originalOn = interceptorOptions.response.on;
-          this.compressionHandler(
-            interceptorOptions.request,
-            interceptorOptions.response,
-            async (error) => {
-              if (error) {
-                reject(error);
-              } else {
-                try {
-                  resolve(await interceptorOptions.next(interceptorOptions));
-                } catch (nextError) {
-                  reject(nextError);
-                }
-              }
-            }
-          );
-          try {
-            return await promise;
-          } finally {
-            interceptorOptions.response.write = originalWrite;
-            interceptorOptions.response.end = originalEnd;
-            interceptorOptions.response.on = originalOn;
-          }
-        },
-        ...toArray(options.nodeHttpInterceptors)
-      ]
-    };
-  }
-}
-
-class BodyLimitHandlerPlugin {
-  name = "~body-limit";
-  maxBodySize;
-  constructor(options) {
-    this.maxBodySize = options.maxBodySize;
-  }
-  initNodeHttpHandlerOptions(options) {
-    return {
-      ...options,
-      nodeHttpInterceptors: [
-        async (interceptorOptions) => {
-          let isHeaderChecked = false;
-          const checkHeader = () => {
-            if (isHeaderChecked) {
-              return;
-            }
-            isHeaderChecked = true;
-            const contentLength = interceptorOptions.request.headers["content-length"];
-            if (contentLength && Number(contentLength) > this.maxBodySize) {
-              throw new ORPCError("PAYLOAD_TOO_LARGE");
-            }
-          };
-          const originalEmit = interceptorOptions.request.emit;
-          let currentBodySize = 0;
-          interceptorOptions.request.emit = (event, ...args) => {
-            if (event === "data") {
-              checkHeader();
-              currentBodySize += args[0]?.length ?? 0;
-              if (currentBodySize > this.maxBodySize) {
-                throw new ORPCError("PAYLOAD_TOO_LARGE");
-              }
-            }
-            return originalEmit.call(interceptorOptions.request, event, ...args);
-          };
-          try {
-            return await interceptorOptions.next(interceptorOptions);
-          } finally {
-            interceptorOptions.request.emit = originalEmit;
-          }
-        },
-        ...toArray(options.nodeHttpInterceptors)
-      ]
-    };
-  }
-}
-
 class CompositeNodeHttpHandlerPlugin {
   name = "~composite/node-http-handler";
   plugins;
@@ -176,4 +70,4 @@ class RPCHandler extends NodeHttpHandler {
   }
 }
 
-export { BodyCompressionHandlerPlugin, BodyLimitHandlerPlugin, CompositeNodeHttpHandlerPlugin, NodeHttpHandler, RPCHandler };
+export { CompositeNodeHttpHandlerPlugin, NodeHttpHandler, RPCHandler };

package/dist/plugins/index.d.mts

@@ -30,6 +30,29 @@ interface BatchHandlerPluginOptions<T extends Context> {
      * @default {}
      */
     headers?: Value<Promisable<StandardHeaders>, [batchOptions: StandardHandlerRoutingInterceptorOptions<T>]>;
+    /**
+     * Keep-alive settings for streaming batch responses.
+     *
+     * When enabled, a zero-length length-prefixed frame is sent periodically while the
+     * stream is idle (no message sent for `interval` ms). Clients ignore these frames.
+     * Only applies to streaming mode.
+     *
+     * @default { enabled: true, interval: 15000 }
+     */
+    keepAlive?: undefined | {
+        /**
+         * If true, a keep-alive frame is sent periodically while the stream is idle.
+         *
+         * @default true
+         */
+        enabled: boolean;
+        /**
+         * Interval (in milliseconds) between keep-alive frames after the last message.
+         *
+         * @default 15000
+         */
+        interval?: number;
+    };
 }
 declare class BatchHandlerPlugin<T extends Context> implements StandardHandlerPlugin<T> {
     name: string;
@@ -42,6 +65,8 @@ declare class BatchHandlerPlugin<T extends Context> implements StandardHandlerPl
     private readonly mapSubrequest;
     private readonly successStatus;
     private readonly headers;
+    private readonly keepAliveEnabled;
+    private readonly keepAliveInterval;
     constructor(options?: BatchHandlerPluginOptions<T>);
     init(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
 }
@@ -123,6 +148,15 @@ declare class CSRFGuardHandlerPlugin<T extends Context> implements StandardHandl
     init(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
 }
 
+declare class RequestCompressionHandlerPlugin<T extends Context> implements StandardHandlerPlugin<T> {
+    name: string;
+    /**
+     * Should decompress the original batch request body instead of sub-requests.
+     */
+    after: string[];
+    init(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
+}
+
 interface RequestHeadersHandlerPluginContext {
     /**
      * Request headers as a Headers instance. This is injected by the Request Headers Plugin.
@@ -140,6 +174,72 @@ declare class RequestHeadersHandlerPlugin<T extends RequestHeadersHandlerPluginC
     init(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
 }
 
+interface RequestLimitHandlerPluginOptions {
+    /**
+     * The maximum allowed request body size in bytes.
+     */
+    maxBodySize: number;
+}
+/**
+ * Rejects requests whose body exceeds `maxBodySize`.
+ *
+ * When used with the request compression plugin, the limit applies to the
+ * decompressed payload rather than the compressed wire size.
+ *
+ * @see {@link https://orpc.dev/docs/plugins/request-limit Request Limit Plugin Docs}
+ */
+declare class RequestLimitHandlerPlugin<T extends Context> implements StandardHandlerPlugin<T> {
+    name: string;
+    /**
+     * Should limit the original batch request body instead of sub-requests.
+     */
+    after: string[];
+    /**
+     * Should limit the final body size instead of the compressed one.
+     */
+    before: string[];
+    private readonly maxBodySize;
+    constructor(options: RequestLimitHandlerPluginOptions);
+    init(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
+}
+
+interface ResponseCompressionHandlerPluginOptions<_T extends Context> {
+    /**
+     * 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 (via Accept-Encoding).
+     *
+     * @default ['gzip', 'deflate']
+     */
+    encodings?: readonly ('gzip' | 'deflate' | 'deflate-raw')[];
+    /**
+     * 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;
+}
+/**
+ * Compresses response bodies based on the client's Accept-Encoding header.
+ * Works at the standard handler level, so it supports all adapters.
+ *
+ * @see {@link https://orpc.dev/docs/plugins/response-compression Response Compression Plugin Docs}
+ */
+declare class ResponseCompressionHandlerPlugin<T extends Context> implements StandardHandlerPlugin<T> {
+    name: string;
+    /**
+     * Compression should be done after batching, to compress the final response.
+     * Compression should also be done after response headers are set, to access final headers like Content-Type and Cache-Control.
+     */
+    after: string[];
+    private readonly encodings;
+    private readonly threshold;
+    constructor(options?: ResponseCompressionHandlerPluginOptions<T>);
+    init(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
+}
+
 interface ResponseHeadersHandlerPluginContext {
     /**
      * Response headers as a Headers instance. This is injected by the Response Headers Plugin.
@@ -193,5 +293,5 @@ declare class RethrowHandlerPlugin<T extends Context> implements StandardHandler
     init(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
 }
 
-export { BatchHandlerPlugin, CORSHandlerPlugin, CSRFGuardHandlerPlugin, RequestHeadersHandlerPlugin, ResponseHeadersHandlerPlugin, RethrowHandlerPlugin };
-export type { BatchHandlerPluginOptions, CORSHandlerPluginOptions, RequestHeadersHandlerPluginContext, ResponseHeadersHandlerPluginContext, RethrowHandlerPluginOptions };
+export { BatchHandlerPlugin, CORSHandlerPlugin, CSRFGuardHandlerPlugin, RequestCompressionHandlerPlugin, RequestHeadersHandlerPlugin, RequestLimitHandlerPlugin, ResponseCompressionHandlerPlugin, ResponseHeadersHandlerPlugin, RethrowHandlerPlugin };
+export type { BatchHandlerPluginOptions, CORSHandlerPluginOptions, RequestHeadersHandlerPluginContext, RequestLimitHandlerPluginOptions, ResponseCompressionHandlerPluginOptions, ResponseHeadersHandlerPluginContext, RethrowHandlerPluginOptions };

package/dist/plugins/index.d.ts

@@ -30,6 +30,29 @@ interface BatchHandlerPluginOptions<T extends Context> {
      * @default {}
      */
     headers?: Value<Promisable<StandardHeaders>, [batchOptions: StandardHandlerRoutingInterceptorOptions<T>]>;
+    /**
+     * Keep-alive settings for streaming batch responses.
+     *
+     * When enabled, a zero-length length-prefixed frame is sent periodically while the
+     * stream is idle (no message sent for `interval` ms). Clients ignore these frames.
+     * Only applies to streaming mode.
+     *
+     * @default { enabled: true, interval: 15000 }
+     */
+    keepAlive?: undefined | {
+        /**
+         * If true, a keep-alive frame is sent periodically while the stream is idle.
+         *
+         * @default true
+         */
+        enabled: boolean;
+        /**
+         * Interval (in milliseconds) between keep-alive frames after the last message.
+         *
+         * @default 15000
+         */
+        interval?: number;
+    };
 }
 declare class BatchHandlerPlugin<T extends Context> implements StandardHandlerPlugin<T> {
     name: string;
@@ -42,6 +65,8 @@ declare class BatchHandlerPlugin<T extends Context> implements StandardHandlerPl
     private readonly mapSubrequest;
     private readonly successStatus;
     private readonly headers;
+    private readonly keepAliveEnabled;
+    private readonly keepAliveInterval;
     constructor(options?: BatchHandlerPluginOptions<T>);
     init(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
 }
@@ -123,6 +148,15 @@ declare class CSRFGuardHandlerPlugin<T extends Context> implements StandardHandl
     init(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
 }
 
+declare class RequestCompressionHandlerPlugin<T extends Context> implements StandardHandlerPlugin<T> {
+    name: string;
+    /**
+     * Should decompress the original batch request body instead of sub-requests.
+     */
+    after: string[];
+    init(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
+}
+
 interface RequestHeadersHandlerPluginContext {
     /**
      * Request headers as a Headers instance. This is injected by the Request Headers Plugin.
@@ -140,6 +174,72 @@ declare class RequestHeadersHandlerPlugin<T extends RequestHeadersHandlerPluginC
     init(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
 }
 
+interface RequestLimitHandlerPluginOptions {
+    /**
+     * The maximum allowed request body size in bytes.
+     */
+    maxBodySize: number;
+}
+/**
+ * Rejects requests whose body exceeds `maxBodySize`.
+ *
+ * When used with the request compression plugin, the limit applies to the
+ * decompressed payload rather than the compressed wire size.
+ *
+ * @see {@link https://orpc.dev/docs/plugins/request-limit Request Limit Plugin Docs}
+ */
+declare class RequestLimitHandlerPlugin<T extends Context> implements StandardHandlerPlugin<T> {
+    name: string;
+    /**
+     * Should limit the original batch request body instead of sub-requests.
+     */
+    after: string[];
+    /**
+     * Should limit the final body size instead of the compressed one.
+     */
+    before: string[];
+    private readonly maxBodySize;
+    constructor(options: RequestLimitHandlerPluginOptions);
+    init(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
+}
+
+interface ResponseCompressionHandlerPluginOptions<_T extends Context> {
+    /**
+     * 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 (via Accept-Encoding).
+     *
+     * @default ['gzip', 'deflate']
+     */
+    encodings?: readonly ('gzip' | 'deflate' | 'deflate-raw')[];
+    /**
+     * 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;
+}
+/**
+ * Compresses response bodies based on the client's Accept-Encoding header.
+ * Works at the standard handler level, so it supports all adapters.
+ *
+ * @see {@link https://orpc.dev/docs/plugins/response-compression Response Compression Plugin Docs}
+ */
+declare class ResponseCompressionHandlerPlugin<T extends Context> implements StandardHandlerPlugin<T> {
+    name: string;
+    /**
+     * Compression should be done after batching, to compress the final response.
+     * Compression should also be done after response headers are set, to access final headers like Content-Type and Cache-Control.
+     */
+    after: string[];
+    private readonly encodings;
+    private readonly threshold;
+    constructor(options?: ResponseCompressionHandlerPluginOptions<T>);
+    init(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
+}
+
 interface ResponseHeadersHandlerPluginContext {
     /**
      * Response headers as a Headers instance. This is injected by the Response Headers Plugin.
@@ -193,5 +293,5 @@ declare class RethrowHandlerPlugin<T extends Context> implements StandardHandler
     init(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
 }
 
-export { BatchHandlerPlugin, CORSHandlerPlugin, CSRFGuardHandlerPlugin, RequestHeadersHandlerPlugin, ResponseHeadersHandlerPlugin, RethrowHandlerPlugin };
-export type { BatchHandlerPluginOptions, CORSHandlerPluginOptions, RequestHeadersHandlerPluginContext, ResponseHeadersHandlerPluginContext, RethrowHandlerPluginOptions };
+export { BatchHandlerPlugin, CORSHandlerPlugin, CSRFGuardHandlerPlugin, RequestCompressionHandlerPlugin, RequestHeadersHandlerPlugin, RequestLimitHandlerPlugin, ResponseCompressionHandlerPlugin, ResponseHeadersHandlerPlugin, RethrowHandlerPlugin };
+export type { BatchHandlerPluginOptions, CORSHandlerPluginOptions, RequestHeadersHandlerPluginContext, RequestLimitHandlerPluginOptions, ResponseCompressionHandlerPluginOptions, ResponseHeadersHandlerPluginContext, RethrowHandlerPluginOptions };

package/dist/plugins/index.mjs

@@ -1,9 +1,9 @@
-import { toArray, value } from '@orpc/shared';
-import { flattenStandardHeader, parseStandardUrl, mergeStandardHeaders } from '@standardserver/core';
+import { toArray, value, isCompressibleContentType, isAsyncIteratorObject, stringifyJSON } from '@orpc/shared';
+import { flattenStandardHeader, parseStandardUrl, generateContentDisposition, mergeStandardHeaders } from '@standardserver/core';
 import { isClientPeerSendMessage, ServerPeer, encodePeerMessage } from '@standardserver/peer';
 export { C as CSRFGuardHandlerPlugin } from '../shared/server.D_QauotT.mjs';
-import { toFetchHeaders, toStandardHeaders } from '@standardserver/fetch';
-import '@orpc/client';
+import { toFetchHeaders, toStandardBody, toStandardHeaders } from '@standardserver/fetch';
+import { ORPCError } from '@orpc/client';
 
 class BatchHandlerPlugin {
   name = "~batch";
@@ -16,6 +16,8 @@ class BatchHandlerPlugin {
   mapSubrequest;
   successStatus;
   headers;
+  keepAliveEnabled;
+  keepAliveInterval;
   constructor(options = {}) {
     this.maxSize = options.maxSize ?? 10;
     this.mapSubrequest = options.mapSubrequest ?? ((subRequest, { request: batchRequest }) => ({
@@ -29,6 +31,8 @@ class BatchHandlerPlugin {
     }));
     this.successStatus = options.successStatus ?? 207;
     this.headers = options.headers ?? {};
+    this.keepAliveEnabled = options.keepAlive?.enabled ?? true;
+    this.keepAliveInterval = options.keepAlive?.interval ?? 15e3;
   }
   init(options) {
     const routingInterceptor = async (interceptorOptions) => {
@@ -127,9 +131,35 @@ class BatchHandlerPlugin {
         };
       }
       let streamController;
+      let keepAliveTimer;
+      const clearKeepAlive = () => {
+        if (keepAliveTimer !== void 0) {
+          clearInterval(keepAliveTimer);
+          keepAliveTimer = void 0;
+        }
+      };
+      const scheduleKeepAlive = () => {
+        if (!this.keepAliveEnabled) {
+          return;
+        }
+        clearKeepAlive();
+        keepAliveTimer = setInterval(() => {
+          try {
+            const lengthBuffer = new ArrayBuffer(4);
+            new DataView(lengthBuffer).setUint32(0, 0, false);
+            streamController.enqueue(new Uint8Array(lengthBuffer));
+          } catch {
+            clearKeepAlive();
+          }
+        }, this.keepAliveInterval);
+      };
       const stream = new ReadableStream({
         start(controller) {
           streamController = controller;
+          scheduleKeepAlive();
+        },
+        cancel() {
+          clearKeepAlive();
         }
       });
       const peer = new ServerPeer(async (message) => {
@@ -139,11 +169,14 @@ class BatchHandlerPlugin {
         new DataView(lengthBuffer).setUint32(0, bytes.byteLength, false);
         streamController.enqueue(new Uint8Array(lengthBuffer));
         streamController.enqueue(bytes);
+        scheduleKeepAlive();
       });
       Promise.all(messages.map((msg) => peer.message(msg, handleIndividualRequest))).then(async () => {
+        clearKeepAlive();
         streamController.close();
         await peer.close();
       }).catch(async (error) => {
+        clearKeepAlive();
         streamController.error(error);
         await peer.close(error);
       });
@@ -193,7 +226,10 @@ class CORSHandlerPlugin {
         if (allowedOrigins.includes(origin)) {
           resHeaders["access-control-allow-origin"] = origin;
         }
-        resHeaders.vary = interceptorOptions.request.headers.vary ?? "origin";
+        const existingVary = flattenStandardHeader(resHeaders.vary);
+        if (!existingVary?.split(",").some((v) => v.trim().toLowerCase() === "origin")) {
+          resHeaders.vary = existingVary ? `${existingVary}, Origin` : "Origin";
+        }
       }
       const allowedTimingOrigins = toArray(await value(this.options.timingOrigin, origin, interceptorOptions));
       if (allowedTimingOrigins.includes("*")) {
@@ -244,6 +280,69 @@ class CORSHandlerPlugin {
   }
 }
 
+class RequestCompressionHandlerPlugin {
+  name = "~request-compression";
+  /**
+   * Should decompress the original batch request body instead of sub-requests.
+   */
+  after = ["~batch"];
+  init(options) {
+    const routingInterceptor = async ({ next, ...interceptorOptions }) => {
+      const encodings = parseContentEncodings(
+        flattenStandardHeader(interceptorOptions.request.headers["content-encoding"])
+      );
+      if (encodings.length === 0 || !encodings.every(isSupportedEncoding)) {
+        return next();
+      }
+      const decompressedHeaders = {
+        ...interceptorOptions.request.headers,
+        "content-length": void 0,
+        "content-encoding": void 0
+      };
+      return next({
+        ...interceptorOptions,
+        request: {
+          ...interceptorOptions.request,
+          headers: decompressedHeaders,
+          async resolveBody(hint) {
+            const stream = await interceptorOptions.request.resolveBody("octet-stream");
+            if (!(stream instanceof ReadableStream)) {
+              return stream;
+            }
+            let decompressedStream = stream;
+            for (let i = encodings.length - 1; i >= 0; i--) {
+              decompressedStream = decompressedStream.pipeThrough(
+                new DecompressionStream(encodings[i])
+              );
+            }
+            const response = new Response(decompressedStream, {
+              headers: toFetchHeaders(decompressedHeaders)
+            });
+            return toStandardBody(response, { hint });
+          }
+        }
+      });
+    };
+    return {
+      ...options,
+      routingInterceptors: [
+        routingInterceptor,
+        ...toArray(options.routingInterceptors)
+      ]
+    };
+  }
+}
+const SUPPORTED_ENCODINGS = ["gzip", "deflate", "deflate-raw"];
+function isSupportedEncoding(encoding) {
+  return SUPPORTED_ENCODINGS.includes(encoding);
+}
+function parseContentEncodings(header) {
+  if (header === void 0) {
+    return [];
+  }
+  return header.split(",").map((part) => part.trim().toLowerCase());
+}
+
 class RequestHeadersHandlerPlugin {
   name = "~request-headers";
   init(options) {
@@ -266,6 +365,243 @@ class RequestHeadersHandlerPlugin {
   }
 }
 
+class RequestLimitHandlerPlugin {
+  name = "~request-limit";
+  /**
+   * Should limit the original batch request body instead of sub-requests.
+   */
+  after = ["~batch"];
+  /**
+   * Should limit the final body size instead of the compressed one.
+   */
+  before = ["~request-compression"];
+  maxBodySize;
+  constructor(options) {
+    this.maxBodySize = options.maxBodySize;
+  }
+  init(options) {
+    const maxBodySize = this.maxBodySize;
+    const routingInterceptor = async ({ next, ...interceptorOptions }) => {
+      return next({
+        ...interceptorOptions,
+        request: {
+          ...interceptorOptions.request,
+          async resolveBody(hint) {
+            const contentLength = Number(
+              flattenStandardHeader(interceptorOptions.request.headers["content-length"])
+            );
+            if (Number.isFinite(contentLength) && contentLength > maxBodySize) {
+              throw new ORPCError("PAYLOAD_TOO_LARGE");
+            }
+            const stream = await interceptorOptions.request.resolveBody("octet-stream");
+            if (!(stream instanceof ReadableStream)) {
+              return stream;
+            }
+            let currentBodySize = 0;
+            const limitedStream = stream.pipeThrough(
+              new TransformStream({
+                transform(chunk, controller) {
+                  currentBodySize += chunk.byteLength;
+                  if (currentBodySize > maxBodySize) {
+                    controller.error(new ORPCError("PAYLOAD_TOO_LARGE"));
+                    return;
+                  }
+                  controller.enqueue(chunk);
+                }
+              })
+            );
+            const response = new Response(limitedStream, {
+              headers: toFetchHeaders(interceptorOptions.request.headers)
+            });
+            return toStandardBody(response, { hint });
+          }
+        }
+      });
+    };
+    return {
+      ...options,
+      routingInterceptors: [
+        routingInterceptor,
+        ...toArray(options.routingInterceptors)
+      ]
+    };
+  }
+}
+
+const AVG_BYTES_PER_CHAR = 1.2;
+class ResponseCompressionHandlerPlugin {
+  name = "~response-compression";
+  /**
+   * Compression should be done after batching, to compress the final response.
+   * Compression should also be done after response headers are set, to access final headers like Content-Type and Cache-Control.
+   */
+  after = ["~batch", "~response-headers"];
+  encodings;
+  threshold;
+  constructor(options = {}) {
+    this.encodings = options.encodings ?? ["gzip", "deflate"];
+    this.threshold = options.threshold ?? 1024;
+  }
+  init(options) {
+    const routingInterceptor = async ({ next, ...interceptorOptions }) => {
+      const result = await next();
+      if (!result.matched) {
+        return result;
+      }
+      const response = result.response;
+      const contentEncoding = flattenStandardHeader(response.headers["content-encoding"])?.trim()?.toLowerCase();
+      if (contentEncoding !== void 0) {
+        return result;
+      }
+      if (isNoTransformCacheControl(flattenStandardHeader(response.headers["cache-control"]))) {
+        return result;
+      }
+      const acceptEncodings = parseAcceptEncodings(
+        flattenStandardHeader(interceptorOptions.request.headers["accept-encoding"])
+      );
+      const encoding = this.encodings.find((enc) => acceptEncodings.includes(enc));
+      if (encoding === void 0) {
+        return result;
+      }
+      const body = response.body;
+      const headers = response.headers;
+      if (body instanceof ReadableStream) {
+        const contentLength = Number(flattenStandardHeader(headers["content-length"]));
+        if ((!Number.isFinite(contentLength) || contentLength >= this.threshold) && isCompressibleContentType(flattenStandardHeader(headers["content-type"]))) {
+          return {
+            ...result,
+            response: {
+              ...response,
+              body: body.pipeThrough(new CompressionStream(encoding)),
+              headers: {
+                ...headers,
+                "standard-server": "octet-stream",
+                "content-length": [],
+                "content-encoding": encoding
+              }
+            }
+          };
+        }
+      } else if (body instanceof Blob) {
+        if ((!Number.isFinite(body.size) || body.size >= this.threshold) && isCompressibleContentType(body.type)) {
+          const contentDisposition = headers["content-disposition"] ?? generateContentDisposition(
+            body instanceof File ? body.name : "blob"
+          );
+          return {
+            ...result,
+            response: {
+              ...response,
+              body: body.stream().pipeThrough(new CompressionStream(encoding)),
+              headers: {
+                ...headers,
+                "standard-server": "file",
+                "content-type": body.type,
+                "content-length": [],
+                "content-disposition": contentDisposition,
+                "content-encoding": encoding
+              }
+            }
+          };
+        }
+      } else if (body instanceof FormData) {
+        const PART_OVERHEAD = 64;
+        let contentLength = 0;
+        for (const [key, value] of body) {
+          contentLength += PART_OVERHEAD + key.length;
+          if (value instanceof Blob) {
+            if (!Number.isFinite(value.size)) {
+              if (!isCompressibleContentType(value.type)) {
+                contentLength = -Infinity;
+                break;
+              }
+              contentLength = Infinity;
+            } else {
+              contentLength += isCompressibleContentType(value.type) ? value.size : -value.size;
+            }
+          } else {
+            contentLength += value.length * AVG_BYTES_PER_CHAR;
+          }
+        }
+        if (contentLength >= this.threshold) {
+          const res = new Response(body);
+          const compressedStream = res.body.pipeThrough(new CompressionStream(encoding));
+          return {
+            ...result,
+            response: {
+              ...response,
+              body: compressedStream,
+              headers: {
+                ...headers,
+                "standard-server": [],
+                "content-type": res.headers.get("content-type"),
+                "content-length": [],
+                "content-encoding": encoding
+              }
+            }
+          };
+        }
+      } else if (body instanceof URLSearchParams) {
+        const string = body.toString();
+        if (string.length * AVG_BYTES_PER_CHAR >= this.threshold) {
+          return {
+            ...result,
+            response: {
+              ...response,
+              body: new Blob([string]).stream().pipeThrough(new CompressionStream(encoding)),
+              headers: {
+                ...headers,
+                "standard-server": [],
+                "content-type": "application/x-www-form-urlencoded",
+                "content-length": [],
+                "content-encoding": encoding
+              }
+            }
+          };
+        }
+      } else if (body !== void 0 && !isAsyncIteratorObject(body)) {
+        const string = stringifyJSON(body);
+        if (string.length * AVG_BYTES_PER_CHAR >= this.threshold) {
+          return {
+            ...result,
+            response: {
+              ...response,
+              body: new Blob([string]).stream().pipeThrough(new CompressionStream(encoding)),
+              headers: {
+                ...headers,
+                "standard-server": [],
+                "content-type": "application/json",
+                "content-length": [],
+                "content-encoding": encoding
+              }
+            }
+          };
+        }
+      }
+      return result;
+    };
+    return {
+      ...options,
+      routingInterceptors: [
+        routingInterceptor,
+        ...toArray(options.routingInterceptors)
+      ]
+    };
+  }
+}
+function parseAcceptEncodings(header) {
+  if (header === void 0) {
+    return [];
+  }
+  return header.split(",").map((part) => part.trim().split(";")[0].trim().toLowerCase()).filter(Boolean);
+}
+const CACHE_CONTROL_NO_TRANSFORM_REGEX = /(?:^|,)\s*no-transform\s*(?:,|$)/i;
+function isNoTransformCacheControl(cacheControl) {
+  if (cacheControl === void 0) {
+    return false;
+  }
+  return CACHE_CONTROL_NO_TRANSFORM_REGEX.test(cacheControl);
+}
+
 class ResponseHeadersHandlerPlugin {
   name = "~response-headers";
   /**
@@ -354,4 +690,4 @@ class RethrowHandlerPlugin {
   }
 }
 
-export { BatchHandlerPlugin, CORSHandlerPlugin, RequestHeadersHandlerPlugin, ResponseHeadersHandlerPlugin, RethrowHandlerPlugin };
+export { BatchHandlerPlugin, CORSHandlerPlugin, RequestCompressionHandlerPlugin, RequestHeadersHandlerPlugin, RequestLimitHandlerPlugin, ResponseCompressionHandlerPlugin, ResponseHeadersHandlerPlugin, RethrowHandlerPlugin };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/server",
   "type": "module",
-  "version": "2.0.0-beta.15",
+  "version": "2.0.0-beta.17",
   "license": "MIT",
   "homepage": "https://orpc.dev",
   "repository": {
@@ -85,15 +85,14 @@
     }
   },
   "dependencies": {
-    "@standardserver/core": "^0.0.32",
-    "@standardserver/fetch": "^0.0.32",
-    "@standardserver/node": "^0.0.32",
-    "@standardserver/peer": "^0.0.32",
+    "@standardserver/core": "^0.4.2",
+    "@standardserver/fetch": "^0.4.2",
+    "@standardserver/node": "^0.4.2",
+    "@standardserver/peer": "^0.4.2",
     "cookie": "^2.0.1",
-    "@orpc/client": "2.0.0-beta.15",
-    "@orpc/contract": "2.0.0-beta.15",
-    "@orpc/interop": "2.0.0-beta.15",
-    "@orpc/shared": "2.0.0-beta.15"
+    "@orpc/client": "2.0.0-beta.17",
+    "@orpc/contract": "2.0.0-beta.17",
+    "@orpc/shared": "2.0.0-beta.17"
   },
   "devDependencies": {
     "crossws": "^0.4.6",