@orpc/client 1.14.5 → 2.0.0-beta.1

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

@@ -1,29 +1,121 @@
-import { StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
-import { b as ClientContext, c as ClientOptions } from '../../shared/client.i2uoJbEp.js';
-import { f as StandardLinkClient } from '../../shared/client.2jUAqzYU.js';
-import { f as StandardRPCLinkOptions, g as StandardRPCLink } from '../../shared/client.B3pNRBih.js';
-import '@orpc/shared';
+import { C as ClientContext, a as ClientOptions } from '../../shared/client.8ug8I-zu.js';
+import { Promisable } from '@orpc/shared';
+import { StandardRequest, StandardLazyResponse } from '@standardserver/core';
+import { EncodePeerMessageOptions, DecodePeerMessageOptions } from '@standardserver/peer';
+import { S as StandardLinkTransport, a as StandardLink, b as StandardLinkOptions } from '../../shared/client.CPF3hX6O.js';
+import { RPCLinkCodecOptions } from '../standard/index.js';
+import '../../shared/client.BdItY5DT.js';
 
-interface LinkWebsocketClientOptions {
-    websocket: Pick<WebSocket, 'addEventListener' | 'send' | 'readyState'>;
+type WebSocketLike = Pick<WebSocket, 'addEventListener' | 'removeEventListener' | 'send' | 'readyState'>;
+interface WebsocketLinkTransportAttemptInfo {
+    /**
+     * Total number of connection attempts for this transport's lifetime.
+     * Starts at 1 on the first attempt, increments on every subsequent
+     * attempt, and never resets.
+     */
+    totalAttempt: number;
+    /**
+     * Attempt number within the current (re)connect cycle.
+     * Starts at 1, increments on each consecutive failure, and resets to 1
+     * once a connection succeeds. Use this for backoff calculations.
+     */
+    attempt: number;
 }
-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 WebsocketLinkTransportReconnectOptions {
+    /**
+     * Whether to automatically reconnect when the connection is lost.
+     *
+     * @default false
+     */
+    enabled: boolean;
+    /**
+     * Delay before a (re)connect attempt, in milliseconds.
+     *
+     * @default info => info.attempt === 1 ? 0 : 2_000
+     */
+    delay?: undefined | ((info: WebsocketLinkTransportAttemptInfo) => number);
+    /**
+     * Maximum number of consecutive failed attempts before giving up.
+     * When exceeded, `getConnectedPeer` throws instead of retrying.
+     * Should greater than 1
+     *
+     * @default Infinity
+     */
+    maxAttempt?: undefined | number;
+    /**
+     * Whether to proactively reconnect right after the socket closes,
+     * rather than waiting for the next call to trigger reconnection.
+     * Reduces latency for the next request.
+     *
+     * @default { enabled: false }
+     */
+    onClose?: undefined | {
+        /**
+         * Whether to proactively reconnect right after the socket closes,
+         * rather than waiting for the next call to trigger reconnection.
+         * Reduces latency for the next request.
+         *
+         * @default false
+         */
+        enabled: boolean;
+        /**
+         * Delay before reconnecting after the socket closes, in milliseconds.
+         *
+         * @default 0
+         */
+        delay?: number;
+    };
+}
+interface WebsocketLinkTransportOptions<_T extends ClientContext> {
+    /**
+     * Returns a WebSocket instance for peer communication.
+     * Can be async for lazy resolution.
+     */
+    connect: (info: WebsocketLinkTransportAttemptInfo) => Promisable<WebSocketLike>;
+    /**
+     * Whether to connect immediately on initialization, instead of waiting
+     * for the first call. Reduces latency for the first request.
+     *
+     * @default false
+     */
+    connectOnInit?: undefined | boolean;
+    /**
+     * Reconnection behavior when the connection is lost.
+     *
+     * @default { enabled: false }
+     */
+    reconnect?: undefined | WebsocketLinkTransportReconnectOptions;
+    /**
+     * Options for encoding peer messages. such as `prefix` for distinguishing messages on the same channel..
+     */
+    encodePeerMessage?: EncodePeerMessageOptions | undefined;
+    /**
+     * Options for decoding peer messages. such as `prefix` for distinguishing messages on the same channel..
+     */
+    decodePeerMessage?: DecodePeerMessageOptions | undefined;
+}
+declare class WebsocketLinkTransport<T extends ClientContext> implements StandardLinkTransport<T> {
+    private readonly connect;
+    private readonly reconnectEnabled;
+    private readonly reconnectDelay;
+    private readonly reconnectMaxAttempt;
+    private readonly reconnectOnCloseEnabled;
+    private readonly reconnectOnCloseDelay;
+    private readonly encodePeerMessageOptions;
+    private readonly decodePeerMessageOptions;
+    constructor(options: WebsocketLinkTransportOptions<T>);
+    send(standardRequest: StandardRequest, _path: string[], _options: ClientOptions<T>): Promise<StandardLazyResponse>;
+    private totalAttempt;
+    private attempt;
+    private current;
+    private getConnectedPeer;
 }
 
-interface RPCLinkOptions<T extends ClientContext> extends Omit<StandardRPCLinkOptions<T>, 'url' | 'method' | 'fallbackMethod' | 'maxUrlLength'>, LinkWebsocketClientOptions {
+interface RPCLinkOptions<T extends ClientContext> extends StandardLinkOptions<T>, WebsocketLinkTransportOptions<T>, RPCLinkCodecOptions<T> {
 }
-/**
- * The RPC Link communicates with the server using the RPC protocol over WebSocket.
- *
- * @see {@link https://orpc.dev/docs/client/rpc-link RPC Link Docs}
- * @see {@link https://orpc.dev/docs/adapters/websocket WebSocket Adapter Docs}
- */
-declare class RPCLink<T extends ClientContext> extends StandardRPCLink<T> {
+declare class RPCLink<T extends ClientContext> extends StandardLink<T> {
     constructor(options: RPCLinkOptions<T>);
 }
 
-export { LinkWebsocketClient, RPCLink };
-export type { LinkWebsocketClientOptions, RPCLinkOptions };
+export { RPCLink, WebsocketLinkTransport };
+export type { RPCLinkOptions, WebSocketLike, WebsocketLinkTransportAttemptInfo, WebsocketLinkTransportOptions, WebsocketLinkTransportReconnectOptions };

package/dist/adapters/websocket/index.mjs

@@ -1,47 +1,110 @@
-import { readAsBuffer } from '@orpc/shared';
-import { ClientPeer } from '@orpc/standard-server-peer';
-import { c as StandardRPCLink } from '../../shared/client.DxgEFWjV.mjs';
-import '@orpc/standard-server';
-import '../../shared/client.C9pc00-H.mjs';
-import '@orpc/standard-server-fetch';
-import '../../shared/client.BLtwTQUg.mjs';
+import { runWithSignal, AbortError, sleep, promiseWithResolvers, toStringOrBytes } from '@orpc/shared';
+import { ClientPeer, encodePeerMessage, decodePeerMessage, isServerPeerSendMessage } from '@standardserver/peer';
+import { S as StandardLink, R as RPCLinkCodec } from '../../shared/client.DXhchJ84.mjs';
+import '@standardserver/core';
+import '@standardserver/fetch';
+import '../../shared/client.Dnfj8jnT.mjs';
+import '../../shared/client.DMXKFDyV.mjs';
 
 const WEBSOCKET_CONNECTING = 0;
-class LinkWebsocketClient {
-  peer;
+const WEBSOCKET_OPEN = 1;
+class WebsocketLinkTransport {
+  connect;
+  reconnectEnabled;
+  reconnectDelay;
+  reconnectMaxAttempt;
+  reconnectOnCloseEnabled;
+  reconnectOnCloseDelay;
+  encodePeerMessageOptions;
+  decodePeerMessageOptions;
   constructor(options) {
-    const untilOpen = new Promise((resolve) => {
-      if (options.websocket.readyState === WEBSOCKET_CONNECTING) {
-        options.websocket.addEventListener("open", () => {
-          resolve();
-        }, { once: true });
-      } else {
-        resolve();
+    this.connect = options.connect;
+    this.reconnectEnabled = options.reconnect?.enabled ?? false;
+    this.reconnectDelay = options.reconnect?.delay ?? ((info) => info.attempt === 1 ? 0 : 2e3);
+    this.reconnectMaxAttempt = options.reconnect?.maxAttempt ?? Infinity;
+    this.reconnectOnCloseEnabled = this.reconnectEnabled && (options.reconnect?.onClose?.enabled ?? false);
+    this.reconnectOnCloseDelay = options.reconnect?.onClose?.delay ?? 0;
+    this.encodePeerMessageOptions = options.encodePeerMessage;
+    this.decodePeerMessageOptions = options.decodePeerMessage;
+    if (options.connectOnInit) {
+      this.getConnectedPeer().catch(() => {
+      });
+    }
+  }
+  async send(standardRequest, _path, _options) {
+    const peer = await runWithSignal(
+      standardRequest.signal,
+      () => this.getConnectedPeer()
+    );
+    return peer.request(standardRequest);
+  }
+  totalAttempt = 0;
+  attempt = 0;
+  current;
+  async getConnectedPeer() {
+    const current = this.current;
+    const resolved = await current;
+    if (resolved && (!this.reconnectEnabled || resolved.websocket.readyState === WEBSOCKET_OPEN)) {
+      this.attempt = 0;
+      return resolved.peer;
+    }
+    if (current !== this.current) {
+      return this.getConnectedPeer();
+    }
+    if (this.attempt >= this.reconnectMaxAttempt) {
+      throw new AbortError(`WebSocket reconnect failed after ${this.attempt} attempt(s)`);
+    }
+    this.current = (async () => {
+      this.totalAttempt += 1;
+      this.attempt += 1;
+      const info = { totalAttempt: this.totalAttempt, attempt: this.attempt };
+      await sleep(this.reconnectDelay(info));
+      const websocket = await this.connect(info);
+      const peer = new ClientPeer(async (message) => {
+        const encoded = await encodePeerMessage(message, this.encodePeerMessageOptions);
+        return websocket.send(encoded);
+      });
+      let connectingResolvers;
+      if (websocket.readyState === WEBSOCKET_CONNECTING) {
+        connectingResolvers = promiseWithResolvers();
+        websocket.addEventListener("open", () => {
+          connectingResolvers?.resolve();
+        });
+      }
+      websocket.addEventListener("message", async (event) => {
+        const message = await toStringOrBytes(event.data);
+        const result = decodePeerMessage(message, this.decodePeerMessageOptions);
+        if (result.matched && isServerPeerSendMessage(result.message)) {
+          await peer.message(result.message);
+        }
+      });
+      websocket.addEventListener("close", async (event) => {
+        connectingResolvers?.resolve();
+        if (this.reconnectOnCloseEnabled) {
+          sleep(this.reconnectOnCloseDelay).then(() => this.getConnectedPeer()).catch(() => {
+          });
+        }
+        const reason = new AbortError(`WebSocket closed (code ${event.code}: ${event.reason})`);
+        await peer.close(reason);
+      });
+      await connectingResolvers?.promise;
+      connectingResolvers = void 0;
+      return { websocket, peer };
+    })().catch((error) => {
+      if (!this.reconnectEnabled) {
+        throw error;
       }
     });
-    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) };
+    return this.getConnectedPeer();
   }
 }
 
-class RPCLink extends StandardRPCLink {
+class RPCLink extends StandardLink {
   constructor(options) {
-    const linkClient = new LinkWebsocketClient(options);
-    super(linkClient, { ...options, url: "http://orpc" });
+    const codec = new RPCLinkCodec(options);
+    const transport = new WebsocketLinkTransport(options);
+    super(codec, transport, options);
   }
 }
 
-export { LinkWebsocketClient, RPCLink };
+export { RPCLink, WebsocketLinkTransport };

package/dist/index.d.mts

@@ -1,165 +1,79 @@
-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.i2uoJbEp.mjs';
-export { f as HTTPMethod, H as HTTPPath, h as InferClientBodyInputs, j as InferClientBodyOutputs, l as InferClientErrorUnion, k as InferClientErrors, g as InferClientInputs, i as InferClientOutputs } from './shared/client.i2uoJbEp.mjs';
-import { MaybeOptionalOptions, ThrowableError, OnFinishState, Promisable, AsyncIteratorClass } from '@orpc/shared';
-export { AsyncIteratorClass, EventPublisher, EventPublisherOptions, EventPublisherSubscribeIteratorOptions, Registry, ThrowableError, asyncIteratorToStream as eventIteratorToStream, asyncIteratorToUnproxiedDataStream as eventIteratorToUnproxiedDataStream, onError, onFinish, onStart, onSuccess, streamToAsyncIteratorClass as streamToEventIterator } from '@orpc/shared';
-export { ErrorEvent, EventMeta, getEventMeta, withEventMeta } from '@orpc/standard-server';
+import { O as ORPCErrorCode, c as ORPCError, d as ORPCErrorJSON, A as AnyORPCError, C as ClientContext, a as ClientOptions, e as AnyNestedClient, I as InferClientContext, f as InferClientError, g as Client, b as ClientLink, h as ClientRest, F as FriendlyClientOptions } from './shared/client.8ug8I-zu.mjs';
+export { i as AnyORPCErrorJSON, j as COMMON_ERROR_STATUS_MAP, k as InferClientBodyInputs, l as InferClientBodyOutputs, m as InferClientErrors, n as InferClientInputs, o as InferClientOutputs, N as NestedClient, p as ORPCErrorOptions } from './shared/client.8ug8I-zu.mjs';
+import { Interceptor, PromiseWithError, ThrowableError, Promisable, WrapAsyncIteratorOptions, AsyncIteratorClass } from '@orpc/shared';
+export { AsyncCleanupFn, AsyncIteratorClass, AsyncIteratorClassNextFn, Registry, ThrowableError, asyncIteratorToStream as eventIteratorToStream, asyncIteratorToUnproxiedDataStream as eventIteratorToUnproxiedDataStream, onError, onFinish, onStart, onSuccess, streamToAsyncIteratorClass as streamToEventIterator } from '@orpc/shared';
+export { R as RPCJsonSerialization, a as RPCJsonSerializationMeta, b as RPCJsonSerializer, c as RPCJsonSerializerHandler, d as RPCJsonSerializerOptions, e as RPCSerializer, f as RPCSerializerOptions, g as RPCSerializerSerializeOptions } from './shared/client.BdItY5DT.mjs';
+export { ErrorEvent, getEventMeta, unwrapEvent, withEventMeta } from '@standardserver/core';
 
-interface createORPCClientOptions {
+declare function isInferableError<T>(error: T): error is Extract<T, AnyORPCError>;
+declare function toORPCError<T>(error: T): Extract<T, AnyORPCError> | ORPCError<'INTERNAL_SERVER_ERROR', undefined>;
+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 cloneORPCError<T extends ORPCErrorCode, TData>(error: ORPCError<T, TData>): ORPCError<T, TData>;
+
+interface ORPCClientInterceptorOptions<TClientContext extends ClientContext, TInput> extends ClientOptions<TClientContext> {
+    path: string[];
+    input: TInput;
+}
+type ORPCClientInterceptor<TClientContext extends ClientContext, TInput, TOutput, TError> = Interceptor<ORPCClientInterceptorOptions<TClientContext, TInput>, PromiseWithError<TOutput, TError>>;
+interface ORPCClientScopedOptions<TClientContext extends ClientContext, TInput, TOutput, TError> {
     /**
-     * Use as base path for all procedure, useful when you only want to call a subset of the procedure.
+     * Interceptors that wrap the entire client call lifecycle.
      */
-    path?: readonly string[];
+    interceptors?: ORPCClientInterceptor<TClientContext, TInput, TOutput, TError>[];
 }
-/**
- * Create a oRPC client-side client from a link.
- *
- * @see {@link https://orpc.dev/docs/client/client-side Client-side Client Docs}
- */
-declare function createORPCClient<T extends NestedClient<any>>(link: ClientLink<InferClientContext<T>>, options?: createORPCClientOptions): T;
-
-declare const COMMON_ORPC_ERROR_DEFS: {
-    readonly BAD_REQUEST: {
-        readonly status: 400;
-        readonly message: "Bad Request";
-    };
-    readonly UNAUTHORIZED: {
-        readonly status: 401;
-        readonly message: "Unauthorized";
-    };
-    readonly FORBIDDEN: {
-        readonly status: 403;
-        readonly message: "Forbidden";
-    };
-    readonly NOT_FOUND: {
-        readonly status: 404;
-        readonly message: "Not Found";
-    };
-    readonly METHOD_NOT_SUPPORTED: {
-        readonly status: 405;
-        readonly message: "Method Not Supported";
-    };
-    readonly NOT_ACCEPTABLE: {
-        readonly status: 406;
-        readonly message: "Not Acceptable";
-    };
-    readonly TIMEOUT: {
-        readonly status: 408;
-        readonly message: "Request Timeout";
-    };
-    readonly CONFLICT: {
-        readonly status: 409;
-        readonly message: "Conflict";
-    };
-    readonly PRECONDITION_FAILED: {
-        readonly status: 412;
-        readonly message: "Precondition Failed";
-    };
-    readonly PAYLOAD_TOO_LARGE: {
-        readonly status: 413;
-        readonly message: "Payload Too Large";
-    };
-    readonly UNSUPPORTED_MEDIA_TYPE: {
-        readonly status: 415;
-        readonly message: "Unsupported Media Type";
-    };
-    readonly UNPROCESSABLE_CONTENT: {
-        readonly status: 422;
-        readonly message: "Unprocessable Content";
-    };
-    readonly TOO_MANY_REQUESTS: {
-        readonly status: 429;
-        readonly message: "Too Many Requests";
-    };
-    readonly CLIENT_CLOSED_REQUEST: {
-        readonly status: 499;
-        readonly message: "Client Closed Request";
-    };
-    readonly INTERNAL_SERVER_ERROR: {
-        readonly status: 500;
-        readonly message: "Internal Server Error";
-    };
-    readonly NOT_IMPLEMENTED: {
-        readonly status: 501;
-        readonly message: "Not Implemented";
-    };
-    readonly BAD_GATEWAY: {
-        readonly status: 502;
-        readonly message: "Bad Gateway";
-    };
-    readonly SERVICE_UNAVAILABLE: {
-        readonly status: 503;
-        readonly message: "Service Unavailable";
-    };
-    readonly GATEWAY_TIMEOUT: {
-        readonly status: 504;
-        readonly message: "Gateway Timeout";
-    };
+type ORPCClientScoped<T extends AnyNestedClient> = T extends Client<infer UClientContext, infer UInput, infer UOutput, infer UError> ? ORPCClientScopedOptions<UClientContext, UInput, UOutput, UError> : {
+    [K in keyof T]?: T[K] extends AnyNestedClient ? ORPCClientScoped<T[K]> : never;
 };
-type CommonORPCErrorCode = keyof typeof COMMON_ORPC_ERROR_DEFS;
-type ORPCErrorCode = CommonORPCErrorCode | (string & {});
-declare function fallbackORPCErrorStatus(code: ORPCErrorCode, status: number | undefined): number;
-declare function fallbackORPCErrorMessage(code: ORPCErrorCode, message: string | undefined): string;
-type ORPCErrorOptions<TData> = ErrorOptions & {
-    defined?: boolean;
-    status?: number;
-    message?: string;
-} & (undefined extends TData ? {
-    data?: TData;
-} : {
-    data: TData;
-});
-declare class ORPCError<TCode extends ORPCErrorCode, TData> extends Error {
-    readonly defined: boolean;
-    readonly code: TCode;
-    readonly status: number;
-    readonly data: TData;
-    constructor(code: TCode, ...rest: MaybeOptionalOptions<ORPCErrorOptions<TData>>);
-    toJSON(): ORPCErrorJSON<TCode, TData>;
+interface ORPCClientOptions<T extends AnyNestedClient> {
     /**
-     * Workaround for Next.js where different contexts use separate
-     * dependency graphs, causing multiple ORPCError constructors existing and breaking
-     * `instanceof` checks across contexts.
-     *
-     * This is particularly problematic with "Optimized SSR", where orpc-client
-     * executes in one context but is invoked from another. When an error is thrown
-     * in the execution context, `instanceof ORPCError` checks fail in the
-     * invocation context due to separate class constructors.
-     *
-     * @todo Remove this and related code if Next.js resolves the multiple dependency graph issue.
+     * Use as base path for all procedure, useful when you only want to call a subset of the procedure.
      */
-    static [Symbol.hasInstance](instance: unknown): boolean;
+    path?: string[];
+    /**
+     * Interceptors that wrap the entire client call lifecycle, applied to every procedure call.
+     */
+    interceptors?: ORPCClientInterceptor<InferClientContext<T>, unknown, unknown, InferClientError<T>>[];
+    /**
+     * Per-procedure options following the shape of the router.
+     * Allows fine-grained configuration (e.g. additional interceptors) for individual procedures
+     * without affecting the rest of the router.
+     */
+    scoped?: ORPCClientScoped<T>;
 }
-type ORPCErrorJSON<TCode extends string, TData> = Pick<ORPCError<TCode, TData>, 'defined' | 'code' | 'status' | 'message' | 'data'>;
-declare function isDefinedError<T>(error: T): error is Extract<T, ORPCError<any, any>>;
-declare function toORPCError(error: unknown): ORPCError<any, any>;
-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 createORPCClient<T extends AnyNestedClient>(link: ClientLink<InferClientContext<T>>, { path, ...options }?: NoInfer<ORPCClientOptions<T>>): T;
 
-type SafeResult<TOutput, TError> = [error: null, data: TOutput, isDefined: false, isSuccess: true] & {
+declare function resolveFriendlyClientOptions<T extends ClientContext>(options: FriendlyClientOptions<T>): ClientOptions<T>;
+declare function resolveClientRest<TClientContext extends ClientContext, TInput>(rest: ClientRest<TClientContext, TInput>): [input: TInput, options: ClientOptions<TClientContext>];
+type SafeResult<TOutput, TError> = [error: null, data: TOutput, inferableError: null, isSuccess: true] & {
     error: null;
     data: TOutput;
-    isDefined: false;
+    inferableError: null;
     isSuccess: true;
-} | [error: Exclude<TError, ORPCError<any, any>>, data: undefined, isDefined: false, isSuccess: false] & {
-    error: Exclude<TError, ORPCError<any, any>>;
+} | [error: Exclude<TError, AnyORPCError>, data: undefined, inferableError: null, isSuccess: false] & {
+    error: Exclude<TError, AnyORPCError>;
     data: undefined;
-    isDefined: false;
+    inferableError: null;
     isSuccess: false;
-} | [error: Extract<TError, ORPCError<any, any>>, data: undefined, isDefined: true, isSuccess: false] & {
-    error: Extract<TError, ORPCError<any, any>>;
+} | [error: Extract<TError, AnyORPCError>, data: undefined, inferableError: Extract<TError, AnyORPCError>, isSuccess: false] & {
+    error: Extract<TError, AnyORPCError>;
     data: undefined;
-    isDefined: true;
+    inferableError: Extract<TError, AnyORPCError>;
     isSuccess: false;
 };
 /**
- * Works like try/catch, but can infer error types.
+ * Works like try/catch, but help you infer the error type if it is inferable ORPCError.
+ *
+ * @example
+ * ```ts
+ * const [error, data, inferableError, isSuccess] = await safe(client(...))
+ * // or const { error, data, inferableError, isSuccess } = await safe(client(...))
  *
- * @info support both tuple `[error, data, isDefined, isSuccess]` and object `{ error, data, isDefined, isSuccess }` styles.
- * @see {@link https://orpc.dev/docs/client/error-handling Client Error Handling Docs}
+ * if (inferableError) {
+ *  console.log(inferableError) // or error, both are well typed
+ * }
  */
-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>;
+declare function safe<TOutput, TError = ThrowableError>(promise: PromiseWithError<TOutput, TError>): Promise<SafeResult<TOutput, TError>>;
 interface ConsumeEventIteratorOptions<T, TReturn, TError> {
     /**
      * Called on each event
@@ -180,18 +94,18 @@ interface ConsumeEventIteratorOptions<T, TReturn, TError> {
      *
      * @info If iterator is canceled, `undefined` can be passed on success
      */
-    onFinish?: (state: OnFinishState<TReturn | undefined, TError>) => void;
+    onFinish?: (state: [error: TError, data: undefined, isSuccess: false] | [error: null, data: TReturn | undefined, isSuccess: true]) => void;
 }
 /**
  * Consumes an event iterator with lifecycle callbacks
  *
- * @warning If no `onError` or `onFinish` is provided, unhandled rejections will be thrown
+ * @warning If no `onError` or `onFinish` is provided, error will be thrown into unhandled rejection channel.
  * @return unsubscribe callback
  */
-declare function consumeEventIterator<T, TReturn, TError = ThrowableError>(iterator: AsyncIterator<T, TReturn> | ClientPromiseResult<AsyncIterator<T, TReturn>, TError>, options: ConsumeEventIteratorOptions<T, TReturn, TError>): () => Promise<void>;
+declare function consumeEventIterator<T, TReturn, TError = ThrowableError>(iterator: AsyncIterator<T, TReturn> | PromiseWithError<AsyncIterator<T, TReturn>, TError>, options: ConsumeEventIteratorOptions<T, TReturn, TError>): () => Promise<void>;
 
-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;
+type SafeClient<T extends AnyNestedClient> = 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 AnyNestedClient ? SafeClient<T[K]> : never;
 };
 /**
  * Create a safe client that automatically wraps all procedure calls with the `safe` util.
@@ -199,15 +113,24 @@ type SafeClient<T extends NestedClient<any>> = T extends Client<infer UContext,
  * @example
  * ```ts
  * const safeClient = createSafeClient(client)
- * const { error, data, isDefined } = await safeClient.doSomething({ id: '123' })
+ * const { error, data, inferrableError, isSuccess } = await safeClient.doSomething({ id: '123' })
+ * // or const [error, data, inferrableError, isSuccess] = await safeClient.doSomething({ id: '123' })
  * ```
  *
  * @see {@link https://orpc.dev/docs/client/error-handling#using-createsafeclient Safe Client Docs}
  */
-declare function createSafeClient<T extends NestedClient<any>>(client: T): SafeClient<T>;
+declare function createSafeClient<T extends AnyNestedClient>(client: T): SafeClient<T>;
 
-declare const ORPC_CLIENT_PACKAGE_NAME = "@orpc/client";
-declare const ORPC_CLIENT_PACKAGE_VERSION = "1.14.5";
+/**
+ * Property names that should resolve to the underlying value instead of
+ * continuing recursive proxy traversal.
+ *
+ * These properties are commonly accessed automatically by JavaScript runtimes,
+ * language features, or third-party libraries. Returning another recursive
+ * proxy for them can cause unexpected behavior, compatibility issues, or
+ * infinite proxy chains.
+ */
+declare const RECURSIVE_CLIENT_UNWRAP_KEYS: Set<string>;
 
 /**
  * DynamicLink provides a way to dynamically resolve and delegate calls to other ClientLinks
@@ -217,14 +140,16 @@ declare const ORPC_CLIENT_PACKAGE_VERSION = "1.14.5";
  */
 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>;
+    constructor(linkResolver: (options: ClientOptions<TClientContext>, path: string[], input: unknown) => Promisable<ClientLink<TClientContext>>);
+    call(path: 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>;
+declare function wrapEventIteratorPreservingMeta<TYield, TReturn, TMappedYield = TYield, TMappedReturn = TReturn>(iterator: AsyncIterator<TYield, TReturn>, { mapResult, mapError, ...rest }: WrapAsyncIteratorOptions<TYield, TReturn, TMappedYield, TMappedReturn>): AsyncIteratorClass<TMappedYield, TMappedReturn>;
+
+/**
+ * @deprecated Use `isInferableError` instead.
+ */
+declare const isDefinedError: typeof isInferableError;
 
-export { COMMON_ORPC_ERROR_DEFS, Client, ClientContext, ClientLink, ClientOptions, ClientPromiseResult, ClientRest, DynamicLink, FriendlyClientOptions, InferClientContext, NestedClient, ORPCError, ORPC_CLIENT_PACKAGE_NAME, ORPC_CLIENT_PACKAGE_VERSION, consumeEventIterator, createORPCClient, createORPCErrorFromJson, createSafeClient, fallbackORPCErrorMessage, fallbackORPCErrorStatus, isDefinedError, isORPCErrorJson, isORPCErrorStatus, mapEventIterator, resolveFriendlyClientOptions, safe, toORPCError };
-export type { CommonORPCErrorCode, ConsumeEventIteratorOptions, ORPCErrorCode, ORPCErrorJSON, ORPCErrorOptions, SafeClient, SafeResult, createORPCClientOptions };
+export { AnyNestedClient, AnyORPCError, Client, ClientContext, ClientLink, ClientOptions, ClientRest, DynamicLink, FriendlyClientOptions, InferClientContext, InferClientError, ORPCError, ORPCErrorCode, ORPCErrorJSON, RECURSIVE_CLIENT_UNWRAP_KEYS, cloneORPCError, consumeEventIterator, createORPCClient, createORPCErrorFromJson, createSafeClient, isDefinedError, isInferableError, isORPCErrorJson, resolveClientRest, resolveFriendlyClientOptions, safe, toORPCError, wrapEventIteratorPreservingMeta };
+export type { ConsumeEventIteratorOptions, ORPCClientInterceptor, ORPCClientInterceptorOptions, ORPCClientOptions, ORPCClientScoped, ORPCClientScopedOptions, SafeClient, SafeResult };