@orpc/server 2.0.0-beta.2 → 2.0.0-beta.21

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

@@ -1,11 +1,11 @@
 import { SupportedMessagePort } from '@orpc/client/message-port';
 import { Value, Promisable, MaybeOptionalOptions } from '@orpc/shared';
 import { ServerPeer, 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 { C as Context } from '../../shared/server.CcR4kgje.mjs';
+import { S as StandardHandler, a as StandardHandlerOptions } from '../../shared/server.DDFizwfU.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 { R as Router } from '../../shared/server.15O7oC1p.mjs';
+import { R as RPCHandlerCodecOptions } from '../../shared/server.B4BnEWWm.mjs';
 import '@orpc/client';
 import '@orpc/contract';
 import '@standardserver/core';
@@ -41,25 +41,23 @@ declare class MessagePortHandler<T extends Context> {
     private readonly decodePeerMessageOptions;
     constructor(handler: StandardHandler<T>, options?: NoInfer<MessagePortHandlerOptions<T>>);
     /**
-     * Attaches necessary event listeners to a message port to handle incoming messages and peer management.
+     * Attaches message and close listeners to a message port.
+     *
+     * Prefer this over calling `.message()` and `.close()` manually.
      */
     upgrade(port: SupportedMessagePort, ...rest: MaybeOptionalOptions<StandardPeerRequestHandlerOptions<T>>): void;
     /**
      * Handles a single message received from a message port.
      *
-     * @warning AVOID calling this method directly if `.upgrade()` is used, as `.upgrade()` already sets up necessary event listeners to call this method for incoming messages and manage peer lifecycle.
-     *
-     * @param port The message port instance, require consistent instance across messages for proper peer management
+     * @param port The message port instance. Use the same instance for all messages.
      */
-    message(port: SupportedMessagePort, data: any, ...rest: MaybeOptionalOptions<StandardPeerRequestHandlerOptions<T>>): Promise<{
+    message(port: SupportedMessagePort, data: unknown, ...rest: MaybeOptionalOptions<StandardPeerRequestHandlerOptions<T>>): Promise<{
         matched: boolean;
     }>;
     /**
-     * Called when a message port is closed, to clean up any associated peer state.
-     *
-     * @warning AVOID calling this method directly if `.upgrade()` is used, as `.upgrade()` already sets up necessary event listeners to call this method for incoming messages and manage peer lifecycle.
+     * Cleans up peer state for a closed message port.
      *
-     * @param port The message port instance to clean up, must be the same instance used in `.message()` calls to properly clean up
+     * @param port The same message port instance passed to `.message()`.
      */
     close(port: SupportedMessagePort): Promise<void>;
 }

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

@@ -1,11 +1,11 @@
 import { SupportedMessagePort } from '@orpc/client/message-port';
 import { Value, Promisable, MaybeOptionalOptions } from '@orpc/shared';
 import { ServerPeer, 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 { C as Context } from '../../shared/server.CcR4kgje.js';
+import { S as StandardHandler, a as StandardHandlerOptions } from '../../shared/server.BhsVw7m7.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 { R as Router } from '../../shared/server.m3szVJGU.js';
+import { R as RPCHandlerCodecOptions } from '../../shared/server.CnN50DHH.js';
 import '@orpc/client';
 import '@orpc/contract';
 import '@standardserver/core';
@@ -41,25 +41,23 @@ declare class MessagePortHandler<T extends Context> {
     private readonly decodePeerMessageOptions;
     constructor(handler: StandardHandler<T>, options?: NoInfer<MessagePortHandlerOptions<T>>);
     /**
-     * Attaches necessary event listeners to a message port to handle incoming messages and peer management.
+     * Attaches message and close listeners to a message port.
+     *
+     * Prefer this over calling `.message()` and `.close()` manually.
      */
     upgrade(port: SupportedMessagePort, ...rest: MaybeOptionalOptions<StandardPeerRequestHandlerOptions<T>>): void;
     /**
      * Handles a single message received from a message port.
      *
-     * @warning AVOID calling this method directly if `.upgrade()` is used, as `.upgrade()` already sets up necessary event listeners to call this method for incoming messages and manage peer lifecycle.
-     *
-     * @param port The message port instance, require consistent instance across messages for proper peer management
+     * @param port The message port instance. Use the same instance for all messages.
      */
-    message(port: SupportedMessagePort, data: any, ...rest: MaybeOptionalOptions<StandardPeerRequestHandlerOptions<T>>): Promise<{
+    message(port: SupportedMessagePort, data: unknown, ...rest: MaybeOptionalOptions<StandardPeerRequestHandlerOptions<T>>): Promise<{
         matched: boolean;
     }>;
     /**
-     * Called when a message port is closed, to clean up any associated peer state.
-     *
-     * @warning AVOID calling this method directly if `.upgrade()` is used, as `.upgrade()` already sets up necessary event listeners to call this method for incoming messages and manage peer lifecycle.
+     * Cleans up peer state for a closed message port.
      *
-     * @param port The message port instance to clean up, must be the same instance used in `.message()` calls to properly clean up
+     * @param port The same message port instance passed to `.message()`.
      */
     close(port: SupportedMessagePort): Promise<void>;
 }

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

@@ -1,13 +1,13 @@
 import { onMessagePortMessage, onMessagePortClose, postMessagePortMessage } from '@orpc/client/message-port';
-import { value, isPlainObject, resolveMaybeOptionalOptions, toStringOrBytes } from '@orpc/shared';
-import { ServerPeer, encodePeerMessage, decodePeerMessage, isClientPeerSendMessage } from '@standardserver/peer';
+import { value, resolveMaybeOptionalOptions } from '@orpc/shared';
+import { ServerPeer, encodePeerMessage, decodePeerMessage, isClientPeerSendMessage, isPeerMessage } 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.COPVXhDG.mjs';
 import '@orpc/client';
 import '@standardserver/core';
-import '../../shared/server.CrlKQucM.mjs';
+import '../../shared/server.DofEOwf-.mjs';
 import '@orpc/contract';
-import '../../shared/server.BwHnWUuN.mjs';
+import '../../shared/server.BoiFpNT7.mjs';
 
 class MessagePortHandler {
   constructor(handler, options = {}) {
@@ -21,7 +21,9 @@ class MessagePortHandler {
   encodePeerMessageOptions;
   decodePeerMessageOptions;
   /**
-   * Attaches necessary event listeners to a message port to handle incoming messages and peer management.
+   * Attaches message and close listeners to a message port.
+   *
+   * Prefer this over calling `.message()` and `.close()` manually.
    */
   upgrade(port, ...rest) {
     onMessagePortMessage(port, (message) => this.message(port, message, ...rest));
@@ -30,51 +32,45 @@ class MessagePortHandler {
   /**
    * Handles a single message received from a message port.
    *
-   * @warning AVOID calling this method directly if `.upgrade()` is used, as `.upgrade()` already sets up necessary event listeners to call this method for incoming messages and manage peer lifecycle.
-   *
-   * @param port The message port instance, require consistent instance across messages for proper peer management
+   * @param port The message port instance. Use the same instance for all messages.
    */
   async message(port, data, ...rest) {
     let peer = this.peers.get(port);
     if (!peer) {
-      this.peers.set(port, peer = new ServerPeer(async (message2) => {
-        const transfer = await value(this.transfer, message2, port);
+      this.peers.set(port, peer = new ServerPeer(async (message) => {
+        const transfer = await value(this.transfer, message, port);
         if (transfer) {
-          postMessagePortMessage(port, message2, transfer);
+          postMessagePortMessage(port, message, transfer);
         } else {
-          postMessagePortMessage(port, await encodePeerMessage(message2, this.encodePeerMessageOptions));
+          postMessagePortMessage(port, await encodePeerMessage(message, this.encodePeerMessageOptions));
         }
       }));
     }
-    if (isPlainObject(data)) {
-      await peer.message(
-        data,
-        createStandardPeerRequestHandler(this.handler, resolveMaybeOptionalOptions(rest))
-      );
-      return { matched: true };
+    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;
     }
-    const message = await toStringOrBytes(data);
-    const result = decodePeerMessage(message, this.decodePeerMessageOptions);
-    if (result.matched && isClientPeerSendMessage(result.message)) {
-      await peer.message(
-        result.message,
-        createStandardPeerRequestHandler(this.handler, resolveMaybeOptionalOptions(rest))
-      );
+    if (peerMessage === void 0) {
+      return { matched: false };
     }
-    return result;
+    await peer.message(peerMessage, createStandardPeerRequestHandler(this.handler, resolveMaybeOptionalOptions(rest)));
+    return { matched: true };
   }
   /**
-   * Called when a message port is closed, to clean up any associated peer state.
-   *
-   * @warning AVOID calling this method directly if `.upgrade()` is used, as `.upgrade()` already sets up necessary event listeners to call this method for incoming messages and manage peer lifecycle.
+   * Cleans up peer state for a closed message port.
    *
-   * @param port The message port instance to clean up, must be the same instance used in `.message()` calls to properly clean up
+   * @param port The same message port instance passed to `.message()`.
    */
   async close(port) {
     const peer = this.peers.get(port);
     if (peer) {
-      await peer.close();
       this.peers.delete(port);
+      await peer.close();
     }
   }
 }

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

@@ -1,11 +1,10 @@
-import { SendStandardResponseOptions, NodeHttpRequest, NodeHttpResponse } from '@standardserver/node';
-import { C as Context } from '../../shared/server.BL22TloH.mjs';
 import { Interceptor, MaybeOptionalOptions } from '@orpc/shared';
-import { e as StandardHandlerPlugin, b as StandardHandlerHandleOptions, S as StandardHandler, a as StandardHandlerOptions } from '../../shared/server.BB_Ik9Ph.mjs';
+import { SendStandardResponseOptions, NodeHttpRequest, NodeHttpResponse } from '@standardserver/node';
+import { C as Context } from '../../shared/server.CcR4kgje.mjs';
+import { e as StandardHandlerPlugin, b as StandardHandlerHandleOptions, S as StandardHandler, a as StandardHandlerOptions } from '../../shared/server.DDFizwfU.mjs';
 import { FriendlyStandardHandlerHandleOptions } from '../standard/index.mjs';
-import compression from '@orpc/interop/compression';
-import { R as Router } from '../../shared/server.BsNNjG5J.mjs';
-import { R as RPCHandlerCodecOptions } from '../../shared/server.B_U9y00a.mjs';
+import { R as Router } from '../../shared/server.15O7oC1p.mjs';
+import { R as RPCHandlerCodecOptions } from '../../shared/server.B4BnEWWm.mjs';
 import '@orpc/client';
 import '@orpc/contract';
 import '@standardserver/core';
@@ -71,35 +70,6 @@ declare class NodeHttpHandler<T extends Context> {
     handle(request: NodeHttpRequest, response: NodeHttpResponse, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): Promise<NodeHttpHandlerHandleResult>;
 }
 
-interface BodyCompressionHandlerPluginOptions extends compression.CompressionOptions {
-    /**
-     * Override the default content-type filter used to determine which responses should be compressed.
-     *
-     * @warning Event stream responses are never compressed, regardless of this filter's return value.
-     * @default only responses with compressible content types are compressed.
-     */
-    filter?: (request: NodeHttpRequest, response: NodeHttpResponse) => boolean;
-}
-declare class BodyCompressionHandlerPlugin<T extends Context> implements NodeHttpHandlerPlugin<T> {
-    name: string;
-    private readonly compressionHandler;
-    constructor(options?: BodyCompressionHandlerPluginOptions);
-    initNodeHttpHandlerOptions(options: NodeHttpHandlerOptions<T>): NodeHttpHandlerOptions<T>;
-}
-
-interface BodyLimitHandlerPluginOptions {
-    /**
-     * The maximum size of the body in bytes.
-     */
-    maxBodySize: number;
-}
-declare class BodyLimitHandlerPlugin<T extends Context> implements NodeHttpHandlerPlugin<T> {
-    name: string;
-    private readonly maxBodySize;
-    constructor(options: BodyLimitHandlerPluginOptions);
-    initNodeHttpHandlerOptions(options: NodeHttpHandlerOptions<T>): NodeHttpHandlerOptions<T>;
-}
-
 interface RPCHandlerOptions<T extends Context> extends NodeHttpHandlerOptions<T>, Omit<StandardHandlerOptions<T>, 'plugins'>, RPCHandlerCodecOptions<T> {
     /**
      * Configuration for {@link CSRFGuardHandlerPlugin}, which is enabled by default for `RPCHandler` over HTTP.
@@ -117,5 +87,5 @@ declare class RPCHandler<T extends Context> extends NodeHttpHandler<T> {
     constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
 }
 
-export { BodyCompressionHandlerPlugin, BodyLimitHandlerPlugin, CompositeNodeHttpHandlerPlugin, NodeHttpHandler, RPCHandler };
-export type { BodyCompressionHandlerPluginOptions, BodyLimitHandlerPluginOptions, NodeHttpHandlerHandleResult, NodeHttpHandlerNodeHttpInterceptor, NodeHttpHandlerNodeHttpInterceptorOptions, NodeHttpHandlerOptions, NodeHttpHandlerPlugin, RPCHandlerOptions };
+export { CompositeNodeHttpHandlerPlugin, NodeHttpHandler, RPCHandler };
+export type { NodeHttpHandlerHandleResult, NodeHttpHandlerNodeHttpInterceptor, NodeHttpHandlerNodeHttpInterceptorOptions, NodeHttpHandlerOptions, NodeHttpHandlerPlugin, RPCHandlerOptions };

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

@@ -1,11 +1,10 @@
-import { SendStandardResponseOptions, NodeHttpRequest, NodeHttpResponse } from '@standardserver/node';
-import { C as Context } from '../../shared/server.BL22TloH.js';
 import { Interceptor, MaybeOptionalOptions } from '@orpc/shared';
-import { e as StandardHandlerPlugin, b as StandardHandlerHandleOptions, S as StandardHandler, a as StandardHandlerOptions } from '../../shared/server.EOHJ3NJr.js';
+import { SendStandardResponseOptions, NodeHttpRequest, NodeHttpResponse } from '@standardserver/node';
+import { C as Context } from '../../shared/server.CcR4kgje.js';
+import { e as StandardHandlerPlugin, b as StandardHandlerHandleOptions, S as StandardHandler, a as StandardHandlerOptions } from '../../shared/server.BhsVw7m7.js';
 import { FriendlyStandardHandlerHandleOptions } from '../standard/index.js';
-import compression from '@orpc/interop/compression';
-import { R as Router } from '../../shared/server.Pa0F03f_.js';
-import { R as RPCHandlerCodecOptions } from '../../shared/server.T9F3bzZx.js';
+import { R as Router } from '../../shared/server.m3szVJGU.js';
+import { R as RPCHandlerCodecOptions } from '../../shared/server.CnN50DHH.js';
 import '@orpc/client';
 import '@orpc/contract';
 import '@standardserver/core';
@@ -71,35 +70,6 @@ declare class NodeHttpHandler<T extends Context> {
     handle(request: NodeHttpRequest, response: NodeHttpResponse, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): Promise<NodeHttpHandlerHandleResult>;
 }
 
-interface BodyCompressionHandlerPluginOptions extends compression.CompressionOptions {
-    /**
-     * Override the default content-type filter used to determine which responses should be compressed.
-     *
-     * @warning Event stream responses are never compressed, regardless of this filter's return value.
-     * @default only responses with compressible content types are compressed.
-     */
-    filter?: (request: NodeHttpRequest, response: NodeHttpResponse) => boolean;
-}
-declare class BodyCompressionHandlerPlugin<T extends Context> implements NodeHttpHandlerPlugin<T> {
-    name: string;
-    private readonly compressionHandler;
-    constructor(options?: BodyCompressionHandlerPluginOptions);
-    initNodeHttpHandlerOptions(options: NodeHttpHandlerOptions<T>): NodeHttpHandlerOptions<T>;
-}
-
-interface BodyLimitHandlerPluginOptions {
-    /**
-     * The maximum size of the body in bytes.
-     */
-    maxBodySize: number;
-}
-declare class BodyLimitHandlerPlugin<T extends Context> implements NodeHttpHandlerPlugin<T> {
-    name: string;
-    private readonly maxBodySize;
-    constructor(options: BodyLimitHandlerPluginOptions);
-    initNodeHttpHandlerOptions(options: NodeHttpHandlerOptions<T>): NodeHttpHandlerOptions<T>;
-}
-
 interface RPCHandlerOptions<T extends Context> extends NodeHttpHandlerOptions<T>, Omit<StandardHandlerOptions<T>, 'plugins'>, RPCHandlerCodecOptions<T> {
     /**
      * Configuration for {@link CSRFGuardHandlerPlugin}, which is enabled by default for `RPCHandler` over HTTP.
@@ -117,5 +87,5 @@ declare class RPCHandler<T extends Context> extends NodeHttpHandler<T> {
     constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
 }
 
-export { BodyCompressionHandlerPlugin, BodyLimitHandlerPlugin, CompositeNodeHttpHandlerPlugin, NodeHttpHandler, RPCHandler };
-export type { BodyCompressionHandlerPluginOptions, BodyLimitHandlerPluginOptions, NodeHttpHandlerHandleResult, NodeHttpHandlerNodeHttpInterceptor, NodeHttpHandlerNodeHttpInterceptorOptions, NodeHttpHandlerOptions, NodeHttpHandlerPlugin, RPCHandlerOptions };
+export { CompositeNodeHttpHandlerPlugin, NodeHttpHandler, RPCHandler };
+export type { NodeHttpHandlerHandleResult, NodeHttpHandlerNodeHttpInterceptor, NodeHttpHandlerNodeHttpInterceptorOptions, NodeHttpHandlerOptions, NodeHttpHandlerPlugin, RPCHandlerOptions };

package/dist/adapters/node/index.mjs

@@ -1,119 +1,13 @@
-import compression from '@orpc/interop/compression';
-import { toArray, sortPlugins, intercept, resolveMaybeOptionalOptions } from '@orpc/shared';
-import { ORPCError } from '@orpc/client';
+import { sortPlugins, intercept, resolveMaybeOptionalOptions, toArray } 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.COPVXhDG.mjs';
+import '@orpc/client';
 import '@standardserver/core';
-import '../../shared/server.CrlKQucM.mjs';
+import '../../shared/server.DofEOwf-.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.BoiFpNT7.mjs';
 
 class CompositeNodeHttpHandlerPlugin {
   name = "~composite/node-http-handler";
@@ -176,4 +70,4 @@ class RPCHandler extends NodeHttpHandler {
   }
 }
 
-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';
+import { b as StandardHandlerHandleOptions } from '../../shared/server.DDFizwfU.mjs';
+export { C as CompositeStandardHandlerPlugin, O as OtelHandlerPlugin, S as StandardHandler, c as StandardHandlerCodec, d as StandardHandlerCodecResolvedProcedure, h as StandardHandlerHandleResult, i as StandardHandlerInterceptor, g as StandardHandlerInterceptorOptions, a as StandardHandlerOptions, e as StandardHandlerPlugin, j as StandardHandlerRoutingInterceptor, f as StandardHandlerRoutingInterceptorOptions } from '../../shared/server.DDFizwfU.mjs';
+export { a as RPCHandlerCodec, R as RPCHandlerCodecOptions, b as RPCMatcher, c as RPCMatcherOptions } from '../../shared/server.B4BnEWWm.mjs';
+import { C as Context } from '../../shared/server.CcR4kgje.mjs';
+export { StandardBody, StandardBodyHint, StandardHeaders, StandardLazyRequest, StandardLazyResponse, StandardMethod, StandardRequest, StandardResponse, StandardUrl } from '@standardserver/core';
 import '@orpc/client';
 import '@orpc/shared';
-import '@standardserver/core';
 import '@orpc/contract';
-import '../../shared/server.BsNNjG5J.mjs';
+import '../../shared/server.15O7oC1p.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';
+import { b as StandardHandlerHandleOptions } from '../../shared/server.BhsVw7m7.js';
+export { C as CompositeStandardHandlerPlugin, O as OtelHandlerPlugin, S as StandardHandler, c as StandardHandlerCodec, d as StandardHandlerCodecResolvedProcedure, h as StandardHandlerHandleResult, i as StandardHandlerInterceptor, g as StandardHandlerInterceptorOptions, a as StandardHandlerOptions, e as StandardHandlerPlugin, j as StandardHandlerRoutingInterceptor, f as StandardHandlerRoutingInterceptorOptions } from '../../shared/server.BhsVw7m7.js';
+export { a as RPCHandlerCodec, R as RPCHandlerCodecOptions, b as RPCMatcher, c as RPCMatcherOptions } from '../../shared/server.CnN50DHH.js';
+import { C as Context } from '../../shared/server.CcR4kgje.js';
+export { StandardBody, StandardBodyHint, StandardHeaders, StandardLazyRequest, StandardLazyResponse, StandardMethod, StandardRequest, StandardResponse, StandardUrl } from '@standardserver/core';
 import '@orpc/client';
 import '@orpc/shared';
-import '@standardserver/core';
 import '@orpc/contract';
-import '../../shared/server.Pa0F03f_.js';
+import '../../shared/server.m3szVJGU.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, S as StandardHandler } from '../../shared/server.COPVXhDG.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.DofEOwf-.mjs';
 import '@orpc/contract';
-import '../../shared/server.BwHnWUuN.mjs';
+import '../../shared/server.BoiFpNT7.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 { C as Context } from '../../shared/server.CcR4kgje.mjs';
+import { b as StandardHandlerHandleOptions, S as StandardHandler } from '../../shared/server.DDFizwfU.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 { C as Context } from '../../shared/server.CcR4kgje.js';
+import { b as StandardHandlerHandleOptions, S as StandardHandler } from '../../shared/server.BhsVw7m7.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 { C as Context } from '../../shared/server.CcR4kgje.mjs';
+import { S as StandardHandler, a as StandardHandlerOptions } from '../../shared/server.DDFizwfU.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 { R as Router } from '../../shared/server.15O7oC1p.mjs';
+import { R as RPCHandlerCodecOptions } from '../../shared/server.B4BnEWWm.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,46 @@ 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> {
+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 };