@orpc/server 2.0.0-beta.5 → 2.0.0-beta.50

package/dist/adapters/standard/plugin.d.ts

@@ -0,0 +1,26 @@
+import { Context } from "../../context.js";
+import { StandardHandlerOptions } from "./handler.js";
+import { OrderablePlugin } from "@orpc/shared";
+export interface StandardHandlerPlugin<T extends Context> extends OrderablePlugin {
+  /**
+   * Initializes the plugin and returns new handler options.
+   * Called once per plugin instance during composition.
+   *
+   * This method allows plugins to wrap, extend, or transform handler options
+   * such as interceptors, or configuration.
+   *
+   * @param options - The current handler options from previous plugins or base configuration
+   * @returns Transformed handler options with plugin's modifications applied
+   *
+   * @example
+   * ```ts
+   * init(options) {
+   *   return {
+   *     ...options,
+   *     interceptors: [...(options.interceptors || []), myInterceptor]
+   *   }
+   * }
+   * ```
+   */
+  init?(options: StandardHandlerOptions<T>): StandardHandlerOptions<T>;
+}

package/dist/adapters/standard/plugin.js

@@ -0,0 +1,14 @@
+import { sortPlugins } from "@orpc/shared";
+// src/adapters/standard/plugin.ts
+var CompositeStandardHandlerPlugin = class {
+	name = "~composite";
+	plugins;
+	constructor(plugins = []) {
+		this.plugins = sortPlugins(plugins);
+	}
+	init(options) {
+		for (const plugin of this.plugins) if (plugin.init) options = plugin.init(options);
+		return options;
+	}
+};
+export { CompositeStandardHandlerPlugin };

package/dist/adapters/standard/rpc-handler-codec.d.ts

@@ -0,0 +1,42 @@
+import { Context } from "../../context.js";
+import { AnyProcedure } from "../../procedure.js";
+import { ResolvedStandardHandlerHandleOptions } from "./handler.js";
+import { StandardHandlerCodec, StandardHandlerCodecResolvedProcedure } from "./codec.js";
+import { AnyRouter } from "../../router.js";
+import "./index.js";
+import { RPCMatcherOptions } from "./rpc-matcher.js";
+import { Promisable, Public, Value } from "@orpc/shared";
+import { AnyORPCError, RPCSerializer } from "@orpc/client";
+import { StandardLazyRequest, StandardResponse } from "@standard-server/core";
+export interface RPCHandlerCodecOptions<T extends Context> extends RPCMatcherOptions {
+  /**
+   * Override the default RPC serializer.
+   */
+  serializer?: Public<RPCSerializer> | undefined;
+  /**
+   * Resolve HTTP status for encoded successful outputs.
+   *
+   * Value should be in the `2xx` range and must be less than `400`.
+   *
+   * @default DEFAULT_SUCCESS_STATUS (200)
+   */
+  outputStatus?: Value<number, [output: unknown, procedure: AnyProcedure, path: string[], options: ResolvedStandardHandlerHandleOptions<T>]> | undefined;
+  /**
+   * Mapping ORPCError Code -> HTTP Status Code
+   * The status code should be in the `4xx` or `5xx` range (must be greater than or equal to `400`).
+   * Codes missing from the map fall back to `DEFAULT_ERROR_STATUS` (400).
+   *
+   * @default COMMON_ERROR_STATUS_MAP
+   */
+  errorStatusMap?: Record<string, number> | undefined;
+}
+export declare class RPCHandlerCodec<T extends Context> implements StandardHandlerCodec<T> {
+  private readonly matcher;
+  private readonly serializer;
+  private readonly errorStatusMap;
+  private readonly outputStatus;
+  constructor(router: AnyRouter, options?: RPCHandlerCodecOptions<T>);
+  resolveProcedure(request: StandardLazyRequest, options: ResolvedStandardHandlerHandleOptions<T>): Promise<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>;
+}

package/dist/adapters/standard/rpc-handler-codec.js

@@ -0,0 +1,50 @@
+import "../../constants.js";
+import { RPCMatcher } from "./rpc-matcher.js";
+import { getOwn, parseEmptyableJSON, value } from "@orpc/shared";
+import { COMMON_ERROR_STATUS_MAP, RPCSerializer } from "@orpc/client";
+import { parseStandardUrl } from "@standard-server/core";
+// src/adapters/standard/rpc-handler-codec.ts
+var RPCHandlerCodec = class {
+	matcher;
+	serializer;
+	errorStatusMap;
+	outputStatus;
+	constructor(router, options = {}) {
+		this.matcher = new RPCMatcher(router, options);
+		this.serializer = options.serializer ?? new RPCSerializer();
+		this.errorStatusMap = options.errorStatusMap ?? COMMON_ERROR_STATUS_MAP;
+		this.outputStatus = options.outputStatus ?? 200;
+	}
+	async resolveProcedure(request, options) {
+		const [pathname, query] = parseStandardUrl(request.url);
+		const matched = await this.matcher.match(request.method, pathname, options.prefix);
+		if (!matched) return;
+		return {
+			procedure: matched.procedure,
+			path: matched.path,
+			decodeInput: async () => {
+				if (request.method === "GET") {
+					const dataString = new URLSearchParams(query).getAll("data").at(-1);
+					return this.serializer.deserialize(parseEmptyableJSON(dataString));
+				}
+				const body = await request.resolveBody();
+				return this.serializer.deserialize(body);
+			}
+		};
+	}
+	encodeOutput(output, procedure, path, options) {
+		return {
+			headers: {},
+			status: value(this.outputStatus, output, procedure, path, options),
+			body: this.serializer.serialize(output)
+		};
+	}
+	encodeError(error, _procedure, _path, _options) {
+		return {
+			headers: {},
+			status: getOwn(this.errorStatusMap, error.code) ?? 400,
+			body: this.serializer.serialize(error.toJSON())
+		};
+	}
+};
+export { RPCHandlerCodec };

package/dist/adapters/standard/rpc-matcher.d.ts

@@ -0,0 +1,53 @@
+import { AnyProcedure } from "../../procedure.js";
+import { AnyRouter } from "../../router.js";
+import { AnyProcedureContract } from "@orpc/contract";
+import { Value } from "@orpc/shared";
+import { StandardMethod } from "@standard-server/core";
+/**
+ * Methods that can invoke procedures by default. Browsers cannot trigger them
+ * cross-site without a CORS preflight or an HTML form, unlike `GET`, which a plain
+ * `<a>` click or redirect can trigger with `SameSite=Lax` cookies attached. Other
+ * methods (`HEAD`, `OPTIONS`, `QUERY`, ...) have safe semantics that should not
+ * invoke a procedure that can modify data.
+ *
+ * @see {@link https://orpc.dev/docs/rpc/handler#supported-http-methods | RPC Handler - Supported HTTP Methods}
+ */
+export declare const RPC_DEFAULT_ALLOW_METHODS: readonly StandardMethod[];
+export interface RPCMatcherOptions {
+  /**
+   * Filter which procedures are exposed for matching. Return `false` to exclude.
+   *
+   * @default true
+   */
+  filter?: Value<boolean, [procedure: AnyProcedureContract | AnyProcedure, path: string[]]> | undefined;
+  /**
+   * Restricts which HTTP methods can invoke procedures, either with a list of allowed
+   * methods or decided per request via a function. Requests using a disallowed method
+   * are treated as unmatched. `GET` is excluded by default because it is exposed to
+   * Cross-Site Request Forgery (CSRF) attacks.
+   *
+   * @default RPC_DEFAULT_ALLOW_METHODS (['POST', 'PUT', 'PATCH', 'DELETE'])
+   * @see {@link https://orpc.dev/docs/rpc/handler#supported-http-methods | RPC Handler - Supported HTTP Methods}
+   */
+  allowMethods?: readonly StandardMethod[] | ((method: StandardMethod, procedure: AnyProcedure, path: string[]) => boolean) | undefined;
+}
+export declare class RPCMatcher {
+  private readonly filter;
+  private readonly allowMethodsSet;
+  private readonly allowMethodsFn;
+  private readonly rootRouter;
+  private readonly tree;
+  private readonly pendingLazyRouters;
+  /** segment count of the deepest pending key, never lowered so it stays an upper bound */
+  private maxPendingLazyRouterDepth;
+  constructor(router: AnyRouter, options?: RPCMatcherOptions);
+  private index;
+  match(method: StandardMethod, pathname: `/${string}`, prefix: `/${string}` | undefined): Promise<{
+    path: string[];
+    procedure: AnyProcedure;
+  } | undefined>;
+  private resolvePendingLazyRouters;
+  private loadPendingLazyRouter;
+  private indexPendingLazyRouter;
+  private resolveProcedure;
+}

package/dist/adapters/standard/rpc-matcher.js

@@ -0,0 +1,106 @@
+import { unlazy } from "../../lazy.js";
+import { Procedure } from "../../procedure.js";
+import { resolveContractProcedure, walkProcedureContractsSync } from "../../router-utils.js";
+import { normalizeHttpPath, pathToHttpPath, stripHttpPathPrefix, value } from "@orpc/shared";
+// src/adapters/standard/rpc-matcher.ts
+/**
+* Methods that can invoke procedures by default. Browsers cannot trigger them
+* cross-site without a CORS preflight or an HTML form, unlike `GET`, which a plain
+* `<a>` click or redirect can trigger with `SameSite=Lax` cookies attached. Other
+* methods (`HEAD`, `OPTIONS`, `QUERY`, ...) have safe semantics that should not
+* invoke a procedure that can modify data.
+*
+* @see {@link https://orpc.dev/docs/rpc/handler#supported-http-methods | RPC Handler - Supported HTTP Methods}
+*/
+const RPC_DEFAULT_ALLOW_METHODS = [
+	"POST",
+	"PUT",
+	"PATCH",
+	"DELETE"
+];
+const NORMALIZABLE_PATHNAME_REGEX = /[^\w\-.!~*'()/]/;
+var RPCMatcher = class {
+	filter;
+	allowMethodsSet;
+	allowMethodsFn;
+	rootRouter;
+	tree = /* @__PURE__ */ new Map();
+	pendingLazyRouters = /* @__PURE__ */ new Map();
+	/** segment count of the deepest pending key, never lowered so it stays an upper bound */
+	maxPendingLazyRouterDepth = 0;
+	constructor(router, options = {}) {
+		this.filter = options.filter ?? true;
+		const allowMethods = options.allowMethods ?? RPC_DEFAULT_ALLOW_METHODS;
+		if (typeof allowMethods !== "function") this.allowMethodsSet = new Set(allowMethods);
+		else this.allowMethodsFn = allowMethods;
+		this.rootRouter = router;
+		this.index(router);
+	}
+	index(router, path = []) {
+		const lazyResults = walkProcedureContractsSync(router, (procedure, procedurePath) => {
+			if (!value(this.filter, procedure, procedurePath)) return;
+			this.tree.set(pathToHttpPath(procedurePath), {
+				path: procedurePath,
+				contract: procedure,
+				procedure: procedure instanceof Procedure ? procedure : void 0
+			});
+		}, path);
+		for (const result of lazyResults) {
+			this.pendingLazyRouters.set(pathToHttpPath(result.path), result);
+			this.maxPendingLazyRouterDepth = Math.max(this.maxPendingLazyRouterDepth, result.path.length);
+		}
+	}
+	async match(method, pathname, prefix) {
+		if (this.allowMethodsSet && !this.allowMethodsSet.has(method)) return;
+		if (prefix) {
+			const stripped = stripHttpPathPrefix(pathname, prefix);
+			if (stripped === void 0) return;
+			pathname = stripped;
+		}
+		if (pathname.length > 1 && pathname.endsWith("/")) pathname = pathname.slice(0, -1);
+		const loading = this.resolvePendingLazyRouters(pathname);
+		if (loading !== void 0) await loading;
+		let entry = this.tree.get(pathname);
+		if (entry === void 0 && NORMALIZABLE_PATHNAME_REGEX.test(pathname)) {
+			const normalizedPathname = normalizeHttpPath(pathname);
+			const normalizedLoading = this.resolvePendingLazyRouters(normalizedPathname);
+			if (normalizedLoading !== void 0) await normalizedLoading;
+			entry = this.tree.get(normalizedPathname);
+		}
+		if (entry === void 0) return;
+		const procedure = entry.procedure ?? await this.resolveProcedure(entry);
+		if (this.allowMethodsFn && !this.allowMethodsFn(method, procedure, entry.path)) return;
+		return {
+			path: entry.path,
+			procedure
+		};
+	}
+	resolvePendingLazyRouters(pathname) {
+		if (this.pendingLazyRouters.size === 0) return;
+		let slashIndex = 0;
+		for (let depth = 1; slashIndex !== -1 && depth <= this.maxPendingLazyRouterDepth; depth++) {
+			const nextSlashIndex = pathname.indexOf("/", slashIndex + 1);
+			const httpPathPrefix = nextSlashIndex === -1 ? pathname : pathname.slice(0, nextSlashIndex);
+			const pending = this.pendingLazyRouters.get(httpPathPrefix);
+			if (pending !== void 0) return this.loadPendingLazyRouter(httpPathPrefix, pending).then(() => this.resolvePendingLazyRouters(pathname));
+			slashIndex = nextSlashIndex;
+		}
+	}
+	loadPendingLazyRouter(httpPathPrefix, pending) {
+		if (pending.loading === void 0) pending.loading = this.indexPendingLazyRouter(httpPathPrefix, pending).catch((error) => {
+			pending.loading = void 0;
+			throw error;
+		});
+		return pending.loading;
+	}
+	async indexPendingLazyRouter(httpPathPrefix, pending) {
+		const { default: router } = await unlazy(pending.router);
+		this.index(router, pending.path);
+		this.pendingLazyRouters.delete(httpPathPrefix);
+	}
+	async resolveProcedure(entry) {
+		entry.procedure = await resolveContractProcedure(this.rootRouter, entry.contract, entry.path);
+		return entry.procedure;
+	}
+};
+export { RPCMatcher, RPC_DEFAULT_ALLOW_METHODS };

package/dist/adapters/standard/utils.d.ts

@@ -0,0 +1,10 @@
+import { Context } from "../../context.js";
+import { StandardHandlerHandleOptions } from "./handler.js";
+import { Promisable, Value } from "@orpc/shared";
+import { StandardLazyRequest } from "@standard-server/core";
+export type FriendlyStandardHandlerHandleOptions<T extends Context> = Omit<StandardHandlerHandleOptions<T>, "context"> & (object extends T ? {
+  context?: Value<Promisable<T>, [request: StandardLazyRequest]> | undefined;
+} : {
+  context: Value<Promisable<T>, [request: StandardLazyRequest]>;
+});
+export declare function resolveFriendlyStandardHandlerHandleOptions<T extends Context>(options: FriendlyStandardHandlerHandleOptions<T>): StandardHandlerHandleOptions<T>;

package/dist/adapters/standard/utils.js

@@ -0,0 +1,8 @@
+// src/adapters/standard/utils.ts
+function resolveFriendlyStandardHandlerHandleOptions(options) {
+	return {
+		...options,
+		context: options.context ?? {}
+	};
+}
+export { resolveFriendlyStandardHandlerHandleOptions };

package/dist/adapters/standard-peer/index.d.ts

@@ -1,16 +1,2 @@
-import { Value, Promisable } from '@orpc/shared';
-import { StandardLazyRequest, StandardResponse } from '@standardserver/core';
-import { C as Context } from '../../shared/server.BL22TloH.js';
-import { b as StandardHandlerHandleOptions, S as StandardHandler } from '../../shared/server.DBANIheG.js';
-import '@orpc/client';
-import '@orpc/contract';
-
-type StandardPeerRequestHandlerOptions<T extends Context> = Omit<StandardHandlerHandleOptions<T>, 'context'> & (Record<never, never> extends T ? {
-    context?: Value<Promisable<T>, [request: StandardLazyRequest]>;
-} : {
-    context: Value<Promisable<T>, [request: StandardLazyRequest]>;
-});
-declare function createStandardPeerRequestHandler<T extends Context>(handler: StandardHandler<T>, options: StandardPeerRequestHandlerOptions<T>): (request: StandardLazyRequest) => Promise<StandardResponse>;
-
-export { createStandardPeerRequestHandler };
-export type { StandardPeerRequestHandlerOptions };
+import { createStandardPeerRequestHandler } from "./utils.js";
+export { createStandardPeerRequestHandler };

package/dist/adapters/standard-peer/index.js

@@ -0,0 +1 @@
+export { createStandardPeerRequestHandler } from "./utils.js";

package/dist/adapters/standard-peer/utils.d.ts

@@ -0,0 +1,6 @@
+import { Context } from "../../context.js";
+import { StandardHandler } from "../standard/handler.js";
+import { FriendlyStandardHandlerHandleOptions } from "../standard/utils.js";
+import "../standard/index.js";
+import { StandardLazyRequest, StandardResponse } from "@standard-server/core";
+export declare function createStandardPeerRequestHandler<T extends Context>(handler: StandardHandler<T>, options: FriendlyStandardHandlerHandleOptions<T>): (request: StandardLazyRequest) => Promise<StandardResponse>;

package/dist/adapters/standard-peer/utils.js

@@ -0,0 +1,13 @@
+import { resolveFriendlyStandardHandlerHandleOptions } from "../standard/utils.js";
+// src/adapters/standard-peer/utils.ts
+function createStandardPeerRequestHandler(handler, options) {
+	return async (request) => {
+		const { response } = await handler.handle(request, resolveFriendlyStandardHandlerHandleOptions(options));
+		return response ?? {
+			status: 404,
+			headers: {},
+			body: "No procedure matched"
+		};
+	};
+}
+export { createStandardPeerRequestHandler };

package/dist/adapters/websocket/handler.d.ts

@@ -0,0 +1,61 @@
+import { Context } from "../../context.js";
+import { StandardHandler } from "../standard/handler.js";
+import { FriendlyStandardHandlerHandleOptions } from "../standard/utils.js";
+import "../standard/index.js";
+import { Arrayable, MaybeOptionalOptions } from "@orpc/shared";
+import { DecodePeerMessageOptions, EncodePeerMessageOptions } from "@standard-server/peer";
+/**
+ * Supports standard WebSocket instances, Bun ServerWebSocket, "ws" ServerWebSocket,
+ * Cloudflare WebSocket Hibernation, and similar implementations.
+ */
+export type WebSocketLike = {
+  send: (data: string | Uint8Array<ArrayBuffer>) => unknown;
+};
+export interface WebSocketHandlerOptions<_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 WebSocketHandler<T extends Context> {
+  private readonly handler;
+  /**
+   * `null` marks a closed socket, so late messages never create a new peer.
+   */
+  private readonly peers;
+  private readonly encodePeerMessageOptions;
+  private readonly decodePeerMessageOptions;
+  constructor(handler: StandardHandler<T>, options?: NoInfer<WebSocketHandlerOptions<T>>);
+  /**
+   * Handles a single WebSocket message.
+   *
+   * Message order matters. Call this immediately after receiving a message,
+   * before any other async work, to preserve ordering.
+   *
+   * To avoid async Blob reads, configure `ws.binaryType` to return binary data
+   * directly (for example, `arraybuffer`).
+   *
+   * @param ws The WebSocket instance. Use the same instance for all messages.
+   * @param data The received message. Binary data should already be loaded (not a `Blob`).
+   */
+  message(ws: WebSocketLike, data: Arrayable<string | ArrayBuffer | Pick<Uint8Array<ArrayBuffer>, "buffer" | "byteOffset" | "byteLength">>, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): Promise<{
+    matched: boolean;
+  }>;
+  /**
+   * Cleans up peer state for a closed WebSocket.
+   * Messages passed to `.message()` for this WebSocket afterwards are ignored.
+   *
+   * @param ws The same WebSocket instance passed to `.message()`.
+   */
+  close(ws: WebSocketLike): Promise<void>;
+  /**
+   * Attaches message, close, and error event listeners to a WebSocket.
+   *
+   * Prefer this over calling `.message()` and `.close()` manually.
+   */
+  upgrade(ws: Pick<WebSocket, "send" | "addEventListener" | "removeEventListener">, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): void;
+}

package/dist/adapters/websocket/handler.js

@@ -0,0 +1,75 @@
+import { createStandardPeerRequestHandler } from "../standard-peer/utils.js";
+import { loadBytes, resolveMaybeOptionalOptions, sequential, toStringOrBytes } from "@orpc/shared";
+import { ServerPeer, decodePeerMessage, encodePeerMessage, isClientPeerSendMessage } from "@standard-server/peer";
+// src/adapters/websocket/handler.ts
+var WebSocketHandler = class {
+	handler;
+	/**
+	* `null` marks a closed socket, so late messages never create a new peer.
+	*/
+	peers = /* @__PURE__ */ new WeakMap();
+	encodePeerMessageOptions;
+	decodePeerMessageOptions;
+	constructor(handler, options = {}) {
+		this.handler = handler;
+		this.encodePeerMessageOptions = options.encodePeerMessage;
+		this.decodePeerMessageOptions = options.decodePeerMessage;
+	}
+	/**
+	* Handles a single WebSocket message.
+	*
+	* Message order matters. Call this immediately after receiving a message,
+	* before any other async work, to preserve ordering.
+	*
+	* To avoid async Blob reads, configure `ws.binaryType` to return binary data
+	* directly (for example, `arraybuffer`).
+	*
+	* @param ws The WebSocket instance. Use the same instance for all messages.
+	* @param data The received message. Binary data should already be loaded (not a `Blob`).
+	*/
+	async message(ws, data, ...rest) {
+		/**
+		* Message order is important: loading -> decode -> .message.
+		* This flow must stay synchronous, or we need to use `sequential` helper
+		*/
+		const encoded = toStringOrBytes(data);
+		const result = decodePeerMessage(encoded, this.decodePeerMessageOptions);
+		let peer = this.peers.get(ws);
+		if (peer === null) return result;
+		if (!peer) this.peers.set(ws, peer = new ServerPeer(async (message) => {
+			const encoded = await encodePeerMessage(message, this.encodePeerMessageOptions);
+			await ws.send(encoded);
+		}));
+		if (result.matched && isClientPeerSendMessage(result.message)) await peer.message(result.message, createStandardPeerRequestHandler(this.handler, resolveMaybeOptionalOptions(rest)));
+		return result;
+	}
+	/**
+	* Cleans up peer state for a closed WebSocket.
+	* Messages passed to `.message()` for this WebSocket afterwards are ignored.
+	*
+	* @param ws The same WebSocket instance passed to `.message()`.
+	*/
+	async close(ws) {
+		const peer = this.peers.get(ws);
+		this.peers.set(ws, null);
+		await peer?.close();
+	}
+	/**
+	* Attaches message, close, and error event listeners to a WebSocket.
+	*
+	* Prefer this over calling `.message()` and `.close()` manually.
+	*/
+	upgrade(ws, ...rest) {
+		/**
+		* Message order is important: loading -> decode -> .message.
+		* This flow must stay synchronous, or we need to use `sequential` helper
+		*/
+		ws.addEventListener("message", sequential(async (event) => {
+			const data = event.data instanceof Blob ? await loadBytes(event.data) : event.data;
+			this.message(ws, data, ...rest);
+		}));
+		ws.addEventListener("close", () => this.close(ws));
+		ws.addEventListener("error", () => {});
+	}
+};
+export { WebSocketHandler };

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

@@ -1,61 +1,3 @@
-import { MaybeOptionalOptions } from '@orpc/shared';
-import { 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 '@orpc/client';
-import '@orpc/contract';
-import '@standardserver/core';
-
-type WebsocketLike = Pick<WebSocket, 'addEventListener' | 'removeEventListener' | 'send'>;
-interface WebsocketHandlerOptions<_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;
-}
-declare class WebsocketHandler<T extends Context> {
-    private readonly handler;
-    private readonly peers;
-    private readonly encodePeerMessageOptions;
-    private readonly decodePeerMessageOptions;
-    constructor(handler: StandardHandler<T>, options?: NoInfer<WebsocketHandlerOptions<T>>);
-    /**
-     * Attaches necessary event listeners to a WebSocket to handle incoming messages and peer management.
-     */
-    upgrade(ws: WebsocketLike, ...rest: MaybeOptionalOptions<StandardPeerRequestHandlerOptions<T>>): void;
-    /**
-     * Handles a single message received from a WebSocket.
-     *
-     * @warning AVOID calling this method, if `.upgrade()` is used, as `.upgrade()` already sets up necessary event listeners to call this method for incoming messages and manage peer lifecycle.
-     *
-     * @param ws The WebSocket instance, require consistent instance across messages for proper peer management
-     * @param data The message data received from the WebSocket, can be string, ArrayBuffer, Blob, ...
-     */
-    message(ws: WebsocketLike, data: string | ArrayBuffer | Blob | Exclude<ConstructorParameters<typeof Blob>[0], undefined>[0][] | Pick<Uint8Array<ArrayBuffer>, 'buffer' | 'byteOffset' | 'byteLength'>, ...rest: MaybeOptionalOptions<StandardPeerRequestHandlerOptions<T>>): Promise<{
-        matched: boolean;
-    }>;
-    /**
-     * Called when a websocket is closed, to clean up any associated peer state.
-     *
-     * @warning AVOID calling this method, if `.upgrade()` is used, as `.upgrade()` already sets up necessary event listeners to call this method for incoming messages and manage peer lifecycle.
-     *
-     * @param ws The WebSocket instance to clean up, must be the same instance used in `.message()` calls to properly clean up
-     */
-    close(ws: WebsocketLike): Promise<void>;
-}
-
-interface RPCHandlerOptions<T extends Context> extends StandardHandlerOptions<T>, RPCHandlerCodecOptions<T>, WebsocketHandlerOptions<T> {
-}
-declare class RPCHandler<T extends Context> extends WebsocketHandler<T> {
-    constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
-}
-
-export { RPCHandler, WebsocketHandler };
-export type { RPCHandlerOptions, WebsocketHandlerOptions, WebsocketLike };
+import { WebSocketHandler, WebSocketHandlerOptions, WebSocketLike } from "./handler.js";
+import { RPCHandler, RPCHandlerOptions } from "./rpc-handler.js";
+export { RPCHandler, RPCHandlerOptions, WebSocketHandler, WebSocketHandlerOptions, WebSocketLike };

package/dist/adapters/websocket/index.js

@@ -0,0 +1,2 @@
+export { WebSocketHandler } from "./handler.js";
+export { RPCHandler } from "./rpc-handler.js";

package/dist/adapters/websocket/rpc-handler.d.ts

@@ -0,0 +1,16 @@
+import { Context } from "../../context.js";
+import { StandardHandlerOptions } from "../standard/handler.js";
+import { Router } from "../../router.js";
+import { RPCHandlerCodecOptions } from "../standard/rpc-handler-codec.js";
+import "../standard/index.js";
+import { WebSocketHandler, WebSocketHandlerOptions } from "./handler.js";
+export interface RPCHandlerOptions<T extends Context> extends StandardHandlerOptions<T>, RPCHandlerCodecOptions<T>, WebSocketHandlerOptions<T> {}
+/**
+ * Serves an oRPC router over the RPC protocol on a standard WebSocket
+ * connection (Deno, Bun, Cloudflare Durable Objects, and more).
+ *
+ * @see {@link https://orpc.dev/docs/adapters/websocket | WebSocket Adapters}
+ */
+export declare class RPCHandler<T extends Context> extends WebSocketHandler<T> {
+  constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
+}

package/dist/adapters/websocket/rpc-handler.js

@@ -0,0 +1,18 @@
+import { RPCHandlerCodec } from "../standard/rpc-handler-codec.js";
+import { StandardHandler } from "../standard/handler.js";
+import { WebSocketHandler } from "./handler.js";
+// src/adapters/websocket/rpc-handler.ts
+/**
+* Serves an oRPC router over the RPC protocol on a standard WebSocket
+* connection (Deno, Bun, Cloudflare Durable Objects, and more).
+*
+* @see {@link https://orpc.dev/docs/adapters/websocket | WebSocket Adapters}
+*/
+var RPCHandler = class extends WebSocketHandler {
+	constructor(router, options = {}) {
+		const codec = new RPCHandlerCodec(router, options);
+		const handler = new StandardHandler(codec, options);
+		super(handler, options);
+	}
+};
+export { RPCHandler };