@orpc/client 0.0.0-next.f81b4a2 → 0.0.0-next.f9e0a4c

package/README.md

@@ -21,28 +21,24 @@
 
 <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), 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,13 +49,13 @@ 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/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/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/tanstack-query](https://www.npmjs.com/package/@orpc/tanstack-query): [TanStack Query](https://tanstack.com/query/latest) integration.
 - [@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/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/).

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

@@ -1,8 +1,8 @@
 import { StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
 import { ToFetchRequestOptions } from '@orpc/standard-server-fetch';
-import { a as ClientContext, b as ClientOptions } from '../../shared/client.CipPQkhk.mjs';
-import { f as StandardLinkClient } from '../../shared/client.FXep-a3a.mjs';
-import { f as StandardRPCLinkOptions, g as StandardRPCLink } from '../../shared/client.BjJBZryq.mjs';
+import { b as ClientContext, c as ClientOptions } from '../../shared/client.BOYsZIRq.mjs';
+import { f as StandardLinkClient } from '../../shared/client.Bwgm6dgk.mjs';
+import { f as StandardRPCLinkOptions, g as StandardRPCLink } from '../../shared/client.Ycwr4Tuo.mjs';
 import '@orpc/shared';
 
 interface LinkFetchClientOptions<T extends ClientContext> extends ToFetchRequestOptions {

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

@@ -1,8 +1,8 @@
 import { StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
 import { ToFetchRequestOptions } from '@orpc/standard-server-fetch';
-import { a as ClientContext, b as ClientOptions } from '../../shared/client.CipPQkhk.js';
-import { f as StandardLinkClient } from '../../shared/client.C9U9n1f3.js';
-import { f as StandardRPCLinkOptions, g as StandardRPCLink } from '../../shared/client.8TjrVhkC.js';
+import { b as ClientContext, c as ClientOptions } from '../../shared/client.BOYsZIRq.js';
+import { f as StandardLinkClient } from '../../shared/client.BG98rYdO.js';
+import { f as StandardRPCLinkOptions, g as StandardRPCLink } from '../../shared/client.C176log5.js';
 import '@orpc/shared';
 
 interface LinkFetchClientOptions<T extends ClientContext> extends ToFetchRequestOptions {

package/dist/adapters/fetch/index.mjs

@@ -1,8 +1,8 @@
 import { toFetchRequest, toStandardLazyResponse } from '@orpc/standard-server-fetch';
 import '@orpc/shared';
-import { c as StandardRPCLink } from '../../shared/client.DpICn1BD.mjs';
+import { c as StandardRPCLink } from '../../shared/client.DKmRtVO2.mjs';
 import '@orpc/standard-server';
-import '../../shared/client.CRWEpqLB.mjs';
+import '../../shared/client.txdq_i5V.mjs';
 
 class LinkFetchClient {
   fetch;
@@ -14,7 +14,7 @@ class LinkFetchClient {
   async call(request, options, path, input) {
     const fetchRequest = toFetchRequest(request, this.toFetchRequestOptions);
     const fetchResponse = await this.fetch(fetchRequest, { redirect: "manual" }, options, path, input);
-    const lazyResponse = toStandardLazyResponse(fetchResponse);
+    const lazyResponse = toStandardLazyResponse(fetchResponse, { signal: fetchRequest.signal });
     return lazyResponse;
   }
 }

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

@@ -0,0 +1,59 @@
+import { StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
+import { b as ClientContext, c as ClientOptions } from '../../shared/client.BOYsZIRq.mjs';
+import { f as StandardLinkClient } from '../../shared/client.Bwgm6dgk.mjs';
+import { f as StandardRPCLinkOptions, g as StandardRPCLink } from '../../shared/client.Ycwr4Tuo.mjs';
+import '@orpc/shared';
+
+/**
+ * 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) => 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 = string | ArrayBufferLike | Uint8Array;
+declare function postMessagePortMessage(port: SupportedMessagePort, data: SupportedMessagePortData): void;
+declare function onMessagePortMessage(port: SupportedMessagePort, callback: (data: SupportedMessagePortData) => void): void;
+declare function onMessagePortClose(port: SupportedMessagePort, callback: () => void): void;
+
+interface LinkMessagePortClientOptions {
+    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,59 @@
+import { StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
+import { b as ClientContext, c as ClientOptions } from '../../shared/client.BOYsZIRq.js';
+import { f as StandardLinkClient } from '../../shared/client.BG98rYdO.js';
+import { f as StandardRPCLinkOptions, g as StandardRPCLink } from '../../shared/client.C176log5.js';
+import '@orpc/shared';
+
+/**
+ * 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) => 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 = string | ArrayBufferLike | Uint8Array;
+declare function postMessagePortMessage(port: SupportedMessagePort, data: SupportedMessagePortData): void;
+declare function onMessagePortMessage(port: SupportedMessagePort, callback: (data: SupportedMessagePortData) => void): void;
+declare function onMessagePortClose(port: SupportedMessagePort, callback: () => void): void;
+
+interface LinkMessagePortClientOptions {
+    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,71 @@
+import { ClientPeer } from '@orpc/standard-server-peer';
+import '@orpc/shared';
+import { c as StandardRPCLink } from '../../shared/client.DKmRtVO2.mjs';
+import '@orpc/standard-server';
+import '../../shared/client.txdq_i5V.mjs';
+
+function postMessagePortMessage(port, data) {
+  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 ClientPeer((message) => {
+      return postMessagePortMessage(options.port, message);
+    });
+    onMessagePortMessage(options.port, async (message) => {
+      await this.peer.message(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:/" });
+  }
+}
+
+export { LinkMessagePortClient, RPCLink, onMessagePortClose, onMessagePortMessage, postMessagePortMessage };

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

@@ -1,6 +1,6 @@
-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.FXep-a3a.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.BjJBZryq.mjs';
-import { H as HTTPPath } from '../../shared/client.CipPQkhk.mjs';
+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.Bwgm6dgk.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.Ycwr4Tuo.mjs';
+import { H as HTTPPath } from '../../shared/client.BOYsZIRq.mjs';
 import '@orpc/shared';
 import '@orpc/standard-server';
 

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

@@ -1,6 +1,6 @@
-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.C9U9n1f3.js';
-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.8TjrVhkC.js';
-import { H as HTTPPath } from '../../shared/client.CipPQkhk.js';
+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.BG98rYdO.js';
+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.C176log5.js';
+import { H as HTTPPath } from '../../shared/client.BOYsZIRq.js';
 import '@orpc/shared';
 import '@orpc/standard-server';
 

package/dist/adapters/standard/index.mjs

@@ -1,4 +1,4 @@
-export { C as CompositeStandardLinkPlugin, a as STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES, S as StandardLink, b as StandardRPCJsonSerializer, c as StandardRPCLink, d as StandardRPCLinkCodec, e as StandardRPCSerializer, g as getMalformedResponseErrorCode, t as toHttpPath } from '../../shared/client.DpICn1BD.mjs';
+export { C as CompositeStandardLinkPlugin, a as STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES, S as StandardLink, b as StandardRPCJsonSerializer, c as StandardRPCLink, d as StandardRPCLinkCodec, e as StandardRPCSerializer, g as getMalformedResponseErrorCode, t as toHttpPath } from '../../shared/client.DKmRtVO2.mjs';
 import '@orpc/shared';
 import '@orpc/standard-server';
-import '../../shared/client.CRWEpqLB.mjs';
+import '../../shared/client.txdq_i5V.mjs';

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

@@ -0,0 +1,29 @@
+import { StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
+import { b as ClientContext, c as ClientOptions } from '../../shared/client.BOYsZIRq.mjs';
+import { f as StandardLinkClient } from '../../shared/client.Bwgm6dgk.mjs';
+import { f as StandardRPCLinkOptions, g as StandardRPCLink } from '../../shared/client.Ycwr4Tuo.mjs';
+import '@orpc/shared';
+
+interface LinkWebsocketClientOptions {
+    websocket: Pick<WebSocket, 'addEventListener' | 'send' | 'readyState'>;
+}
+declare class LinkWebsocketClient<T extends ClientContext> implements StandardLinkClient<T> {
+    private readonly peer;
+    constructor(options: LinkWebsocketClientOptions);
+    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'>, LinkWebsocketClientOptions {
+}
+/**
+ * The RPC Link communicates with the server using the RPC protocol over WebSocket.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/client/rpc-link RPC Link Docs}
+ * @see {@link https://orpc.unnoq.com/docs/adapters/websocket WebSocket Adapter Docs}
+ */
+declare class RPCLink<T extends ClientContext> extends StandardRPCLink<T> {
+    constructor(options: RPCLinkOptions<T>);
+}
+
+export { LinkWebsocketClient, RPCLink };
+export type { LinkWebsocketClientOptions, RPCLinkOptions };

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

@@ -0,0 +1,29 @@
+import { StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
+import { b as ClientContext, c as ClientOptions } from '../../shared/client.BOYsZIRq.js';
+import { f as StandardLinkClient } from '../../shared/client.BG98rYdO.js';
+import { f as StandardRPCLinkOptions, g as StandardRPCLink } from '../../shared/client.C176log5.js';
+import '@orpc/shared';
+
+interface LinkWebsocketClientOptions {
+    websocket: Pick<WebSocket, 'addEventListener' | 'send' | 'readyState'>;
+}
+declare class LinkWebsocketClient<T extends ClientContext> implements StandardLinkClient<T> {
+    private readonly peer;
+    constructor(options: LinkWebsocketClientOptions);
+    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'>, LinkWebsocketClientOptions {
+}
+/**
+ * The RPC Link communicates with the server using the RPC protocol over WebSocket.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/client/rpc-link RPC Link Docs}
+ * @see {@link https://orpc.unnoq.com/docs/adapters/websocket WebSocket Adapter Docs}
+ */
+declare class RPCLink<T extends ClientContext> extends StandardRPCLink<T> {
+    constructor(options: RPCLinkOptions<T>);
+}
+
+export { LinkWebsocketClient, RPCLink };
+export type { LinkWebsocketClientOptions, RPCLinkOptions };

package/dist/adapters/websocket/index.mjs

@@ -0,0 +1,45 @@
+import { readAsBuffer } from '@orpc/shared';
+import { ClientPeer } from '@orpc/standard-server-peer';
+import { c as StandardRPCLink } from '../../shared/client.DKmRtVO2.mjs';
+import '@orpc/standard-server';
+import '../../shared/client.txdq_i5V.mjs';
+
+const WEBSOCKET_CONNECTING = 0;
+class LinkWebsocketClient {
+  peer;
+  constructor(options) {
+    const untilOpen = new Promise((resolve) => {
+      if (options.websocket.readyState === WEBSOCKET_CONNECTING) {
+        options.websocket.addEventListener("open", () => {
+          resolve();
+        }, { once: true });
+      } else {
+        resolve();
+      }
+    });
+    this.peer = new ClientPeer(async (message) => {
+      await untilOpen;
+      return options.websocket.send(message);
+    });
+    options.websocket.addEventListener("message", async (event) => {
+      const message = event.data instanceof Blob ? await readAsBuffer(event.data) : event.data;
+      this.peer.message(message);
+    });
+    options.websocket.addEventListener("close", () => {
+      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 LinkWebsocketClient(options);
+    super(linkClient, { ...options, url: "orpc:/" });
+  }
+}
+
+export { LinkWebsocketClient, RPCLink };

package/dist/index.d.mts

@@ -1,14 +1,14 @@
-import { N as NestedClient, C as ClientLink, I as InferClientContext, a as ClientContext, b as ClientOptions, c as ClientPromiseResult, F as FriendlyClientOptions } from './shared/client.CipPQkhk.mjs';
-export { f as Client, e as ClientRest, d as HTTPMethod, H as HTTPPath } from './shared/client.CipPQkhk.mjs';
-import { Promisable, MaybeOptionalOptions, ThrowableError } from '@orpc/shared';
-export { Registry, ThrowableError, onError, onFinish, onStart, onSuccess } from '@orpc/shared';
+import { N as NestedClient, C as ClientLink, I as InferClientContext, a as ClientPromiseResult, b as ClientContext, F as FriendlyClientOptions, c as ClientOptions, d as Client, e as ClientRest } from './shared/client.BOYsZIRq.mjs';
+export { f as HTTPMethod, H as HTTPPath } from './shared/client.BOYsZIRq.mjs';
+import { MaybeOptionalOptions, ThrowableError, Promisable, AsyncIteratorClass } from '@orpc/shared';
+export { AsyncIteratorClass, EventPublisher, EventPublisherOptions, EventPublisherSubscribeIteratorOptions, Registry, ThrowableError, asyncIteratorToStream as eventIteratorToStream, onError, onFinish, onStart, onSuccess, streamToAsyncIteratorClass as streamToEventIterator } from '@orpc/shared';
 export { ErrorEvent } from '@orpc/standard-server';
 
 interface createORPCClientOptions {
     /**
      * Use as base path for all procedure, useful when you only want to call a subset of the procedure.
      */
-    path?: string[];
+    path?: readonly string[];
 }
 /**
  * Create a oRPC client-side client from a link.
@@ -17,18 +17,6 @@ interface createORPCClientOptions {
  */
 declare function createORPCClient<T extends NestedClient<any>>(link: ClientLink<InferClientContext<T>>, options?: createORPCClientOptions): T;
 
-/**
- * DynamicLink provides a way to dynamically resolve and delegate calls to other ClientLinks
- * based on the request path, input, and context.
- *
- * @see {@link https://orpc.unnoq.com/docs/client/dynamic-link Dynamic Link Docs}
- */
-declare class DynamicLink<TClientContext extends ClientContext> implements ClientLink<TClientContext> {
-    private readonly linkResolver;
-    constructor(linkResolver: (options: ClientOptions<TClientContext>, path: readonly string[], input: unknown) => Promisable<ClientLink<TClientContext>>);
-    call(path: readonly string[], input: unknown, options: ClientOptions<TClientContext>): Promise<unknown>;
-}
-
 declare const COMMON_ORPC_ERROR_DEFS: {
     readonly BAD_REQUEST: {
         readonly status: 400;
@@ -125,7 +113,7 @@ declare class ORPCError<TCode extends ORPCErrorCode, TData> extends Error {
     readonly code: TCode;
     readonly status: number;
     readonly data: TData;
-    constructor(code: TCode, ...[options]: MaybeOptionalOptions<ORPCErrorOptions<TData>>);
+    constructor(code: TCode, ...rest: MaybeOptionalOptions<ORPCErrorOptions<TData>>);
     toJSON(): ORPCErrorJSON<TCode, TData>;
 }
 type ORPCErrorJSON<TCode extends string, TData> = Pick<ORPCError<TCode, TData>, 'defined' | 'code' | 'status' | 'message' | 'data'>;
@@ -135,11 +123,6 @@ declare function isORPCErrorStatus(status: number): boolean;
 declare function isORPCErrorJson(json: unknown): json is ORPCErrorJSON<ORPCErrorCode, unknown>;
 declare function createORPCErrorFromJson<TCode extends ORPCErrorCode, TData>(json: ORPCErrorJSON<TCode, TData>, options?: ErrorOptions): ORPCError<TCode, TData>;
 
-declare function mapEventIterator<TYield, TReturn, TNext, TMap = TYield | TReturn>(iterator: AsyncIterator<TYield, TReturn, TNext>, maps: {
-    value: (value: NoInfer<TYield | TReturn>, done: boolean | undefined) => Promise<TMap>;
-    error: (error: unknown) => Promise<unknown>;
-}): AsyncGenerator<TMap, TMap, TNext>;
-
 type SafeResult<TOutput, TError> = [error: null, data: TOutput, isDefined: false, isSuccess: true] & {
     error: null;
     data: TOutput;
@@ -165,5 +148,38 @@ type SafeResult<TOutput, TError> = [error: null, data: TOutput, isDefined: false
 declare function safe<TOutput, TError = ThrowableError>(promise: ClientPromiseResult<TOutput, TError>): Promise<SafeResult<TOutput, TError>>;
 declare function resolveFriendlyClientOptions<T extends ClientContext>(options: FriendlyClientOptions<T>): ClientOptions<T>;
 
-export { COMMON_ORPC_ERROR_DEFS, ClientContext, ClientLink, ClientOptions, ClientPromiseResult, DynamicLink, FriendlyClientOptions, InferClientContext, NestedClient, ORPCError, createORPCClient, createORPCErrorFromJson, fallbackORPCErrorMessage, fallbackORPCErrorStatus, isDefinedError, isORPCErrorJson, isORPCErrorStatus, mapEventIterator, resolveFriendlyClientOptions, safe, toORPCError };
-export type { CommonORPCErrorCode, ORPCErrorCode, ORPCErrorJSON, ORPCErrorOptions, SafeResult, createORPCClientOptions };
+type SafeClient<T extends NestedClient<any>> = T extends Client<infer UContext, infer UInput, infer UOutput, infer UError> ? (...rest: ClientRest<UContext, UInput>) => Promise<SafeResult<UOutput, UError>> : {
+    [K in keyof T]: T[K] extends NestedClient<any> ? SafeClient<T[K]> : never;
+};
+/**
+ * Create a safe client that automatically wraps all procedure calls with the `safe` util.
+ *
+ * @example
+ * ```ts
+ * const safeClient = createSafeClient(client)
+ * const { error, data, isDefined } = await safeClient.doSomething({ id: '123' })
+ * ```
+ *
+ * @see {@link https://orpc.unnoq.com/docs/client/error-handling#using-createsafeclient Safe Client Docs}
+ */
+declare function createSafeClient<T extends NestedClient<any>>(client: T): SafeClient<T>;
+
+/**
+ * DynamicLink provides a way to dynamically resolve and delegate calls to other ClientLinks
+ * based on the request path, input, and context.
+ *
+ * @see {@link https://orpc.unnoq.com/docs/client/dynamic-link Dynamic Link Docs}
+ */
+declare class DynamicLink<TClientContext extends ClientContext> implements ClientLink<TClientContext> {
+    private readonly linkResolver;
+    constructor(linkResolver: (options: ClientOptions<TClientContext>, path: readonly string[], input: unknown) => Promisable<ClientLink<TClientContext>>);
+    call(path: readonly string[], input: unknown, options: ClientOptions<TClientContext>): Promise<unknown>;
+}
+
+declare function mapEventIterator<TYield, TReturn, TNext, TMap = TYield | TReturn>(iterator: AsyncIterator<TYield, TReturn, TNext>, maps: {
+    value: (value: NoInfer<TYield | TReturn>, done: boolean | undefined) => Promise<TMap>;
+    error: (error: unknown) => Promise<unknown>;
+}): AsyncIteratorClass<TMap, TMap, TNext>;
+
+export { COMMON_ORPC_ERROR_DEFS, Client, ClientContext, ClientLink, ClientOptions, ClientPromiseResult, ClientRest, DynamicLink, FriendlyClientOptions, InferClientContext, NestedClient, ORPCError, createORPCClient, createORPCErrorFromJson, createSafeClient, fallbackORPCErrorMessage, fallbackORPCErrorStatus, isDefinedError, isORPCErrorJson, isORPCErrorStatus, mapEventIterator, resolveFriendlyClientOptions, safe, toORPCError };
+export type { CommonORPCErrorCode, ORPCErrorCode, ORPCErrorJSON, ORPCErrorOptions, SafeClient, SafeResult, createORPCClientOptions };