@orpc/server 2.0.0-beta.4 → 2.0.0-beta.40

package/dist/adapters/fetch/index.mjs

@@ -1,204 +1,42 @@
-import { toArray, sortPlugins, intercept, resolveMaybeOptionalOptions } from '@orpc/shared';
-import { ORPCError } from '@orpc/client';
-import { toStandardLazyRequest, toFetchResponse } from '@standardserver/fetch';
+export { R as BodyLimitPlugin } from '../../shared/server.1ExWFMze.mjs';
+import { resolveMaybeOptionalOptions } from '@orpc/shared';
+import { toStandardLazyRequest, toFetchResponse } from '@standard-server/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 '@standardserver/core';
-import '../../shared/server.CrlKQucM.mjs';
+import { R as RPCHandlerCodec, S as StandardHandler } from '../../shared/server.C0lFtoHU.mjs';
+import '@orpc/client';
+import '@standard-server/core';
+import '../../shared/server.Djb_ebJT.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)
-      ]
-    };
-  }
-}
-
-class CompositeFetchHandlerPlugin {
-  name = "~composite/fetch-handler";
-  plugins;
-  constructor(plugins = []) {
-    this.plugins = sortPlugins(plugins);
-  }
-  initFetchHandlerOptions(options) {
-    for (const plugin of this.plugins) {
-      if (plugin.initFetchHandlerOptions) {
-        options = plugin.initFetchHandlerOptions(options);
-      }
-    }
-    return options;
-  }
-}
+import '../../shared/server.BynNaBBA.mjs';
 
 class FetchHandler {
   constructor(standardHandler, options = {}) {
     this.standardHandler = standardHandler;
-    options = new CompositeFetchHandlerPlugin(options.plugins).initFetchHandlerOptions(options);
-    this.fetchInterceptors = options.fetchInterceptors;
     this.toFetchResponseOptions = options.toFetchResponse;
   }
   toFetchResponseOptions;
-  fetchInterceptors;
   async handle(request, ...rest) {
-    return intercept(
-      this.fetchInterceptors,
-      {
-        ...resolveFriendlyStandardHandlerHandleOptions(resolveMaybeOptionalOptions(rest)),
-        request,
-        toFetchResponseOptions: this.toFetchResponseOptions
-      },
-      async ({ request: request2, toFetchResponseOptions, ...options }) => {
-        const standardRequest = toStandardLazyRequest(request2);
-        const result = await this.standardHandler.handle(standardRequest, options);
-        if (!result.matched) {
-          return result;
-        }
-        return {
-          matched: true,
-          response: toFetchResponse(result.response, toFetchResponseOptions)
-        };
-      }
+    const standardRequest = toStandardLazyRequest(request);
+    const result = await this.standardHandler.handle(
+      standardRequest,
+      resolveFriendlyStandardHandlerHandleOptions(resolveMaybeOptionalOptions(rest))
     );
+    if (!result.matched) {
+      return result;
+    }
+    return {
+      matched: true,
+      response: toFetchResponse(result.response, this.toFetchResponseOptions)
+    };
   }
 }
 
 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 { FetchHandler, RPCHandler };

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

@@ -1,14 +1,14 @@
 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.DJIkub_t.mjs';
-import { StandardPeerRequestHandlerOptions } from '../standard-peer/index.mjs';
-import { R as Router } from '../../shared/server.BsNNjG5J.mjs';
-import { R as RPCHandlerCodecOptions } from '../../shared/server.Cj5lgPuG.mjs';
+import { ServerPeer, EncodePeerMessageOptions, DecodePeerMessageOptions } from '@standard-server/peer';
+import { Context } from '../../index.mjs';
+import { StandardHandler, StandardHandlerOptions } from '../standard/index.mjs';
+import { FriendlyStandardHandlerHandleOptions } from '../standard/index.mjs';
+import { Router } from '../../index.mjs';
+import { RPCHandlerCodecOptions } from '../standard/index.mjs';
 import '@orpc/client';
 import '@orpc/contract';
-import '@standardserver/core';
+import '@standard-server/core';
 
 type DecodedResponseMessage = ConstructorParameters<typeof ServerPeer>[0] extends (message: infer TMessage) => unknown ? TMessage : never;
 interface MessagePortHandlerOptions<_T extends Context> {
@@ -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;
+    upgrade(port: SupportedMessagePort, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<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<FriendlyStandardHandlerHandleOptions<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,14 +1,14 @@
 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.DBANIheG.js';
-import { StandardPeerRequestHandlerOptions } from '../standard-peer/index.js';
-import { R as Router } from '../../shared/server.Pa0F03f_.js';
-import { R as RPCHandlerCodecOptions } from '../../shared/server.d_2NS3g5.js';
+import { ServerPeer, EncodePeerMessageOptions, DecodePeerMessageOptions } from '@standard-server/peer';
+import { Context } from '../../index.js';
+import { StandardHandler, StandardHandlerOptions } from '../standard/index.js';
+import { FriendlyStandardHandlerHandleOptions } from '../standard/index.js';
+import { Router } from '../../index.js';
+import { RPCHandlerCodecOptions } from '../standard/index.js';
 import '@orpc/client';
 import '@orpc/contract';
-import '@standardserver/core';
+import '@standard-server/core';
 
 type DecodedResponseMessage = ConstructorParameters<typeof ServerPeer>[0] extends (message: infer TMessage) => unknown ? TMessage : never;
 interface MessagePortHandlerOptions<_T extends Context> {
@@ -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;
+    upgrade(port: SupportedMessagePort, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<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<FriendlyStandardHandlerHandleOptions<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,14 @@
 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 { c as createStandardPeerRequestHandler } from '../../shared/server.CX4vUnDk.mjs';
-import { R as RPCHandlerCodec, S as StandardHandler } from '../../shared/server.GDpX6Df8.mjs';
+import { value, resolveMaybeOptionalOptions } from '@orpc/shared';
+import { ServerPeer, encodePeerMessage, decodePeerMessage, isClientPeerSendMessage, isPeerMessage } from '@standard-server/peer';
+import { createStandardPeerRequestHandler } from '../standard-peer/index.mjs';
+import { R as RPCHandlerCodec, S as StandardHandler } from '../../shared/server.C0lFtoHU.mjs';
+import '../../shared/server.W91HSRkE.mjs';
 import '@orpc/client';
-import '@standardserver/core';
-import '../../shared/server.CrlKQucM.mjs';
+import '@standard-server/core';
+import '../../shared/server.Djb_ebJT.mjs';
 import '@orpc/contract';
-import '../../shared/server.BwHnWUuN.mjs';
+import '../../shared/server.BynNaBBA.mjs';
 
 class MessagePortHandler {
   constructor(handler, options = {}) {
@@ -21,7 +22,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 +33,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,121 +1,44 @@
-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';
+export { R as BodyLimitPlugin } from '../../shared/server.C7xllBNN.mjs';
+import { MaybeOptionalOptions } from '@orpc/shared';
+import { SendStandardResponseOptions, NodeHttpRequest, NodeHttpResponse } from '@standard-server/node';
+import { Context } from '../../index.mjs';
+import { 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.Cj5lgPuG.mjs';
+import { Router } from '../../index.mjs';
+import { RPCHandlerCodecOptions } from '../standard/index.mjs';
 import '@orpc/client';
 import '@orpc/contract';
-import '@standardserver/core';
-
-interface NodeHttpHandlerPlugin<T extends Context> extends StandardHandlerPlugin<T> {
-    /**
-     * Initializes the plugin and returns new node HTTP handler options.
-     * Called once per plugin instance during composition.
-     *
-     * This method allows plugins to wrap, extend, or transform node HTTP handler options
-     * such as interceptors, or other configuration.
-     *
-     * @param options - The current handler options from previous plugins or base configuration
-     * @returns Transformed handler options with plugin's modifications applied
-     *
-     * @example
-     * ```ts
-     * initNodeHttpHandlerOptions(options) {
-     *   return {
-     *     ...options,
-     *     nodeHttpInterceptors: [...(options.nodeHttpInterceptors || []), myInterceptor]
-     *   }
-     * }
-     * ```
-     */
-    initNodeHttpHandlerOptions?(options: NodeHttpHandlerOptions<T>): NodeHttpHandlerOptions<T>;
-}
-declare class CompositeNodeHttpHandlerPlugin<T extends Context> implements NodeHttpHandlerPlugin<T> {
-    readonly name = "~composite/node-http-handler";
-    protected readonly plugins: NodeHttpHandlerPlugin<T>[];
-    constructor(plugins?: NodeHttpHandlerPlugin<T>[]);
-    initNodeHttpHandlerOptions(options: NodeHttpHandlerOptions<T>): NodeHttpHandlerOptions<T>;
-}
+import '@standard-server/core';
 
 type NodeHttpHandlerHandleResult = {
     matched: true;
 } | {
     matched: false;
 };
-interface NodeHttpHandlerNodeHttpInterceptorOptions<T extends Context> extends StandardHandlerHandleOptions<T> {
-    request: NodeHttpRequest;
-    response: NodeHttpResponse;
-    sendStandardResponseOptions: SendStandardResponseOptions | undefined;
-}
-type NodeHttpHandlerNodeHttpInterceptor<T extends Context> = Interceptor<NodeHttpHandlerNodeHttpInterceptorOptions<T>, Promise<NodeHttpHandlerHandleResult>>;
-interface NodeHttpHandlerOptions<T extends Context> {
+interface NodeHttpHandlerOptions<_T extends Context> {
     /**
      * Custom options for `sendStandardResponse`, used to send a `Standard Response`
      */
     sendStandardResponse?: SendStandardResponseOptions | undefined;
-    /**
-     * Interceptors that run before the mapping between the Standard API and Node HTTP API,
-     * useful for extending Node HTTP request/response before handling, ...
-     */
-    nodeHttpInterceptors?: NodeHttpHandlerNodeHttpInterceptor<T>[] | undefined;
-    plugins?: NodeHttpHandlerPlugin<T>[] | undefined;
 }
 declare class NodeHttpHandler<T extends Context> {
     private readonly standardHandler;
     private readonly sendStandardResponseOptions;
-    private readonly nodeHttpInterceptors;
     constructor(standardHandler: StandardHandler<T>, options?: NoInfer<NodeHttpHandlerOptions<T>>);
     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;
-    };
-}
+interface RPCHandlerOptions<T extends Context> extends NodeHttpHandlerOptions<T>, StandardHandlerOptions<T>, RPCHandlerCodecOptions<T> {
+}
+/**
+ * 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 { NodeHttpHandler, RPCHandler };
+export type { NodeHttpHandlerHandleResult, NodeHttpHandlerOptions, RPCHandlerOptions };