@orpc/server 1.14.5 → 2.0.0-beta.1

package/dist/adapters/fetch/index.mjs

@@ -1,62 +1,17 @@
+import { toArray, sortPlugins, intercept, resolveMaybeOptionalOptions } from '@orpc/shared';
 import { ORPCError } from '@orpc/client';
-import { toArray, intercept, resolveMaybeOptionalOptions } from '@orpc/shared';
-import { toStandardLazyRequest, toFetchResponse } from '@orpc/standard-server-fetch';
-import { r as resolveFriendlyStandardHandleOptions } from '../../shared/server.DZ5BIITo.mjs';
-import { C as CompositeStandardHandlerPlugin, b as StandardRPCHandler } from '../../shared/server.ZxHCEN1h.mjs';
-import { S as StrictGetMethodPlugin } from '../../shared/server.TEVCLCFC.mjs';
-import '@orpc/client/standard';
-import '@orpc/standard-server';
-import '../../shared/server.DEBcqOjg.mjs';
+import { toStandardLazyRequest, toFetchResponse } from '@standardserver/fetch';
+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 '@standardserver/core';
+import '../../shared/server.CrlKQucM.mjs';
 import '@orpc/contract';
-
-class BodyLimitPlugin {
-  maxBodySize;
-  constructor(options) {
-    this.maxBodySize = options.maxBodySize;
-  }
-  initRuntimeAdapter(options) {
-    options.adapterInterceptors ??= [];
-    options.adapterInterceptors.push(async (options2) => {
-      if (!options2.request.body) {
-        return options2.next();
-      }
-      let currentBodySize = 0;
-      const rawReader = options2.request.body.getReader();
-      const reader = new ReadableStream({
-        start: async (controller) => {
-          try {
-            if (Number(options2.request.headers.get("content-length")) > this.maxBodySize) {
-              controller.error(new ORPCError("PAYLOAD_TOO_LARGE"));
-              return;
-            }
-            while (true) {
-              const { done, value } = await rawReader.read();
-              if (done) {
-                break;
-              }
-              currentBodySize += value.length;
-              if (currentBodySize > this.maxBodySize) {
-                controller.error(new ORPCError("PAYLOAD_TOO_LARGE"));
-                break;
-              }
-              controller.enqueue(value);
-            }
-          } finally {
-            controller.close();
-          }
-        }
-      });
-      const requestInit = { body: reader, duplex: "half" };
-      return options2.next({
-        ...options2,
-        request: new Request(options2.request, requestInit)
-      });
-    });
-  }
-}
+import '../../shared/server.BwHnWUuN.mjs';
 
 const ORDERED_SUPPORTED_ENCODINGS = ["gzip", "deflate"];
-class CompressionPlugin {
+class BodyCompressionHandlerPlugin {
+  name = "~body-compression";
   encodings;
   threshold;
   filter;
@@ -72,42 +27,47 @@ class CompressionPlugin {
       return options.filter ? options.filter(request, response) : isCompressibleContentType(contentType);
     };
   }
-  initRuntimeAdapter(options) {
-    options.adapterInterceptors ??= [];
-    options.adapterInterceptors.unshift(async (options2) => {
-      const result = await options2.next();
-      if (!result.matched) {
-        return result;
-      }
-      const response = result.response;
-      if (response.headers.has("content-encoding") || response.headers.has("transfer-encoding") || isNoTransformCacheControl(response.headers.get("cache-control"))) {
-        return result;
-      }
-      const contentLength = response.headers.get("content-length");
-      if (contentLength && Number(contentLength) < this.threshold) {
-        return result;
-      }
-      const acceptEncoding = options2.request.headers.get("accept-encoding")?.split(",").map((enc) => enc.trim().split(";")[0]);
-      const encoding = this.encodings.find((enc) => acceptEncoding?.includes(enc));
-      if (!response.body || encoding === void 0) {
-        return result;
-      }
-      if (!this.filter(options2.request, response)) {
-        return result;
-      }
-      const compressedBody = response.body.pipeThrough(new CompressionStream(encoding));
-      const compressedHeaders = new Headers(response.headers);
-      compressedHeaders.delete("content-length");
-      compressedHeaders.set("content-encoding", encoding);
-      return {
-        ...result,
-        response: new Response(compressedBody, {
-          status: response.status,
-          statusText: response.statusText,
-          headers: compressedHeaders
-        })
-      };
-    });
+  initFetchHandlerOptions(options) {
+    return {
+      ...options,
+      fetchInterceptors: [
+        async (interceptorOptions) => {
+          const result = await interceptorOptions.next();
+          if (!result.matched) {
+            return result;
+          }
+          const response = result.response;
+          if (response.headers.has("content-encoding") || response.headers.has("transfer-encoding") || isNoTransformCacheControl(response.headers.get("cache-control"))) {
+            return result;
+          }
+          const contentLength = response.headers.get("content-length");
+          if (contentLength && Number(contentLength) < this.threshold) {
+            return result;
+          }
+          const acceptEncoding = interceptorOptions.request.headers.get("accept-encoding")?.split(",").map((enc) => enc.trim().split(";")[0]);
+          const encoding = this.encodings.find((enc) => acceptEncoding?.includes(enc));
+          if (!response.body || encoding === void 0) {
+            return result;
+          }
+          if (!this.filter(interceptorOptions.request, response)) {
+            return result;
+          }
+          const compressedBody = response.body.pipeThrough(new CompressionStream(encoding));
+          const compressedHeaders = new Headers(response.headers);
+          compressedHeaders.delete("content-length");
+          compressedHeaders.set("content-encoding", encoding);
+          return {
+            ...result,
+            response: new Response(compressedBody, {
+              status: response.status,
+              statusText: response.statusText,
+              headers: compressedHeaders
+            })
+          };
+        },
+        ...toArray(options.fetchInterceptors)
+      ]
+    };
   }
 }
 const COMPRESSIBLE_CONTENT_TYPE_REGEX = /^\s*(?:text\/(?!event-stream(?:[;\s]|$))[^;\s]+|application\/(?:javascript|json|xml|xml-dtd|ecmascript|dart|postscript|rtf|tar|toml|vnd\.dart|vnd\.ms-fontobject|vnd\.ms-opentype|wasm|x-httpd-php|x-javascript|x-ns-proxy-autoconfig|x-sh|x-tar|x-virtualbox-hdd|x-virtualbox-ova|x-virtualbox-ovf|x-virtualbox-vbox|x-virtualbox-vdi|x-virtualbox-vhd|x-virtualbox-vmdk|x-www-form-urlencoded)|font\/(?:otf|ttf)|image\/(?:bmp|vnd\.adobe\.photoshop|vnd\.microsoft\.icon|vnd\.ms-dds|x-icon|x-ms-bmp)|message\/rfc822|model\/gltf-binary|x-shader\/x-fragment|x-shader\/x-vertex|[^;\s]+?\+(?:json|text|xml|yaml))(?:[;\s]|$)/i;
@@ -125,29 +85,90 @@ function isNoTransformCacheControl(cacheControl) {
   return CACHE_CONTROL_NO_TRANSFORM_REGEX.test(cacheControl);
 }
 
-class CompositeFetchHandlerPlugin extends CompositeStandardHandlerPlugin {
-  initRuntimeAdapter(options) {
+class BodyLimitHandlerPlugin {
+  name = "~body-limit";
+  maxBodySize;
+  constructor(options) {
+    this.maxBodySize = options.maxBodySize;
+  }
+  initFetchHandlerOptions(options) {
+    return {
+      ...options,
+      fetchInterceptors: [
+        async (interceptorOptions) => {
+          if (!interceptorOptions.request.body) {
+            return interceptorOptions.next();
+          }
+          let currentBodySize = 0;
+          const rawReader = interceptorOptions.request.body.getReader();
+          const body = new ReadableStream({
+            start: async (controller) => {
+              const reject = async (error) => {
+                controller.error(error);
+                await rawReader.cancel(error);
+              };
+              const contentLength = interceptorOptions.request.headers.get("content-length");
+              if (contentLength && Number(contentLength) > this.maxBodySize) {
+                await reject(new ORPCError("PAYLOAD_TOO_LARGE"));
+                return;
+              }
+              while (true) {
+                const { done, value } = await rawReader.read();
+                if (done) {
+                  controller.close();
+                  return;
+                }
+                currentBodySize += value.length;
+                if (currentBodySize > this.maxBodySize) {
+                  await reject(new ORPCError("PAYLOAD_TOO_LARGE"));
+                  return;
+                }
+                controller.enqueue(value);
+              }
+            }
+          });
+          const requestInit = { body, duplex: "half" };
+          return interceptorOptions.next({
+            ...interceptorOptions,
+            request: new Request(interceptorOptions.request, requestInit)
+          });
+        },
+        ...toArray(options.fetchInterceptors)
+      ]
+    };
+  }
+}
+
+class CompositeFetchHandlerPlugin {
+  name = "~composite/fetch-handler";
+  plugins;
+  constructor(plugins = []) {
+    this.plugins = sortPlugins(plugins);
+  }
+  initFetchHandlerOptions(options) {
     for (const plugin of this.plugins) {
-      plugin.initRuntimeAdapter?.(options);
+      if (plugin.initFetchHandlerOptions) {
+        options = plugin.initFetchHandlerOptions(options);
+      }
     }
+    return options;
   }
 }
 
 class FetchHandler {
   constructor(standardHandler, options = {}) {
     this.standardHandler = standardHandler;
-    const plugin = new CompositeFetchHandlerPlugin(options.plugins);
-    plugin.initRuntimeAdapter(options);
-    this.adapterInterceptors = toArray(options.adapterInterceptors);
-    this.toFetchResponseOptions = options;
+    options = new CompositeFetchHandlerPlugin(options.plugins).initFetchHandlerOptions(options);
+    this.fetchInterceptors = options.fetchInterceptors;
+    this.toFetchResponseOptions = options.toFetchResponse;
   }
   toFetchResponseOptions;
-  adapterInterceptors;
+  fetchInterceptors;
   async handle(request, ...rest) {
     return intercept(
-      this.adapterInterceptors,
+      this.fetchInterceptors,
       {
-        ...resolveFriendlyStandardHandleOptions(resolveMaybeOptionalOptions(rest)),
+        ...resolveFriendlyStandardHandlerHandleOptions(resolveMaybeOptionalOptions(rest)),
         request,
         toFetchResponseOptions: this.toFetchResponseOptions
       },
@@ -168,12 +189,16 @@ class FetchHandler {
 
 class RPCHandler extends FetchHandler {
   constructor(router, options = {}) {
-    if (options.strictGetMethodPluginEnabled ?? true) {
-      options.plugins ??= [];
-      options.plugins.push(new StrictGetMethodPlugin());
+    if (options.csrfGuardHandlerPlugin?.enabled !== false) {
+      options = {
+        ...options,
+        plugins: [...toArray(options.plugins), new CSRFGuardHandlerPlugin()]
+      };
     }
-    super(new StandardRPCHandler(router, options), options);
+    const codec = new RPCHandlerCodec(router, options);
+    const handler = new StandardHandler(codec, options);
+    super(handler, options);
   }
 }
 
-export { BodyLimitPlugin, CompositeFetchHandlerPlugin, CompressionPlugin, FetchHandler, RPCHandler };
+export { BodyCompressionHandlerPlugin, BodyLimitHandlerPlugin, CompositeFetchHandlerPlugin, FetchHandler, RPCHandler };

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

@@ -1,56 +1,73 @@
 import { SupportedMessagePort } from '@orpc/client/message-port';
 import { Value, Promisable, MaybeOptionalOptions } from '@orpc/shared';
-import { DecodedResponseMessage } from '@orpc/standard-server-peer';
-import { C as Context, R as Router } from '../../shared/server.qKsRrdxW.mjs';
-import { f as StandardHandler } from '../../shared/server.BqadksTP.mjs';
-import { HandleStandardServerPeerMessageOptions } from '../standard-peer/index.mjs';
-import { S as StandardRPCHandlerOptions } from '../../shared/server.ChUyt5-i.mjs';
+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 { 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 '@orpc/client';
 import '@orpc/contract';
-import '@orpc/standard-server';
-import '../../shared/server.B8gYOD5g.mjs';
-import '@orpc/client/standard';
-import '../../shared/server.C8_sRzQB.mjs';
+import '@standardserver/core';
 
+type DecodedResponseMessage = ConstructorParameters<typeof ServerPeer>[0] extends (message: infer TMessage) => unknown ? TMessage : never;
 interface MessagePortHandlerOptions<_T extends Context> {
     /**
-     * By default, oRPC serializes request/response messages to string/binary data before sending over message port.
-     * If needed, you can define the this option to utilize full power of [MessagePort: postMessage() method](https://developer.mozilla.org/en-US/docs/Web/API/MessagePort/postMessage),
-     * such as transferring ownership of objects to the other side or support unserializable objects like `OffscreenCanvas`.
+     * By default, oRPC encodes peer messages as strings or binary data before sending them over the message port.
+     * Use this option to bypass encoding and leverage the full capabilities of the
+     * [MessagePort: postMessage() method](https://developer.mozilla.org/en-US/docs/Web/API/MessagePort/postMessage),
+     * such as transferring object ownership or supporting non-serializable objects like `OffscreenCanvas` or improving performance.
      *
      * @remarks
-     * - return null | undefined to disable this feature
+     * - Returning `null` or `undefined` disables this feature.
      *
-     * @warning Make sure your message port supports `transfer` before using this feature.
-     * @example
-     * ```ts
-     * experimental_transfer: (message, port) => {
-     *   const transfer = deepFindTransferableObjects(message) // implement your own logic
-     *   return transfer.length ? transfer : null // only enable when needed
-     * }
-     * ```
-     *
-     * @see {@link https://orpc.dev/docs/adapters/message-port#transfer Message Port Transfer Docs}
+     * @warning Ensure your message port implementation supports `transferable` objects before enabling this.
      */
     experimental_transfer?: Value<Promisable<object[] | null | undefined>, [message: DecodedResponseMessage, port: SupportedMessagePort]>;
+    /**
+     * 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 MessagePortHandler<T extends Context> {
-    private readonly standardHandler;
+    private readonly handler;
+    private readonly peers;
     private readonly transfer;
-    constructor(standardHandler: StandardHandler<T>, options?: NoInfer<MessagePortHandlerOptions<T>>);
-    upgrade(port: SupportedMessagePort, ...rest: MaybeOptionalOptions<HandleStandardServerPeerMessageOptions<T>>): void;
+    private readonly encodePeerMessageOptions;
+    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.
+     */
+    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
+     */
+    message(port: SupportedMessagePort, data: any, ...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.
+     *
+     * @param port The message port instance to clean up, must be the same instance used in `.message()` calls to properly clean up
+     */
+    close(port: SupportedMessagePort): Promise<void>;
 }
 
-interface RPCHandlerOptions<T extends Context> extends StandardRPCHandlerOptions<T>, MessagePortHandlerOptions<T> {
+interface RPCHandlerOptions<T extends Context> extends StandardHandlerOptions<T>, RPCHandlerCodecOptions<T>, MessagePortHandlerOptions<T> {
 }
-/**
- * RPC Handler for common message port implementations.
- *
- * @see {@link https://orpc.dev/docs/rpc-handler RPC Handler Docs}
- * @see {@link https://orpc.dev/docs/adapters/message-port Message Port Adapter Docs}
- */
 declare class RPCHandler<T extends Context> extends MessagePortHandler<T> {
-    constructor(router: Router<any, T>, options?: NoInfer<RPCHandlerOptions<T>>);
+    constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
 }
 
 export { MessagePortHandler, RPCHandler };

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

@@ -1,56 +1,73 @@
 import { SupportedMessagePort } from '@orpc/client/message-port';
 import { Value, Promisable, MaybeOptionalOptions } from '@orpc/shared';
-import { DecodedResponseMessage } from '@orpc/standard-server-peer';
-import { C as Context, R as Router } from '../../shared/server.qKsRrdxW.js';
-import { f as StandardHandler } from '../../shared/server.7cEtMB30.js';
-import { HandleStandardServerPeerMessageOptions } from '../standard-peer/index.js';
-import { S as StandardRPCHandlerOptions } from '../../shared/server.yoEB3Fx4.js';
+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 { 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 '@orpc/client';
 import '@orpc/contract';
-import '@orpc/standard-server';
-import '../../shared/server.EfTOZ2Q7.js';
-import '@orpc/client/standard';
-import '../../shared/server.ChyoA9XY.js';
+import '@standardserver/core';
 
+type DecodedResponseMessage = ConstructorParameters<typeof ServerPeer>[0] extends (message: infer TMessage) => unknown ? TMessage : never;
 interface MessagePortHandlerOptions<_T extends Context> {
     /**
-     * By default, oRPC serializes request/response messages to string/binary data before sending over message port.
-     * If needed, you can define the this option to utilize full power of [MessagePort: postMessage() method](https://developer.mozilla.org/en-US/docs/Web/API/MessagePort/postMessage),
-     * such as transferring ownership of objects to the other side or support unserializable objects like `OffscreenCanvas`.
+     * By default, oRPC encodes peer messages as strings or binary data before sending them over the message port.
+     * Use this option to bypass encoding and leverage the full capabilities of the
+     * [MessagePort: postMessage() method](https://developer.mozilla.org/en-US/docs/Web/API/MessagePort/postMessage),
+     * such as transferring object ownership or supporting non-serializable objects like `OffscreenCanvas` or improving performance.
      *
      * @remarks
-     * - return null | undefined to disable this feature
+     * - Returning `null` or `undefined` disables this feature.
      *
-     * @warning Make sure your message port supports `transfer` before using this feature.
-     * @example
-     * ```ts
-     * experimental_transfer: (message, port) => {
-     *   const transfer = deepFindTransferableObjects(message) // implement your own logic
-     *   return transfer.length ? transfer : null // only enable when needed
-     * }
-     * ```
-     *
-     * @see {@link https://orpc.dev/docs/adapters/message-port#transfer Message Port Transfer Docs}
+     * @warning Ensure your message port implementation supports `transferable` objects before enabling this.
      */
     experimental_transfer?: Value<Promisable<object[] | null | undefined>, [message: DecodedResponseMessage, port: SupportedMessagePort]>;
+    /**
+     * 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 MessagePortHandler<T extends Context> {
-    private readonly standardHandler;
+    private readonly handler;
+    private readonly peers;
     private readonly transfer;
-    constructor(standardHandler: StandardHandler<T>, options?: NoInfer<MessagePortHandlerOptions<T>>);
-    upgrade(port: SupportedMessagePort, ...rest: MaybeOptionalOptions<HandleStandardServerPeerMessageOptions<T>>): void;
+    private readonly encodePeerMessageOptions;
+    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.
+     */
+    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
+     */
+    message(port: SupportedMessagePort, data: any, ...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.
+     *
+     * @param port The message port instance to clean up, must be the same instance used in `.message()` calls to properly clean up
+     */
+    close(port: SupportedMessagePort): Promise<void>;
 }
 
-interface RPCHandlerOptions<T extends Context> extends StandardRPCHandlerOptions<T>, MessagePortHandlerOptions<T> {
+interface RPCHandlerOptions<T extends Context> extends StandardHandlerOptions<T>, RPCHandlerCodecOptions<T>, MessagePortHandlerOptions<T> {
 }
-/**
- * RPC Handler for common message port implementations.
- *
- * @see {@link https://orpc.dev/docs/rpc-handler RPC Handler Docs}
- * @see {@link https://orpc.dev/docs/adapters/message-port Message Port Adapter Docs}
- */
 declare class RPCHandler<T extends Context> extends MessagePortHandler<T> {
-    constructor(router: Router<any, T>, options?: NoInfer<RPCHandlerOptions<T>>);
+    constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
 }
 
 export { MessagePortHandler, RPCHandler };

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

@@ -1,54 +1,89 @@
-import { postMessagePortMessage, onMessagePortMessage, onMessagePortClose } from '@orpc/client/message-port';
-import { value, resolveMaybeOptionalOptions, isObject } from '@orpc/shared';
-import { experimental_ServerPeerWithoutCodec, serializeResponseMessage, encodeResponseMessage, deserializeRequestMessage, decodeRequestMessage } from '@orpc/standard-server-peer';
-import { createServerPeerHandleRequestFn } from '../standard-peer/index.mjs';
-import { b as StandardRPCHandler } from '../../shared/server.ZxHCEN1h.mjs';
-import '../../shared/server.DZ5BIITo.mjs';
-import '@orpc/client/standard';
+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 { c as createStandardPeerRequestHandler } from '../../shared/server.CX4vUnDk.mjs';
+import { R as RPCHandlerCodec, S as StandardHandler } from '../../shared/server.GDpX6Df8.mjs';
 import '@orpc/client';
-import '@orpc/standard-server';
-import '../../shared/server.DEBcqOjg.mjs';
+import '@standardserver/core';
+import '../../shared/server.CrlKQucM.mjs';
 import '@orpc/contract';
+import '../../shared/server.BwHnWUuN.mjs';
 
 class MessagePortHandler {
-  constructor(standardHandler, options = {}) {
-    this.standardHandler = standardHandler;
+  constructor(handler, options = {}) {
+    this.handler = handler;
     this.transfer = options.experimental_transfer;
+    this.encodePeerMessageOptions = options.encodePeerMessage;
+    this.decodePeerMessageOptions = options.decodePeerMessage;
   }
+  peers = /* @__PURE__ */ new WeakMap();
   transfer;
+  encodePeerMessageOptions;
+  decodePeerMessageOptions;
+  /**
+   * Attaches necessary event listeners to a message port to handle incoming messages and peer management.
+   */
   upgrade(port, ...rest) {
-    const peer = new experimental_ServerPeerWithoutCodec(async (message) => {
-      const [id, type, payload] = message;
-      const transfer = await value(this.transfer, message, port);
-      if (transfer) {
-        postMessagePortMessage(port, serializeResponseMessage(id, type, payload), transfer);
-      } else {
-        postMessagePortMessage(port, await encodeResponseMessage(id, type, payload));
-      }
-    });
-    onMessagePortMessage(port, async (message) => {
-      const handleFn = createServerPeerHandleRequestFn(this.standardHandler, resolveMaybeOptionalOptions(rest));
-      if (isObject(message)) {
-        await peer.message(
-          deserializeRequestMessage(message),
-          handleFn
-        );
-      } else {
-        await peer.message(
-          await decodeRequestMessage(message),
-          handleFn
-        );
-      }
-    });
-    onMessagePortClose(port, () => {
-      peer.close();
-    });
+    onMessagePortMessage(port, (message) => this.message(port, message, ...rest));
+    onMessagePortClose(port, () => this.close(port));
+  }
+  /**
+   * 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
+   */
+  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);
+        if (transfer) {
+          postMessagePortMessage(port, message2, transfer);
+        } else {
+          postMessagePortMessage(port, await encodePeerMessage(message2, this.encodePeerMessageOptions));
+        }
+      }));
+    }
+    if (isPlainObject(data)) {
+      await peer.message(
+        data,
+        createStandardPeerRequestHandler(this.handler, resolveMaybeOptionalOptions(rest))
+      );
+      return { matched: true };
+    }
+    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))
+      );
+    }
+    return result;
+  }
+  /**
+   * 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.
+   *
+   * @param port The message port instance to clean up, must be the same instance used in `.message()` calls to properly clean up
+   */
+  async close(port) {
+    const peer = this.peers.get(port);
+    if (peer) {
+      await peer.close();
+      this.peers.delete(port);
+    }
   }
 }
 
 class RPCHandler extends MessagePortHandler {
   constructor(router, options = {}) {
-    super(new StandardRPCHandler(router, options), options);
+    const codec = new RPCHandlerCodec(router, options);
+    const handler = new StandardHandler(codec, options);
+    super(handler, options);
   }
 }