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

package/dist/adapters/fetch/index.mjs

@@ -1,146 +1,16 @@
-import { toArray, sortPlugins, intercept, resolveMaybeOptionalOptions } from '@orpc/shared';
-import { ORPCError } from '@orpc/client';
+export { R as BodyLimitPlugin } from '../../shared/server.Cd4Z1hpV.mjs';
+import { sortPlugins, intercept, resolveMaybeOptionalOptions } 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.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';
-
-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)
-      ]
-    };
-  }
-}
+import '../../shared/server.Dh77P3ii.mjs';
 
 class CompositeFetchHandlerPlugin {
-  name = "~composite/fetch-handler";
+  name = "~composite/fetch";
   plugins;
   constructor(plugins = []) {
     this.plugins = sortPlugins(plugins);
@@ -189,16 +59,10 @@ class FetchHandler {
 
 class RPCHandler extends FetchHandler {
   constructor(router, options = {}) {
-    if (options.csrfGuardHandlerPlugin?.enabled !== false) {
-      options = {
-        ...options,
-        plugins: [...toArray(options.plugins), new CSRFGuardHandlerPlugin()]
-      };
-    }
     const codec = new RPCHandlerCodec(router, options);
     const handler = new StandardHandler(codec, options);
     super(handler, options);
   }
 }
 
-export { BodyCompressionHandlerPlugin, BodyLimitHandlerPlugin, CompositeFetchHandlerPlugin, FetchHandler, RPCHandler };
+export { CompositeFetchHandlerPlugin, FetchHandler, RPCHandler };

package/dist/adapters/message-port/index.d.mts

@@ -1,11 +1,11 @@
 import { SupportedMessagePort } from '@orpc/client/message-port';
 import { Value, Promisable, MaybeOptionalOptions } from '@orpc/shared';
 import { ServerPeer, EncodePeerMessageOptions, DecodePeerMessageOptions } from '@standardserver/peer';
-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';
@@ -19,9 +19,8 @@ interface MessagePortHandlerOptions<_T extends Context> {
      * such as transferring object ownership or supporting non-serializable objects like `OffscreenCanvas` or improving performance.
      *
      * @remarks
-     * - Returning `null` or `undefined` disables this feature.
-     *
-     * @warning Ensure your message port implementation supports `transferable` objects before enabling this.
+     * **Note**: Returning `null` or `undefined` disables this feature.
+     * **Warning**: Ensure your message port implementation supports `transferable` objects before enabling this.
      */
     experimental_transfer?: Value<Promisable<object[] | null | undefined>, [message: DecodedResponseMessage, port: SupportedMessagePort]>;
     /**
@@ -41,31 +40,35 @@ declare class MessagePortHandler<T extends Context> {
     private readonly decodePeerMessageOptions;
     constructor(handler: StandardHandler<T>, options?: NoInfer<MessagePortHandlerOptions<T>>);
     /**
-     * Attaches necessary event listeners to a message port to handle incoming messages and peer management.
+     * Attaches message and close listeners to a message port.
+     *
+     * Prefer this over calling `.message()` and `.close()` manually.
      */
     upgrade(port: SupportedMessagePort, ...rest: MaybeOptionalOptions<StandardPeerRequestHandlerOptions<T>>): void;
     /**
      * Handles a single message received from a message port.
      *
-     * @warning AVOID calling this method directly if `.upgrade()` is used, as `.upgrade()` already sets up necessary event listeners to call this method for incoming messages and manage peer lifecycle.
-     *
-     * @param port The message port instance, require consistent instance across messages for proper peer management
+     * @param port The message port instance. Use the same instance for all messages.
      */
-    message(port: SupportedMessagePort, data: any, ...rest: MaybeOptionalOptions<StandardPeerRequestHandlerOptions<T>>): Promise<{
+    message(port: SupportedMessagePort, data: unknown, ...rest: MaybeOptionalOptions<StandardPeerRequestHandlerOptions<T>>): Promise<{
         matched: boolean;
     }>;
     /**
-     * Called when a message port is closed, to clean up any associated peer state.
-     *
-     * @warning AVOID calling this method directly if `.upgrade()` is used, as `.upgrade()` already sets up necessary event listeners to call this method for incoming messages and manage peer lifecycle.
+     * Cleans up peer state for a closed message port.
      *
-     * @param port The message port instance to clean up, must be the same instance used in `.message()` calls to properly clean up
+     * @param port The same message port instance passed to `.message()`.
      */
     close(port: SupportedMessagePort): Promise<void>;
 }
 
 interface RPCHandlerOptions<T extends Context> extends StandardHandlerOptions<T>, RPCHandlerCodecOptions<T>, MessagePortHandlerOptions<T> {
 }
+/**
+ * Serves an oRPC router over the RPC protocol on a message port,
+ * such as browser extensions, Electron, or worker threads.
+ *
+ * @see {@link https://orpc.dev/docs/adapters/message-port | Message Port Adapter}
+ */
 declare class RPCHandler<T extends Context> extends MessagePortHandler<T> {
     constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
 }

package/dist/adapters/message-port/index.d.ts

@@ -1,11 +1,11 @@
 import { SupportedMessagePort } from '@orpc/client/message-port';
 import { Value, Promisable, MaybeOptionalOptions } from '@orpc/shared';
 import { ServerPeer, EncodePeerMessageOptions, DecodePeerMessageOptions } from '@standardserver/peer';
-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';
@@ -19,9 +19,8 @@ interface MessagePortHandlerOptions<_T extends Context> {
      * such as transferring object ownership or supporting non-serializable objects like `OffscreenCanvas` or improving performance.
      *
      * @remarks
-     * - Returning `null` or `undefined` disables this feature.
-     *
-     * @warning Ensure your message port implementation supports `transferable` objects before enabling this.
+     * **Note**: Returning `null` or `undefined` disables this feature.
+     * **Warning**: Ensure your message port implementation supports `transferable` objects before enabling this.
      */
     experimental_transfer?: Value<Promisable<object[] | null | undefined>, [message: DecodedResponseMessage, port: SupportedMessagePort]>;
     /**
@@ -41,31 +40,35 @@ declare class MessagePortHandler<T extends Context> {
     private readonly decodePeerMessageOptions;
     constructor(handler: StandardHandler<T>, options?: NoInfer<MessagePortHandlerOptions<T>>);
     /**
-     * Attaches necessary event listeners to a message port to handle incoming messages and peer management.
+     * Attaches message and close listeners to a message port.
+     *
+     * Prefer this over calling `.message()` and `.close()` manually.
      */
     upgrade(port: SupportedMessagePort, ...rest: MaybeOptionalOptions<StandardPeerRequestHandlerOptions<T>>): void;
     /**
      * Handles a single message received from a message port.
      *
-     * @warning AVOID calling this method directly if `.upgrade()` is used, as `.upgrade()` already sets up necessary event listeners to call this method for incoming messages and manage peer lifecycle.
-     *
-     * @param port The message port instance, require consistent instance across messages for proper peer management
+     * @param port The message port instance. Use the same instance for all messages.
      */
-    message(port: SupportedMessagePort, data: any, ...rest: MaybeOptionalOptions<StandardPeerRequestHandlerOptions<T>>): Promise<{
+    message(port: SupportedMessagePort, data: unknown, ...rest: MaybeOptionalOptions<StandardPeerRequestHandlerOptions<T>>): Promise<{
         matched: boolean;
     }>;
     /**
-     * Called when a message port is closed, to clean up any associated peer state.
-     *
-     * @warning AVOID calling this method directly if `.upgrade()` is used, as `.upgrade()` already sets up necessary event listeners to call this method for incoming messages and manage peer lifecycle.
+     * Cleans up peer state for a closed message port.
      *
-     * @param port The message port instance to clean up, must be the same instance used in `.message()` calls to properly clean up
+     * @param port The same message port instance passed to `.message()`.
      */
     close(port: SupportedMessagePort): Promise<void>;
 }
 
 interface RPCHandlerOptions<T extends Context> extends StandardHandlerOptions<T>, RPCHandlerCodecOptions<T>, MessagePortHandlerOptions<T> {
 }
+/**
+ * Serves an oRPC router over the RPC protocol on a message port,
+ * such as browser extensions, Electron, or worker threads.
+ *
+ * @see {@link https://orpc.dev/docs/adapters/message-port | Message Port Adapter}
+ */
 declare class RPCHandler<T extends Context> extends MessagePortHandler<T> {
     constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
 }

package/dist/adapters/message-port/index.mjs

@@ -1,13 +1,13 @@
 import { onMessagePortMessage, onMessagePortClose, postMessagePortMessage } from '@orpc/client/message-port';
-import { value, isPlainObject, resolveMaybeOptionalOptions, toStringOrBytes } from '@orpc/shared';
-import { ServerPeer, encodePeerMessage, decodePeerMessage, isClientPeerSendMessage } from '@standardserver/peer';
+import { value, resolveMaybeOptionalOptions } from '@orpc/shared';
+import { ServerPeer, encodePeerMessage, decodePeerMessage, isClientPeerSendMessage, isPeerMessage } 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 MessagePortHandler {
   constructor(handler, options = {}) {
@@ -21,7 +21,9 @@ class MessagePortHandler {
   encodePeerMessageOptions;
   decodePeerMessageOptions;
   /**
-   * Attaches necessary event listeners to a message port to handle incoming messages and peer management.
+   * Attaches message and close listeners to a message port.
+   *
+   * Prefer this over calling `.message()` and `.close()` manually.
    */
   upgrade(port, ...rest) {
     onMessagePortMessage(port, (message) => this.message(port, message, ...rest));
@@ -30,51 +32,45 @@ class MessagePortHandler {
   /**
    * Handles a single message received from a message port.
    *
-   * @warning AVOID calling this method directly if `.upgrade()` is used, as `.upgrade()` already sets up necessary event listeners to call this method for incoming messages and manage peer lifecycle.
-   *
-   * @param port The message port instance, require consistent instance across messages for proper peer management
+   * @param port The message port instance. Use the same instance for all messages.
    */
   async message(port, data, ...rest) {
     let peer = this.peers.get(port);
     if (!peer) {
-      this.peers.set(port, peer = new ServerPeer(async (message2) => {
-        const transfer = await value(this.transfer, message2, port);
+      this.peers.set(port, peer = new ServerPeer(async (message) => {
+        const transfer = await value(this.transfer, message, port);
         if (transfer) {
-          postMessagePortMessage(port, message2, transfer);
+          postMessagePortMessage(port, message, transfer);
         } else {
-          postMessagePortMessage(port, await encodePeerMessage(message2, this.encodePeerMessageOptions));
+          postMessagePortMessage(port, await encodePeerMessage(message, this.encodePeerMessageOptions));
         }
       }));
     }
-    if (isPlainObject(data)) {
-      await peer.message(
-        data,
-        createStandardPeerRequestHandler(this.handler, resolveMaybeOptionalOptions(rest))
-      );
-      return { matched: true };
+    let peerMessage;
+    if (typeof data === "string" || data instanceof Uint8Array) {
+      const result = decodePeerMessage(data, this.decodePeerMessageOptions);
+      if (result.matched && isClientPeerSendMessage(result.message)) {
+        peerMessage = result.message;
+      }
+    } else if (isPeerMessage(data) && isClientPeerSendMessage(data)) {
+      peerMessage = data;
     }
-    const message = await toStringOrBytes(data);
-    const result = decodePeerMessage(message, this.decodePeerMessageOptions);
-    if (result.matched && isClientPeerSendMessage(result.message)) {
-      await peer.message(
-        result.message,
-        createStandardPeerRequestHandler(this.handler, resolveMaybeOptionalOptions(rest))
-      );
+    if (peerMessage === void 0) {
+      return { matched: false };
     }
-    return result;
+    await peer.message(peerMessage, createStandardPeerRequestHandler(this.handler, resolveMaybeOptionalOptions(rest)));
+    return { matched: true };
   }
   /**
-   * Called when a message port is closed, to clean up any associated peer state.
-   *
-   * @warning AVOID calling this method directly if `.upgrade()` is used, as `.upgrade()` already sets up necessary event listeners to call this method for incoming messages and manage peer lifecycle.
+   * Cleans up peer state for a closed message port.
    *
-   * @param port The message port instance to clean up, must be the same instance used in `.message()` calls to properly clean up
+   * @param port The same message port instance passed to `.message()`.
    */
   async close(port) {
     const peer = this.peers.get(port);
     if (peer) {
-      await peer.close();
       this.peers.delete(port);
+      await peer.close();
     }
   }
 }

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

@@ -1,11 +1,11 @@
-import { SendStandardResponseOptions, NodeHttpRequest, NodeHttpResponse } from '@standardserver/node';
-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 { e as StandardHandlerPlugin, b as StandardHandlerHandleOptions, S as StandardHandler, a as StandardHandlerOptions } from '../../shared/server.BB_Ik9Ph.mjs';
+import { SendStandardResponseOptions, NodeHttpRequest, NodeHttpResponse } from '@standardserver/node';
+import { Context } from '../../index.mjs';
+import { StandardHandlerPlugin, StandardHandlerHandleOptions, StandardHandler, StandardHandlerOptions } from '../standard/index.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.B_U9y00a.mjs';
+import { Router } from '../../index.mjs';
+import { RPCHandlerCodecOptions } from '../standard/index.mjs';
 import '@orpc/client';
 import '@orpc/contract';
 import '@standardserver/core';
@@ -34,7 +34,7 @@ interface NodeHttpHandlerPlugin<T extends Context> extends StandardHandlerPlugin
     initNodeHttpHandlerOptions?(options: NodeHttpHandlerOptions<T>): NodeHttpHandlerOptions<T>;
 }
 declare class CompositeNodeHttpHandlerPlugin<T extends Context> implements NodeHttpHandlerPlugin<T> {
-    readonly name = "~composite/node-http-handler";
+    readonly name = "~composite/node-http";
     protected readonly plugins: NodeHttpHandlerPlugin<T>[];
     constructor(plugins?: NodeHttpHandlerPlugin<T>[]);
     initNodeHttpHandlerOptions(options: NodeHttpHandlerOptions<T>): NodeHttpHandlerOptions<T>;
@@ -71,51 +71,17 @@ 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.
-     */
-    csrfGuardPlugin?: {
-        /**
-         * If `false`, this plugin is disabled.
-         *
-         * @default true
-         */
-        enabled?: boolean;
-    };
 }
+/**
+ * Serves an oRPC router over the RPC protocol using Node.js built-in
+ * HTTP request/response objects.
+ *
+ * @see {@link https://orpc.dev/docs/adapters/node-http | Node HTTP Adapter}
+ */
 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,11 +1,11 @@
-import { SendStandardResponseOptions, NodeHttpRequest, NodeHttpResponse } from '@standardserver/node';
-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 { e as StandardHandlerPlugin, b as StandardHandlerHandleOptions, S as StandardHandler, a as StandardHandlerOptions } from '../../shared/server.EOHJ3NJr.js';
+import { SendStandardResponseOptions, NodeHttpRequest, NodeHttpResponse } from '@standardserver/node';
+import { Context } from '../../index.js';
+import { StandardHandlerPlugin, StandardHandlerHandleOptions, StandardHandler, StandardHandlerOptions } from '../standard/index.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.T9F3bzZx.js';
+import { Router } from '../../index.js';
+import { RPCHandlerCodecOptions } from '../standard/index.js';
 import '@orpc/client';
 import '@orpc/contract';
 import '@standardserver/core';
@@ -34,7 +34,7 @@ interface NodeHttpHandlerPlugin<T extends Context> extends StandardHandlerPlugin
     initNodeHttpHandlerOptions?(options: NodeHttpHandlerOptions<T>): NodeHttpHandlerOptions<T>;
 }
 declare class CompositeNodeHttpHandlerPlugin<T extends Context> implements NodeHttpHandlerPlugin<T> {
-    readonly name = "~composite/node-http-handler";
+    readonly name = "~composite/node-http";
     protected readonly plugins: NodeHttpHandlerPlugin<T>[];
     constructor(plugins?: NodeHttpHandlerPlugin<T>[]);
     initNodeHttpHandlerOptions(options: NodeHttpHandlerOptions<T>): NodeHttpHandlerOptions<T>;
@@ -71,51 +71,17 @@ 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.
-     */
-    csrfGuardPlugin?: {
-        /**
-         * If `false`, this plugin is disabled.
-         *
-         * @default true
-         */
-        enabled?: boolean;
-    };
 }
+/**
+ * Serves an oRPC router over the RPC protocol using Node.js built-in
+ * HTTP request/response objects.
+ *
+ * @see {@link https://orpc.dev/docs/adapters/node-http | Node HTTP Adapter}
+ */
 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 };