@orpc/client 0.0.0-next.de7ca70 → 0.0.0-next.dea79a3

package/README.md

@@ -30,6 +30,7 @@
 - **🔗 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.
@@ -38,7 +39,6 @@
 - **📡 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.
-- **🛡️ Reliability**: Well-tested, TypeScript-based, production-ready, and MIT licensed.
 
 ## Documentation
 
@@ -50,6 +50,7 @@ You can find the full documentation [here](https://orpc.unnoq.com).
 - [@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/tanstack-query](https://www.npmjs.com/package/@orpc/tanstack-query): [TanStack Query](https://tanstack.com/query/latest) integration.

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.4TS_0JaO.mjs';
-import { f as StandardLinkClient } from '../../shared/client.BMoG_EdN.mjs';
-import { f as StandardRPCLinkOptions, g as StandardRPCLink } from '../../shared/client.BdD8cpjs.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.4TS_0JaO.js';
-import { f as StandardLinkClient } from '../../shared/client.C0KbSWlC.js';
-import { f as StandardRPCLinkOptions, g as StandardRPCLink } from '../../shared/client.7UM0t5o-.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.DwfV9Oyl.mjs';
+import { c as StandardRPCLink } from '../../shared/client.DKmRtVO2.mjs';
 import '@orpc/standard-server';
-import '../../shared/client.DHOfWE0c.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

@@ -1,7 +1,7 @@
 import { StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
-import { a as ClientContext, b as ClientOptions } from '../../shared/client.4TS_0JaO.mjs';
-import { f as StandardLinkClient } from '../../shared/client.BMoG_EdN.mjs';
-import { f as StandardRPCLinkOptions, g as StandardRPCLink } from '../../shared/client.BdD8cpjs.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';
 
 /**
@@ -34,16 +34,16 @@ declare function postMessagePortMessage(port: SupportedMessagePort, data: Suppor
 declare function onMessagePortMessage(port: SupportedMessagePort, callback: (data: SupportedMessagePortData) => void): void;
 declare function onMessagePortClose(port: SupportedMessagePort, callback: () => void): void;
 
-interface experimental_LinkMessagePortClientOptions {
+interface LinkMessagePortClientOptions {
     port: SupportedMessagePort;
 }
-declare class experimental_LinkMessagePortClient<T extends ClientContext> implements StandardLinkClient<T> {
+declare class LinkMessagePortClient<T extends ClientContext> implements StandardLinkClient<T> {
     private readonly peer;
-    constructor(options: experimental_LinkMessagePortClientOptions);
+    constructor(options: LinkMessagePortClientOptions);
     call(request: StandardRequest, _options: ClientOptions<T>, _path: readonly string[], _input: unknown): Promise<StandardLazyResponse>;
 }
 
-interface experimental_RPCLinkOptions<T extends ClientContext> extends Omit<StandardRPCLinkOptions<T>, 'url' | 'headers' | 'method' | 'fallbackMethod' | 'maxUrlLength'>, experimental_LinkMessagePortClientOptions {
+interface RPCLinkOptions<T extends ClientContext> extends Omit<StandardRPCLinkOptions<T>, 'url' | 'method' | 'fallbackMethod' | 'maxUrlLength'>, LinkMessagePortClientOptions {
 }
 /**
  * The RPC Link for common message port implementations.
@@ -51,9 +51,9 @@ interface experimental_RPCLinkOptions<T extends ClientContext> extends Omit<Stan
  * @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 experimental_RPCLink<T extends ClientContext> extends StandardRPCLink<T> {
-    constructor(options: experimental_RPCLinkOptions<T>);
+declare class RPCLink<T extends ClientContext> extends StandardRPCLink<T> {
+    constructor(options: RPCLinkOptions<T>);
 }
 
-export { experimental_LinkMessagePortClient, experimental_RPCLink, onMessagePortClose, onMessagePortMessage, postMessagePortMessage };
-export type { BrowserPortLike, MessagePortMainLike, SupportedMessagePort, SupportedMessagePortData, experimental_LinkMessagePortClientOptions, experimental_RPCLinkOptions };
+export { LinkMessagePortClient, RPCLink, onMessagePortClose, onMessagePortMessage, postMessagePortMessage };
+export type { BrowserPortLike, LinkMessagePortClientOptions, MessagePortMainLike, RPCLinkOptions, SupportedMessagePort, SupportedMessagePortData };

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

@@ -1,7 +1,7 @@
 import { StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
-import { a as ClientContext, b as ClientOptions } from '../../shared/client.4TS_0JaO.js';
-import { f as StandardLinkClient } from '../../shared/client.C0KbSWlC.js';
-import { f as StandardRPCLinkOptions, g as StandardRPCLink } from '../../shared/client.7UM0t5o-.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';
 
 /**
@@ -34,16 +34,16 @@ declare function postMessagePortMessage(port: SupportedMessagePort, data: Suppor
 declare function onMessagePortMessage(port: SupportedMessagePort, callback: (data: SupportedMessagePortData) => void): void;
 declare function onMessagePortClose(port: SupportedMessagePort, callback: () => void): void;
 
-interface experimental_LinkMessagePortClientOptions {
+interface LinkMessagePortClientOptions {
     port: SupportedMessagePort;
 }
-declare class experimental_LinkMessagePortClient<T extends ClientContext> implements StandardLinkClient<T> {
+declare class LinkMessagePortClient<T extends ClientContext> implements StandardLinkClient<T> {
     private readonly peer;
-    constructor(options: experimental_LinkMessagePortClientOptions);
+    constructor(options: LinkMessagePortClientOptions);
     call(request: StandardRequest, _options: ClientOptions<T>, _path: readonly string[], _input: unknown): Promise<StandardLazyResponse>;
 }
 
-interface experimental_RPCLinkOptions<T extends ClientContext> extends Omit<StandardRPCLinkOptions<T>, 'url' | 'headers' | 'method' | 'fallbackMethod' | 'maxUrlLength'>, experimental_LinkMessagePortClientOptions {
+interface RPCLinkOptions<T extends ClientContext> extends Omit<StandardRPCLinkOptions<T>, 'url' | 'method' | 'fallbackMethod' | 'maxUrlLength'>, LinkMessagePortClientOptions {
 }
 /**
  * The RPC Link for common message port implementations.
@@ -51,9 +51,9 @@ interface experimental_RPCLinkOptions<T extends ClientContext> extends Omit<Stan
  * @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 experimental_RPCLink<T extends ClientContext> extends StandardRPCLink<T> {
-    constructor(options: experimental_RPCLinkOptions<T>);
+declare class RPCLink<T extends ClientContext> extends StandardRPCLink<T> {
+    constructor(options: RPCLinkOptions<T>);
 }
 
-export { experimental_LinkMessagePortClient, experimental_RPCLink, onMessagePortClose, onMessagePortMessage, postMessagePortMessage };
-export type { BrowserPortLike, MessagePortMainLike, SupportedMessagePort, SupportedMessagePortData, experimental_LinkMessagePortClientOptions, experimental_RPCLinkOptions };
+export { LinkMessagePortClient, RPCLink, onMessagePortClose, onMessagePortMessage, postMessagePortMessage };
+export type { BrowserPortLike, LinkMessagePortClientOptions, MessagePortMainLike, RPCLinkOptions, SupportedMessagePort, SupportedMessagePortData };

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

@@ -1,8 +1,8 @@
 import { ClientPeer } from '@orpc/standard-server-peer';
 import '@orpc/shared';
-import { c as StandardRPCLink } from '../../shared/client.DwfV9Oyl.mjs';
+import { c as StandardRPCLink } from '../../shared/client.DKmRtVO2.mjs';
 import '@orpc/standard-server';
-import '../../shared/client.DHOfWE0c.mjs';
+import '../../shared/client.txdq_i5V.mjs';
 
 function postMessagePortMessage(port, data) {
   port.postMessage(data);
@@ -42,7 +42,7 @@ function onMessagePortClose(port, callback) {
   }
 }
 
-class experimental_LinkMessagePortClient {
+class LinkMessagePortClient {
   peer;
   constructor(options) {
     this.peer = new ClientPeer((message) => {
@@ -61,11 +61,11 @@ class experimental_LinkMessagePortClient {
   }
 }
 
-class experimental_RPCLink extends StandardRPCLink {
+class RPCLink extends StandardRPCLink {
   constructor(options) {
-    const linkClient = new experimental_LinkMessagePortClient(options);
+    const linkClient = new LinkMessagePortClient(options);
     super(linkClient, { ...options, url: "orpc:/" });
   }
 }
 
-export { experimental_LinkMessagePortClient, experimental_RPCLink, onMessagePortClose, onMessagePortMessage, postMessagePortMessage };
+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.BMoG_EdN.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.BdD8cpjs.mjs';
-import { H as HTTPPath } from '../../shared/client.4TS_0JaO.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.C0KbSWlC.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.7UM0t5o-.js';
-import { H as HTTPPath } from '../../shared/client.4TS_0JaO.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.DwfV9Oyl.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.DHOfWE0c.mjs';
+import '../../shared/client.txdq_i5V.mjs';

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

@@ -1,19 +1,19 @@
 import { StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
-import { a as ClientContext, b as ClientOptions } from '../../shared/client.4TS_0JaO.mjs';
-import { f as StandardLinkClient } from '../../shared/client.BMoG_EdN.mjs';
-import { f as StandardRPCLinkOptions, g as StandardRPCLink } from '../../shared/client.BdD8cpjs.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 experimental_LinkWebsocketClientOptions {
+interface LinkWebsocketClientOptions {
     websocket: Pick<WebSocket, 'addEventListener' | 'send' | 'readyState'>;
 }
-declare class experimental_LinkWebsocketClient<T extends ClientContext> implements StandardLinkClient<T> {
+declare class LinkWebsocketClient<T extends ClientContext> implements StandardLinkClient<T> {
     private readonly peer;
-    constructor(options: experimental_LinkWebsocketClientOptions);
+    constructor(options: LinkWebsocketClientOptions);
     call(request: StandardRequest, _options: ClientOptions<T>, _path: readonly string[], _input: unknown): Promise<StandardLazyResponse>;
 }
 
-interface experimental_RPCLinkOptions<T extends ClientContext> extends Omit<StandardRPCLinkOptions<T>, 'url' | 'headers' | 'method' | 'fallbackMethod' | 'maxUrlLength'>, experimental_LinkWebsocketClientOptions {
+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.
@@ -21,9 +21,9 @@ interface experimental_RPCLinkOptions<T extends ClientContext> extends Omit<Stan
  * @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 experimental_RPCLink<T extends ClientContext> extends StandardRPCLink<T> {
-    constructor(options: experimental_RPCLinkOptions<T>);
+declare class RPCLink<T extends ClientContext> extends StandardRPCLink<T> {
+    constructor(options: RPCLinkOptions<T>);
 }
 
-export { experimental_LinkWebsocketClient, experimental_RPCLink };
-export type { experimental_LinkWebsocketClientOptions, experimental_RPCLinkOptions };
+export { LinkWebsocketClient, RPCLink };
+export type { LinkWebsocketClientOptions, RPCLinkOptions };

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

@@ -1,19 +1,19 @@
 import { StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
-import { a as ClientContext, b as ClientOptions } from '../../shared/client.4TS_0JaO.js';
-import { f as StandardLinkClient } from '../../shared/client.C0KbSWlC.js';
-import { f as StandardRPCLinkOptions, g as StandardRPCLink } from '../../shared/client.7UM0t5o-.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 experimental_LinkWebsocketClientOptions {
+interface LinkWebsocketClientOptions {
     websocket: Pick<WebSocket, 'addEventListener' | 'send' | 'readyState'>;
 }
-declare class experimental_LinkWebsocketClient<T extends ClientContext> implements StandardLinkClient<T> {
+declare class LinkWebsocketClient<T extends ClientContext> implements StandardLinkClient<T> {
     private readonly peer;
-    constructor(options: experimental_LinkWebsocketClientOptions);
+    constructor(options: LinkWebsocketClientOptions);
     call(request: StandardRequest, _options: ClientOptions<T>, _path: readonly string[], _input: unknown): Promise<StandardLazyResponse>;
 }
 
-interface experimental_RPCLinkOptions<T extends ClientContext> extends Omit<StandardRPCLinkOptions<T>, 'url' | 'headers' | 'method' | 'fallbackMethod' | 'maxUrlLength'>, experimental_LinkWebsocketClientOptions {
+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.
@@ -21,9 +21,9 @@ interface experimental_RPCLinkOptions<T extends ClientContext> extends Omit<Stan
  * @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 experimental_RPCLink<T extends ClientContext> extends StandardRPCLink<T> {
-    constructor(options: experimental_RPCLinkOptions<T>);
+declare class RPCLink<T extends ClientContext> extends StandardRPCLink<T> {
+    constructor(options: RPCLinkOptions<T>);
 }
 
-export { experimental_LinkWebsocketClient, experimental_RPCLink };
-export type { experimental_LinkWebsocketClientOptions, experimental_RPCLinkOptions };
+export { LinkWebsocketClient, RPCLink };
+export type { LinkWebsocketClientOptions, RPCLinkOptions };

package/dist/adapters/websocket/index.mjs

@@ -1,14 +1,15 @@
 import { readAsBuffer } from '@orpc/shared';
 import { ClientPeer } from '@orpc/standard-server-peer';
-import { c as StandardRPCLink } from '../../shared/client.DwfV9Oyl.mjs';
+import { c as StandardRPCLink } from '../../shared/client.DKmRtVO2.mjs';
 import '@orpc/standard-server';
-import '../../shared/client.DHOfWE0c.mjs';
+import '../../shared/client.txdq_i5V.mjs';
 
-class experimental_LinkWebsocketClient {
+const WEBSOCKET_CONNECTING = 0;
+class LinkWebsocketClient {
   peer;
   constructor(options) {
     const untilOpen = new Promise((resolve) => {
-      if (options.websocket.readyState === 0) {
+      if (options.websocket.readyState === WEBSOCKET_CONNECTING) {
         options.websocket.addEventListener("open", () => {
           resolve();
         }, { once: true });
@@ -34,11 +35,11 @@ class experimental_LinkWebsocketClient {
   }
 }
 
-class experimental_RPCLink extends StandardRPCLink {
+class RPCLink extends StandardRPCLink {
   constructor(options) {
-    const linkClient = new experimental_LinkWebsocketClient(options);
+    const linkClient = new LinkWebsocketClient(options);
     super(linkClient, { ...options, url: "orpc:/" });
   }
 }
 
-export { experimental_LinkWebsocketClient, experimental_RPCLink };
+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.4TS_0JaO.mjs';
-export { f as Client, e as ClientRest, d as HTTPMethod, H as HTTPPath } from './shared/client.4TS_0JaO.mjs';
-import { Promisable, MaybeOptionalOptions, AsyncIteratorClass, ThrowableError } from '@orpc/shared';
-export { EventPublisher, EventPublisherOptions, EventPublisherSubscribeIteratorOptions, 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>;
-}): AsyncIteratorClass<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 };

package/dist/index.d.ts

@@ -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.4TS_0JaO.js';
-export { f as Client, e as ClientRest, d as HTTPMethod, H as HTTPPath } from './shared/client.4TS_0JaO.js';
-import { Promisable, MaybeOptionalOptions, AsyncIteratorClass, ThrowableError } from '@orpc/shared';
-export { EventPublisher, EventPublisherOptions, EventPublisherSubscribeIteratorOptions, 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.js';
+export { f as HTTPMethod, H as HTTPPath } from './shared/client.BOYsZIRq.js';
+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>;
-}): AsyncIteratorClass<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 };

package/dist/index.mjs

@@ -1,6 +1,7 @@
-import { i as isDefinedError } from './shared/client.DHOfWE0c.mjs';
-export { C as COMMON_ORPC_ERROR_DEFS, O as ORPCError, d as createORPCErrorFromJson, a as fallbackORPCErrorMessage, f as fallbackORPCErrorStatus, c as isORPCErrorJson, b as isORPCErrorStatus, m as mapEventIterator, t as toORPCError } from './shared/client.DHOfWE0c.mjs';
-export { EventPublisher, onError, onFinish, onStart, onSuccess } from '@orpc/shared';
+import { i as isDefinedError } from './shared/client.txdq_i5V.mjs';
+export { C as COMMON_ORPC_ERROR_DEFS, O as ORPCError, d as createORPCErrorFromJson, a as fallbackORPCErrorMessage, f as fallbackORPCErrorStatus, c as isORPCErrorJson, b as isORPCErrorStatus, m as mapEventIterator, t as toORPCError } from './shared/client.txdq_i5V.mjs';
+import { isTypescriptObject } from '@orpc/shared';
+export { AsyncIteratorClass, EventPublisher, asyncIteratorToStream as eventIteratorToStream, onError, onFinish, onStart, onSuccess, streamToAsyncIteratorClass as streamToEventIterator } from '@orpc/shared';
 export { ErrorEvent } from '@orpc/standard-server';
 
 async function safe(promise) {
@@ -32,8 +33,8 @@ function resolveFriendlyClientOptions(options) {
   };
 }
 
-function createORPCClient(link, options) {
-  const path = options?.path ?? [];
+function createORPCClient(link, options = {}) {
+  const path = options.path ?? [];
   const procedureClient = async (...[input, options2 = {}]) => {
     return await link.call(path, input, resolveFriendlyClientOptions(options2));
   };
@@ -51,6 +52,22 @@ function createORPCClient(link, options) {
   return recursive;
 }
 
+function createSafeClient(client) {
+  const proxy = new Proxy((...args) => safe(client(...args)), {
+    get(_, prop, receiver) {
+      const value = Reflect.get(client, prop, receiver);
+      if (typeof prop !== "string") {
+        return value;
+      }
+      if (!isTypescriptObject(value)) {
+        return value;
+      }
+      return createSafeClient(value);
+    }
+  });
+  return proxy;
+}
+
 class DynamicLink {
   constructor(linkResolver) {
     this.linkResolver = linkResolver;
@@ -62,4 +79,4 @@ class DynamicLink {
   }
 }
 
-export { DynamicLink, createORPCClient, isDefinedError, resolveFriendlyClientOptions, safe };
+export { DynamicLink, createORPCClient, createSafeClient, isDefinedError, resolveFriendlyClientOptions, safe };

package/dist/plugins/index.d.mts

@@ -1,8 +1,8 @@
 import { Value, Promisable } from '@orpc/shared';
 import { StandardHeaders, StandardRequest } from '@orpc/standard-server';
 import { BatchResponseMode } from '@orpc/standard-server/batch';
-import { S as StandardLinkClientInterceptorOptions, a as StandardLinkPlugin, b as StandardLinkOptions, c as StandardLinkInterceptorOptions } from '../shared/client.BMoG_EdN.mjs';
-import { a as ClientContext } from '../shared/client.4TS_0JaO.mjs';
+import { S as StandardLinkClientInterceptorOptions, a as StandardLinkPlugin, b as StandardLinkOptions, c as StandardLinkInterceptorOptions } from '../shared/client.Bwgm6dgk.mjs';
+import { b as ClientContext } from '../shared/client.BOYsZIRq.mjs';
 
 interface BatchLinkPluginGroup<T extends ClientContext> {
     condition(options: StandardLinkClientInterceptorOptions<T>): boolean;

package/dist/plugins/index.d.ts

@@ -1,8 +1,8 @@
 import { Value, Promisable } from '@orpc/shared';
 import { StandardHeaders, StandardRequest } from '@orpc/standard-server';
 import { BatchResponseMode } from '@orpc/standard-server/batch';
-import { S as StandardLinkClientInterceptorOptions, a as StandardLinkPlugin, b as StandardLinkOptions, c as StandardLinkInterceptorOptions } from '../shared/client.C0KbSWlC.js';
-import { a as ClientContext } from '../shared/client.4TS_0JaO.js';
+import { S as StandardLinkClientInterceptorOptions, a as StandardLinkPlugin, b as StandardLinkOptions, c as StandardLinkInterceptorOptions } from '../shared/client.BG98rYdO.js';
+import { b as ClientContext } from '../shared/client.BOYsZIRq.js';
 
 interface BatchLinkPluginGroup<T extends ClientContext> {
     condition(options: StandardLinkClientInterceptorOptions<T>): boolean;

package/dist/plugins/index.mjs

@@ -64,7 +64,7 @@ class BatchLinkPlugin {
       });
     });
     options.clientInterceptors.push((options2) => {
-      if (this.exclude(options2) || options2.request.body instanceof Blob || options2.request.body instanceof FormData || isAsyncIteratorObject(options2.request.body)) {
+      if (this.exclude(options2) || options2.request.body instanceof Blob || options2.request.body instanceof FormData || isAsyncIteratorObject(options2.request.body) || options2.request.signal?.aborted) {
         return options2.next();
       }
       const group = this.groups.find((group2) => group2.condition(options2));
@@ -130,16 +130,27 @@ class BatchLinkPlugin {
         return;
       }
       const mode = value(this.mode, options);
-      const lazyResponse = await options[0].next({
-        request: { ...batchRequest, headers: { ...batchRequest.headers, "x-orpc-batch": mode } },
-        signal: batchRequest.signal,
-        context: group.context,
-        input: group.input,
-        path: toArray(group.path)
-      });
-      const parsed = parseBatchResponse({ ...lazyResponse, body: await lazyResponse.body() });
-      for await (const item of parsed) {
-        batchItems[item.index]?.[1]({ ...item, body: () => Promise.resolve(item.body) });
+      try {
+        const lazyResponse = await options[0].next({
+          request: { ...batchRequest, headers: { ...batchRequest.headers, "x-orpc-batch": mode } },
+          signal: batchRequest.signal,
+          context: group.context,
+          input: group.input,
+          path: toArray(group.path)
+        });
+        const parsed = parseBatchResponse({ ...lazyResponse, body: await lazyResponse.body() });
+        for await (const item of parsed) {
+          batchItems[item.index]?.[1]({ ...item, body: () => Promise.resolve(item.body) });
+        }
+      } catch (err) {
+        if (batchRequest.signal?.aborted && batchRequest.signal.reason === err) {
+          for (const [{ signal }, , reject] of batchItems) {
+            if (signal?.aborted) {
+              reject(signal.reason);
+            }
+          }
+        }
+        throw err;
       }
       throw new Error("Something went wrong make batch response not contains enough responses. This can be a bug please report it.");
     } catch (error) {

package/dist/shared/{client.C0KbSWlC.d.ts → client.BG98rYdO.d.ts}

@@ -1,6 +1,6 @@
 import { Interceptor } from '@orpc/shared';
 import { StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
-import { a as ClientContext, b as ClientOptions, C as ClientLink } from './client.4TS_0JaO.js';
+import { b as ClientContext, c as ClientOptions, C as ClientLink } from './client.BOYsZIRq.js';
 
 interface StandardLinkPlugin<T extends ClientContext> {
     order?: number;
@@ -33,7 +33,6 @@ interface StandardLinkOptions<T extends ClientContext> {
     plugins?: StandardLinkPlugin<T>[];
 }
 declare class StandardLink<T extends ClientContext> implements ClientLink<T> {
-    #private;
     readonly codec: StandardLinkCodec<T>;
     readonly sender: StandardLinkClient<T>;
     private readonly interceptors;

package/dist/shared/{client.4TS_0JaO.d.mts → client.BOYsZIRq.d.mts}

@@ -26,4 +26,4 @@ interface ClientLink<TClientContext extends ClientContext> {
     call: (path: readonly string[], input: unknown, options: ClientOptions<TClientContext>) => Promise<unknown>;
 }
 
-export type { ClientLink as C, FriendlyClientOptions as F, HTTPPath as H, InferClientContext as I, NestedClient as N, ClientContext as a, ClientOptions as b, ClientPromiseResult as c, HTTPMethod as d, ClientRest as e, Client as f };
+export type { ClientLink as C, FriendlyClientOptions as F, HTTPPath as H, InferClientContext as I, NestedClient as N, ClientPromiseResult as a, ClientContext as b, ClientOptions as c, Client as d, ClientRest as e, HTTPMethod as f };

package/dist/shared/{client.4TS_0JaO.d.ts → client.BOYsZIRq.d.ts}

@@ -26,4 +26,4 @@ interface ClientLink<TClientContext extends ClientContext> {
     call: (path: readonly string[], input: unknown, options: ClientOptions<TClientContext>) => Promise<unknown>;
 }
 
-export type { ClientLink as C, FriendlyClientOptions as F, HTTPPath as H, InferClientContext as I, NestedClient as N, ClientContext as a, ClientOptions as b, ClientPromiseResult as c, HTTPMethod as d, ClientRest as e, Client as f };
+export type { ClientLink as C, FriendlyClientOptions as F, HTTPPath as H, InferClientContext as I, NestedClient as N, ClientPromiseResult as a, ClientContext as b, ClientOptions as c, Client as d, ClientRest as e, HTTPMethod as f };

package/dist/shared/{client.BMoG_EdN.d.mts → client.Bwgm6dgk.d.mts}

@@ -1,6 +1,6 @@
 import { Interceptor } from '@orpc/shared';
 import { StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
-import { a as ClientContext, b as ClientOptions, C as ClientLink } from './client.4TS_0JaO.mjs';
+import { b as ClientContext, c as ClientOptions, C as ClientLink } from './client.BOYsZIRq.mjs';
 
 interface StandardLinkPlugin<T extends ClientContext> {
     order?: number;
@@ -33,7 +33,6 @@ interface StandardLinkOptions<T extends ClientContext> {
     plugins?: StandardLinkPlugin<T>[];
 }
 declare class StandardLink<T extends ClientContext> implements ClientLink<T> {
-    #private;
     readonly codec: StandardLinkCodec<T>;
     readonly sender: StandardLinkClient<T>;
     private readonly interceptors;

package/dist/shared/{client.7UM0t5o-.d.ts → client.C176log5.d.ts}

@@ -1,5 +1,5 @@
-import { a as ClientContext, b as ClientOptions, d as HTTPMethod } from './client.4TS_0JaO.js';
-import { e as StandardLinkCodec, b as StandardLinkOptions, d as StandardLink, f as StandardLinkClient } from './client.C0KbSWlC.js';
+import { b as ClientContext, c as ClientOptions, f as HTTPMethod } from './client.BOYsZIRq.js';
+import { e as StandardLinkCodec, b as StandardLinkOptions, d as StandardLink, f as StandardLinkClient } from './client.BG98rYdO.js';
 import { Segment, Value, Promisable } from '@orpc/shared';
 import { StandardHeaders, StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
 

package/dist/shared/{client.DwfV9Oyl.mjs → client.DKmRtVO2.mjs}

@@ -1,6 +1,6 @@
-import { toArray, intercept, isObject, value, isAsyncIteratorObject, stringifyJSON } from '@orpc/shared';
+import { toArray, runWithSpan, ORPC_NAME, isAsyncIteratorObject, asyncIteratorWithSpan, intercept, getGlobalOtelConfig, isObject, value, stringifyJSON } from '@orpc/shared';
 import { mergeStandardHeaders, ErrorEvent } from '@orpc/standard-server';
-import { C as COMMON_ORPC_ERROR_DEFS, b as isORPCErrorStatus, c as isORPCErrorJson, d as createORPCErrorFromJson, O as ORPCError, m as mapEventIterator, t as toORPCError } from './client.DHOfWE0c.mjs';
+import { C as COMMON_ORPC_ERROR_DEFS, b as isORPCErrorStatus, c as isORPCErrorJson, d as createORPCErrorFromJson, O as ORPCError, m as mapEventIterator, t as toORPCError } from './client.txdq_i5V.mjs';
 
 class CompositeStandardLinkPlugin {
   plugins;
@@ -26,20 +26,52 @@ class StandardLink {
   interceptors;
   clientInterceptors;
   call(path, input, options) {
-    return intercept(this.interceptors, { ...options, path, input }, async ({ path: path2, input: input2, ...options2 }) => {
-      const output = await this.#call(path2, input2, options2);
-      return output;
-    });
-  }
-  async #call(path, input, options) {
-    const request = await this.codec.encode(path, input, options);
-    const response = await intercept(
-      this.clientInterceptors,
-      { ...options, input, path, request },
-      ({ input: input2, path: path2, request: request2, ...options2 }) => this.sender.call(request2, options2, path2, input2)
+    return runWithSpan(
+      { name: `${ORPC_NAME}.${path.join("/")}`, signal: options.signal },
+      (span) => {
+        span?.setAttribute("rpc.system", ORPC_NAME);
+        span?.setAttribute("rpc.method", path.join("."));
+        if (isAsyncIteratorObject(input)) {
+          input = asyncIteratorWithSpan(
+            { name: "consume_event_iterator_input", signal: options.signal },
+            input
+          );
+        }
+        return intercept(this.interceptors, { ...options, path, input }, async ({ path: path2, input: input2, ...options2 }) => {
+          const otelConfig = getGlobalOtelConfig();
+          let otelContext;
+          const currentSpan = otelConfig?.trace.getActiveSpan() ?? span;
+          if (currentSpan && otelConfig) {
+            otelContext = otelConfig?.trace.setSpan(otelConfig.context.active(), currentSpan);
+          }
+          const request = await runWithSpan(
+            { name: "encode_request", context: otelContext },
+            () => this.codec.encode(path2, input2, options2)
+          );
+          const response = await intercept(
+            this.clientInterceptors,
+            { ...options2, input: input2, path: path2, request },
+            ({ input: input3, path: path3, request: request2, ...options3 }) => {
+              return runWithSpan(
+                { name: "send_request", signal: options3.signal, context: otelContext },
+                () => this.sender.call(request2, options3, path3, input3)
+              );
+            }
+          );
+          const output = await runWithSpan(
+            { name: "decode_response", context: otelContext },
+            () => this.codec.decode(response, options2, path2, input2)
+          );
+          if (isAsyncIteratorObject(output)) {
+            return asyncIteratorWithSpan(
+              { name: "consume_event_iterator_output", signal: options2.signal },
+              output
+            );
+          }
+          return output;
+        });
+      }
     );
-    const output = await this.codec.decode(response, options, path, input);
-    return output;
   }
 }
 
@@ -330,6 +362,9 @@ class StandardRPCSerializer {
     return this.#deserialize(data);
   }
   #deserialize(data) {
+    if (data === void 0) {
+      return void 0;
+    }
     if (!(data instanceof FormData)) {
       return this.jsonSerializer.deserialize(data.json, data.meta ?? []);
     }

package/dist/shared/{client.BdD8cpjs.d.mts → client.Ycwr4Tuo.d.mts}

@@ -1,5 +1,5 @@
-import { a as ClientContext, b as ClientOptions, d as HTTPMethod } from './client.4TS_0JaO.mjs';
-import { e as StandardLinkCodec, b as StandardLinkOptions, d as StandardLink, f as StandardLinkClient } from './client.BMoG_EdN.mjs';
+import { b as ClientContext, c as ClientOptions, f as HTTPMethod } from './client.BOYsZIRq.mjs';
+import { e as StandardLinkCodec, b as StandardLinkOptions, d as StandardLink, f as StandardLinkClient } from './client.Bwgm6dgk.mjs';
 import { Segment, Value, Promisable } from '@orpc/shared';
 import { StandardHeaders, StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
 

package/dist/shared/{client.DHOfWE0c.mjs → client.txdq_i5V.mjs}

@@ -1,4 +1,4 @@
-import { isObject, AsyncIteratorClass, isTypescriptObject } from '@orpc/shared';
+import { resolveMaybeOptionalOptions, isObject, AsyncIteratorClass, isTypescriptObject } from '@orpc/shared';
 import { getEventMeta, withEventMeta } from '@orpc/standard-server';
 
 const COMMON_ORPC_ERROR_DEFS = {
@@ -90,16 +90,17 @@ class ORPCError extends Error {
   code;
   status;
   data;
-  constructor(code, ...[options]) {
-    if (options?.status && !isORPCErrorStatus(options.status)) {
+  constructor(code, ...rest) {
+    const options = resolveMaybeOptionalOptions(rest);
+    if (options.status !== void 0 && !isORPCErrorStatus(options.status)) {
       throw new Error("[ORPCError] Invalid error status code.");
     }
-    const message = fallbackORPCErrorMessage(code, options?.message);
+    const message = fallbackORPCErrorMessage(code, options.message);
     super(message, options);
     this.code = code;
-    this.status = fallbackORPCErrorStatus(code, options?.status);
-    this.defined = options?.defined ?? false;
-    this.data = options?.data;
+    this.status = fallbackORPCErrorStatus(code, options.status);
+    this.defined = options.defined ?? false;
+    this.data = options.data;
   }
   toJSON() {
     return {
@@ -141,19 +142,22 @@ function createORPCErrorFromJson(json, options = {}) {
 }
 
 function mapEventIterator(iterator, maps) {
+  const mapError = async (error) => {
+    let mappedError = await maps.error(error);
+    if (mappedError !== error) {
+      const meta = getEventMeta(error);
+      if (meta && isTypescriptObject(mappedError)) {
+        mappedError = withEventMeta(mappedError, meta);
+      }
+    }
+    return mappedError;
+  };
   return new AsyncIteratorClass(async () => {
     const { done, value } = await (async () => {
       try {
         return await iterator.next();
       } catch (error) {
-        let mappedError = await maps.error(error);
-        if (mappedError !== error) {
-          const meta = getEventMeta(error);
-          if (meta && isTypescriptObject(mappedError)) {
-            mappedError = withEventMeta(mappedError, meta);
-          }
-        }
-        throw mappedError;
+        throw await mapError(error);
       }
     })();
     let mappedValue = await maps.value(value, done);
@@ -165,7 +169,11 @@ function mapEventIterator(iterator, maps) {
     }
     return { done, value: mappedValue };
   }, async () => {
-    await iterator.return?.();
+    try {
+      await iterator.return?.();
+    } catch (error) {
+      throw await mapError(error);
+    }
   });
 }
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/client",
   "type": "module",
-  "version": "0.0.0-next.de7ca70",
+  "version": "0.0.0-next.dea79a3",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -49,13 +49,13 @@
     "dist"
   ],
   "dependencies": {
-    "@orpc/standard-server": "0.0.0-next.de7ca70",
-    "@orpc/shared": "0.0.0-next.de7ca70",
-    "@orpc/standard-server-fetch": "0.0.0-next.de7ca70",
-    "@orpc/standard-server-peer": "0.0.0-next.de7ca70"
+    "@orpc/shared": "0.0.0-next.dea79a3",
+    "@orpc/standard-server": "0.0.0-next.dea79a3",
+    "@orpc/standard-server-peer": "0.0.0-next.dea79a3",
+    "@orpc/standard-server-fetch": "0.0.0-next.dea79a3"
   },
   "devDependencies": {
-    "zod": "^3.25.76"
+    "zod": "^4.0.17"
   },
   "scripts": {
     "build": "unbuild",