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

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

@@ -1,16 +0,0 @@
-export * from "./handler.mjs";
-export * from "./rpc-handler.mjs";
-export type { AnyAPIGatewayProxyEvent, APIGatewayProxyEvent, 
-/**
-* AWS API Gateway proxy event, payload format 2.0, also used by Lambda Function URLs.
-*
-* @see {@link https://orpc.dev/docs/adapters/aws-lambda | AWS Lambda Adapter}
-*/
- APIGatewayProxyEventV2, 
-/**
-* Shape of the `awslambda` global the Lambda Node.js runtime injects when response streaming is enabled.
-* Declare it yourself: `declare const awslambda: AwsLambdaGlobal`.
-*
-* @see {@link https://orpc.dev/docs/adapters/aws-lambda | AWS Lambda Adapter}
-*/
- AwsLambdaGlobal, HttpResponseStream } from "@standard-server/aws-lambda";

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

@@ -1,2 +0,0 @@
-export * from "./handler.mjs";
-export * from "./rpc-handler.mjs";

package/dist/adapters/aws-lambda/rpc-handler.d.mts

@@ -1,18 +0,0 @@
-import type { Context } from "../../context.mjs";
-import type { Router } from "../../router.mjs";
-import type { RPCHandlerCodecOptions, StandardHandlerOptions } from "../standard/index.mjs";
-import type { AwsLambdaHandlerOptions } from "./handler.mjs";
-import { AwsLambdaHandler } from "./handler.mjs";
-export interface RPCHandlerOptions<T extends Context> extends AwsLambdaHandlerOptions<T>, StandardHandlerOptions<T>, RPCHandlerCodecOptions<T> {}
-/**
-* Serves an oRPC router over the RPC protocol on AWS Lambda,
-* behind API Gateway or Lambda Function URLs.
-*
-* @remarks
-* **Warning**: Requires the Lambda Node.js runtime with response streaming enabled, so handlers must be wrapped with `awslambda.streamifyResponse`.
-*
-* @see {@link https://orpc.dev/docs/adapters/aws-lambda | AWS Lambda Adapter}
-*/
-export declare class RPCHandler<T extends Context> extends AwsLambdaHandler<T> {
-	constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
-}

package/dist/adapters/aws-lambda/rpc-handler.mjs

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

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

@@ -1,41 +0,0 @@
-import type { MaybeOptionalOptions } from "@orpc/shared";
-import type { DecodePeerMessageOptions, EncodePeerMessageOptions } from "@standard-server/peer";
-import type { Message, Peer } from "crossws";
-import type { Context } from "../../context.mjs";
-import type { FriendlyStandardHandlerHandleOptions, StandardHandler } from "../standard/index.mjs";
-export type CrosswsPeerLike = Pick<Peer, "send">;
-export type CrosswsMessageLike = Pick<Message, "rawData" | "uint8Array">;
-export interface experimental_CrosswsHandlerOptions<_T extends Context> {
-	/**
-	* 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 experimental_CrosswsHandler<T extends Context> {
-	private readonly handler;
-	private readonly peers;
-	private readonly encodePeerMessageOptions;
-	private readonly decodePeerMessageOptions;
-	constructor(handler: StandardHandler<T>, options?: NoInfer<experimental_CrosswsHandlerOptions<T>>);
-	/**
-	* Handles a single WebSocket message.
-	*
-	* Message order matters. Call this immediately after receiving a message,
-	* before any other async work, to preserve ordering.
-	*
-	* @param ws The crossws peer instance. Use the same instance for all messages.
-	*/
-	message(ws: CrosswsPeerLike, message: CrosswsMessageLike, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): Promise<{
-		matched: boolean;
-	}>;
-	/**
-	* Cleans up peer state for a closed WebSocket.
-	*
-	* @param ws The same crossws peer instance passed to `.message()`.
-	*/
-	close(ws: CrosswsPeerLike): Promise<void>;
-}

package/dist/adapters/crossws/handler.mjs

@@ -1,38 +0,0 @@
-import { resolveMaybeOptionalOptions } from "@orpc/shared";
-import { decodePeerMessage, encodePeerMessage, isClientPeerSendMessage, ServerPeer } from "@standard-server/peer";
-import { createStandardPeerRequestHandler } from "../standard-peer/index.mjs";
-export class experimental_CrosswsHandler {
-	handler;
-	peers = new WeakMap();
-	encodePeerMessageOptions;
-	decodePeerMessageOptions;
-	constructor(handler, options = {}) {
-		this.handler = handler;
-		this.encodePeerMessageOptions = options.encodePeerMessage;
-		this.decodePeerMessageOptions = options.decodePeerMessage;
-	}
-	
-	async message(ws, message, ...rest) {
-		let peer = this.peers.get(ws);
-		if (!peer) {
-			this.peers.set(ws, peer = new ServerPeer(async (message) => {
-				ws.send(await encodePeerMessage(message, this.encodePeerMessageOptions));
-			}));
-		}
-		
-		const encodedMessage = typeof message.rawData === "string" ? message.rawData : message.uint8Array();
-		const result = decodePeerMessage(encodedMessage, this.decodePeerMessageOptions);
-		if (result.matched && isClientPeerSendMessage(result.message)) {
-			await peer.message(result.message, createStandardPeerRequestHandler(this.handler, resolveMaybeOptionalOptions(rest)));
-		}
-		return result;
-	}
-	
-	async close(ws) {
-		const server = this.peers.get(ws);
-		if (server) {
-			await server.close();
-			this.peers.delete(ws);
-		}
-	}
-}

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

@@ -1,2 +0,0 @@
-export * from "./handler.mjs";
-export * from "./rpc-handler.mjs";

package/dist/adapters/crossws/index.mjs

@@ -1,2 +0,0 @@
-export * from "./handler.mjs";
-export * from "./rpc-handler.mjs";

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

@@ -1,15 +0,0 @@
-import type { Context } from "../../context.mjs";
-import type { Router } from "../../router.mjs";
-import type { RPCHandlerCodecOptions, StandardHandlerOptions } from "../standard/index.mjs";
-import type { experimental_CrosswsHandlerOptions as CrosswsHandlerOptions } from "./handler.mjs";
-import { experimental_CrosswsHandler as CrosswsHandler } from "./handler.mjs";
-export interface experimental_RPCHandlerOptions<T extends Context> extends StandardHandlerOptions<T>, RPCHandlerCodecOptions<T>, CrosswsHandlerOptions<T> {}
-/**
-* Serves an oRPC router over the RPC protocol on a WebSocket connection
-* managed by [crossws](https://github.com/h3js/crossws).
-*
-* @see {@link https://orpc.dev/docs/adapters/websocket | WebSocket Adapters}
-*/
-export declare class experimental_RPCHandler<T extends Context> extends CrosswsHandler<T> {
-	constructor(router: Router<T>, options?: NoInfer<experimental_RPCHandlerOptions<T>>);
-}

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

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

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

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

package/dist/adapters/fastify/handler.mjs

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

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

@@ -1,2 +0,0 @@
-export * from "./handler.mjs";
-export * from "./rpc-handler.mjs";

package/dist/adapters/fastify/index.mjs

@@ -1,2 +0,0 @@
-export * from "./handler.mjs";
-export * from "./rpc-handler.mjs";

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

@@ -1,14 +0,0 @@
-import type { Context } from "../../context.mjs";
-import type { Router } from "../../router.mjs";
-import type { RPCHandlerCodecOptions, StandardHandlerOptions } from "../standard/index.mjs";
-import type { FastifyHandlerOptions } from "./handler.mjs";
-import { FastifyHandler } from "./handler.mjs";
-export interface RPCHandlerOptions<T extends Context> extends FastifyHandlerOptions<T>, StandardHandlerOptions<T>, RPCHandlerCodecOptions<T> {}
-/**
-* Serves an oRPC router over the RPC protocol inside a Fastify server.
-*
-* @see {@link https://orpc.dev/docs/adapters/fastify | Fastify Adapter}
-*/
-export declare class RPCHandler<T extends Context> extends FastifyHandler<T> {
-	constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
-}

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

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

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

@@ -1,23 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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,7 +0,0 @@
-export { 
-/**
-* @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,5 +0,0 @@
-export { 
-
- 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

@@ -1,16 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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

@@ -1,62 +0,0 @@
-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,2 +0,0 @@
-export * from "./handler.mjs";
-export * from "./rpc-handler.mjs";

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

@@ -1,2 +0,0 @@
-export * from "./handler.mjs";
-export * from "./rpc-handler.mjs";

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

@@ -1,15 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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,7 +0,0 @@
-export { 
-/**
-* @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,5 +0,0 @@
-export { 
-
- 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

@@ -1,15 +0,0 @@
-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>>);
-}

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

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

package/dist/adapters/standard/codec.d.mts

@@ -1,16 +0,0 @@
-import type { AnyORPCError } from "@orpc/client";
-import type { Promisable } from "@orpc/shared";
-import type { StandardLazyRequest, StandardResponse } from "@standard-server/core";
-import type { Context } from "../../context.mjs";
-import type { AnyProcedure } from "../../procedure.mjs";
-import type { ResolvedStandardHandlerHandleOptions } from "./handler.mjs";
-export interface StandardHandlerCodecResolvedProcedure {
-	path: string[];
-	procedure: AnyProcedure;
-	decodeInput: () => Promise<unknown>;
-}
-export interface StandardHandlerCodec<T extends Context> {
-	resolveProcedure(request: StandardLazyRequest, options: ResolvedStandardHandlerHandleOptions<T>): Promisable<StandardHandlerCodecResolvedProcedure | undefined>;
-	encodeOutput(output: unknown, procedure: AnyProcedure, path: string[], options: ResolvedStandardHandlerHandleOptions<T>): Promisable<StandardResponse>;
-	encodeError(error: AnyORPCError, procedure: AnyProcedure, path: string[], options: ResolvedStandardHandlerHandleOptions<T>): Promisable<StandardResponse>;
-}