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

package/dist/adapters/crossws/handler.js

@@ -0,0 +1,53 @@
+import { createStandardPeerRequestHandler } from "../standard-peer/utils.js";
+import { resolveMaybeOptionalOptions } from "@orpc/shared";
+import { ServerPeer, decodePeerMessage, encodePeerMessage, isClientPeerSendMessage } from "@standard-server/peer";
+// src/adapters/crossws/handler.ts
+var experimental_CrosswsHandler = class {
+	handler;
+	/**
+	* `null` marks a closed peer, so late messages never create a new server peer.
+	*/
+	peers = /* @__PURE__ */ new WeakMap();
+	encodePeerMessageOptions;
+	decodePeerMessageOptions;
+	constructor(handler, options = {}) {
+		this.handler = handler;
+		this.encodePeerMessageOptions = options.encodePeerMessage;
+		this.decodePeerMessageOptions = options.decodePeerMessage;
+	}
+	/**
+	* Handles a single WebSocket message.
+	*
+	* Message order matters. Call this immediately after receiving a message,
+	* before any other async work, to preserve ordering.
+	*
+	* @param ws The crossws peer instance. Use the same instance for all messages.
+	*/
+	async message(ws, message, ...rest) {
+		/**
+		* Message order is important: loading -> decode -> .message.
+		* This flow must stay synchronous, or we need to use `sequential` helper
+		*/
+		const encodedMessage = typeof message.rawData === "string" ? message.rawData : message.uint8Array();
+		const result = decodePeerMessage(encodedMessage, this.decodePeerMessageOptions);
+		let peer = this.peers.get(ws);
+		if (peer === null) return result;
+		if (!peer) this.peers.set(ws, peer = new ServerPeer(async (message) => {
+			ws.send(await encodePeerMessage(message, this.encodePeerMessageOptions));
+		}));
+		if (result.matched && isClientPeerSendMessage(result.message)) await peer.message(result.message, createStandardPeerRequestHandler(this.handler, resolveMaybeOptionalOptions(rest)));
+		return result;
+	}
+	/**
+	* Cleans up peer state for a closed WebSocket.
+	* Messages passed to `.message()` for this peer afterwards are ignored.
+	*
+	* @param ws The same crossws peer instance passed to `.message()`.
+	*/
+	async close(ws) {
+		const peer = this.peers.get(ws);
+		this.peers.set(ws, null);
+		await peer?.close();
+	}
+};
+export { experimental_CrosswsHandler };

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

@@ -1,54 +1,3 @@
-import { MaybeOptionalOptions } from '@orpc/shared';
-import { EncodePeerMessageOptions, DecodePeerMessageOptions } from '@standardserver/peer';
-import { Message, Peer } from 'crossws';
-import { C as Context } from '../../shared/server.BL22TloH.js';
-import { S as StandardHandler, a as StandardHandlerOptions } from '../../shared/server.DBANIheG.js';
-import { StandardPeerRequestHandlerOptions } from '../standard-peer/index.js';
-import { R as Router } from '../../shared/server.Pa0F03f_.js';
-import { R as RPCHandlerCodecOptions } from '../../shared/server.d_2NS3g5.js';
-import '@orpc/client';
-import '@orpc/contract';
-import '@standardserver/core';
-
-type CrosswsPeerLike = Pick<Peer, 'send'>;
-type CrosswsMessageLike = Pick<Message, 'rawData' | 'uint8Array'>;
-interface experimental_CrosswsHandlerOptions<_T extends Context> {
-    /**
-     * Options for encoding peer messages. such as `prefix` for distinguishing messages on the same channel..
-     */
-    encodePeerMessage?: EncodePeerMessageOptions | undefined;
-    /**
-     * Options for decoding peer messages. such as `prefix` for distinguishing messages on the same channel..
-     */
-    decodePeerMessage?: DecodePeerMessageOptions | undefined;
-}
-declare class experimental_CrosswsHandler<T extends Context> {
-    private readonly handler;
-    private readonly peers;
-    private readonly encodePeerMessageOptions;
-    private readonly decodePeerMessageOptions;
-    constructor(handler: StandardHandler<T>, options?: NoInfer<experimental_CrosswsHandlerOptions<T>>);
-    /**
-     * Handles a single message received from a crossws Peer.
-     *
-     * @param ws The crossws Peer instance, require consistent instance across messages for proper peer management
-     */
-    message(ws: CrosswsPeerLike, message: CrosswsMessageLike, ...rest: MaybeOptionalOptions<StandardPeerRequestHandlerOptions<T>>): Promise<{
-        matched: boolean;
-    }>;
-    /**
-     * Closes the peer connection and cleans up associated resources.
-     *
-     * @param ws The crossws Peer instance to close, require consistent instance for proper peer management
-     */
-    close(ws: CrosswsPeerLike): Promise<void>;
-}
-
-interface experimental_RPCHandlerOptions<T extends Context> extends StandardHandlerOptions<T>, RPCHandlerCodecOptions<T>, experimental_CrosswsHandlerOptions<T> {
-}
-declare class experimental_RPCHandler<T extends Context> extends experimental_CrosswsHandler<T> {
-    constructor(router: Router<T>, options?: NoInfer<experimental_RPCHandlerOptions<T>>);
-}
-
-export { experimental_CrosswsHandler, experimental_RPCHandler };
-export type { CrosswsMessageLike, CrosswsPeerLike, experimental_CrosswsHandlerOptions, experimental_RPCHandlerOptions };
+import { CrosswsMessageLike, CrosswsPeerLike, experimental_CrosswsHandler, experimental_CrosswsHandlerOptions } from "./handler.js";
+import { experimental_RPCHandler, experimental_RPCHandlerOptions } from "./rpc-handler.js";
+export { CrosswsMessageLike, CrosswsPeerLike, experimental_CrosswsHandler, experimental_CrosswsHandlerOptions, experimental_RPCHandler, experimental_RPCHandlerOptions };

package/dist/adapters/crossws/index.js

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

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

@@ -0,0 +1,16 @@
+import { Context } from "../../context.js";
+import { StandardHandlerOptions } from "../standard/handler.js";
+import { Router } from "../../router.js";
+import { RPCHandlerCodecOptions } from "../standard/rpc-handler-codec.js";
+import "../standard/index.js";
+import { experimental_CrosswsHandler, experimental_CrosswsHandlerOptions } from "./handler.js";
+export interface experimental_RPCHandlerOptions<T extends Context> extends StandardHandlerOptions<T>, RPCHandlerCodecOptions<T>, experimental_CrosswsHandlerOptions<T> {}
+/**
+ * Serves an oRPC router over the RPC protocol on a WebSocket connection
+ * managed by [crossws](https://github.com/h3js/crossws).
+ *
+ * @see {@link https://orpc.dev/docs/adapters/websocket | WebSocket Adapters}
+ */
+export declare class experimental_RPCHandler<T extends Context> extends experimental_CrosswsHandler<T> {
+  constructor(router: Router<T>, options?: NoInfer<experimental_RPCHandlerOptions<T>>);
+}

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

@@ -0,0 +1,18 @@
+import { RPCHandlerCodec } from "../standard/rpc-handler-codec.js";
+import { StandardHandler } from "../standard/handler.js";
+import { experimental_CrosswsHandler } from "./handler.js";
+// src/adapters/crossws/rpc-handler.ts
+/**
+* Serves an oRPC router over the RPC protocol on a WebSocket connection
+* managed by [crossws](https://github.com/h3js/crossws).
+*
+* @see {@link https://orpc.dev/docs/adapters/websocket | WebSocket Adapters}
+*/
+var experimental_RPCHandler = class extends experimental_CrosswsHandler {
+	constructor(router, options = {}) {
+		const codec = new RPCHandlerCodec(router, options);
+		const handler = new StandardHandler(codec, options);
+		super(handler, options);
+	}
+};
+export { experimental_RPCHandler };

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

@@ -0,0 +1,23 @@
+import { Context } from "../../context.js";
+import { StandardHandler } from "../standard/handler.js";
+import { FriendlyStandardHandlerHandleOptions } from "../standard/utils.js";
+import "../standard/index.js";
+import { MaybeOptionalOptions } from "@orpc/shared";
+import { AnyFastifyReply, AnyFastifyRequest, SendStandardResponseOptions } from "@standard-server/fastify";
+export type FastifyHandlerHandleResult = {
+  matched: true;
+} | {
+  matched: false;
+};
+export interface FastifyHandlerOptions<_T extends Context> {
+  /**
+   * Custom options for `sendStandardResponse`, used to send a `Standard Response`
+   */
+  sendStandardResponse?: SendStandardResponseOptions | undefined;
+}
+export declare class FastifyHandler<T extends Context> {
+  private readonly standardHandler;
+  private readonly sendStandardResponseOptions;
+  constructor(standardHandler: StandardHandler<T>, options?: NoInfer<FastifyHandlerOptions<T>>);
+  handle(request: AnyFastifyRequest, reply: AnyFastifyReply, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): Promise<FastifyHandlerHandleResult>;
+}

package/dist/adapters/fastify/handler.js

@@ -0,0 +1,20 @@
+import { resolveFriendlyStandardHandlerHandleOptions } from "../standard/utils.js";
+import { resolveMaybeOptionalOptions } from "@orpc/shared";
+import { sendStandardResponse, toStandardLazyRequest } from "@standard-server/fastify";
+// src/adapters/fastify/handler.ts
+var FastifyHandler = class {
+	standardHandler;
+	sendStandardResponseOptions;
+	constructor(standardHandler, options = {}) {
+		this.standardHandler = standardHandler;
+		this.sendStandardResponseOptions = options.sendStandardResponse;
+	}
+	async handle(request, reply, ...rest) {
+		const standardRequest = toStandardLazyRequest(request, reply);
+		const result = await this.standardHandler.handle(standardRequest, resolveFriendlyStandardHandlerHandleOptions(resolveMaybeOptionalOptions(rest)));
+		if (!result.matched) return result;
+		await sendStandardResponse(reply, result.response, this.sendStandardResponseOptions);
+		return result;
+	}
+};
+export { FastifyHandler };

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

@@ -0,0 +1,3 @@
+import { FastifyHandler, FastifyHandlerHandleResult, FastifyHandlerOptions } from "./handler.js";
+import { RPCHandler, RPCHandlerOptions } from "./rpc-handler.js";
+export { FastifyHandler, FastifyHandlerHandleResult, FastifyHandlerOptions, RPCHandler, RPCHandlerOptions };

package/dist/adapters/fastify/index.js

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

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

@@ -0,0 +1,15 @@
+import { Context } from "../../context.js";
+import { StandardHandlerOptions } from "../standard/handler.js";
+import { Router } from "../../router.js";
+import { RPCHandlerCodecOptions } from "../standard/rpc-handler-codec.js";
+import "../standard/index.js";
+import { FastifyHandler, FastifyHandlerOptions } from "./handler.js";
+export interface RPCHandlerOptions<T extends Context> extends FastifyHandlerOptions<T>, StandardHandlerOptions<T>, RPCHandlerCodecOptions<T> {}
+/**
+ * Serves an oRPC router over the RPC protocol inside a Fastify server.
+ *
+ * @see {@link https://orpc.dev/docs/adapters/fastify | Fastify Adapter}
+ */
+export declare class RPCHandler<T extends Context> extends FastifyHandler<T> {
+  constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
+}

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

@@ -0,0 +1,17 @@
+import { RPCHandlerCodec } from "../standard/rpc-handler-codec.js";
+import { StandardHandler } from "../standard/handler.js";
+import { FastifyHandler } from "./handler.js";
+// src/adapters/fastify/rpc-handler.ts
+/**
+* Serves an oRPC router over the RPC protocol inside a Fastify server.
+*
+* @see {@link https://orpc.dev/docs/adapters/fastify | Fastify Adapter}
+*/
+var RPCHandler = class extends FastifyHandler {
+	constructor(router, options = {}) {
+		const codec = new RPCHandlerCodec(router, options);
+		const handler = new StandardHandler(codec, options);
+		super(handler, options);
+	}
+};
+export { RPCHandler };

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

@@ -0,0 +1,25 @@
+import { Context } from "../../context.js";
+import { StandardHandler } from "../standard/handler.js";
+import { FriendlyStandardHandlerHandleOptions } from "../standard/utils.js";
+import "../standard/index.js";
+import { MaybeOptionalOptions } from "@orpc/shared";
+import { ToFetchResponseOptions } from "@standard-server/fetch";
+export type FetchHandlerHandleResult = {
+  matched: true;
+  response: Response;
+} | {
+  matched: false;
+  response?: undefined;
+};
+export interface FetchHandlerOptions<_T extends Context> {
+  /**
+   * Options for how to convert the Fetch Response to a Standard Response, like event stream options, etc.
+   */
+  toFetchResponse?: ToFetchResponseOptions | undefined;
+}
+export declare class FetchHandler<T extends Context> {
+  private readonly standardHandler;
+  private readonly toFetchResponseOptions;
+  constructor(standardHandler: StandardHandler<T>, options?: NoInfer<FetchHandlerOptions<T>>);
+  handle(request: Request, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): Promise<FetchHandlerHandleResult>;
+}

package/dist/adapters/fetch/handler.js

@@ -0,0 +1,22 @@
+import { resolveFriendlyStandardHandlerHandleOptions } from "../standard/utils.js";
+import { resolveMaybeOptionalOptions } from "@orpc/shared";
+import { toFetchResponse, toStandardLazyRequest } from "@standard-server/fetch";
+// src/adapters/fetch/handler.ts
+var FetchHandler = class {
+	standardHandler;
+	toFetchResponseOptions;
+	constructor(standardHandler, options = {}) {
+		this.standardHandler = standardHandler;
+		this.toFetchResponseOptions = options.toFetchResponse;
+	}
+	async handle(request, ...rest) {
+		const standardRequest = toStandardLazyRequest(request);
+		const result = await this.standardHandler.handle(standardRequest, resolveFriendlyStandardHandlerHandleOptions(resolveMaybeOptionalOptions(rest)));
+		if (!result.matched) return result;
+		return {
+			matched: true,
+			response: toFetchResponse(result.response, this.toFetchResponseOptions)
+		};
+	}
+};
+export { FetchHandler };

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

@@ -1,140 +1,4 @@
-import { C as Context } from '../../shared/server.BL22TloH.js';
-import { Interceptor, MaybeOptionalOptions } from '@orpc/shared';
-import { ToFetchResponseOptions } from '@standardserver/fetch';
-import { e as StandardHandlerPlugin, b as StandardHandlerHandleOptions, S as StandardHandler, a as StandardHandlerOptions } from '../../shared/server.DBANIheG.js';
-import { FriendlyStandardHandlerHandleOptions } from '../standard/index.js';
-import { R as Router } from '../../shared/server.Pa0F03f_.js';
-import { R as RPCHandlerCodecOptions } from '../../shared/server.d_2NS3g5.js';
-import '@orpc/client';
-import '@orpc/contract';
-import '@standardserver/core';
-
-interface FetchHandlerPlugin<T extends Context> extends StandardHandlerPlugin<T> {
-    /**
-     * Initializes the plugin and returns new fetch handler options.
-     * Called once per plugin instance during composition.
-     *
-     * This method allows plugins to wrap, extend, or transform fetch handler options
-     * such as fetch interceptors, or fetch configuration.
-     *
-     * @param options - The current handler options from previous plugins or base configuration
-     * @returns Transformed handler options with plugin's modifications applied
-     *
-     * @example
-     * ```ts
-     * initFetchHandlerOptions(options) {
-     *   return {
-     *     ...options,
-     *     interceptors: [...(options.interceptors || []), myInterceptor]
-     *   }
-     * }
-     * ```
-     */
-    initFetchHandlerOptions?(options: FetchHandlerOptions<T>): FetchHandlerOptions<T>;
-}
-declare class CompositeFetchHandlerPlugin<T extends Context> implements FetchHandlerPlugin<T> {
-    readonly name = "~composite/fetch-handler";
-    protected readonly plugins: FetchHandlerPlugin<T>[];
-    constructor(plugins?: FetchHandlerPlugin<T>[]);
-    initFetchHandlerOptions(options: FetchHandlerOptions<T>): FetchHandlerOptions<T>;
-}
-
-type FetchHandlerHandleResult = {
-    matched: true;
-    response: Response;
-} | {
-    matched: false;
-    response?: undefined;
-};
-interface FetchHandlerFetchInterceptorOptions<T extends Context> extends StandardHandlerHandleOptions<T> {
-    request: Request;
-    toFetchResponseOptions: ToFetchResponseOptions | undefined;
-}
-type FetchHandlerFetchInterceptor<T extends Context> = Interceptor<FetchHandlerFetchInterceptorOptions<T>, Promise<FetchHandlerHandleResult>>;
-interface FetchHandlerOptions<T extends Context> {
-    /**
-     * Options for how to convert the Fetch Response to a Standard Response, like event iterator options, etc.
-     */
-    toFetchResponse?: undefined | ToFetchResponseOptions;
-    /**
-     * Interceptors that run before the mapping between the Standard API and Fetch API,
-     * useful for customizing the mapping behavior (e.g. extending the body parser).
-     */
-    fetchInterceptors?: FetchHandlerFetchInterceptor<T>[] | undefined;
-    plugins?: FetchHandlerPlugin<T>[] | undefined;
-}
-declare class FetchHandler<T extends Context> {
-    private readonly standardHandler;
-    private readonly toFetchResponseOptions;
-    private readonly fetchInterceptors;
-    constructor(standardHandler: StandardHandler<T>, options?: NoInfer<FetchHandlerOptions<T>>);
-    handle(request: Request, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): Promise<FetchHandlerHandleResult>;
-}
-
-declare const ORDERED_SUPPORTED_ENCODINGS: readonly ["gzip", "deflate"];
-interface BodyCompressionHandlerPluginOptions {
-    /**
-     * The compression schemes to use for response compression.
-     * Schemes are prioritized by their order in this array and
-     * only applied if the client supports them.
-     *
-     * @default ['gzip', 'deflate']
-     */
-    encodings?: readonly (typeof ORDERED_SUPPORTED_ENCODINGS)[number][];
-    /**
-     * The minimum response size in bytes required to trigger compression.
-     * Responses smaller than this threshold will not be compressed to avoid overhead.
-     * If the response size cannot be determined, compression will still be applied.
-     *
-     * @default 1024 (1KB)
-     */
-    threshold?: number;
-    /**
-     * 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: Request, response: Response) => boolean;
-}
-declare class BodyCompressionHandlerPlugin<T extends Context> implements FetchHandlerPlugin<T> {
-    name: string;
-    private readonly encodings;
-    private readonly threshold;
-    private readonly filter;
-    constructor(options?: BodyCompressionHandlerPluginOptions);
-    initFetchHandlerOptions(options: FetchHandlerOptions<T>): FetchHandlerOptions<T>;
-}
-
-interface BodyLimitHandlerPluginOptions {
-    /**
-     * The maximum size of the body in bytes.
-     */
-    maxBodySize: number;
-}
-declare class BodyLimitHandlerPlugin<T extends Context> implements FetchHandlerPlugin<T> {
-    name: string;
-    private readonly maxBodySize;
-    constructor(options: BodyLimitHandlerPluginOptions);
-    initFetchHandlerOptions(options: FetchHandlerOptions<T>): FetchHandlerOptions<T>;
-}
-
-interface RPCHandlerOptions<T extends Context> extends FetchHandlerOptions<T>, Omit<StandardHandlerOptions<T>, 'plugins'>, RPCHandlerCodecOptions<T> {
-    /**
-     * Configuration for {@link CSRFGuardHandlerPlugin}, which is enabled by default for `RPCHandler` over HTTP.
-     */
-    csrfGuardHandlerPlugin?: {
-        /**
-         * If `false`, this plugin is disabled.
-         *
-         * @default true
-         */
-        enabled?: boolean;
-    };
-}
-declare class RPCHandler<T extends Context> extends FetchHandler<T> {
-    constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
-}
-
-export { BodyCompressionHandlerPlugin, BodyLimitHandlerPlugin, CompositeFetchHandlerPlugin, FetchHandler, RPCHandler };
-export type { BodyCompressionHandlerPluginOptions, BodyLimitHandlerPluginOptions, FetchHandlerFetchInterceptor, FetchHandlerFetchInterceptorOptions, FetchHandlerHandleResult, FetchHandlerOptions, FetchHandlerPlugin, RPCHandlerOptions };
+import { RequestLimitHandlerPlugin } from "../../plugins/request-limit.js";
+import { FetchHandler, FetchHandlerHandleResult, FetchHandlerOptions } from "./handler.js";
+import { RPCHandler, RPCHandlerOptions } from "./rpc-handler.js";
+export { RequestLimitHandlerPlugin as BodyLimitPlugin, FetchHandler, FetchHandlerHandleResult, FetchHandlerOptions, RPCHandler, RPCHandlerOptions };

package/dist/adapters/fetch/index.js

@@ -0,0 +1,3 @@
+export { RequestLimitHandlerPlugin as BodyLimitPlugin } from "../../plugins/request-limit.js";
+export { FetchHandler } from "./handler.js";
+export { RPCHandler } from "./rpc-handler.js";

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

@@ -0,0 +1,17 @@
+import { Context } from "../../context.js";
+import { StandardHandlerOptions } from "../standard/handler.js";
+import { Router } from "../../router.js";
+import { RPCHandlerCodecOptions } from "../standard/rpc-handler-codec.js";
+import "../standard/index.js";
+import { FetchHandler, FetchHandlerOptions } from "./handler.js";
+export interface RPCHandlerOptions<T extends Context> extends FetchHandlerOptions<T>, StandardHandlerOptions<T>, RPCHandlerCodecOptions<T> {}
+/**
+ * Serves an oRPC router over the RPC protocol using the Fetch API
+ * (Request/Response), supported by modern runtimes like Deno, Bun,
+ * Cloudflare Workers, and browsers.
+ *
+ * @see {@link https://orpc.dev/docs/adapters/fetch-api | Fetch API Adapter}
+ */
+export declare class RPCHandler<T extends Context> extends FetchHandler<T> {
+  constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
+}

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

@@ -0,0 +1,19 @@
+import { RPCHandlerCodec } from "../standard/rpc-handler-codec.js";
+import { StandardHandler } from "../standard/handler.js";
+import { FetchHandler } from "./handler.js";
+// src/adapters/fetch/rpc-handler.ts
+/**
+* Serves an oRPC router over the RPC protocol using the Fetch API
+* (Request/Response), supported by modern runtimes like Deno, Bun,
+* Cloudflare Workers, and browsers.
+*
+* @see {@link https://orpc.dev/docs/adapters/fetch-api | Fetch API Adapter}
+*/
+var RPCHandler = class extends FetchHandler {
+	constructor(router, options = {}) {
+		const codec = new RPCHandlerCodec(router, options);
+		const handler = new StandardHandler(codec, options);
+		super(handler, options);
+	}
+};
+export { RPCHandler };

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

@@ -0,0 +1,62 @@
+import { Context } from "../../context.js";
+import { StandardHandler } from "../standard/handler.js";
+import { FriendlyStandardHandlerHandleOptions } from "../standard/utils.js";
+import "../standard/index.js";
+import { MaybeOptionalOptions, Promisable, Value } from "@orpc/shared";
+import { DecodePeerMessageOptions, EncodePeerMessageOptions, ServerPeer } from "@standard-server/peer";
+import { SupportedMessagePort } from "@orpc/client/message-port";
+type DecodedResponseMessage = ConstructorParameters<typeof ServerPeer>[0] extends ((message: infer TMessage) => unknown) ? TMessage : never;
+export interface MessagePortHandlerOptions<_T extends Context> {
+  /**
+   * 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
+   * **Note**: Returning `null` or `undefined` disables this feature.
+   * **Warning**: Ensure your message port implementation supports `transferable` objects before enabling this.
+   */
+  experimental_transfer?: Value<Promisable<object[] | null | undefined>, [message: DecodedResponseMessage, port: SupportedMessagePort]> | undefined;
+  /**
+   * Options for encoding peer messages. such as `prefix` for distinguishing messages on the same channel..
+   */
+  encodePeerMessage?: EncodePeerMessageOptions | undefined;
+  /**
+   * Options for decoding peer messages. such as `prefix` for distinguishing messages on the same channel..
+   */
+  decodePeerMessage?: DecodePeerMessageOptions | undefined;
+}
+export declare class MessagePortHandler<T extends Context> {
+  private readonly handler;
+  /**
+   * `null` marks a closed port, so late messages never create a new peer.
+   */
+  private readonly peers;
+  private readonly transfer;
+  private readonly encodePeerMessageOptions;
+  private readonly decodePeerMessageOptions;
+  constructor(handler: StandardHandler<T>, options?: NoInfer<MessagePortHandlerOptions<T>>);
+  /**
+   * Attaches message and close listeners to a message port.
+   *
+   * Prefer this over calling `.message()` and `.close()` manually.
+   */
+  upgrade(port: SupportedMessagePort, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): void;
+  /**
+   * Handles a single message received from a message port.
+   *
+   * @param port The message port instance. Use the same instance for all messages.
+   */
+  message(port: SupportedMessagePort, data: unknown, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): Promise<{
+    matched: boolean;
+  }>;
+  /**
+   * Cleans up peer state for a closed message port.
+   * Messages passed to `.message()` for this port afterwards are ignored.
+   *
+   * @param port The same message port instance passed to `.message()`.
+   */
+  close(port: SupportedMessagePort): Promise<void>;
+}
+export {};

package/dist/adapters/message-port/handler.js

@@ -0,0 +1,72 @@
+import { createStandardPeerRequestHandler } from "../standard-peer/utils.js";
+import { resolveMaybeOptionalOptions, value } from "@orpc/shared";
+import { ServerPeer, decodePeerMessage, encodePeerMessage, isClientPeerSendMessage, isPeerMessage } from "@standard-server/peer";
+import { onMessagePortClose, onMessagePortMessage, postMessagePortMessage } from "@orpc/client/message-port";
+// src/adapters/message-port/handler.ts
+var MessagePortHandler = class {
+	handler;
+	/**
+	* `null` marks a closed port, so late messages never create a new peer.
+	*/
+	peers = /* @__PURE__ */ new WeakMap();
+	transfer;
+	encodePeerMessageOptions;
+	decodePeerMessageOptions;
+	constructor(handler, options = {}) {
+		this.handler = handler;
+		this.transfer = options.experimental_transfer;
+		this.encodePeerMessageOptions = options.encodePeerMessage;
+		this.decodePeerMessageOptions = options.decodePeerMessage;
+	}
+	/**
+	* Attaches message and close listeners to a message port.
+	*
+	* Prefer this over calling `.message()` and `.close()` manually.
+	*/
+	upgrade(port, ...rest) {
+		/**
+		* Message order is important: loading -> decode -> .message.
+		* This flow must stay synchronous, or we need to use `sequential` helper
+		*/
+		onMessagePortMessage(port, (message) => this.message(port, message, ...rest));
+		onMessagePortClose(port, () => this.close(port));
+	}
+	/**
+	* Handles a single message received from a message port.
+	*
+	* @param port The message port instance. Use the same instance for all messages.
+	*/
+	async message(port, data, ...rest) {
+		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;
+		if (peerMessage === void 0) return { matched: false };
+		let peer = this.peers.get(port);
+		if (peer === null) return { matched: true };
+		if (!peer) this.peers.set(port, peer = new ServerPeer(async (message) => {
+			const transfer = await value(this.transfer, message, port);
+			if (transfer) postMessagePortMessage(port, message, transfer);
+			else postMessagePortMessage(port, await encodePeerMessage(message, this.encodePeerMessageOptions));
+		}));
+		/**
+		* Message order is important: loading -> decode -> .message.
+		* This flow must stay synchronous, or we need to use `sequential` helper
+		*/
+		await peer.message(peerMessage, createStandardPeerRequestHandler(this.handler, resolveMaybeOptionalOptions(rest)));
+		return { matched: true };
+	}
+	/**
+	* Cleans up peer state for a closed message port.
+	* Messages passed to `.message()` for this port afterwards are ignored.
+	*
+	* @param port The same message port instance passed to `.message()`.
+	*/
+	async close(port) {
+		const peer = this.peers.get(port);
+		this.peers.set(port, null);
+		await peer?.close();
+	}
+};
+export { MessagePortHandler };