@orpc/server 2.0.0-beta.3 → 2.0.0-beta.31

package/dist/adapters/node/index.mjs

@@ -1,122 +1,17 @@
-import compression from '@orpc/interop/compression';
-import { toArray, sortPlugins, intercept, resolveMaybeOptionalOptions } from '@orpc/shared';
-import { ORPCError } from '@orpc/client';
+export { R as BodyLimitPlugin } from '../../shared/server.Cd4Z1hpV.mjs';
+import { sortPlugins, intercept, resolveMaybeOptionalOptions } from '@orpc/shared';
 import { toStandardLazyRequest, sendStandardResponse } from '@standardserver/node';
 import { r as resolveFriendlyStandardHandlerHandleOptions } from '../../shared/server.W91HSRkE.mjs';
-import { C as CSRFGuardHandlerPlugin } from '../../shared/server.D_QauotT.mjs';
-import { R as RPCHandlerCodec, S as StandardHandler } from '../../shared/server.GDpX6Df8.mjs';
+import { R as RPCHandlerCodec, S as StandardHandler } from '../../shared/server.DpUGXBi2.mjs';
+import '@orpc/client';
 import '@standardserver/core';
-import '../../shared/server.CrlKQucM.mjs';
+import '@standardserver/fetch';
+import '../../shared/server.CkButhNT.mjs';
 import '@orpc/contract';
-import '../../shared/server.BwHnWUuN.mjs';
-
-class BodyCompressionHandlerPlugin {
-  name = "~body-compression";
-  compressionHandler;
-  constructor(options = {}) {
-    this.compressionHandler = compression({
-      ...options,
-      filter: (request, response) => {
-        const hasContentDisposition = response.hasHeader("content-disposition");
-        const contentType = response.getHeader("content-type")?.toString();
-        if (!hasContentDisposition && contentType?.startsWith("text/event-stream")) {
-          return false;
-        }
-        return options.filter ? options.filter(request, response) : compression.filter(request, response);
-      }
-    });
-  }
-  initNodeHttpHandlerOptions(options) {
-    return {
-      ...options,
-      nodeHttpInterceptors: [
-        async (interceptorOptions) => {
-          let resolve;
-          let reject;
-          const promise = new Promise((res, rej) => {
-            resolve = res;
-            reject = rej;
-          });
-          const originalWrite = interceptorOptions.response.write;
-          const originalEnd = interceptorOptions.response.end;
-          const originalOn = interceptorOptions.response.on;
-          this.compressionHandler(
-            interceptorOptions.request,
-            interceptorOptions.response,
-            async (error) => {
-              if (error) {
-                reject(error);
-              } else {
-                try {
-                  resolve(await interceptorOptions.next(interceptorOptions));
-                } catch (nextError) {
-                  reject(nextError);
-                }
-              }
-            }
-          );
-          try {
-            return await promise;
-          } finally {
-            interceptorOptions.response.write = originalWrite;
-            interceptorOptions.response.end = originalEnd;
-            interceptorOptions.response.on = originalOn;
-          }
-        },
-        ...toArray(options.nodeHttpInterceptors)
-      ]
-    };
-  }
-}
-
-class BodyLimitHandlerPlugin {
-  name = "~body-limit";
-  maxBodySize;
-  constructor(options) {
-    this.maxBodySize = options.maxBodySize;
-  }
-  initNodeHttpHandlerOptions(options) {
-    return {
-      ...options,
-      nodeHttpInterceptors: [
-        async (interceptorOptions) => {
-          let isHeaderChecked = false;
-          const checkHeader = () => {
-            if (isHeaderChecked) {
-              return;
-            }
-            isHeaderChecked = true;
-            const contentLength = interceptorOptions.request.headers["content-length"];
-            if (contentLength && Number(contentLength) > this.maxBodySize) {
-              throw new ORPCError("PAYLOAD_TOO_LARGE");
-            }
-          };
-          const originalEmit = interceptorOptions.request.emit;
-          let currentBodySize = 0;
-          interceptorOptions.request.emit = (event, ...args) => {
-            if (event === "data") {
-              checkHeader();
-              currentBodySize += args[0]?.length ?? 0;
-              if (currentBodySize > this.maxBodySize) {
-                throw new ORPCError("PAYLOAD_TOO_LARGE");
-              }
-            }
-            return originalEmit.call(interceptorOptions.request, event, ...args);
-          };
-          try {
-            return await interceptorOptions.next(interceptorOptions);
-          } finally {
-            interceptorOptions.request.emit = originalEmit;
-          }
-        },
-        ...toArray(options.nodeHttpInterceptors)
-      ]
-    };
-  }
-}
+import '../../shared/server.Dh77P3ii.mjs';
 
 class CompositeNodeHttpHandlerPlugin {
-  name = "~composite/node-http-handler";
+  name = "~composite/node-http";
   plugins;
   constructor(plugins = []) {
     this.plugins = sortPlugins(plugins);
@@ -164,16 +59,10 @@ class NodeHttpHandler {
 
 class RPCHandler extends NodeHttpHandler {
   constructor(router, options = {}) {
-    if (options.csrfGuardPlugin?.enabled !== false) {
-      options = {
-        ...options,
-        plugins: [...toArray(options.plugins), new CSRFGuardHandlerPlugin()]
-      };
-    }
     const codec = new RPCHandlerCodec(router, options);
     const handler = new StandardHandler(codec, options);
     super(handler, options);
   }
 }
 
-export { BodyCompressionHandlerPlugin, BodyLimitHandlerPlugin, CompositeNodeHttpHandlerPlugin, NodeHttpHandler, RPCHandler };
+export { CompositeNodeHttpHandlerPlugin, NodeHttpHandler, RPCHandler };

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

@@ -1,12 +1,12 @@
-import { b as StandardHandlerHandleOptions } from '../../shared/server.BB_Ik9Ph.mjs';
-export { C as CompositeStandardHandlerPlugin, O as OtelHandlerPlugin, S as StandardHandler, c as StandardHandlerCodec, d as StandardHandlerCodecResolvedProcedure, g as StandardHandlerHandleResult, h as StandardHandlerInterceptor, i as StandardHandlerInterceptorOptions, a as StandardHandlerOptions, e as StandardHandlerPlugin, j as StandardHandlerRoutingInterceptor, f as StandardHandlerRoutingInterceptorOptions } from '../../shared/server.BB_Ik9Ph.mjs';
-export { a as RPCHandlerCodec, R as RPCHandlerCodecOptions, b as RPCMatcher, c as RPCMatcherOptions } from '../../shared/server.B_U9y00a.mjs';
-import { C as Context } from '../../shared/server.BL22TloH.mjs';
-export { StandardBody, StandardBodyHint, StandardHeaders, StandardLazyRequest, StandardLazyResponse, StandardMethod, StandardRequest, StandardResponse, StandardUrl } from '@standardserver/core';
+import { c as StandardHandlerHandleOptions } from '../../shared/server.JbCIPL4P.mjs';
+export { C as CompositeStandardHandlerPlugin, O as OtelHandlerPlugin, b as StandardHandler, d as StandardHandlerCodec, e as StandardHandlerCodecResolvedProcedure, h as StandardHandlerHandleResult, i as StandardHandlerInterceptor, g as StandardHandlerInterceptorOptions, a as StandardHandlerOptions, S as StandardHandlerPlugin, j as StandardHandlerRoutingInterceptor, f as StandardHandlerRoutingInterceptorOptions } from '../../shared/server.JbCIPL4P.mjs';
+export { a as RPCHandlerCodec, R as RPCHandlerCodecOptions, b as RPCMatcher, c as RPCMatcherOptions, d as RPC_DEFAULT_ALLOW_METHODS } from '../../shared/server.CkNnZ5F-.mjs';
+import { Context } from '../../index.mjs';
 import '@orpc/client';
 import '@orpc/shared';
+import '@standardserver/core';
 import '@orpc/contract';
-import '../../shared/server.BsNNjG5J.mjs';
+import '../../shared/server.Dm0os-OP.mjs';
 
 type FriendlyStandardHandlerHandleOptions<T extends Context> = Omit<StandardHandlerHandleOptions<T>, 'context'> & (object extends T ? {
     context?: T;

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

@@ -1,12 +1,12 @@
-import { b as StandardHandlerHandleOptions } from '../../shared/server.EOHJ3NJr.js';
-export { C as CompositeStandardHandlerPlugin, O as OtelHandlerPlugin, S as StandardHandler, c as StandardHandlerCodec, d as StandardHandlerCodecResolvedProcedure, g as StandardHandlerHandleResult, h as StandardHandlerInterceptor, i as StandardHandlerInterceptorOptions, a as StandardHandlerOptions, e as StandardHandlerPlugin, j as StandardHandlerRoutingInterceptor, f as StandardHandlerRoutingInterceptorOptions } from '../../shared/server.EOHJ3NJr.js';
-export { a as RPCHandlerCodec, R as RPCHandlerCodecOptions, b as RPCMatcher, c as RPCMatcherOptions } from '../../shared/server.T9F3bzZx.js';
-import { C as Context } from '../../shared/server.BL22TloH.js';
-export { StandardBody, StandardBodyHint, StandardHeaders, StandardLazyRequest, StandardLazyResponse, StandardMethod, StandardRequest, StandardResponse, StandardUrl } from '@standardserver/core';
+import { c as StandardHandlerHandleOptions } from '../../shared/server.DrN1Pj1-.js';
+export { C as CompositeStandardHandlerPlugin, O as OtelHandlerPlugin, b as StandardHandler, d as StandardHandlerCodec, e as StandardHandlerCodecResolvedProcedure, h as StandardHandlerHandleResult, i as StandardHandlerInterceptor, g as StandardHandlerInterceptorOptions, a as StandardHandlerOptions, S as StandardHandlerPlugin, j as StandardHandlerRoutingInterceptor, f as StandardHandlerRoutingInterceptorOptions } from '../../shared/server.DrN1Pj1-.js';
+export { a as RPCHandlerCodec, R as RPCHandlerCodecOptions, b as RPCMatcher, c as RPCMatcherOptions, d as RPC_DEFAULT_ALLOW_METHODS } from '../../shared/server.C2n16pp0.js';
+import { Context } from '../../index.js';
 import '@orpc/client';
 import '@orpc/shared';
+import '@standardserver/core';
 import '@orpc/contract';
-import '../../shared/server.Pa0F03f_.js';
+import '../../shared/server.DtfwuV6U.js';
 
 type FriendlyStandardHandlerHandleOptions<T extends Context> = Omit<StandardHandlerHandleOptions<T>, 'context'> & (object extends T ? {
     context?: T;

package/dist/adapters/standard/index.mjs

@@ -1,8 +1,8 @@
-export { C as CompositeStandardHandlerPlugin, O as OtelHandlerPlugin, R as RPCHandlerCodec, a as RPCMatcher, S as StandardHandler } from '../../shared/server.GDpX6Df8.mjs';
+export { C as CompositeStandardHandlerPlugin, O as OtelHandlerPlugin, R as RPCHandlerCodec, a as RPCMatcher, b as RPC_DEFAULT_ALLOW_METHODS, S as StandardHandler } from '../../shared/server.DpUGXBi2.mjs';
 export { r as resolveFriendlyStandardHandlerHandleOptions } from '../../shared/server.W91HSRkE.mjs';
 import '@orpc/client';
 import '@orpc/shared';
 import '@standardserver/core';
-import '../../shared/server.CrlKQucM.mjs';
+import '../../shared/server.CkButhNT.mjs';
 import '@orpc/contract';
-import '../../shared/server.BwHnWUuN.mjs';
+import '../../shared/server.Dh77P3ii.mjs';

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

@@ -1,7 +1,7 @@
 import { Value, Promisable } from '@orpc/shared';
 import { StandardLazyRequest, StandardResponse } from '@standardserver/core';
-import { C as Context } from '../../shared/server.BL22TloH.mjs';
-import { b as StandardHandlerHandleOptions, S as StandardHandler } from '../../shared/server.BB_Ik9Ph.mjs';
+import { Context } from '../../index.mjs';
+import { StandardHandlerHandleOptions, StandardHandler } from '../standard/index.mjs';
 import '@orpc/client';
 import '@orpc/contract';
 

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

@@ -1,7 +1,7 @@
 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.EOHJ3NJr.js';
+import { Context } from '../../index.js';
+import { StandardHandlerHandleOptions, StandardHandler } from '../standard/index.js';
 import '@orpc/client';
 import '@orpc/contract';
 

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

@@ -1,16 +1,22 @@
-import { MaybeOptionalOptions } from '@orpc/shared';
+import { Arrayable, MaybeOptionalOptions } from '@orpc/shared';
 import { EncodePeerMessageOptions, DecodePeerMessageOptions } from '@standardserver/peer';
-import { C as Context } from '../../shared/server.BL22TloH.mjs';
-import { S as StandardHandler, a as StandardHandlerOptions } from '../../shared/server.BB_Ik9Ph.mjs';
+import { Context } from '../../index.mjs';
+import { StandardHandler, StandardHandlerOptions } from '../standard/index.mjs';
 import { StandardPeerRequestHandlerOptions } from '../standard-peer/index.mjs';
-import { R as Router } from '../../shared/server.BsNNjG5J.mjs';
-import { R as RPCHandlerCodecOptions } from '../../shared/server.B_U9y00a.mjs';
+import { Router } from '../../index.mjs';
+import { RPCHandlerCodecOptions } from '../standard/index.mjs';
 import '@orpc/client';
 import '@orpc/contract';
 import '@standardserver/core';
 
-type WebsocketLike = Pick<WebSocket, 'addEventListener' | 'removeEventListener' | 'send'>;
-interface WebsocketHandlerOptions<_T extends Context> {
+/**
+ * Supports standard WebSocket instances, Bun ServerWebSocket, "ws" ServerWebSocket,
+ * Cloudflare WebSocket Hibernation, and similar implementations.
+ */
+type WebSocketLike = {
+    send: (data: string | Uint8Array<ArrayBuffer>) => unknown;
+};
+interface WebSocketHandlerOptions<_T extends Context> {
     /**
      * Options for encoding peer messages. such as `prefix` for distinguishing messages on the same channel..
      */
@@ -20,42 +26,52 @@ interface WebsocketHandlerOptions<_T extends Context> {
      */
     decodePeerMessage?: DecodePeerMessageOptions | undefined;
 }
-declare class WebsocketHandler<T extends Context> {
+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>>);
+    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.
+     * Handles a single WebSocket message.
+     *
+     * Message order matters. Call this immediately after receiving a message,
+     * before any other async work, to preserve ordering.
      *
-     * @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.
+     * To avoid async Blob reads, configure `ws.binaryType` to return binary data
+     * directly (for example, `arraybuffer`).
      *
-     * @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, ...
+     * @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: string | ArrayBuffer | Blob | Exclude<ConstructorParameters<typeof Blob>[0], undefined>[0][] | Pick<Uint8Array<ArrayBuffer>, 'buffer' | 'byteOffset' | 'byteLength'>, ...rest: MaybeOptionalOptions<StandardPeerRequestHandlerOptions<T>>): Promise<{
+    message(ws: WebSocketLike, data: Arrayable<string | ArrayBuffer | 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.
+     * Cleans up peer state for a closed 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 same WebSocket instance passed to `.message()`.
+     */
+    close(ws: WebSocketLike): Promise<void>;
+    /**
+     * Attaches message and close event listeners to a WebSocket.
      *
-     * @param ws The WebSocket instance to clean up, must be the same instance used in `.message()` calls to properly clean up
+     * Prefer this over calling `.message()` and `.close()` manually.
      */
-    close(ws: WebsocketLike): Promise<void>;
+    upgrade(ws: Pick<WebSocket, 'send' | 'addEventListener' | 'removeEventListener'>, ...rest: MaybeOptionalOptions<StandardPeerRequestHandlerOptions<T>>): void;
 }
 
-interface RPCHandlerOptions<T extends Context> extends StandardHandlerOptions<T>, RPCHandlerCodecOptions<T>, WebsocketHandlerOptions<T> {
+interface RPCHandlerOptions<T extends Context> extends StandardHandlerOptions<T>, RPCHandlerCodecOptions<T>, WebSocketHandlerOptions<T> {
 }
-declare class RPCHandler<T extends Context> extends WebsocketHandler<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}
+ */
+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 };
+export { RPCHandler, WebSocketHandler };
+export type { RPCHandlerOptions, WebSocketHandlerOptions, WebSocketLike };

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

@@ -1,16 +1,22 @@
-import { MaybeOptionalOptions } from '@orpc/shared';
+import { Arrayable, 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.EOHJ3NJr.js';
+import { Context } from '../../index.js';
+import { StandardHandler, StandardHandlerOptions } from '../standard/index.js';
 import { StandardPeerRequestHandlerOptions } from '../standard-peer/index.js';
-import { R as Router } from '../../shared/server.Pa0F03f_.js';
-import { R as RPCHandlerCodecOptions } from '../../shared/server.T9F3bzZx.js';
+import { Router } from '../../index.js';
+import { RPCHandlerCodecOptions } from '../standard/index.js';
 import '@orpc/client';
 import '@orpc/contract';
 import '@standardserver/core';
 
-type WebsocketLike = Pick<WebSocket, 'addEventListener' | 'removeEventListener' | 'send'>;
-interface WebsocketHandlerOptions<_T extends Context> {
+/**
+ * Supports standard WebSocket instances, Bun ServerWebSocket, "ws" ServerWebSocket,
+ * Cloudflare WebSocket Hibernation, and similar implementations.
+ */
+type WebSocketLike = {
+    send: (data: string | Uint8Array<ArrayBuffer>) => unknown;
+};
+interface WebSocketHandlerOptions<_T extends Context> {
     /**
      * Options for encoding peer messages. such as `prefix` for distinguishing messages on the same channel..
      */
@@ -20,42 +26,52 @@ interface WebsocketHandlerOptions<_T extends Context> {
      */
     decodePeerMessage?: DecodePeerMessageOptions | undefined;
 }
-declare class WebsocketHandler<T extends Context> {
+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>>);
+    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.
+     * Handles a single WebSocket message.
+     *
+     * Message order matters. Call this immediately after receiving a message,
+     * before any other async work, to preserve ordering.
      *
-     * @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.
+     * To avoid async Blob reads, configure `ws.binaryType` to return binary data
+     * directly (for example, `arraybuffer`).
      *
-     * @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, ...
+     * @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: string | ArrayBuffer | Blob | Exclude<ConstructorParameters<typeof Blob>[0], undefined>[0][] | Pick<Uint8Array<ArrayBuffer>, 'buffer' | 'byteOffset' | 'byteLength'>, ...rest: MaybeOptionalOptions<StandardPeerRequestHandlerOptions<T>>): Promise<{
+    message(ws: WebSocketLike, data: Arrayable<string | ArrayBuffer | 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.
+     * Cleans up peer state for a closed 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 same WebSocket instance passed to `.message()`.
+     */
+    close(ws: WebSocketLike): Promise<void>;
+    /**
+     * Attaches message and close event listeners to a WebSocket.
      *
-     * @param ws The WebSocket instance to clean up, must be the same instance used in `.message()` calls to properly clean up
+     * Prefer this over calling `.message()` and `.close()` manually.
      */
-    close(ws: WebsocketLike): Promise<void>;
+    upgrade(ws: Pick<WebSocket, 'send' | 'addEventListener' | 'removeEventListener'>, ...rest: MaybeOptionalOptions<StandardPeerRequestHandlerOptions<T>>): void;
 }
 
-interface RPCHandlerOptions<T extends Context> extends StandardHandlerOptions<T>, RPCHandlerCodecOptions<T>, WebsocketHandlerOptions<T> {
+interface RPCHandlerOptions<T extends Context> extends StandardHandlerOptions<T>, RPCHandlerCodecOptions<T>, WebSocketHandlerOptions<T> {
 }
-declare class RPCHandler<T extends Context> extends WebsocketHandler<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}
+ */
+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 };
+export { RPCHandler, WebSocketHandler };
+export type { RPCHandlerOptions, WebSocketHandlerOptions, WebSocketLike };

package/dist/adapters/websocket/index.mjs

@@ -1,14 +1,14 @@
-import { toStringOrBytes, resolveMaybeOptionalOptions } from '@orpc/shared';
+import { toStringOrBytes, resolveMaybeOptionalOptions, sequential, loadBytes } from '@orpc/shared';
 import { ServerPeer, encodePeerMessage, decodePeerMessage, isClientPeerSendMessage } from '@standardserver/peer';
 import { c as createStandardPeerRequestHandler } from '../../shared/server.CX4vUnDk.mjs';
-import { R as RPCHandlerCodec, S as StandardHandler } from '../../shared/server.GDpX6Df8.mjs';
+import { R as RPCHandlerCodec, S as StandardHandler } from '../../shared/server.DpUGXBi2.mjs';
 import '@orpc/client';
 import '@standardserver/core';
-import '../../shared/server.CrlKQucM.mjs';
+import '../../shared/server.CkButhNT.mjs';
 import '@orpc/contract';
-import '../../shared/server.BwHnWUuN.mjs';
+import '../../shared/server.Dh77P3ii.mjs';
 
-class WebsocketHandler {
+class WebSocketHandler {
   constructor(handler, options = {}) {
     this.handler = handler;
     this.encodePeerMessageOptions = options.encodePeerMessage;
@@ -18,28 +18,26 @@ class WebsocketHandler {
   encodePeerMessageOptions;
   decodePeerMessageOptions;
   /**
-   * Attaches necessary event listeners to a WebSocket to handle incoming messages and peer management.
-   */
-  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.
+   * Handles a single WebSocket message.
+   *
+   * Message order matters. Call this immediately after receiving a message,
+   * before any other async work, to preserve ordering.
    *
-   * @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.
+   * To avoid async Blob reads, configure `ws.binaryType` to return binary data
+   * directly (for example, `arraybuffer`).
    *
-   * @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, ...
+   * @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) {
     let peer = this.peers.get(ws);
     if (!peer) {
       this.peers.set(ws, peer = new ServerPeer(async (message) => {
-        return ws.send(await encodePeerMessage(message, this.encodePeerMessageOptions));
+        const encoded2 = await encodePeerMessage(message, this.encodePeerMessageOptions);
+        await ws.send(encoded2);
       }));
     }
-    const encoded = await toStringOrBytes(data);
+    const encoded = toStringOrBytes(data);
     const result = decodePeerMessage(encoded, this.decodePeerMessageOptions);
     if (result.matched && isClientPeerSendMessage(result.message)) {
       await peer.message(
@@ -50,22 +48,32 @@ class WebsocketHandler {
     return result;
   }
   /**
-   * Called when a websocket is closed, to clean up any associated peer state.
+   * Cleans up peer state for a closed 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 to clean up, must be the same instance used in `.message()` calls to properly clean up
+   * @param ws The same WebSocket instance passed to `.message()`.
    */
   async close(ws) {
     const peer = this.peers.get(ws);
     if (peer) {
-      await peer.close();
       this.peers.delete(ws);
+      await peer.close();
     }
   }
+  /**
+   * Attaches message and close event listeners to a WebSocket.
+   *
+   * Prefer this over calling `.message()` and `.close()` manually.
+   */
+  upgrade(ws, ...rest) {
+    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));
+  }
 }
 
-class RPCHandler extends WebsocketHandler {
+class RPCHandler extends WebSocketHandler {
   constructor(router, options = {}) {
     const codec = new RPCHandlerCodec(router, options);
     const handler = new StandardHandler(codec, options);
@@ -73,4 +81,4 @@ class RPCHandler extends WebsocketHandler {
   }
 }
 
-export { RPCHandler, WebsocketHandler };
+export { RPCHandler, WebSocketHandler };

package/dist/extensions/callable.d.mts

@@ -1,9 +1,9 @@
 import { AnyORPCError, ClientContext } from '@orpc/client';
 import { AnySchema, ErrorMap } from '@orpc/contract';
 import { MaybeOptionalOptions } from '@orpc/shared';
-import { C as Context, P as ProcedureClientOptions, a as Procedure, b as ProcedureClient } from '../shared/server.BL22TloH.mjs';
+import { Context, ProcedureClientOptions, Procedure, ProcedureClient } from '../index.mjs';
 
-declare module "../index" {
+declare module '@orpc/server' {
     interface DecoratedProcedure<TInitialContext extends Context, TInjectedContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TReturnedError extends AnyORPCError> {
         callable<TClientContext extends ClientContext>(...rest: MaybeOptionalOptions<ProcedureClientOptions<TInitialContext, TOutputSchema, TErrorMap, TReturnedError, TClientContext>>): Procedure<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, TErrorMap, TReturnedError> & ProcedureClient<TClientContext, TInputSchema, TOutputSchema, TErrorMap, TReturnedError>;
     }

package/dist/extensions/callable.d.ts

@@ -1,9 +1,9 @@
 import { AnyORPCError, ClientContext } from '@orpc/client';
 import { AnySchema, ErrorMap } from '@orpc/contract';
 import { MaybeOptionalOptions } from '@orpc/shared';
-import { C as Context, P as ProcedureClientOptions, a as Procedure, b as ProcedureClient } from '../shared/server.BL22TloH.js';
+import { Context, ProcedureClientOptions, Procedure, ProcedureClient } from '../index.js';
 
-declare module "../index" {
+declare module '@orpc/server' {
     interface DecoratedProcedure<TInitialContext extends Context, TInjectedContext extends Context, TInputSchema extends AnySchema, TOutputSchema extends AnySchema, TErrorMap extends ErrorMap, TReturnedError extends AnyORPCError> {
         callable<TClientContext extends ClientContext>(...rest: MaybeOptionalOptions<ProcedureClientOptions<TInitialContext, TOutputSchema, TErrorMap, TReturnedError, TClientContext>>): Procedure<TInitialContext, TInjectedContext, TInputSchema, TOutputSchema, TErrorMap, TReturnedError> & ProcedureClient<TClientContext, TInputSchema, TOutputSchema, TErrorMap, TReturnedError>;
     }

package/dist/extensions/callable.mjs

@@ -1,5 +1,5 @@
-import { c as createProcedureClient } from '../shared/server.CrlKQucM.mjs';
-import { D as DecoratedProcedure } from '../shared/server.CjOb6ItT.mjs';
+import { c as createProcedureClient } from '../shared/server.CkButhNT.mjs';
+import { D as DecoratedProcedure } from '../shared/server.eCTV8Vpp.mjs';
 import '@orpc/client';
 import '@orpc/contract';
 import '@orpc/shared';