@orpc/server 2.0.0-beta.48 → 2.0.0-beta.49

package/README.md

@@ -5,7 +5,7 @@
     <img alt="codecov" src="https://codecov.io/gh/middleapi/orpc/branch/main/graph/badge.svg">
   </a>
   <a href="https://www.npmjs.com/package/@orpc/server">
-    <img alt="weekly downloads" src="https://img.shields.io/npm/dw/%40orpc%2Fserver?logo=npm" />
+    <img alt="monthly downloads" src="https://img.shields.io/npm/dm/%40orpc%2Fserver?logo=npm" />
   </a>
   <a href="https://app.codspeed.io/middleapi/orpc?utm_source=badge">
     <img alt="CodSpeed" src="https://img.shields.io/endpoint?url=https://codspeed.io/badge.json" />
@@ -41,10 +41,11 @@ export const router = {
 Then call them from a client that knows every input and output, without generating anything:
 
 ```ts
-import type { RouterClient } from '@orpc/server'
-import type { router } from './router'
 import { createORPCClient } from '@orpc/client'
 import { RPCLink } from '@orpc/client/fetch'
+import type { RouterClient } from '@orpc/server'
+
+import type { router } from './router'
 
 const link = new RPCLink({ origin: 'http://localhost:3000', url: '/rpc' })
 const client: RouterClient<typeof router> = createORPCClient(link)
@@ -208,7 +209,6 @@ With thanks to [40 past sponsors](https://orpc.dev/sponsors#past-sponsors) who h
   <tr>
    <td align="center"><a href="https://claude.com/contact-sales/claude-for-oss" target="_blank" rel="noopener" title="Claude for Open Source"><img src="https://cdn.simpleicons.org/claude" width="64" alt="Claude"/><br />Claude</a></td>
    <td align="center"><a href="https://pullfrog.com/for-oss" target="_blank" rel="noopener" title="Pullfrog for OSS"><img src="https://avatars.githubusercontent.com/in/1768019?s=128&amp;v=4" width="64" alt="Pullfrog"/><br />Pullfrog</a></td>
-   <td align="center"><a href="https://macroscope.com/open-source" target="_blank" rel="noopener" title="Macroscope for Open Source"><img src="https://avatars.githubusercontent.com/in/900172?s=128&amp;v=4" width="64" alt="Macroscope"/><br />Macroscope</a></td>
   </tr>
 </table>
 

package/dist/adapters/aws-lambda/handler.d.ts

@@ -0,0 +1,25 @@
+import type { MaybeOptionalOptions } from '@orpc/shared';
+import type { AnyAPIGatewayProxyEvent, HttpResponseStream, SendStandardResponseOptions } from '@standard-server/aws-lambda';
+import type { Context } from '../../context.ts';
+import type { FriendlyStandardHandlerHandleOptions, StandardHandler } from '../standard/index.ts';
+export type AwsLambdaHandlerHandleResult = {
+    matched: true;
+} | {
+    matched: false;
+};
+export interface AwsLambdaHandlerOptions<_T extends Context> {
+    /**
+     * Custom options for `sendStandardResponse`, used to send a `Standard Response`
+     */
+    sendStandardResponse?: SendStandardResponseOptions | undefined;
+}
+/**
+ * Requires the AWS Lambda Node.js runtime with response streaming enabled,
+ * handlers should be wrapped with `awslambda.streamifyResponse`.
+ */
+export declare class AwsLambdaHandler<T extends Context> {
+    private readonly standardHandler;
+    private readonly sendStandardResponseOptions;
+    constructor(standardHandler: StandardHandler<T>, options?: NoInfer<AwsLambdaHandlerOptions<T>>);
+    handle(event: AnyAPIGatewayProxyEvent, responseStream: HttpResponseStream, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): Promise<AwsLambdaHandlerHandleResult>;
+}

package/dist/adapters/aws-lambda/handler.js

@@ -0,0 +1,24 @@
+import { resolveMaybeOptionalOptions } from '@orpc/shared';
+import { sendStandardResponse, toStandardLazyRequest } from '@standard-server/aws-lambda';
+import { resolveFriendlyStandardHandlerHandleOptions } from '../standard/index.js';
+/**
+ * Requires the AWS Lambda Node.js runtime with response streaming enabled,
+ * handlers should be wrapped with `awslambda.streamifyResponse`.
+ */
+export class AwsLambdaHandler {
+    standardHandler;
+    sendStandardResponseOptions;
+    constructor(standardHandler, options = {}) {
+        this.standardHandler = standardHandler;
+        this.sendStandardResponseOptions = options.sendStandardResponse;
+    }
+    async handle(event, responseStream, ...rest) {
+        const standardRequest = toStandardLazyRequest(event, responseStream);
+        const result = await this.standardHandler.handle(standardRequest, resolveFriendlyStandardHandlerHandleOptions(resolveMaybeOptionalOptions(rest)));
+        if (!result.matched) {
+            return result;
+        }
+        await sendStandardResponse(responseStream, result.response, this.sendStandardResponseOptions);
+        return result;
+    }
+}

package/dist/adapters/aws-lambda/index.d.ts

@@ -0,0 +1,16 @@
+export * from './handler.ts';
+export * from './rpc-handler.ts';
+export type { AnyAPIGatewayProxyEvent, APIGatewayProxyEvent, 
+/**
+ * AWS API Gateway proxy event, payload format 2.0, also used by Lambda Function URLs.
+ *
+ * @see {@link https://orpc.dev/docs/adapters/aws-lambda | AWS Lambda Adapter}
+ */
+APIGatewayProxyEventV2, 
+/**
+ * Shape of the `awslambda` global the Lambda Node.js runtime injects when response streaming is enabled.
+ * Declare it yourself: `declare const awslambda: AwsLambdaGlobal`.
+ *
+ * @see {@link https://orpc.dev/docs/adapters/aws-lambda | AWS Lambda Adapter}
+ */
+AwsLambdaGlobal, HttpResponseStream, } from '@standard-server/aws-lambda';

package/dist/adapters/aws-lambda/index.js

@@ -0,0 +1,2 @@
+export * from './handler.js';
+export * from './rpc-handler.js';

package/dist/adapters/aws-lambda/rpc-handler.d.ts

@@ -0,0 +1,19 @@
+import type { Context } from '../../context.ts';
+import type { Router } from '../../router.ts';
+import type { RPCHandlerCodecOptions, StandardHandlerOptions } from '../standard/index.ts';
+import type { AwsLambdaHandlerOptions } from './handler.ts';
+import { AwsLambdaHandler } from './handler.ts';
+export interface RPCHandlerOptions<T extends Context> extends AwsLambdaHandlerOptions<T>, StandardHandlerOptions<T>, RPCHandlerCodecOptions<T> {
+}
+/**
+ * Serves an oRPC router over the RPC protocol on AWS Lambda,
+ * behind API Gateway or Lambda Function URLs.
+ *
+ * @remarks
+ * **Warning**: Requires the Lambda Node.js runtime with response streaming enabled, so handlers must be wrapped with `awslambda.streamifyResponse`.
+ *
+ * @see {@link https://orpc.dev/docs/adapters/aws-lambda | AWS Lambda Adapter}
+ */
+export declare class RPCHandler<T extends Context> extends AwsLambdaHandler<T> {
+    constructor(router: Router<T>, options?: NoInfer<RPCHandlerOptions<T>>);
+}

package/dist/adapters/aws-lambda/rpc-handler.js

@@ -0,0 +1,18 @@
+import { RPCHandlerCodec, StandardHandler } from '../standard/index.js';
+import { AwsLambdaHandler } from './handler.js';
+/**
+ * Serves an oRPC router over the RPC protocol on AWS Lambda,
+ * behind API Gateway or Lambda Function URLs.
+ *
+ * @remarks
+ * **Warning**: Requires the Lambda Node.js runtime with response streaming enabled, so handlers must be wrapped with `awslambda.streamifyResponse`.
+ *
+ * @see {@link https://orpc.dev/docs/adapters/aws-lambda | AWS Lambda Adapter}
+ */
+export class RPCHandler extends AwsLambdaHandler {
+    constructor(router, options = {}) {
+        const codec = new RPCHandlerCodec(router, options);
+        const handler = new StandardHandler(codec, options);
+        super(handler, options);
+    }
+}

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

@@ -0,0 +1,45 @@
+import type { MaybeOptionalOptions } from '@orpc/shared';
+import type { DecodePeerMessageOptions, EncodePeerMessageOptions } from '@standard-server/peer';
+import type { Message, Peer } from 'crossws';
+import type { Context } from '../../context.ts';
+import type { FriendlyStandardHandlerHandleOptions, StandardHandler } from '../standard/index.ts';
+export type CrosswsPeerLike = Pick<Peer, 'send'>;
+export type CrosswsMessageLike = Pick<Message, 'rawData' | 'uint8Array'>;
+export 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;
+}
+export declare class experimental_CrosswsHandler<T extends Context> {
+    private readonly handler;
+    /**
+     * `null` marks a closed peer, so late messages never create a new server peer.
+     */
+    private readonly peers;
+    private readonly encodePeerMessageOptions;
+    private readonly decodePeerMessageOptions;
+    constructor(handler: StandardHandler<T>, options?: NoInfer<experimental_CrosswsHandlerOptions<T>>);
+    /**
+     * 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.
+     */
+    message(ws: CrosswsPeerLike, message: CrosswsMessageLike, ...rest: MaybeOptionalOptions<FriendlyStandardHandlerHandleOptions<T>>): Promise<{
+        matched: boolean;
+    }>;
+    /**
+     * 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()`.
+     */
+    close(ws: CrosswsPeerLike): Promise<void>;
+}

package/dist/adapters/crossws/handler.js

@@ -0,0 +1,60 @@
+import { resolveMaybeOptionalOptions } from '@orpc/shared';
+import { decodePeerMessage, encodePeerMessage, isClientPeerSendMessage, ServerPeer, } from '@standard-server/peer';
+import { createStandardPeerRequestHandler } from '../standard-peer/index.js';
+export class experimental_CrosswsHandler {
+    handler;
+    /**
+     * `null` marks a closed peer, so late messages never create a new server peer.
+     */
+    peers = 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);
+        // Closed: a new peer here would leak and its requests would never be aborted.
+        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();
+    }
+}

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

@@ -0,0 +1,2 @@
+export * from './handler.ts';
+export * from './rpc-handler.ts';

package/dist/adapters/crossws/index.js

@@ -0,0 +1,2 @@
+export * from './handler.js';
+export * from './rpc-handler.js';

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

@@ -0,0 +1,16 @@
+import type { Context } from '../../context.ts';
+import type { Router } from '../../router.ts';
+import type { RPCHandlerCodecOptions, StandardHandlerOptions } from '../standard/index.ts';
+import type { experimental_CrosswsHandlerOptions as CrosswsHandlerOptions } from './handler.ts';
+import { experimental_CrosswsHandler as CrosswsHandler } from './handler.ts';
+export interface experimental_RPCHandlerOptions<T extends Context> extends StandardHandlerOptions<T>, RPCHandlerCodecOptions<T>, 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 CrosswsHandler<T> {
+    constructor(router: Router<T>, options?: NoInfer<experimental_RPCHandlerOptions<T>>);
+}

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

@@ -0,0 +1,15 @@
+import { RPCHandlerCodec, StandardHandler } from '../standard/index.js';
+import { experimental_CrosswsHandler as CrosswsHandler } from './handler.js';
+/**
+ * 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 class experimental_RPCHandler extends CrosswsHandler {
+    constructor(router, options = {}) {
+        const codec = new RPCHandlerCodec(router, options);
+        const handler = new StandardHandler(codec, options);
+        super(handler, options);
+    }
+}

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

@@ -0,0 +1,21 @@
+import type { MaybeOptionalOptions } from '@orpc/shared';
+import type { AnyFastifyReply, AnyFastifyRequest, SendStandardResponseOptions } from '@standard-server/fastify';
+import type { Context } from '../../context.ts';
+import type { FriendlyStandardHandlerHandleOptions, StandardHandler } from '../standard/index.ts';
+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 { resolveMaybeOptionalOptions } from '@orpc/shared';
+import { sendStandardResponse, toStandardLazyRequest } from '@standard-server/fastify';
+import { resolveFriendlyStandardHandlerHandleOptions } from '../standard/index.js';
+export class FastifyHandler {
+    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;
+    }
+}

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

@@ -0,0 +1,2 @@
+export * from './handler.ts';
+export * from './rpc-handler.ts';

package/dist/adapters/fastify/index.js

@@ -0,0 +1,2 @@
+export * from './handler.js';
+export * from './rpc-handler.js';

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

@@ -0,0 +1,15 @@
+import type { Context } from '../../context.ts';
+import type { Router } from '../../router.ts';
+import type { RPCHandlerCodecOptions, StandardHandlerOptions } from '../standard/index.ts';
+import type { FastifyHandlerOptions } from './handler.ts';
+import { FastifyHandler } from './handler.ts';
+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,14 @@
+import { RPCHandlerCodec, StandardHandler } from '../standard/index.js';
+import { FastifyHandler } from './handler.js';
+/**
+ * Serves an oRPC router over the RPC protocol inside a Fastify server.
+ *
+ * @see {@link https://orpc.dev/docs/adapters/fastify | Fastify Adapter}
+ */
+export class RPCHandler extends FastifyHandler {
+    constructor(router, options = {}) {
+        const codec = new RPCHandlerCodec(router, options);
+        const handler = new StandardHandler(codec, options);
+        super(handler, options);
+    }
+}

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

@@ -0,0 +1,23 @@
+import type { MaybeOptionalOptions } from '@orpc/shared';
+import type { ToFetchResponseOptions } from '@standard-server/fetch';
+import type { Context } from '../../context.ts';
+import type { FriendlyStandardHandlerHandleOptions, StandardHandler } from '../standard/index.ts';
+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 { resolveMaybeOptionalOptions } from '@orpc/shared';
+import { toFetchResponse, toStandardLazyRequest } from '@standard-server/fetch';
+import { resolveFriendlyStandardHandlerHandleOptions } from '../standard/index.js';
+export class FetchHandler {
+    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),
+        };
+    }
+}

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

@@ -0,0 +1,7 @@
+export { 
+/**
+ * @deprecated Use `RequestLimitHandlerPlugin` from `@orpc/server/plugins` instead.
+ */
+RequestLimitHandlerPlugin as BodyLimitPlugin, } from '../../plugins/request-limit.ts';
+export * from './handler.ts';
+export * from './rpc-handler.ts';

package/dist/adapters/fetch/index.js

@@ -0,0 +1,7 @@
+export { 
+/**
+ * @deprecated Use `RequestLimitHandlerPlugin` from `@orpc/server/plugins` instead.
+ */
+RequestLimitHandlerPlugin as BodyLimitPlugin, } from '../../plugins/request-limit.js';
+export * from './handler.js';
+export * from './rpc-handler.js';

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

@@ -0,0 +1,17 @@
+import type { Context } from '../../context.ts';
+import type { Router } from '../../router.ts';
+import type { RPCHandlerCodecOptions, StandardHandlerOptions } from '../standard/index.ts';
+import type { FetchHandlerOptions } from './handler.ts';
+import { FetchHandler } from './handler.ts';
+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,16 @@
+import { RPCHandlerCodec, StandardHandler } from '../standard/index.js';
+import { FetchHandler } from './handler.js';
+/**
+ * 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 class RPCHandler extends FetchHandler {
+    constructor(router, options = {}) {
+        const codec = new RPCHandlerCodec(router, options);
+        const handler = new StandardHandler(codec, options);
+        super(handler, options);
+    }
+}

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

@@ -0,0 +1,64 @@
+import type { SupportedMessagePort } from '@orpc/client/message-port';
+import type { MaybeOptionalOptions, Promisable, Value } from '@orpc/shared';
+import type { DecodePeerMessageOptions, EncodePeerMessageOptions } from '@standard-server/peer';
+import { ServerPeer } from '@standard-server/peer';
+import type { Context } from '../../context.ts';
+import type { FriendlyStandardHandlerHandleOptions, StandardHandler } from '../standard/index.ts';
+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,86 @@
+import { onMessagePortClose, onMessagePortMessage, postMessagePortMessage, } from '@orpc/client/message-port';
+import { resolveMaybeOptionalOptions, value } from '@orpc/shared';
+import { decodePeerMessage, encodePeerMessage, isClientPeerSendMessage, isPeerMessage, ServerPeer, } from '@standard-server/peer';
+import { createStandardPeerRequestHandler } from '../standard-peer/index.js';
+export class MessagePortHandler {
+    handler;
+    /**
+     * `null` marks a closed port, so late messages never create a new peer.
+     */
+    peers = 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) {
+            // MessagePort receives the exact payload sent, and `encodePeerMessage` only returns string or 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 === undefined) {
+            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();
+    }
+}

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

@@ -0,0 +1,2 @@
+export * from './handler.ts';
+export * from './rpc-handler.ts';

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

@@ -0,0 +1,2 @@
+export * from './handler.js';
+export * from './rpc-handler.js';