@orpc/server 0.0.0-next.c3068b4 → 0.0.0-next.c38f426

package/dist/adapters/node/index.mjs

@@ -0,0 +1,152 @@
+import { ORPCError } from '@orpc/client';
+import { once, toArray, intercept, resolveMaybeOptionalOptions } from '@orpc/shared';
+import compression from '@orpc/interop/compression';
+import { toStandardLazyRequest, sendStandardResponse } from '@orpc/standard-server-node';
+import { r as resolveFriendlyStandardHandleOptions } from '../../shared/server.DZ5BIITo.mjs';
+import '@orpc/standard-server';
+import '@orpc/contract';
+import { C as CompositeStandardHandlerPlugin, b as StandardRPCHandler } from '../../shared/server.Bxx6tqNe.mjs';
+import '@orpc/client/standard';
+import '@orpc/standard-server/batch';
+import '@orpc/standard-server-fetch';
+import { S as StrictGetMethodPlugin } from '../../shared/server.TEVCLCFC.mjs';
+import '../../shared/server.Ds4HPpvH.mjs';
+
+class BodyLimitPlugin {
+  maxBodySize;
+  constructor(options) {
+    this.maxBodySize = options.maxBodySize;
+  }
+  initRuntimeAdapter(options) {
+    options.adapterInterceptors ??= [];
+    options.adapterInterceptors.push(async (options2) => {
+      const checkHeader = once(() => {
+        if (Number(options2.request.headers["content-length"]) > this.maxBodySize) {
+          throw new ORPCError("PAYLOAD_TOO_LARGE");
+        }
+      });
+      const originalEmit = options2.request.emit;
+      let currentBodySize = 0;
+      options2.request.emit = (event, ...args) => {
+        if (event === "data") {
+          checkHeader();
+          currentBodySize += args[0].length;
+          if (currentBodySize > this.maxBodySize) {
+            throw new ORPCError("PAYLOAD_TOO_LARGE");
+          }
+        }
+        return originalEmit.call(options2.request, event, ...args);
+      };
+      try {
+        return await options2.next(options2);
+      } finally {
+        options2.request.emit = originalEmit;
+      }
+    });
+  }
+}
+
+class CompressionPlugin {
+  compressionHandler;
+  constructor(options = {}) {
+    this.compressionHandler = compression({
+      ...options,
+      filter: (req, res) => {
+        const hasContentDisposition = res.hasHeader("content-disposition");
+        const contentType = res.getHeader("content-type")?.toString();
+        if (!hasContentDisposition && contentType?.startsWith("text/event-stream")) {
+          return false;
+        }
+        return options.filter ? options.filter(req, res) : compression.filter(req, res);
+      }
+    });
+  }
+  initRuntimeAdapter(options) {
+    options.adapterInterceptors ??= [];
+    options.adapterInterceptors.unshift(async (options2) => {
+      let resolve;
+      let reject;
+      const promise = new Promise((res, rej) => {
+        resolve = res;
+        reject = rej;
+      });
+      const originalWrite = options2.response.write;
+      const originalEnd = options2.response.end;
+      const originalOn = options2.response.on;
+      this.compressionHandler(
+        options2.request,
+        options2.response,
+        async (err) => {
+          if (err) {
+            reject(err);
+          } else {
+            try {
+              resolve(await options2.next());
+            } catch (error) {
+              reject(error);
+            }
+          }
+        }
+      );
+      try {
+        return await promise;
+      } finally {
+        options2.response.write = originalWrite;
+        options2.response.end = originalEnd;
+        options2.response.on = originalOn;
+      }
+    });
+  }
+}
+
+class CompositeNodeHttpHandlerPlugin extends CompositeStandardHandlerPlugin {
+  initRuntimeAdapter(options) {
+    for (const plugin of this.plugins) {
+      plugin.initRuntimeAdapter?.(options);
+    }
+  }
+}
+
+class NodeHttpHandler {
+  constructor(standardHandler, options = {}) {
+    this.standardHandler = standardHandler;
+    const plugin = new CompositeNodeHttpHandlerPlugin(options.plugins);
+    plugin.initRuntimeAdapter(options);
+    this.adapterInterceptors = toArray(options.adapterInterceptors);
+    this.sendStandardResponseOptions = options;
+  }
+  sendStandardResponseOptions;
+  adapterInterceptors;
+  async handle(request, response, ...rest) {
+    return intercept(
+      this.adapterInterceptors,
+      {
+        ...resolveFriendlyStandardHandleOptions(resolveMaybeOptionalOptions(rest)),
+        request,
+        response,
+        sendStandardResponseOptions: this.sendStandardResponseOptions
+      },
+      async ({ request: request2, response: response2, sendStandardResponseOptions, ...options }) => {
+        const standardRequest = toStandardLazyRequest(request2, response2);
+        const result = await this.standardHandler.handle(standardRequest, options);
+        if (!result.matched) {
+          return { matched: false };
+        }
+        await sendStandardResponse(response2, result.response, sendStandardResponseOptions);
+        return { matched: true };
+      }
+    );
+  }
+}
+
+class RPCHandler extends NodeHttpHandler {
+  constructor(router, options = {}) {
+    if (options.strictGetMethodPluginEnabled ?? true) {
+      options.plugins ??= [];
+      options.plugins.push(new StrictGetMethodPlugin());
+    }
+    super(new StandardRPCHandler(router, options), options);
+  }
+}
+
+export { BodyLimitPlugin, CompositeNodeHttpHandlerPlugin, CompressionPlugin, NodeHttpHandler, RPCHandler };

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

@@ -0,0 +1,21 @@
+import { S as StandardCodec, a as StandardParams } from '../../shared/server.DBCUJijK.mjs';
+export { C as CompositeStandardHandlerPlugin, b as StandardHandleOptions, c as StandardHandleResult, f as StandardHandler, d as StandardHandlerInterceptorOptions, e as StandardHandlerOptions, g as StandardHandlerPlugin, h as StandardMatchResult, i as StandardMatcher } from '../../shared/server.DBCUJijK.mjs';
+import { ORPCError } from '@orpc/client';
+import { StandardRPCSerializer } from '@orpc/client/standard';
+import { StandardLazyRequest, StandardResponse } from '@orpc/standard-server';
+import { A as AnyProcedure } from '../../shared/server.B4BGqy3Y.mjs';
+export { a as StandardRPCHandler, S as StandardRPCHandlerOptions, c as StandardRPCMatcher, b as StandardRPCMatcherOptions } from '../../shared/server.Ck-gOLzq.mjs';
+export { F as FriendlyStandardHandleOptions, r as resolveFriendlyStandardHandleOptions } from '../../shared/server.CVKCo60T.mjs';
+import '@orpc/contract';
+import '@orpc/shared';
+import '../../shared/server.DzV1hr3z.mjs';
+
+declare class StandardRPCCodec implements StandardCodec {
+    private readonly serializer;
+    constructor(serializer: StandardRPCSerializer);
+    decode(request: StandardLazyRequest, _params: StandardParams | undefined, _procedure: AnyProcedure): Promise<unknown>;
+    encode(output: unknown, _procedure: AnyProcedure): StandardResponse;
+    encodeError(error: ORPCError<any, any>): StandardResponse;
+}
+
+export { StandardCodec, StandardParams, StandardRPCCodec };

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

@@ -0,0 +1,21 @@
+import { S as StandardCodec, a as StandardParams } from '../../shared/server.DPIFWpxG.js';
+export { C as CompositeStandardHandlerPlugin, b as StandardHandleOptions, c as StandardHandleResult, f as StandardHandler, d as StandardHandlerInterceptorOptions, e as StandardHandlerOptions, g as StandardHandlerPlugin, h as StandardMatchResult, i as StandardMatcher } from '../../shared/server.DPIFWpxG.js';
+import { ORPCError } from '@orpc/client';
+import { StandardRPCSerializer } from '@orpc/client/standard';
+import { StandardLazyRequest, StandardResponse } from '@orpc/standard-server';
+import { A as AnyProcedure } from '../../shared/server.B4BGqy3Y.js';
+export { a as StandardRPCHandler, S as StandardRPCHandlerOptions, c as StandardRPCMatcher, b as StandardRPCMatcherOptions } from '../../shared/server.COL12UTb.js';
+export { F as FriendlyStandardHandleOptions, r as resolveFriendlyStandardHandleOptions } from '../../shared/server.DNtJ-p60.js';
+import '@orpc/contract';
+import '@orpc/shared';
+import '../../shared/server.Cb6yD7DZ.js';
+
+declare class StandardRPCCodec implements StandardCodec {
+    private readonly serializer;
+    constructor(serializer: StandardRPCSerializer);
+    decode(request: StandardLazyRequest, _params: StandardParams | undefined, _procedure: AnyProcedure): Promise<unknown>;
+    encode(output: unknown, _procedure: AnyProcedure): StandardResponse;
+    encodeError(error: ORPCError<any, any>): StandardResponse;
+}
+
+export { StandardCodec, StandardParams, StandardRPCCodec };

package/dist/adapters/standard/index.mjs

@@ -0,0 +1,8 @@
+export { C as CompositeStandardHandlerPlugin, S as StandardHandler, a as StandardRPCCodec, b as StandardRPCHandler, c as StandardRPCMatcher } from '../../shared/server.Bxx6tqNe.mjs';
+export { r as resolveFriendlyStandardHandleOptions } from '../../shared/server.DZ5BIITo.mjs';
+import '@orpc/client/standard';
+import '@orpc/client';
+import '@orpc/shared';
+import '@orpc/standard-server';
+import '../../shared/server.Ds4HPpvH.mjs';
+import '@orpc/contract';

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

@@ -0,0 +1,18 @@
+import { ServerPeer, EncodedMessage, ServerPeerHandleRequestFn } from '@orpc/standard-server-peer';
+import { C as Context } from '../../shared/server.B4BGqy3Y.mjs';
+import { f as StandardHandler } from '../../shared/server.DBCUJijK.mjs';
+import { F as FriendlyStandardHandleOptions } from '../../shared/server.CVKCo60T.mjs';
+import '@orpc/client';
+import '@orpc/contract';
+import '@orpc/shared';
+import '@orpc/standard-server';
+
+type HandleStandardServerPeerMessageOptions<T extends Context> = Omit<FriendlyStandardHandleOptions<T>, 'prefix'>;
+/**
+ * @deprecated Use `createServerPeerRequestHandleFn` instead.
+ */
+declare function handleStandardServerPeerMessage<T extends Context>(handler: StandardHandler<T>, peer: ServerPeer, message: EncodedMessage, options: HandleStandardServerPeerMessageOptions<T>): Promise<void>;
+declare function createServerPeerHandleRequestFn<T extends Context>(handler: StandardHandler<T>, options: HandleStandardServerPeerMessageOptions<T>): ServerPeerHandleRequestFn;
+
+export { createServerPeerHandleRequestFn, handleStandardServerPeerMessage };
+export type { HandleStandardServerPeerMessageOptions };

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

@@ -0,0 +1,18 @@
+import { ServerPeer, EncodedMessage, ServerPeerHandleRequestFn } from '@orpc/standard-server-peer';
+import { C as Context } from '../../shared/server.B4BGqy3Y.js';
+import { f as StandardHandler } from '../../shared/server.DPIFWpxG.js';
+import { F as FriendlyStandardHandleOptions } from '../../shared/server.DNtJ-p60.js';
+import '@orpc/client';
+import '@orpc/contract';
+import '@orpc/shared';
+import '@orpc/standard-server';
+
+type HandleStandardServerPeerMessageOptions<T extends Context> = Omit<FriendlyStandardHandleOptions<T>, 'prefix'>;
+/**
+ * @deprecated Use `createServerPeerRequestHandleFn` instead.
+ */
+declare function handleStandardServerPeerMessage<T extends Context>(handler: StandardHandler<T>, peer: ServerPeer, message: EncodedMessage, options: HandleStandardServerPeerMessageOptions<T>): Promise<void>;
+declare function createServerPeerHandleRequestFn<T extends Context>(handler: StandardHandler<T>, options: HandleStandardServerPeerMessageOptions<T>): ServerPeerHandleRequestFn;
+
+export { createServerPeerHandleRequestFn, handleStandardServerPeerMessage };
+export type { HandleStandardServerPeerMessageOptions };

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

@@ -0,0 +1,7 @@
+export { c as createServerPeerHandleRequestFn, h as handleStandardServerPeerMessage } from '../../shared/server.UVMTOWrk.mjs';
+import '@orpc/client';
+import '@orpc/shared';
+import '@orpc/standard-server';
+import '@orpc/contract';
+import '@orpc/client/standard';
+import '../../shared/server.DZ5BIITo.mjs';

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

@@ -0,0 +1,56 @@
+import { MaybeOptionalOptions } from '@orpc/shared';
+import { C as Context, R as Router } from '../../shared/server.B4BGqy3Y.mjs';
+import { f as StandardHandler } from '../../shared/server.DBCUJijK.mjs';
+import { HandleStandardServerPeerMessageOptions } from '../standard-peer/index.mjs';
+import { S as StandardRPCHandlerOptions } from '../../shared/server.Ck-gOLzq.mjs';
+import '@orpc/client';
+import '@orpc/contract';
+import '@orpc/standard-server';
+import '@orpc/standard-server-peer';
+import '../../shared/server.CVKCo60T.mjs';
+import '@orpc/client/standard';
+import '../../shared/server.DzV1hr3z.mjs';
+
+type MinimalWebsocket = Pick<WebSocket, 'addEventListener' | 'send'>;
+declare class WebsocketHandler<T extends Context> {
+    #private;
+    constructor(standardHandler: StandardHandler<T>);
+    /**
+     * Upgrades a WebSocket to enable handling
+     *
+     * This attaches the necessary 'message' and 'close' listeners to the WebSocket
+     *
+     * @warning Do not use this method if you're using `.message()` or `.close()`
+     */
+    upgrade(ws: MinimalWebsocket, ...rest: MaybeOptionalOptions<HandleStandardServerPeerMessageOptions<T>>): void;
+    /**
+     * Handles a single message received from a WebSocket.
+     *
+     * @warning Avoid calling this directly if `.upgrade()` is used.
+     *
+     * @param ws The WebSocket instance
+     * @param data The message payload, usually place in `event.data`
+     */
+    message(ws: MinimalWebsocket, data: string | ArrayBuffer | Blob, ...rest: MaybeOptionalOptions<HandleStandardServerPeerMessageOptions<T>>): Promise<void>;
+    /**
+     * Closes the WebSocket peer and cleans up.
+     *
+     * @warning Avoid calling this directly if `.upgrade()` is used.
+     */
+    close(ws: MinimalWebsocket): void;
+}
+
+interface RPCHandlerOptions<T extends Context> extends StandardRPCHandlerOptions<T> {
+}
+/**
+ * RPC Handler for Websocket adapter
+ *
+ * @see {@link https://orpc.unnoq.com/docs/rpc-handler RPC Handler Docs}
+ * @see {@link https://orpc.unnoq.com/docs/adapters/websocket Websocket Adapter Docs}
+ */
+declare class RPCHandler<T extends Context> extends WebsocketHandler<T> {
+    constructor(router: Router<any, T>, options?: NoInfer<RPCHandlerOptions<T>>);
+}
+
+export { RPCHandler, WebsocketHandler };
+export type { MinimalWebsocket, RPCHandlerOptions };

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

@@ -0,0 +1,56 @@
+import { MaybeOptionalOptions } from '@orpc/shared';
+import { C as Context, R as Router } from '../../shared/server.B4BGqy3Y.js';
+import { f as StandardHandler } from '../../shared/server.DPIFWpxG.js';
+import { HandleStandardServerPeerMessageOptions } from '../standard-peer/index.js';
+import { S as StandardRPCHandlerOptions } from '../../shared/server.COL12UTb.js';
+import '@orpc/client';
+import '@orpc/contract';
+import '@orpc/standard-server';
+import '@orpc/standard-server-peer';
+import '../../shared/server.DNtJ-p60.js';
+import '@orpc/client/standard';
+import '../../shared/server.Cb6yD7DZ.js';
+
+type MinimalWebsocket = Pick<WebSocket, 'addEventListener' | 'send'>;
+declare class WebsocketHandler<T extends Context> {
+    #private;
+    constructor(standardHandler: StandardHandler<T>);
+    /**
+     * Upgrades a WebSocket to enable handling
+     *
+     * This attaches the necessary 'message' and 'close' listeners to the WebSocket
+     *
+     * @warning Do not use this method if you're using `.message()` or `.close()`
+     */
+    upgrade(ws: MinimalWebsocket, ...rest: MaybeOptionalOptions<HandleStandardServerPeerMessageOptions<T>>): void;
+    /**
+     * Handles a single message received from a WebSocket.
+     *
+     * @warning Avoid calling this directly if `.upgrade()` is used.
+     *
+     * @param ws The WebSocket instance
+     * @param data The message payload, usually place in `event.data`
+     */
+    message(ws: MinimalWebsocket, data: string | ArrayBuffer | Blob, ...rest: MaybeOptionalOptions<HandleStandardServerPeerMessageOptions<T>>): Promise<void>;
+    /**
+     * Closes the WebSocket peer and cleans up.
+     *
+     * @warning Avoid calling this directly if `.upgrade()` is used.
+     */
+    close(ws: MinimalWebsocket): void;
+}
+
+interface RPCHandlerOptions<T extends Context> extends StandardRPCHandlerOptions<T> {
+}
+/**
+ * RPC Handler for Websocket adapter
+ *
+ * @see {@link https://orpc.unnoq.com/docs/rpc-handler RPC Handler Docs}
+ * @see {@link https://orpc.unnoq.com/docs/adapters/websocket Websocket Adapter Docs}
+ */
+declare class RPCHandler<T extends Context> extends WebsocketHandler<T> {
+    constructor(router: Router<any, T>, options?: NoInfer<RPCHandlerOptions<T>>);
+}
+
+export { RPCHandler, WebsocketHandler };
+export type { MinimalWebsocket, RPCHandlerOptions };

package/dist/adapters/websocket/index.mjs

@@ -0,0 +1,67 @@
+import { readAsBuffer, resolveMaybeOptionalOptions } from '@orpc/shared';
+import { ServerPeer } from '@orpc/standard-server-peer';
+import { c as createServerPeerHandleRequestFn } from '../../shared/server.UVMTOWrk.mjs';
+import '@orpc/client';
+import '@orpc/standard-server';
+import '@orpc/contract';
+import { b as StandardRPCHandler } from '../../shared/server.Bxx6tqNe.mjs';
+import '@orpc/client/standard';
+import '../../shared/server.DZ5BIITo.mjs';
+import '../../shared/server.Ds4HPpvH.mjs';
+
+class WebsocketHandler {
+  #peers = /* @__PURE__ */ new WeakMap();
+  #handler;
+  constructor(standardHandler) {
+    this.#handler = standardHandler;
+  }
+  /**
+   * Upgrades a WebSocket to enable handling
+   *
+   * This attaches the necessary 'message' and 'close' listeners to the WebSocket
+   *
+   * @warning Do not use this method if you're using `.message()` or `.close()`
+   */
+  upgrade(ws, ...rest) {
+    ws.addEventListener("message", (event) => this.message(ws, event.data, ...rest));
+    ws.addEventListener("close", () => this.close(ws));
+  }
+  /**
+   * Handles a single message received from a WebSocket.
+   *
+   * @warning Avoid calling this directly if `.upgrade()` is used.
+   *
+   * @param ws The WebSocket instance
+   * @param data The message payload, usually place in `event.data`
+   */
+  async message(ws, data, ...rest) {
+    let peer = this.#peers.get(ws);
+    if (!peer) {
+      this.#peers.set(ws, peer = new ServerPeer(ws.send.bind(ws)));
+    }
+    const message = data instanceof Blob ? await readAsBuffer(data) : data;
+    await peer.message(
+      message,
+      createServerPeerHandleRequestFn(this.#handler, resolveMaybeOptionalOptions(rest))
+    );
+  }
+  /**
+   * Closes the WebSocket peer and cleans up.
+   *
+   * @warning Avoid calling this directly if `.upgrade()` is used.
+   */
+  close(ws) {
+    const peer = this.#peers.get(ws);
+    if (peer) {
+      peer.close();
+    }
+  }
+}
+
+class RPCHandler extends WebsocketHandler {
+  constructor(router, options = {}) {
+    super(new StandardRPCHandler(router, options));
+  }
+}
+
+export { RPCHandler, WebsocketHandler };

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

@@ -0,0 +1,31 @@
+import { MaybeOptionalOptions } from '@orpc/shared';
+import { WebSocket } from 'ws';
+import { C as Context, R as Router } from '../../shared/server.B4BGqy3Y.mjs';
+import { f as StandardHandler } from '../../shared/server.DBCUJijK.mjs';
+import { HandleStandardServerPeerMessageOptions } from '../standard-peer/index.mjs';
+import { S as StandardRPCHandlerOptions } from '../../shared/server.Ck-gOLzq.mjs';
+import '@orpc/client';
+import '@orpc/contract';
+import '@orpc/standard-server';
+import '@orpc/standard-server-peer';
+import '../../shared/server.CVKCo60T.mjs';
+import '@orpc/client/standard';
+import '../../shared/server.DzV1hr3z.mjs';
+
+declare class WsHandler<T extends Context> {
+    private readonly standardHandler;
+    constructor(standardHandler: StandardHandler<T>);
+    upgrade(ws: Pick<WebSocket, 'addEventListener' | 'send'>, ...rest: MaybeOptionalOptions<HandleStandardServerPeerMessageOptions<T>>): Promise<void>;
+}
+
+/**
+ * RPC Handler for ws (node ws) adapter
+ *
+ * @see {@link https://orpc.unnoq.com/docs/rpc-handler RPC Handler Docs}
+ * @see {@link https://orpc.unnoq.com/docs/adapters/websocket Websocket Adapter Docs}
+ */
+declare class RPCHandler<T extends Context> extends WsHandler<T> {
+    constructor(router: Router<any, T>, options?: NoInfer<StandardRPCHandlerOptions<T>>);
+}
+
+export { RPCHandler, WsHandler };

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

@@ -0,0 +1,31 @@
+import { MaybeOptionalOptions } from '@orpc/shared';
+import { WebSocket } from 'ws';
+import { C as Context, R as Router } from '../../shared/server.B4BGqy3Y.js';
+import { f as StandardHandler } from '../../shared/server.DPIFWpxG.js';
+import { HandleStandardServerPeerMessageOptions } from '../standard-peer/index.js';
+import { S as StandardRPCHandlerOptions } from '../../shared/server.COL12UTb.js';
+import '@orpc/client';
+import '@orpc/contract';
+import '@orpc/standard-server';
+import '@orpc/standard-server-peer';
+import '../../shared/server.DNtJ-p60.js';
+import '@orpc/client/standard';
+import '../../shared/server.Cb6yD7DZ.js';
+
+declare class WsHandler<T extends Context> {
+    private readonly standardHandler;
+    constructor(standardHandler: StandardHandler<T>);
+    upgrade(ws: Pick<WebSocket, 'addEventListener' | 'send'>, ...rest: MaybeOptionalOptions<HandleStandardServerPeerMessageOptions<T>>): Promise<void>;
+}
+
+/**
+ * RPC Handler for ws (node ws) adapter
+ *
+ * @see {@link https://orpc.unnoq.com/docs/rpc-handler RPC Handler Docs}
+ * @see {@link https://orpc.unnoq.com/docs/adapters/websocket Websocket Adapter Docs}
+ */
+declare class RPCHandler<T extends Context> extends WsHandler<T> {
+    constructor(router: Router<any, T>, options?: NoInfer<StandardRPCHandlerOptions<T>>);
+}
+
+export { RPCHandler, WsHandler };

package/dist/adapters/ws/index.mjs

@@ -0,0 +1,37 @@
+import { readAsBuffer, resolveMaybeOptionalOptions } from '@orpc/shared';
+import { ServerPeer } from '@orpc/standard-server-peer';
+import { c as createServerPeerHandleRequestFn } from '../../shared/server.UVMTOWrk.mjs';
+import '@orpc/client';
+import '@orpc/standard-server';
+import '@orpc/contract';
+import { b as StandardRPCHandler } from '../../shared/server.Bxx6tqNe.mjs';
+import '@orpc/client/standard';
+import '../../shared/server.DZ5BIITo.mjs';
+import '../../shared/server.Ds4HPpvH.mjs';
+
+class WsHandler {
+  constructor(standardHandler) {
+    this.standardHandler = standardHandler;
+  }
+  async upgrade(ws, ...rest) {
+    const peer = new ServerPeer(ws.send.bind(ws));
+    ws.addEventListener("message", async (event) => {
+      const message = Array.isArray(event.data) ? await readAsBuffer(new Blob(event.data)) : event.data;
+      await peer.message(
+        message,
+        createServerPeerHandleRequestFn(this.standardHandler, resolveMaybeOptionalOptions(rest))
+      );
+    });
+    ws.addEventListener("close", () => {
+      peer.close();
+    });
+  }
+}
+
+class RPCHandler extends WsHandler {
+  constructor(router, options = {}) {
+    super(new StandardRPCHandler(router, options));
+  }
+}
+
+export { RPCHandler, WsHandler };