@orpc/client 0.0.0-next.e563486 → 0.0.0-next.e565e67

package/README.md

@@ -17,32 +17,31 @@
   <a href="https://discord.gg/TXEbwRBvQn">
     <img alt="Discord" src="https://img.shields.io/discord/1308966753044398161?color=7389D8&label&logo=discord&logoColor=ffffff" />
   </a>
+  <a href="https://deepwiki.com/unnoq/orpc">
+    <img src="https://deepwiki.com/badge.svg" alt="Ask DeepWiki">
+  </a>
 </div>
 
 <h3 align="center">Typesafe APIs Made Simple 🪄</h3>
 
-**oRPC is a powerful combination of RPC and OpenAPI**, makes it easy to build APIs that are end-to-end type-safe and adhere to OpenAPI standards, ensuring a smooth and enjoyable developer experience.
+**oRPC is a powerful combination of RPC and OpenAPI**, makes it easy to build APIs that are end-to-end type-safe and adhere to OpenAPI standards
 
 ---
 
 ## Highlights
 
-- **End-to-End Type Safety 🔒**: Ensure complete type safety from inputs to outputs and errors, bridging server and client seamlessly.
-- **First-Class OpenAPI 📄**: Adheres to the OpenAPI standard out of the box, ensuring seamless integration and comprehensive API documentation.
-- **Contract-First Development 📜**: (Optional) Define your API contract upfront and implement it with confidence.
-- **Exceptional Developer Experience ✨**: Enjoy a streamlined workflow with robust typing and clear, in-code documentation.
-- **Multi-Runtime Support 🌍**: Run your code seamlessly on Cloudflare, Deno, Bun, Node.js, and more.
-- **Framework Integrations 🧩**: Supports Tanstack Query (React, Vue, Solid, Svelte), Pinia Colada, and more.
-- **Server Actions ⚡️**: Fully compatible with React Server Actions on Next.js, TanStack Start, and more.
-- **Standard Schema Support 🗂️**: Effortlessly work with Zod, Valibot, ArkType, and others right out of the box.
-- **Fast & Lightweight 💨**: Built on native APIs across all runtimes – optimized for speed and efficiency.
-- **Native Types 📦**: Enjoy built-in support for Date, File, Blob, BigInt, URL and more with no extra setup.
-- **Lazy Router ⏱️**: Improve cold start times with our lazy routing feature.
-- **SSE & Streaming 📡**: Provides SSE and streaming features – perfect for real-time notifications and AI-powered streaming responses.
-- **Reusability 🔄**: Write once and reuse your code across multiple purposes effortlessly.
-- **Extendability 🔌**: Easily enhance oRPC with plugins, middleware, and interceptors.
-- **Reliability 🛡️**: Well-tested, fully TypeScript, production-ready, and MIT licensed for peace of mind.
-- **Simplicity 💡**: Enjoy straightforward, clean code with no hidden magic.
+- **🔗 End-to-End Type Safety**: Ensure type-safe inputs, outputs, and errors from client to server.
+- **📘 First-Class OpenAPI**: Built-in support that fully adheres to the OpenAPI standard.
+- **📝 Contract-First Development**: Optionally define your API contract before implementation.
+- **🔍 First-Class OpenTelemetry**: Seamlessly integrate with OpenTelemetry for observability.
+- **⚙️ Framework Integrations**: Seamlessly integrate with TanStack Query (React, Vue, Solid, Svelte, Angular), SWR, Pinia Colada, and more.
+- **🚀 Server Actions**: Fully compatible with React Server Actions on Next.js, TanStack Start, and other platforms.
+- **🔠 Standard Schema Support**: Works out of the box with Zod, Valibot, ArkType, and other schema validators.
+- **🗃️ Native Types**: Supports native types like Date, File, Blob, BigInt, URL, and more.
+- **⏱️ Lazy Router**: Enhance cold start times with our lazy routing feature.
+- **📡 SSE & Streaming**: Enjoy full type-safe support for SSE and streaming.
+- **🌍 Multi-Runtime Support**: Fast and lightweight on Cloudflare, Deno, Bun, Node.js, and beyond.
+- **🔌 Extendability**: Easily extend functionality with plugins, middleware, and interceptors.
 
 ## Documentation
 
@@ -53,12 +52,14 @@ You can find the full documentation [here](https://orpc.unnoq.com).
 - [@orpc/contract](https://www.npmjs.com/package/@orpc/contract): Build your API contract.
 - [@orpc/server](https://www.npmjs.com/package/@orpc/server): Build your API or implement API contract.
 - [@orpc/client](https://www.npmjs.com/package/@orpc/client): Consume your API on the client with type-safety.
-- [@orpc/react-query](https://www.npmjs.com/package/@orpc/react-query): Integration with [React Query](https://tanstack.com/query/latest/docs/framework/react/overview).
-- [@orpc/vue-query](https://www.npmjs.com/package/@orpc/vue-query): Integration with [Vue Query](https://tanstack.com/query/latest/docs/framework/vue/overview).
-- [@orpc/solid-query](https://www.npmjs.com/package/@orpc/solid-query): Integration with [Solid Query](https://tanstack.com/query/latest/docs/framework/solid/overview).
-- [@orpc/svelte-query](https://www.npmjs.com/package/@orpc/svelte-query): Integration with [Svelte Query](https://tanstack.com/query/latest/docs/framework/svelte/overview).
-- [@orpc/vue-colada](https://www.npmjs.com/package/@orpc/vue-colada): Integration with [Pinia Colada](https://pinia-colada.esm.dev/).
 - [@orpc/openapi](https://www.npmjs.com/package/@orpc/openapi): Generate OpenAPI specs and handle OpenAPI requests.
+- [@orpc/otel](https://www.npmjs.com/package/@orpc/otel): [OpenTelemetry](https://opentelemetry.io/) integration for observability.
+- [@orpc/nest](https://www.npmjs.com/package/@orpc/nest): Deeply integrate oRPC with [NestJS](https://nestjs.com/).
+- [@orpc/react](https://www.npmjs.com/package/@orpc/react): Utilities for integrating oRPC with React and React Server Actions.
+- [@orpc/tanstack-query](https://www.npmjs.com/package/@orpc/tanstack-query): [TanStack Query](https://tanstack.com/query/latest) integration.
+- [@orpc/experimental-react-swr](https://www.npmjs.com/package/@orpc/experimental-react-swr): [SWR](https://swr.vercel.app/) integration.
+- [@orpc/vue-colada](https://www.npmjs.com/package/@orpc/vue-colada): Integration with [Pinia Colada](https://pinia-colada.esm.dev/).
+- [@orpc/hey-api](https://www.npmjs.com/package/@orpc/hey-api): [Hey API](https://heyapi.dev/) integration.
 - [@orpc/zod](https://www.npmjs.com/package/@orpc/zod): More schemas that [Zod](https://zod.dev/) doesn't support yet.
 - [@orpc/valibot](https://www.npmjs.com/package/@orpc/valibot): OpenAPI spec generation from [Valibot](https://valibot.dev/).
 - [@orpc/arktype](https://www.npmjs.com/package/@orpc/arktype): OpenAPI spec generation from [ArkType](https://arktype.io/).
@@ -87,6 +88,14 @@ const client: RouterClient<typeof router> = createORPCClient(link)
 const client: ContractRouterClient<typeof contract> = createORPCClient(link)
 ```
 
+## Sponsors
+
+<p align="center">
+  <a href="https://cdn.jsdelivr.net/gh/unnoq/unnoq/sponsors.svg">
+    <img src='https://cdn.jsdelivr.net/gh/unnoq/unnoq/sponsors.svg'/>
+  </a>
+</p>
+
 ## License
 
 Distributed under the MIT License. See [LICENSE](https://github.com/unnoq/orpc/blob/main/LICENSE) for more information.

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

@@ -1,30 +1,46 @@
+import { Interceptor } from '@orpc/shared';
 import { StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
 import { ToFetchRequestOptions } from '@orpc/standard-server-fetch';
-import { a as ClientContext, C as ClientOptionsOut, b as ClientLink } from '../../shared/client.CupM8eRP.mjs';
-import { b as StandardLinkClient } from '../../shared/client.DrOAzyMB.mjs';
-import { StandardRPCLinkOptions } from '../standard/index.mjs';
-import '@orpc/shared';
+import { b as ClientContext, c as ClientOptions } from '../../shared/client.BH1AYT_p.mjs';
+import { a as StandardLinkPlugin, f as StandardLinkClient } from '../../shared/client.CPgZaUox.mjs';
+import { f as StandardRPCLinkOptions, g as StandardRPCLink } from '../../shared/client.D8lMmWVC.mjs';
 
+interface LinkFetchPlugin<T extends ClientContext> extends StandardLinkPlugin<T> {
+    initRuntimeAdapter?(options: LinkFetchClientOptions<T>): void;
+}
+
+interface LinkFetchInterceptorOptions<T extends ClientContext> extends ClientOptions<T> {
+    request: Request;
+    init: {
+        redirect?: Request['redirect'];
+    };
+    path: readonly string[];
+    input: unknown;
+}
 interface LinkFetchClientOptions<T extends ClientContext> extends ToFetchRequestOptions {
-    fetch?: (request: Request, init: Record<never, never>, options: ClientOptionsOut<T>, path: readonly string[], input: unknown) => Promise<Response>;
+    fetch?: (request: Request, init: LinkFetchInterceptorOptions<T>['init'], options: ClientOptions<T>, path: readonly string[], input: unknown) => Promise<Response>;
+    adapterInterceptors?: Interceptor<LinkFetchInterceptorOptions<T>, Promise<Response>>[];
+    plugins?: LinkFetchPlugin<T>[];
 }
 declare class LinkFetchClient<T extends ClientContext> implements StandardLinkClient<T> {
     private readonly fetch;
     private readonly toFetchRequestOptions;
+    private readonly adapterInterceptors;
     constructor(options: LinkFetchClientOptions<T>);
-    call(request: StandardRequest, options: ClientOptionsOut<T>, path: readonly string[], input: unknown): Promise<StandardLazyResponse>;
+    call(standardRequest: StandardRequest, options: ClientOptions<T>, path: readonly string[], input: unknown): Promise<StandardLazyResponse>;
 }
 
-interface RPCLinkOptions<T extends ClientContext> extends StandardRPCLinkOptions<T>, LinkFetchClientOptions<T> {
+interface RPCLinkOptions<T extends ClientContext> extends LinkFetchClientOptions<T>, Omit<StandardRPCLinkOptions<T>, 'plugins'> {
 }
-declare class RPCLink<T extends ClientContext> implements ClientLink<T> {
-    private readonly standardLink;
+/**
+ * The RPC Link communicates with the server using the RPC protocol.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/client/rpc-link RPC Link Docs}
+ * @see {@link https://orpc.unnoq.com/docs/advanced/rpc-protocol RPC Protocol Docs}
+ */
+declare class RPCLink<T extends ClientContext> extends StandardRPCLink<T> {
     constructor(options: RPCLinkOptions<T>);
-    call(path: readonly string[], input: unknown, options: ClientOptionsOut<T>): Promise<unknown>;
-}
-
-interface FetchWithContext<TClientContext extends ClientContext> {
-    (url: URL, init: RequestInit, options: ClientOptionsOut<TClientContext>, path: readonly string[], input: unknown): Promise<Response>;
 }
 
-export { type FetchWithContext, LinkFetchClient, type LinkFetchClientOptions, RPCLink, type RPCLinkOptions };
+export { LinkFetchClient, RPCLink };
+export type { LinkFetchClientOptions, LinkFetchInterceptorOptions, RPCLinkOptions };

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

@@ -1,30 +1,46 @@
+import { Interceptor } from '@orpc/shared';
 import { StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
 import { ToFetchRequestOptions } from '@orpc/standard-server-fetch';
-import { a as ClientContext, C as ClientOptionsOut, b as ClientLink } from '../../shared/client.CupM8eRP.js';
-import { b as StandardLinkClient } from '../../shared/client.aGal-uGY.js';
-import { StandardRPCLinkOptions } from '../standard/index.js';
-import '@orpc/shared';
+import { b as ClientContext, c as ClientOptions } from '../../shared/client.BH1AYT_p.js';
+import { a as StandardLinkPlugin, f as StandardLinkClient } from '../../shared/client.De8SW4Kw.js';
+import { f as StandardRPCLinkOptions, g as StandardRPCLink } from '../../shared/client.BxV-mzeR.js';
 
+interface LinkFetchPlugin<T extends ClientContext> extends StandardLinkPlugin<T> {
+    initRuntimeAdapter?(options: LinkFetchClientOptions<T>): void;
+}
+
+interface LinkFetchInterceptorOptions<T extends ClientContext> extends ClientOptions<T> {
+    request: Request;
+    init: {
+        redirect?: Request['redirect'];
+    };
+    path: readonly string[];
+    input: unknown;
+}
 interface LinkFetchClientOptions<T extends ClientContext> extends ToFetchRequestOptions {
-    fetch?: (request: Request, init: Record<never, never>, options: ClientOptionsOut<T>, path: readonly string[], input: unknown) => Promise<Response>;
+    fetch?: (request: Request, init: LinkFetchInterceptorOptions<T>['init'], options: ClientOptions<T>, path: readonly string[], input: unknown) => Promise<Response>;
+    adapterInterceptors?: Interceptor<LinkFetchInterceptorOptions<T>, Promise<Response>>[];
+    plugins?: LinkFetchPlugin<T>[];
 }
 declare class LinkFetchClient<T extends ClientContext> implements StandardLinkClient<T> {
     private readonly fetch;
     private readonly toFetchRequestOptions;
+    private readonly adapterInterceptors;
     constructor(options: LinkFetchClientOptions<T>);
-    call(request: StandardRequest, options: ClientOptionsOut<T>, path: readonly string[], input: unknown): Promise<StandardLazyResponse>;
+    call(standardRequest: StandardRequest, options: ClientOptions<T>, path: readonly string[], input: unknown): Promise<StandardLazyResponse>;
 }
 
-interface RPCLinkOptions<T extends ClientContext> extends StandardRPCLinkOptions<T>, LinkFetchClientOptions<T> {
+interface RPCLinkOptions<T extends ClientContext> extends LinkFetchClientOptions<T>, Omit<StandardRPCLinkOptions<T>, 'plugins'> {
 }
-declare class RPCLink<T extends ClientContext> implements ClientLink<T> {
-    private readonly standardLink;
+/**
+ * The RPC Link communicates with the server using the RPC protocol.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/client/rpc-link RPC Link Docs}
+ * @see {@link https://orpc.unnoq.com/docs/advanced/rpc-protocol RPC Protocol Docs}
+ */
+declare class RPCLink<T extends ClientContext> extends StandardRPCLink<T> {
     constructor(options: RPCLinkOptions<T>);
-    call(path: readonly string[], input: unknown, options: ClientOptionsOut<T>): Promise<unknown>;
-}
-
-interface FetchWithContext<TClientContext extends ClientContext> {
-    (url: URL, init: RequestInit, options: ClientOptionsOut<TClientContext>, path: readonly string[], input: unknown): Promise<Response>;
 }
 
-export { type FetchWithContext, LinkFetchClient, type LinkFetchClientOptions, RPCLink, type RPCLinkOptions };
+export { LinkFetchClient, RPCLink };
+export type { LinkFetchClientOptions, LinkFetchInterceptorOptions, RPCLinkOptions };

package/dist/adapters/fetch/index.mjs

@@ -1,36 +1,45 @@
+import { toArray, intercept } from '@orpc/shared';
 import { toFetchRequest, toStandardLazyResponse } from '@orpc/standard-server-fetch';
-import { b as StandardRPCJsonSerializer, c as StandardRPCLinkCodec, d as StandardRPCSerializer, S as StandardLink } from '../../shared/client.CjUckqXO.mjs';
-import '@orpc/shared';
-import '../../shared/client.CvnV7_uV.mjs';
+import { C as CompositeStandardLinkPlugin, c as StandardRPCLink } from '../../shared/client.CdE4ChCn.mjs';
 import '@orpc/standard-server';
-import '../../shared/client.BacCdg3F.mjs';
+import '../../shared/client.Cs5F1cjw.mjs';
+import '../../shared/client.BLtwTQUg.mjs';
+
+class CompositeLinkFetchPlugin extends CompositeStandardLinkPlugin {
+  initRuntimeAdapter(options) {
+    for (const plugin of this.plugins) {
+      plugin.initRuntimeAdapter?.(options);
+    }
+  }
+}
 
 class LinkFetchClient {
   fetch;
   toFetchRequestOptions;
+  adapterInterceptors;
   constructor(options) {
-    this.fetch = options?.fetch ?? globalThis.fetch.bind(globalThis);
+    const plugin = new CompositeLinkFetchPlugin(options.plugins);
+    plugin.initRuntimeAdapter(options);
+    this.fetch = options.fetch ?? globalThis.fetch.bind(globalThis);
     this.toFetchRequestOptions = options;
+    this.adapterInterceptors = toArray(options.adapterInterceptors);
   }
-  async call(request, options, path, input) {
-    const fetchRequest = toFetchRequest(request, this.toFetchRequestOptions);
-    const fetchResponse = await this.fetch(fetchRequest, {}, options, path, input);
-    const lazyResponse = toStandardLazyResponse(fetchResponse);
+  async call(standardRequest, options, path, input) {
+    const request = toFetchRequest(standardRequest, this.toFetchRequestOptions);
+    const fetchResponse = await intercept(
+      this.adapterInterceptors,
+      { ...options, request, path, input, init: { redirect: "manual" } },
+      ({ request: request2, path: path2, input: input2, init, ...options2 }) => this.fetch(request2, init, options2, path2, input2)
+    );
+    const lazyResponse = toStandardLazyResponse(fetchResponse, { signal: request.signal });
     return lazyResponse;
   }
 }
 
-class RPCLink {
-  standardLink;
+class RPCLink extends StandardRPCLink {
   constructor(options) {
-    const jsonSerializer = new StandardRPCJsonSerializer(options);
-    const serializer = new StandardRPCSerializer(jsonSerializer);
-    const linkCodec = new StandardRPCLinkCodec(serializer, options);
     const linkClient = new LinkFetchClient(options);
-    this.standardLink = new StandardLink(linkCodec, linkClient, options);
-  }
-  async call(path, input, options) {
-    return this.standardLink.call(path, input, options);
+    super(linkClient, options);
   }
 }
 

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

@@ -0,0 +1,80 @@
+import { Value, Promisable } from '@orpc/shared';
+import { StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
+import { DecodedRequestMessage } from '@orpc/standard-server-peer';
+import { b as ClientContext, c as ClientOptions } from '../../shared/client.BH1AYT_p.mjs';
+import { f as StandardLinkClient } from '../../shared/client.CPgZaUox.mjs';
+import { f as StandardRPCLinkOptions, g as StandardRPCLink } from '../../shared/client.D8lMmWVC.mjs';
+
+/**
+ * The message port used by electron in main process
+ */
+interface MessagePortMainLike {
+    on: <T extends string>(event: T, callback: (event?: {
+        data: any;
+    }) => void) => void;
+    postMessage: (data: any, transfer?: any[]) => void;
+}
+/**
+ * The message port used by browser extension
+ */
+interface BrowserPortLike {
+    onMessage: {
+        addListener: (callback: (data: any) => void) => void;
+    };
+    onDisconnect: {
+        addListener: (callback: () => void) => void;
+    };
+    postMessage: (data: any) => void;
+}
+type SupportedMessagePort = Pick<MessagePort, 'addEventListener' | 'postMessage'> | MessagePortMainLike | BrowserPortLike;
+/**
+ *  Message port can support [The structured clone algorithm](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Structured_clone_algorithm)
+ */
+type SupportedMessagePortData = any;
+declare function postMessagePortMessage(port: SupportedMessagePort, data: SupportedMessagePortData, transfer?: any[]): void;
+declare function onMessagePortMessage(port: SupportedMessagePort, callback: (data: SupportedMessagePortData) => void): void;
+declare function onMessagePortClose(port: SupportedMessagePort, callback: () => void): void;
+
+interface LinkMessagePortClientOptions {
+    port: SupportedMessagePort;
+    /**
+     * 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`.
+     *
+     * @remarks
+     * - return null | undefined to disable 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.unnoq.com/docs/adapters/message-port#transfer Message Port Transfer Docs}
+     */
+    experimental_transfer?: Value<Promisable<object[] | null | undefined>, [message: DecodedRequestMessage, port: SupportedMessagePort]>;
+}
+declare class LinkMessagePortClient<T extends ClientContext> implements StandardLinkClient<T> {
+    private readonly peer;
+    constructor(options: LinkMessagePortClientOptions);
+    call(request: StandardRequest, _options: ClientOptions<T>, _path: readonly string[], _input: unknown): Promise<StandardLazyResponse>;
+}
+
+interface RPCLinkOptions<T extends ClientContext> extends Omit<StandardRPCLinkOptions<T>, 'url' | 'method' | 'fallbackMethod' | 'maxUrlLength'>, LinkMessagePortClientOptions {
+}
+/**
+ * The RPC Link for common message port implementations.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/client/rpc-link RPC Link Docs}
+ * @see {@link https://orpc.unnoq.com/docs/adapters/message-port Message Port Adapter Docs}
+ */
+declare class RPCLink<T extends ClientContext> extends StandardRPCLink<T> {
+    constructor(options: RPCLinkOptions<T>);
+}
+
+export { LinkMessagePortClient, RPCLink, onMessagePortClose, onMessagePortMessage, postMessagePortMessage };
+export type { BrowserPortLike, LinkMessagePortClientOptions, MessagePortMainLike, RPCLinkOptions, SupportedMessagePort, SupportedMessagePortData };

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

@@ -0,0 +1,80 @@
+import { Value, Promisable } from '@orpc/shared';
+import { StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
+import { DecodedRequestMessage } from '@orpc/standard-server-peer';
+import { b as ClientContext, c as ClientOptions } from '../../shared/client.BH1AYT_p.js';
+import { f as StandardLinkClient } from '../../shared/client.De8SW4Kw.js';
+import { f as StandardRPCLinkOptions, g as StandardRPCLink } from '../../shared/client.BxV-mzeR.js';
+
+/**
+ * The message port used by electron in main process
+ */
+interface MessagePortMainLike {
+    on: <T extends string>(event: T, callback: (event?: {
+        data: any;
+    }) => void) => void;
+    postMessage: (data: any, transfer?: any[]) => void;
+}
+/**
+ * The message port used by browser extension
+ */
+interface BrowserPortLike {
+    onMessage: {
+        addListener: (callback: (data: any) => void) => void;
+    };
+    onDisconnect: {
+        addListener: (callback: () => void) => void;
+    };
+    postMessage: (data: any) => void;
+}
+type SupportedMessagePort = Pick<MessagePort, 'addEventListener' | 'postMessage'> | MessagePortMainLike | BrowserPortLike;
+/**
+ *  Message port can support [The structured clone algorithm](https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API/Structured_clone_algorithm)
+ */
+type SupportedMessagePortData = any;
+declare function postMessagePortMessage(port: SupportedMessagePort, data: SupportedMessagePortData, transfer?: any[]): void;
+declare function onMessagePortMessage(port: SupportedMessagePort, callback: (data: SupportedMessagePortData) => void): void;
+declare function onMessagePortClose(port: SupportedMessagePort, callback: () => void): void;
+
+interface LinkMessagePortClientOptions {
+    port: SupportedMessagePort;
+    /**
+     * 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`.
+     *
+     * @remarks
+     * - return null | undefined to disable 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.unnoq.com/docs/adapters/message-port#transfer Message Port Transfer Docs}
+     */
+    experimental_transfer?: Value<Promisable<object[] | null | undefined>, [message: DecodedRequestMessage, port: SupportedMessagePort]>;
+}
+declare class LinkMessagePortClient<T extends ClientContext> implements StandardLinkClient<T> {
+    private readonly peer;
+    constructor(options: LinkMessagePortClientOptions);
+    call(request: StandardRequest, _options: ClientOptions<T>, _path: readonly string[], _input: unknown): Promise<StandardLazyResponse>;
+}
+
+interface RPCLinkOptions<T extends ClientContext> extends Omit<StandardRPCLinkOptions<T>, 'url' | 'method' | 'fallbackMethod' | 'maxUrlLength'>, LinkMessagePortClientOptions {
+}
+/**
+ * The RPC Link for common message port implementations.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/client/rpc-link RPC Link Docs}
+ * @see {@link https://orpc.unnoq.com/docs/adapters/message-port Message Port Adapter Docs}
+ */
+declare class RPCLink<T extends ClientContext> extends StandardRPCLink<T> {
+    constructor(options: RPCLinkOptions<T>);
+}
+
+export { LinkMessagePortClient, RPCLink, onMessagePortClose, onMessagePortMessage, postMessagePortMessage };
+export type { BrowserPortLike, LinkMessagePortClientOptions, MessagePortMainLike, RPCLinkOptions, SupportedMessagePort, SupportedMessagePortData };

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

@@ -0,0 +1,87 @@
+import { value, isObject } from '@orpc/shared';
+import { experimental_ClientPeerWithoutCodec, serializeRequestMessage, encodeRequestMessage, deserializeResponseMessage, decodeResponseMessage } from '@orpc/standard-server-peer';
+import { c as StandardRPCLink } from '../../shared/client.CdE4ChCn.mjs';
+import '@orpc/standard-server';
+import '../../shared/client.Cs5F1cjw.mjs';
+import '@orpc/standard-server-fetch';
+import '../../shared/client.BLtwTQUg.mjs';
+
+function postMessagePortMessage(port, data, transfer) {
+  if (transfer) {
+    port.postMessage(data, transfer);
+  } else {
+    port.postMessage(data);
+  }
+}
+function onMessagePortMessage(port, callback) {
+  if ("addEventListener" in port) {
+    port.addEventListener("message", (event) => {
+      callback(event.data);
+    });
+  } else if ("on" in port) {
+    port.on("message", (event) => {
+      callback(event?.data);
+    });
+  } else if ("onMessage" in port) {
+    port.onMessage.addListener((data) => {
+      callback(data);
+    });
+  } else {
+    throw new Error("Cannot find a addEventListener/on/onMessage method on the port");
+  }
+}
+function onMessagePortClose(port, callback) {
+  if ("addEventListener" in port) {
+    port.addEventListener("close", async () => {
+      callback();
+    });
+  } else if ("on" in port) {
+    port.on("close", async () => {
+      callback();
+    });
+  } else if ("onDisconnect" in port) {
+    port.onDisconnect.addListener(() => {
+      callback();
+    });
+  } else {
+    throw new Error("Cannot find a addEventListener/on/onDisconnect method on the port");
+  }
+}
+
+class LinkMessagePortClient {
+  peer;
+  constructor(options) {
+    this.peer = new experimental_ClientPeerWithoutCodec(async (message) => {
+      const [id, type, payload] = message;
+      const transfer = await value(options.experimental_transfer, message, options.port);
+      if (transfer) {
+        postMessagePortMessage(options.port, serializeRequestMessage(id, type, payload), transfer);
+      } else {
+        postMessagePortMessage(options.port, await encodeRequestMessage(id, type, payload));
+      }
+    });
+    onMessagePortMessage(options.port, async (message) => {
+      if (isObject(message)) {
+        await this.peer.message(deserializeResponseMessage(message));
+      } else {
+        await this.peer.message(await decodeResponseMessage(message));
+      }
+    });
+    onMessagePortClose(options.port, () => {
+      this.peer.close();
+    });
+  }
+  async call(request, _options, _path, _input) {
+    const response = await this.peer.request(request);
+    return { ...response, body: () => Promise.resolve(response.body) };
+  }
+}
+
+class RPCLink extends StandardRPCLink {
+  constructor(options) {
+    const linkClient = new LinkMessagePortClient(options);
+    super(linkClient, { ...options, url: "orpc://localhost" });
+  }
+}
+
+export { LinkMessagePortClient, RPCLink, onMessagePortClose, onMessagePortMessage, postMessagePortMessage };

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

@@ -1,105 +1,11 @@
-import { c as StandardLinkCodec, S as StandardLinkOptions } from '../../shared/client.DrOAzyMB.mjs';
-export { I as InvalidEventIteratorRetryResponse, d as StandardLink, b as StandardLinkClient } from '../../shared/client.DrOAzyMB.mjs';
-import { Segment, Value } from '@orpc/shared';
-import { a as ClientContext, C as ClientOptionsOut } from '../../shared/client.CupM8eRP.mjs';
-import { StandardHeaders, StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
+export { C as CompositeStandardLinkPlugin, d as StandardLink, f as StandardLinkClient, S as StandardLinkClientInterceptorOptions, e as StandardLinkCodec, c as StandardLinkInterceptorOptions, b as StandardLinkOptions, a as StandardLinkPlugin } from '../../shared/client.CPgZaUox.mjs';
+export { S as STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES, c as StandardRPCCustomJsonSerializer, b as StandardRPCJsonSerialized, a as StandardRPCJsonSerializedMetaItem, e as StandardRPCJsonSerializer, d as StandardRPCJsonSerializerOptions, g as StandardRPCLink, i as StandardRPCLinkCodec, h as StandardRPCLinkCodecOptions, f as StandardRPCLinkOptions, j as StandardRPCSerializer } from '../../shared/client.D8lMmWVC.mjs';
+import { StandardHeaders } from '@orpc/standard-server';
+import { H as HTTPPath } from '../../shared/client.BH1AYT_p.mjs';
+import '@orpc/shared';
 
-declare const STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES: {
-    readonly BIGINT: 0;
-    readonly DATE: 1;
-    readonly NAN: 2;
-    readonly UNDEFINED: 3;
-    readonly URL: 4;
-    readonly REGEXP: 5;
-    readonly SET: 6;
-    readonly MAP: 7;
-};
-type StandardRPCJsonSerializedMetaItem = readonly [type: number, ...path: Segment[]];
-type StandardRPCJsonSerialized = [json: unknown, meta: StandardRPCJsonSerializedMetaItem[], maps: Segment[][], blobs: Blob[]];
-interface StandardRPCCustomJsonSerializer {
-    type: number;
-    condition(data: unknown): boolean;
-    serialize(data: any): unknown;
-    deserialize(serialized: any): unknown;
-}
-interface StandardRPCJsonSerializerOptions {
-    customJsonSerializers?: readonly StandardRPCCustomJsonSerializer[];
-}
-declare class StandardRPCJsonSerializer {
-    private readonly customSerializers;
-    constructor(options?: StandardRPCJsonSerializerOptions);
-    serialize(data: unknown, segments?: Segment[], meta?: StandardRPCJsonSerializedMetaItem[], maps?: Segment[][], blobs?: Blob[]): StandardRPCJsonSerialized;
-    deserialize(json: unknown, meta: readonly StandardRPCJsonSerializedMetaItem[]): unknown;
-    deserialize(json: unknown, meta: readonly StandardRPCJsonSerializedMetaItem[], maps: readonly Segment[][], getBlob: (index: number) => Blob): unknown;
-}
+declare function toHttpPath(path: readonly string[]): HTTPPath;
+declare function toStandardHeaders(headers: Headers | StandardHeaders): StandardHeaders;
+declare function getMalformedResponseErrorCode(status: number): string;
 
-declare class StandardRPCSerializer {
-    #private;
-    private readonly jsonSerializer;
-    constructor(jsonSerializer: StandardRPCJsonSerializer);
-    serialize(data: unknown): unknown;
-    deserialize(data: unknown): unknown;
-}
-
-type HTTPMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
-interface StandardRPCLinkCodecOptions<T extends ClientContext> {
-    /**
-     * Base url for all requests.
-     */
-    url: Value<string | URL, [
-        options: ClientOptionsOut<T>,
-        path: readonly string[],
-        input: unknown
-    ]>;
-    /**
-     * The maximum length of the URL.
-     *
-     * @default 2083
-     */
-    maxUrlLength?: Value<number, [
-        options: ClientOptionsOut<T>,
-        path: readonly string[],
-        input: unknown
-    ]>;
-    /**
-     * The method used to make the request.
-     *
-     * @default 'POST'
-     */
-    method?: Value<HTTPMethod, [
-        options: ClientOptionsOut<T>,
-        path: readonly string[],
-        input: unknown
-    ]>;
-    /**
-     * The method to use when the payload cannot safely pass to the server with method return from method function.
-     * GET is not allowed, it's very dangerous.
-     *
-     * @default 'POST'
-     */
-    fallbackMethod?: Exclude<HTTPMethod, 'GET'>;
-    /**
-     * Inject headers to the request.
-     */
-    headers?: Value<StandardHeaders, [
-        options: ClientOptionsOut<T>,
-        path: readonly string[],
-        input: unknown
-    ]>;
-}
-declare class StandardRPCLinkCodec<T extends ClientContext> implements StandardLinkCodec<T> {
-    private readonly serializer;
-    private readonly baseUrl;
-    private readonly maxUrlLength;
-    private readonly fallbackMethod;
-    private readonly expectedMethod;
-    private readonly headers;
-    constructor(serializer: StandardRPCSerializer, options: StandardRPCLinkCodecOptions<T>);
-    encode(path: readonly string[], input: unknown, options: ClientOptionsOut<any>): Promise<StandardRequest>;
-    decode(response: StandardLazyResponse): Promise<unknown>;
-}
-
-interface StandardRPCLinkOptions<T extends ClientContext> extends StandardLinkOptions<T>, StandardRPCLinkCodecOptions<T>, StandardRPCJsonSerializerOptions {
-}
-
-export { STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES, StandardLinkCodec, StandardLinkOptions, type StandardRPCCustomJsonSerializer, type StandardRPCJsonSerialized, type StandardRPCJsonSerializedMetaItem, StandardRPCJsonSerializer, type StandardRPCJsonSerializerOptions, StandardRPCLinkCodec, type StandardRPCLinkCodecOptions, type StandardRPCLinkOptions, StandardRPCSerializer };
+export { getMalformedResponseErrorCode, toHttpPath, toStandardHeaders };