@orpc/server 2.0.0-beta.46 → 2.0.0-beta.48

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

@@ -0,0 +1,23 @@
+import type { MaybeOptionalOptions } from "@orpc/shared";
+import type { ToFetchResponseOptions } from "@standard-server/fetch";
+import type { Context } from "../../context.mjs";
+import type { FriendlyStandardHandlerHandleOptions, StandardHandler } from "../standard/index.mjs";
+export type FetchHandlerHandleResult = {
+	matched: true;
+	response: Response;
+} | {
+	matched: false;
+	response?: undefined;
+};
+export interface FetchHandlerOptions<_T extends Context> {
+	/**
+	* Options for how to convert the Fetch Response to a Standard Response, like event stream options, etc.
+	*/
+	toFetchResponse?: ToFetchResponseOptions | undefined;
+}
+export declare class FetchHandler<T extends Context> {
+	private readonly standardHandler;
+	private readonly toFetchResponseOptions;
+	constructor(standardHandler: StandardHandler<T>, options?: NoInfer<FetchHandlerOptions<T>>);
+	handle(request: Request, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): Promise<FetchHandlerHandleResult>;
+}

package/dist/adapters/fetch/handler.mjs

@@ -0,0 +1,22 @@
+import { resolveMaybeOptionalOptions } from "@orpc/shared";
+import { toFetchResponse, toStandardLazyRequest } from "@standard-server/fetch";
+import { resolveFriendlyStandardHandlerHandleOptions } from "../standard/index.mjs";
+export class FetchHandler {
+	standardHandler;
+	toFetchResponseOptions;
+	constructor(standardHandler, options = {}) {
+		this.standardHandler = standardHandler;
+		this.toFetchResponseOptions = options.toFetchResponse;
+	}
+	async handle(request, ...rest) {
+		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)
+		};
+	}
+}

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

@@ -1,47 +1,7 @@
-export { R as BodyLimitPlugin } from '../../shared/server.CTV_mC2P.mjs';
-import { MaybeOptionalOptions } from '@orpc/shared';
-import { ToFetchResponseOptions } from '@standard-server/fetch';
-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 '@standard-server/core';
-
-type FetchHandlerHandleResult = {
-    matched: true;
-    response: Response;
-} | {
-    matched: false;
-    response?: undefined;
-};
-interface FetchHandlerOptions<_T extends Context> {
-    /**
-     * Options for how to convert the Fetch Response to a Standard Response, like event stream options, etc.
-     */
-    toFetchResponse?: ToFetchResponseOptions | undefined;
-}
-declare class FetchHandler<T extends Context> {
-    private readonly standardHandler;
-    private readonly toFetchResponseOptions;
-    constructor(standardHandler: StandardHandler<T>, options?: NoInfer<FetchHandlerOptions<T>>);
-    handle(request: Request, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): Promise<FetchHandlerHandleResult>;
-}
-
-interface RPCHandlerOptions<T extends Context> extends FetchHandlerOptions<T>, StandardHandlerOptions<T>, RPCHandlerCodecOptions<T> {
-}
+export { 
 /**
- * Serves an oRPC router over the RPC protocol using the Fetch API
- * (Request/Response), supported by modern runtimes like Deno, Bun,
- * Cloudflare Workers, and browsers.
- *
- * @see {@link https://orpc.dev/docs/adapters/fetch-api | Fetch API Adapter}
- */
-declare class RPCHandler<T extends Context> extends FetchHandler<T> {
-    constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
-}
-
-export { FetchHandler, RPCHandler };
-export type { FetchHandlerHandleResult, FetchHandlerOptions, RPCHandlerOptions };
+* @deprecated Use `RequestLimitHandlerPlugin` from `@orpc/server/plugins` instead.
+*/
+ RequestLimitHandlerPlugin as BodyLimitPlugin } from "../../plugins/request-limit.mjs";
+export * from "./handler.mjs";
+export * from "./rpc-handler.mjs";

package/dist/adapters/fetch/index.mjs

@@ -1,42 +1,5 @@
-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 { R as RPCHandlerCodec, S as StandardHandler } from '../../shared/server.Chq5FpXf.mjs';
-import '@orpc/client';
-import '@standard-server/core';
-import '../../shared/server.BB464y-6.mjs';
-import '@orpc/contract';
-import '../../shared/server.CYbIpHbH.mjs';
+export { 
 
-class FetchHandler {
-  constructor(standardHandler, options = {}) {
-    this.standardHandler = standardHandler;
-    this.toFetchResponseOptions = options.toFetchResponse;
-  }
-  toFetchResponseOptions;
-  async handle(request, ...rest) {
-    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 = {}) {
-    const codec = new RPCHandlerCodec(router, options);
-    const handler = new StandardHandler(codec, options);
-    super(handler, options);
-  }
-}
-
-export { FetchHandler, RPCHandler };
+ RequestLimitHandlerPlugin as BodyLimitPlugin } from "../../plugins/request-limit.mjs";
+export * from "./handler.mjs";
+export * from "./rpc-handler.mjs";

package/dist/adapters/fetch/rpc-handler.d.mts

@@ -0,0 +1,16 @@
+import type { Context } from "../../context.mjs";
+import type { Router } from "../../router.mjs";
+import type { RPCHandlerCodecOptions, StandardHandlerOptions } from "../standard/index.mjs";
+import type { FetchHandlerOptions } from "./handler.mjs";
+import { FetchHandler } from "./handler.mjs";
+export interface RPCHandlerOptions<T extends Context> extends FetchHandlerOptions<T>, StandardHandlerOptions<T>, RPCHandlerCodecOptions<T> {}
+/**
+* Serves an oRPC router over the RPC protocol using the Fetch API
+* (Request/Response), supported by modern runtimes like Deno, Bun,
+* Cloudflare Workers, and browsers.
+*
+* @see {@link https://orpc.dev/docs/adapters/fetch-api | Fetch API Adapter}
+*/
+export declare class RPCHandler<T extends Context> extends FetchHandler<T> {
+	constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
+}

package/dist/adapters/fetch/rpc-handler.mjs

@@ -0,0 +1,10 @@
+import { RPCHandlerCodec, StandardHandler } from "../standard/index.mjs";
+import { FetchHandler } from "./handler.mjs";
+
+export class RPCHandler extends FetchHandler {
+	constructor(router, options = {}) {
+		const codec = new RPCHandlerCodec(router, options);
+		const handler = new StandardHandler(codec, options);
+		super(handler, options);
+	}
+}

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

@@ -0,0 +1,57 @@
+import type { SupportedMessagePort } from "@orpc/client/message-port";
+import type { MaybeOptionalOptions, Promisable, Value } from "@orpc/shared";
+import type { DecodePeerMessageOptions, EncodePeerMessageOptions } from "@standard-server/peer";
+import type { Context } from "../../context.mjs";
+import type { FriendlyStandardHandlerHandleOptions, StandardHandler } from "../standard/index.mjs";
+import { ServerPeer } from "@standard-server/peer";
+type DecodedResponseMessage = ConstructorParameters<typeof ServerPeer>[0] extends (message: infer TMessage) => unknown ? TMessage : never;
+export interface MessagePortHandlerOptions<_T extends Context> {
+	/**
+	* By default, oRPC encodes peer messages as strings or binary data before sending them over the message port.
+	* Use this option to bypass encoding and leverage the full capabilities of the
+	* [MessagePort: postMessage() method](https://developer.mozilla.org/en-US/docs/Web/API/MessagePort/postMessage),
+	* such as transferring object ownership or supporting non-serializable objects like `OffscreenCanvas` or improving performance.
+	*
+	* @remarks
+	* **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]> | undefined;
+	/**
+	* Options for encoding peer messages. such as `prefix` for distinguishing messages on the same channel..
+	*/
+	encodePeerMessage?: EncodePeerMessageOptions | undefined;
+	/**
+	* Options for decoding peer messages. such as `prefix` for distinguishing messages on the same channel..
+	*/
+	decodePeerMessage?: DecodePeerMessageOptions | undefined;
+}
+export declare class MessagePortHandler<T extends Context> {
+	private readonly handler;
+	private readonly peers;
+	private readonly transfer;
+	private readonly encodePeerMessageOptions;
+	private readonly decodePeerMessageOptions;
+	constructor(handler: StandardHandler<T>, options?: NoInfer<MessagePortHandlerOptions<T>>);
+	/**
+	* Attaches message and close listeners to a message port.
+	*
+	* Prefer this over calling `.message()` and `.close()` manually.
+	*/
+	upgrade(port: SupportedMessagePort, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): void;
+	/**
+	* Handles a single message received from a message port.
+	*
+	* @param port The message port instance. Use the same instance for all messages.
+	*/
+	message(port: SupportedMessagePort, data: unknown, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): Promise<{
+		matched: boolean;
+	}>;
+	/**
+	* Cleans up peer state for a closed message port.
+	*
+	* @param port The same message port instance passed to `.message()`.
+	*/
+	close(port: SupportedMessagePort): Promise<void>;
+}
+export {};

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

@@ -0,0 +1,62 @@
+import { onMessagePortClose, onMessagePortMessage, postMessagePortMessage } from "@orpc/client/message-port";
+import { resolveMaybeOptionalOptions, value } from "@orpc/shared";
+import { decodePeerMessage, encodePeerMessage, isClientPeerSendMessage, isPeerMessage, ServerPeer } from "@standard-server/peer";
+import { createStandardPeerRequestHandler } from "../standard-peer/index.mjs";
+export class MessagePortHandler {
+	handler;
+	peers = new WeakMap();
+	transfer;
+	encodePeerMessageOptions;
+	decodePeerMessageOptions;
+	constructor(handler, options = {}) {
+		this.handler = handler;
+		this.transfer = options.experimental_transfer;
+		this.encodePeerMessageOptions = options.encodePeerMessage;
+		this.decodePeerMessageOptions = options.decodePeerMessage;
+	}
+	
+	upgrade(port, ...rest) {
+		
+		onMessagePortMessage(port, (message) => this.message(port, message, ...rest));
+		onMessagePortClose(port, () => this.close(port));
+	}
+	
+	async message(port, data, ...rest) {
+		let peer = this.peers.get(port);
+		if (!peer) {
+			this.peers.set(port, peer = new ServerPeer(async (message) => {
+				const transfer = await value(this.transfer, message, port);
+				if (transfer) {
+					postMessagePortMessage(port, message, transfer);
+				} else {
+					postMessagePortMessage(port, await encodePeerMessage(message, this.encodePeerMessageOptions));
+				}
+			}));
+		}
+		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;
+		}
+		if (peerMessage === undefined) {
+			return { matched: false };
+		}
+		
+		await peer.message(peerMessage, createStandardPeerRequestHandler(this.handler, resolveMaybeOptionalOptions(rest)));
+		return { matched: true };
+	}
+	
+	async close(port) {
+		const peer = this.peers.get(port);
+		if (peer) {
+			
+			this.peers.delete(port);
+			await peer.close();
+		}
+	}
+}

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

@@ -1,77 +1,2 @@
-import { SupportedMessagePort } from '@orpc/client/message-port';
-import { Value, Promisable, MaybeOptionalOptions } from '@orpc/shared';
-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 '@standard-server/core';
-
-type DecodedResponseMessage = ConstructorParameters<typeof ServerPeer>[0] extends (message: infer TMessage) => unknown ? TMessage : never;
-interface MessagePortHandlerOptions<_T extends Context> {
-    /**
-     * By default, oRPC encodes peer messages as strings or binary data before sending them over the message port.
-     * Use this option to bypass encoding and leverage the full capabilities of the
-     * [MessagePort: postMessage() method](https://developer.mozilla.org/en-US/docs/Web/API/MessagePort/postMessage),
-     * such as transferring object ownership or supporting non-serializable objects like `OffscreenCanvas` or improving performance.
-     *
-     * @remarks
-     * **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]> | undefined;
-    /**
-     * Options for encoding peer messages. such as `prefix` for distinguishing messages on the same channel..
-     */
-    encodePeerMessage?: EncodePeerMessageOptions | undefined;
-    /**
-     * Options for decoding peer messages. such as `prefix` for distinguishing messages on the same channel..
-     */
-    decodePeerMessage?: DecodePeerMessageOptions | undefined;
-}
-declare class MessagePortHandler<T extends Context> {
-    private readonly handler;
-    private readonly peers;
-    private readonly transfer;
-    private readonly encodePeerMessageOptions;
-    private readonly decodePeerMessageOptions;
-    constructor(handler: StandardHandler<T>, options?: NoInfer<MessagePortHandlerOptions<T>>);
-    /**
-     * Attaches message and close listeners to a message port.
-     *
-     * Prefer this over calling `.message()` and `.close()` manually.
-     */
-    upgrade(port: SupportedMessagePort, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): void;
-    /**
-     * Handles a single message received from a message port.
-     *
-     * @param port The message port instance. Use the same instance for all messages.
-     */
-    message(port: SupportedMessagePort, data: unknown, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): Promise<{
-        matched: boolean;
-    }>;
-    /**
-     * Cleans up peer state for a closed message port.
-     *
-     * @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>>);
-}
-
-export { MessagePortHandler, RPCHandler };
-export type { MessagePortHandlerOptions, RPCHandlerOptions };
+export * from "./handler.mjs";
+export * from "./rpc-handler.mjs";

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

@@ -1,87 +1,2 @@
-import { onMessagePortMessage, onMessagePortClose, postMessagePortMessage } from '@orpc/client/message-port';
-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.Chq5FpXf.mjs';
-import '../../shared/server.W91HSRkE.mjs';
-import '@orpc/client';
-import '@standard-server/core';
-import '../../shared/server.BB464y-6.mjs';
-import '@orpc/contract';
-import '../../shared/server.CYbIpHbH.mjs';
-
-class MessagePortHandler {
-  constructor(handler, options = {}) {
-    this.handler = handler;
-    this.transfer = options.experimental_transfer;
-    this.encodePeerMessageOptions = options.encodePeerMessage;
-    this.decodePeerMessageOptions = options.decodePeerMessage;
-  }
-  peers = /* @__PURE__ */ new WeakMap();
-  transfer;
-  encodePeerMessageOptions;
-  decodePeerMessageOptions;
-  /**
-   * 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));
-    onMessagePortClose(port, () => this.close(port));
-  }
-  /**
-   * Handles a single message received from a message port.
-   *
-   * @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 (message) => {
-        const transfer = await value(this.transfer, message, port);
-        if (transfer) {
-          postMessagePortMessage(port, message, transfer);
-        } else {
-          postMessagePortMessage(port, await encodePeerMessage(message, this.encodePeerMessageOptions));
-        }
-      }));
-    }
-    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;
-    }
-    if (peerMessage === void 0) {
-      return { matched: false };
-    }
-    await peer.message(peerMessage, createStandardPeerRequestHandler(this.handler, resolveMaybeOptionalOptions(rest)));
-    return { matched: true };
-  }
-  /**
-   * Cleans up peer state for a closed message port.
-   *
-   * @param port The same message port instance passed to `.message()`.
-   */
-  async close(port) {
-    const peer = this.peers.get(port);
-    if (peer) {
-      this.peers.delete(port);
-      await peer.close();
-    }
-  }
-}
-
-class RPCHandler extends MessagePortHandler {
-  constructor(router, options = {}) {
-    const codec = new RPCHandlerCodec(router, options);
-    const handler = new StandardHandler(codec, options);
-    super(handler, options);
-  }
-}
-
-export { MessagePortHandler, RPCHandler };
+export * from "./handler.mjs";
+export * from "./rpc-handler.mjs";

package/dist/adapters/message-port/rpc-handler.d.mts

@@ -0,0 +1,15 @@
+import type { Context } from "../../context.mjs";
+import type { Router } from "../../router.mjs";
+import type { RPCHandlerCodecOptions, StandardHandlerOptions } from "../standard/index.mjs";
+import type { MessagePortHandlerOptions } from "./handler.mjs";
+import { MessagePortHandler } from "./handler.mjs";
+export 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}
+*/
+export declare class RPCHandler<T extends Context> extends MessagePortHandler<T> {
+	constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
+}

package/dist/adapters/message-port/rpc-handler.mjs

@@ -0,0 +1,10 @@
+import { RPCHandlerCodec, StandardHandler } from "../standard/index.mjs";
+import { MessagePortHandler } from "./handler.mjs";
+
+export class RPCHandler extends MessagePortHandler {
+	constructor(router, options = {}) {
+		const codec = new RPCHandlerCodec(router, options);
+		const handler = new StandardHandler(codec, options);
+		super(handler, options);
+	}
+}

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

@@ -0,0 +1,21 @@
+import type { MaybeOptionalOptions } from "@orpc/shared";
+import type { NodeHttpRequest, NodeHttpResponse, SendStandardResponseOptions } from "@standard-server/node";
+import type { Context } from "../../context.mjs";
+import type { FriendlyStandardHandlerHandleOptions, StandardHandler } from "../standard/index.mjs";
+export type NodeHttpHandlerHandleResult = {
+	matched: true;
+} | {
+	matched: false;
+};
+export interface NodeHttpHandlerOptions<_T extends Context> {
+	/**
+	* Custom options for `sendStandardResponse`, used to send a `Standard Response`
+	*/
+	sendStandardResponse?: SendStandardResponseOptions | undefined;
+}
+export declare class NodeHttpHandler<T extends Context> {
+	private readonly standardHandler;
+	private readonly sendStandardResponseOptions;
+	constructor(standardHandler: StandardHandler<T>, options?: NoInfer<NodeHttpHandlerOptions<T>>);
+	handle(request: NodeHttpRequest, response: NodeHttpResponse, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): Promise<NodeHttpHandlerHandleResult>;
+}

package/dist/adapters/node/handler.mjs

@@ -0,0 +1,20 @@
+import { resolveMaybeOptionalOptions } from "@orpc/shared";
+import { sendStandardResponse, toStandardLazyRequest } from "@standard-server/node";
+import { resolveFriendlyStandardHandlerHandleOptions } from "../standard/index.mjs";
+export class NodeHttpHandler {
+	standardHandler;
+	sendStandardResponseOptions;
+	constructor(standardHandler, options = {}) {
+		this.standardHandler = standardHandler;
+		this.sendStandardResponseOptions = options.sendStandardResponse;
+	}
+	async handle(request, response, ...rest) {
+		const standardRequest = toStandardLazyRequest(request, response);
+		const result = await this.standardHandler.handle(standardRequest, resolveFriendlyStandardHandlerHandleOptions(resolveMaybeOptionalOptions(rest)));
+		if (!result.matched) {
+			return result;
+		}
+		await sendStandardResponse(response, result.response, this.sendStandardResponseOptions);
+		return result;
+	}
+}

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

@@ -1,44 +1,7 @@
-export { R as BodyLimitPlugin } from '../../shared/server.CTV_mC2P.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 { Router } from '../../index.mjs';
-import { RPCHandlerCodecOptions } from '../standard/index.mjs';
-import '@orpc/client';
-import '@orpc/contract';
-import '@standard-server/core';
-
-type NodeHttpHandlerHandleResult = {
-    matched: true;
-} | {
-    matched: false;
-};
-interface NodeHttpHandlerOptions<_T extends Context> {
-    /**
-     * Custom options for `sendStandardResponse`, used to send a `Standard Response`
-     */
-    sendStandardResponse?: SendStandardResponseOptions | undefined;
-}
-declare class NodeHttpHandler<T extends Context> {
-    private readonly standardHandler;
-    private readonly sendStandardResponseOptions;
-    constructor(standardHandler: StandardHandler<T>, options?: NoInfer<NodeHttpHandlerOptions<T>>);
-    handle(request: NodeHttpRequest, response: NodeHttpResponse, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): Promise<NodeHttpHandlerHandleResult>;
-}
-
-interface RPCHandlerOptions<T extends Context> extends NodeHttpHandlerOptions<T>, StandardHandlerOptions<T>, RPCHandlerCodecOptions<T> {
-}
+export { 
 /**
- * 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 { NodeHttpHandler, RPCHandler };
-export type { NodeHttpHandlerHandleResult, NodeHttpHandlerOptions, RPCHandlerOptions };
+* @deprecated Use `RequestLimitHandlerPlugin` from `@orpc/server/plugins` instead.
+*/
+ RequestLimitHandlerPlugin as BodyLimitPlugin } from "../../plugins/request-limit.mjs";
+export * from "./handler.mjs";
+export * from "./rpc-handler.mjs";

package/dist/adapters/node/index.mjs

@@ -1,41 +1,5 @@
-export { R as BodyLimitPlugin } from '../../shared/server.1ExWFMze.mjs';
-import { resolveMaybeOptionalOptions } from '@orpc/shared';
-import { toStandardLazyRequest, sendStandardResponse } from '@standard-server/node';
-import { r as resolveFriendlyStandardHandlerHandleOptions } from '../../shared/server.W91HSRkE.mjs';
-import { R as RPCHandlerCodec, S as StandardHandler } from '../../shared/server.Chq5FpXf.mjs';
-import '@orpc/client';
-import '@standard-server/core';
-import '@standard-server/fetch';
-import '../../shared/server.BB464y-6.mjs';
-import '@orpc/contract';
-import '../../shared/server.CYbIpHbH.mjs';
+export { 
 
-class NodeHttpHandler {
-  constructor(standardHandler, options = {}) {
-    this.standardHandler = standardHandler;
-    this.sendStandardResponseOptions = options.sendStandardResponse;
-  }
-  sendStandardResponseOptions;
-  async handle(request, response, ...rest) {
-    const standardRequest = toStandardLazyRequest(request, response);
-    const result = await this.standardHandler.handle(
-      standardRequest,
-      resolveFriendlyStandardHandlerHandleOptions(resolveMaybeOptionalOptions(rest))
-    );
-    if (!result.matched) {
-      return result;
-    }
-    await sendStandardResponse(response, result.response, this.sendStandardResponseOptions);
-    return result;
-  }
-}
-
-class RPCHandler extends NodeHttpHandler {
-  constructor(router, options = {}) {
-    const codec = new RPCHandlerCodec(router, options);
-    const handler = new StandardHandler(codec, options);
-    super(handler, options);
-  }
-}
-
-export { NodeHttpHandler, RPCHandler };
+ RequestLimitHandlerPlugin as BodyLimitPlugin } from "../../plugins/request-limit.mjs";
+export * from "./handler.mjs";
+export * from "./rpc-handler.mjs";

package/dist/adapters/node/rpc-handler.d.mts

@@ -0,0 +1,15 @@
+import type { Context } from "../../context.mjs";
+import type { Router } from "../../router.mjs";
+import type { RPCHandlerCodecOptions, StandardHandlerOptions } from "../standard/index.mjs";
+import type { NodeHttpHandlerOptions } from "./handler.mjs";
+import { NodeHttpHandler } from "./handler.mjs";
+export 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}
+*/
+export declare class RPCHandler<T extends Context> extends NodeHttpHandler<T> {
+	constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
+}