@orpc/client 1.14.11 → 1.14.12

package/dist/index.d.ts

@@ -1,78 +1,197 @@
-import { WrapAsyncIteratorOptions, AsyncIteratorClass, Interceptor, PromiseWithError, ThrowableError, Promisable } from '@orpc/shared';
-export { AsyncCleanupFn, AsyncIteratorClass, AsyncIteratorClassNextFn, MaybeOptionalOptions, PromiseWithError, Registry, ThrowableError, asyncIteratorToStream, asyncIteratorToUnproxiedDataStream, consumeAsyncIterator, consumeAsyncIterator as consumeEventIterator, asyncIteratorToStream as eventIteratorToStream, asyncIteratorToUnproxiedDataStream as eventIteratorToUnproxiedDataStream, onAsyncIteratorObjectError, onError, onFinish, onReadableStreamError, onStart, onSuccess, streamToAsyncIteratorObject, streamToAsyncIteratorObject as streamToEventIterator } from '@orpc/shared';
-import { C as ClientContext, a as ClientOptions, c as AnyNestedClient, I as InferClientContext, d as InferClientError, e as Client, b as ClientLink, A as AnyORPCError, f as ClientRest, F as FriendlyClientOptions, O as ORPCErrorCode, g as ORPCError, h as ORPCErrorJSON } from './shared/client.BBZBQID8.js';
-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.BBZBQID8.js';
-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.js';
-export { ErrorEvent, EventMeta, getEventMeta, unwrapEvent, withEventMeta } from '@standardserver/core';
+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.js';
+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.js';
+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';
 
-declare function wrapAsyncIteratorPreservingEventMeta<TYield, TReturn, TMappedYield = TYield, TMappedReturn = TReturn>(iterator: AsyncIterator<TYield, TReturn>, { mapResult, mapError, ...rest }: WrapAsyncIteratorOptions<TYield, TReturn, TMappedYield, TMappedReturn>): AsyncIteratorClass<TMappedYield, TMappedReturn>;
-
-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> {
+interface createORPCClientOptions {
     /**
-     * Interceptors that wrap the entire client call lifecycle.
+     * Use as base path for all procedure, useful when you only want to call a subset of the procedure.
      */
-    interceptors?: ORPCClientInterceptor<TClientContext, TInput, TOutput, TError>[];
+    path?: readonly string[];
 }
-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;
+/**
+ * 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";
+    };
 };
-interface ORPCClientOptions<T extends AnyNestedClient> {
+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>;
     /**
-     * Use as base path for all procedure, useful when you only want to call a subset of the procedure.
+     * 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.
      */
-    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>;
+    static [Symbol.hasInstance](instance: unknown): boolean;
 }
-declare function createORPCClient<T extends AnyNestedClient>(link: ClientLink<InferClientContext<T>>, { path, ...options }?: NoInfer<ORPCClientOptions<T>>): 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 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] & {
+type SafeResult<TOutput, TError> = [error: null, data: TOutput, isDefined: false, isSuccess: true] & {
     error: null;
     data: TOutput;
-    inferableError: null;
+    isDefined: false;
     isSuccess: true;
-} | [error: Exclude<TError, AnyORPCError>, data: undefined, inferableError: null, isSuccess: false] & {
-    error: Exclude<TError, AnyORPCError>;
+} | [error: Exclude<TError, ORPCError<any, any>>, data: undefined, isDefined: false, isSuccess: false] & {
+    error: Exclude<TError, ORPCError<any, any>>;
     data: undefined;
-    inferableError: null;
+    isDefined: false;
     isSuccess: false;
-} | [error: Extract<TError, AnyORPCError>, data: undefined, inferableError: Extract<TError, AnyORPCError>, isSuccess: false] & {
-    error: Extract<TError, AnyORPCError>;
+} | [error: Extract<TError, ORPCError<any, any>>, data: undefined, isDefined: true, isSuccess: false] & {
+    error: Extract<TError, ORPCError<any, any>>;
     data: undefined;
-    inferableError: Extract<TError, AnyORPCError>;
+    isDefined: true;
     isSuccess: false;
 };
 /**
- * Works like try/catch, but help you infer the error type if it is inferable ORPCError.
+ * Works like try/catch, but can infer error types.
  *
- * @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}
+ */
+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>;
+interface ConsumeEventIteratorOptions<T, TReturn, TError> {
+    /**
+     * Called on each event
+     */
+    onEvent: (event: T) => void;
+    /**
+     * Called once error happens
+     */
+    onError?: (error: TError) => void;
+    /**
+     * Called once event iterator is done
+     *
+     * @info If iterator is canceled, `undefined` can be passed on success
+     */
+    onSuccess?: (value: TReturn | undefined) => void;
+    /**
+     * Called once after onError or onSuccess
+     *
+     * @info If iterator is canceled, `undefined` can be passed on success
+     */
+    onFinish?: (state: OnFinishState<TReturn | undefined, TError>) => void;
+}
+/**
+ * Consumes an event iterator with lifecycle callbacks
  *
- * if (inferableError) {
- *  console.log(inferableError) // or error, both are well typed
- * }
+ * @warning If no `onError` or `onFinish` is provided, unhandled rejections will be thrown
+ * @return unsubscribe callback
  */
-declare function safe<TOutput, TError = ThrowableError>(promise: PromiseWithError<TOutput, TError>): Promise<SafeResult<TOutput, TError>>;
+declare function consumeEventIterator<T, TReturn, TError = ThrowableError>(iterator: AsyncIterator<T, TReturn> | ClientPromiseResult<AsyncIterator<T, TReturn>, TError>, options: ConsumeEventIteratorOptions<T, TReturn, TError>): () => Promise<void>;
 
-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;
+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.
@@ -80,24 +199,15 @@ type SafeClient<T extends AnyNestedClient> = T extends Client<infer UContext, in
  * @example
  * ```ts
  * const safeClient = createSafeClient(client)
- * const { error, data, inferrableError, isSuccess } = await safeClient.doSomething({ id: '123' })
- * // or const [error, data, inferrableError, isSuccess] = await safeClient.doSomething({ id: '123' })
+ * const { error, data, isDefined } = await safeClient.doSomething({ id: '123' })
  * ```
  *
  * @see {@link https://orpc.dev/docs/client/error-handling#using-createsafeclient Safe Client Docs}
  */
-declare function createSafeClient<T extends AnyNestedClient>(client: T): SafeClient<T>;
+declare function createSafeClient<T extends NestedClient<any>>(client: T): SafeClient<T>;
 
-/**
- * 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>;
+declare const ORPC_CLIENT_PACKAGE_NAME = "@orpc/client";
+declare const ORPC_CLIENT_PACKAGE_VERSION = "1.14.12";
 
 /**
  * DynamicLink provides a way to dynamically resolve and delegate calls to other ClientLinks
@@ -107,15 +217,14 @@ declare const RECURSIVE_CLIENT_UNWRAP_KEYS: Set<string>;
  */
 declare class DynamicLink<TClientContext extends ClientContext> implements ClientLink<TClientContext> {
     private readonly linkResolver;
-    constructor(linkResolver: (options: ClientOptions<TClientContext>, path: string[], input: unknown) => Promisable<ClientLink<TClientContext>>);
-    call(path: string[], input: unknown, options: ClientOptions<TClientContext>): Promise<unknown>;
+    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 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>;
+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 { AnyNestedClient, AnyORPCError, Client, ClientContext, ClientLink, ClientOptions, ClientRest, DynamicLink, FriendlyClientOptions, InferClientContext, InferClientError, ORPCError, ORPCErrorCode, ORPCErrorJSON, RECURSIVE_CLIENT_UNWRAP_KEYS, cloneORPCError, createORPCClient, createORPCErrorFromJson, createSafeClient, isInferableError as isDefinedError, isInferableError, isORPCErrorJson, resolveClientRest, resolveFriendlyClientOptions, safe, toORPCError, wrapAsyncIteratorPreservingEventMeta };
-export type { ORPCClientInterceptor, ORPCClientInterceptorOptions, ORPCClientOptions, ORPCClientScoped, ORPCClientScopedOptions, SafeClient, SafeResult };
+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 };

package/dist/index.mjs

@@ -1,105 +1,94 @@
-import { a as isInferableError } from './shared/client.DqYwRDUO.mjs';
-export { b as RPCJsonSerializer, R as RPCSerializer, d as cloneORPCError, c as createORPCErrorFromJson, i as isORPCErrorJson, t as toORPCError, w as wrapAsyncIteratorPreservingEventMeta } from './shared/client.DqYwRDUO.mjs';
-import { getOrBind, toArray, intercept, isTypescriptObject } from '@orpc/shared';
-export { AsyncIteratorClass, asyncIteratorToStream, asyncIteratorToUnproxiedDataStream, consumeAsyncIterator, consumeAsyncIterator as consumeEventIterator, asyncIteratorToStream as eventIteratorToStream, asyncIteratorToUnproxiedDataStream as eventIteratorToUnproxiedDataStream, onAsyncIteratorObjectError, onError, onFinish, onReadableStreamError, onStart, onSuccess, streamToAsyncIteratorObject, streamToAsyncIteratorObject as streamToEventIterator } from '@orpc/shared';
-export { C as COMMON_ERROR_STATUS_MAP, O as ORPCError } from './shared/client.Dnfj8jnT.mjs';
-export { ErrorEvent, getEventMeta, unwrapEvent, withEventMeta } from '@standardserver/core';
+import { preventNativeAwait, isTypescriptObject } from '@orpc/shared';
+export { AsyncIteratorClass, EventPublisher, asyncIteratorToStream as eventIteratorToStream, asyncIteratorToUnproxiedDataStream as eventIteratorToUnproxiedDataStream, onError, onFinish, onStart, onSuccess, streamToAsyncIteratorClass as streamToEventIterator } from '@orpc/shared';
+import { i as isDefinedError } from './shared/client.DrCRv_sG.mjs';
+export { C as COMMON_ORPC_ERROR_DEFS, c as ORPCError, O as ORPC_CLIENT_PACKAGE_NAME, a as ORPC_CLIENT_PACKAGE_VERSION, g as createORPCErrorFromJson, b as fallbackORPCErrorMessage, f as fallbackORPCErrorStatus, e as isORPCErrorJson, d as isORPCErrorStatus, t as toORPCError } from './shared/client.DrCRv_sG.mjs';
+export { m as mapEventIterator } from './shared/client.BLtwTQUg.mjs';
+export { ErrorEvent, getEventMeta, withEventMeta } from '@orpc/standard-server';
 
-const RECURSIVE_CLIENT_UNWRAP_KEYS = /* @__PURE__ */ new Set([
-  /**
-   * Prevents the client from being treated as a thenable when users
-   * accidentally write `await client`.
-   */
-  "then",
-  /**
-   * Commonly used by libraries to bind functions to a specific `this`
-   * context.
-   */
-  "bind",
-  /**
-   * Commonly accessed during primitive conversion, inspection, and logging.
-   */
-  "valueOf",
-  /**
-   * Commonly accessed during string conversion, inspection, and logging.
-   */
-  "toString",
-  /**
-   * Commonly accessed by serializers such as `JSON.stringify`.
-   */
-  "toJSON"
-]);
-
-function resolveFriendlyClientOptions(options) {
-  return {
-    ...options,
-    context: options.context ?? {}
-    // Context only optional if all fields are optional
-  };
-}
-function resolveClientRest(rest) {
-  return [
-    rest[0],
-    // rest[0] can be undefined if TInput is optional,
-    resolveFriendlyClientOptions(rest[1] ?? {})
-    // rest[1] can be undefined if all fields of FriendlyClientOptions are optional
-  ];
-}
 async function safe(promise) {
   try {
     const output = await promise;
     return Object.assign(
-      [null, output, null, true],
-      { error: null, data: output, inferableError: null, isSuccess: true }
+      [null, output, false, true],
+      { error: null, data: output, isDefined: false, isSuccess: true }
     );
   } catch (e) {
     const error = e;
-    if (isInferableError(error)) {
+    if (isDefinedError(error)) {
       return Object.assign(
-        [error, void 0, error, false],
-        { error, data: void 0, inferableError: error, isSuccess: false }
+        [error, void 0, true, false],
+        { error, data: void 0, isDefined: true, isSuccess: false }
       );
     }
     return Object.assign(
-      [error, void 0, null, false],
-      { error, data: void 0, inferableError: null, isSuccess: false }
+      [error, void 0, false, false],
+      { error, data: void 0, isDefined: false, isSuccess: false }
     );
   }
 }
+function resolveFriendlyClientOptions(options) {
+  return {
+    ...options,
+    context: options.context ?? {}
+    // Context only optional if all fields are optional
+  };
+}
+function consumeEventIterator(iterator, options) {
+  void (async () => {
+    let onFinishState;
+    try {
+      const resolvedIterator = await iterator;
+      while (true) {
+        const { done, value } = await resolvedIterator.next();
+        if (done) {
+          const realValue = value;
+          onFinishState = [null, realValue, true];
+          options.onSuccess?.(realValue);
+          break;
+        }
+        options.onEvent(value);
+      }
+    } catch (error) {
+      onFinishState = [error, void 0, false];
+      if (!options.onError && !options.onFinish) {
+        throw error;
+      }
+      options.onError?.(error);
+    } finally {
+      options.onFinish?.(onFinishState);
+    }
+  })();
+  return async () => {
+    await (await iterator)?.return?.();
+  };
+}
 
-function createORPCClient(link, { path = [], ...options } = {}) {
-  const procedureClient = (...rest) => {
-    const [input, callOptions] = resolveClientRest(rest);
-    const interceptors = [
-      ...toArray(options.interceptors),
-      ...toArray(options.scoped?.interceptors)
-    ];
-    return intercept(
-      interceptors,
-      { ...callOptions, input, path },
-      ({ path: path2, input: input2, ...callOptions2 }) => link.call(path2, input2, callOptions2)
-    );
+function createORPCClient(link, options = {}) {
+  const path = options.path ?? [];
+  const procedureClient = async (...[input, options2 = {}]) => {
+    return await link.call(path, input, resolveFriendlyClientOptions(options2));
   };
   const recursive = new Proxy(procedureClient, {
     get(target, key) {
-      if (typeof key !== "string" || RECURSIVE_CLIENT_UNWRAP_KEYS.has(key)) {
-        return getOrBind(target, key);
+      if (typeof key !== "string") {
+        return Reflect.get(target, key);
       }
-      const scoped = options.scoped === void 0 ? void 0 : options.scoped[key];
       return createORPCClient(link, {
         ...options,
-        path: [...path, key],
-        scoped
+        path: [...path, key]
       });
     }
   });
-  return recursive;
+  return preventNativeAwait(recursive);
 }
 
 function createSafeClient(client) {
   const proxy = new Proxy((...args) => safe(client(...args)), {
-    get(_, prop) {
-      const value = getOrBind(client, prop);
+    get(_, prop, receiver) {
+      const value = Reflect.get(client, prop, receiver);
+      if (typeof prop !== "string") {
+        return value;
+      }
       if (!isTypescriptObject(value)) {
         return value;
       }
@@ -120,4 +109,4 @@ class DynamicLink {
   }
 }
 
-export { DynamicLink, RECURSIVE_CLIENT_UNWRAP_KEYS, createORPCClient, createSafeClient, isInferableError as isDefinedError, isInferableError, resolveClientRest, resolveFriendlyClientOptions, safe };
+export { DynamicLink, consumeEventIterator, createORPCClient, createSafeClient, isDefinedError, resolveFriendlyClientOptions, safe };