@orpc/client 2.0.0-beta.4 → 2.0.0-beta.40

package/dist/index.d.mts

@@ -1,15 +1,12 @@
-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, MaybeOptionalOptions, PromiseWithError, 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, EventMeta, getEventMeta, unwrapEvent, withEventMeta } from '@standardserver/core';
+import { WrapAsyncIteratorOptions, AsyncIteratorClass, Interceptor, PromiseWithError, ThrowableError, Promisable } from '@orpc/shared';
+export { AsyncCleanupFn, AsyncIteratorClass, AsyncIteratorClassNextFn, PromiseWithError as ClientPromiseResult, 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 ORPCErrorJSON, h as ORPCError, M as MalformedResponseErrorOptions } from './shared/client.BoXZCzuS.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, p as MalformedResponseError, N as NestedClient, q as ORPCErrorOptions } from './shared/client.BoXZCzuS.mjs';
+import { StandardResponse } from '@standard-server/core';
+export { ErrorEvent, EventMeta, StandardBody, StandardBodyHint, StandardHeaders, StandardLazyRequest, StandardLazyResponse, StandardMethod, StandardRequest, StandardResponse, StandardUrl, getEventMeta, unwrapEvent, withEventMeta } from '@standard-server/core';
+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.n8K9dFhY.mjs';
 
-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 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[];
@@ -41,68 +38,49 @@ interface ORPCClientOptions<T extends AnyNestedClient> {
      */
     scoped?: ORPCClientScoped<T>;
 }
+/**
+ * Creates a fully typed oRPC client from a link.
+ * The returned client mirrors the shape of your router or contract,
+ * so calling a procedure is as simple as calling a function.
+ *
+ * @see {@link https://orpc.dev/docs/client/client-side | Client-Side Clients}
+ */
 declare function createORPCClient<T extends AnyNestedClient>(link: ClientLink<InferClientContext<T>>, { path, ...options }?: NoInfer<ORPCClientOptions<T>>): T;
 
 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, definedError: null, isSuccess: true] & {
     error: null;
     data: TOutput;
-    inferableError: null;
+    definedError: null;
     isSuccess: true;
-} | [error: Exclude<TError, AnyORPCError>, data: undefined, inferableError: null, isSuccess: false] & {
+} | [error: Exclude<TError, AnyORPCError>, data: undefined, definedError: null, isSuccess: false] & {
     error: Exclude<TError, AnyORPCError>;
     data: undefined;
-    inferableError: null;
+    definedError: null;
     isSuccess: false;
-} | [error: Extract<TError, AnyORPCError>, data: undefined, inferableError: Extract<TError, AnyORPCError>, isSuccess: false] & {
+} | [error: Extract<TError, AnyORPCError>, data: undefined, definedError: Extract<TError, AnyORPCError>, isSuccess: false] & {
     error: Extract<TError, AnyORPCError>;
     data: undefined;
-    inferableError: Extract<TError, AnyORPCError>;
+    definedError: Extract<TError, AnyORPCError>;
     isSuccess: false;
 };
 /**
- * Works like try/catch, but help you infer the error type if it is inferable ORPCError.
+ * Works like try/catch, but help you infer the error type if it is a defined ORPCError.
  *
  * @example
  * ```ts
- * const [error, data, inferableError, isSuccess] = await safe(client(...))
- * // or const { error, data, inferableError, isSuccess } = await safe(client(...))
+ * const [error, data, definedError, isSuccess] = await safe(client(...))
+ * // or const { error, data, definedError, isSuccess } = await safe(client(...))
  *
- * if (inferableError) {
- *  console.log(inferableError) // or error, both are well typed
+ * if (definedError) {
+ *  console.log(definedError) // or error, both are well typed
  * }
- */
-declare function safe<TOutput, TError = ThrowableError>(promise: PromiseWithError<TOutput, TError>): Promise<SafeResult<TOutput, TError>>;
-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: [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, error will be thrown into unhandled rejection channel.
- * @return unsubscribe callback
+ * @see {@link https://orpc.dev/docs/client/error-handling#using-safe-and-isdefinederror | Client Error Handling - Using safe and isDefinedError}
  */
-declare function consumeEventIterator<T, TReturn, TError = ThrowableError>(iterator: AsyncIterator<T, TReturn> | PromiseWithError<AsyncIterator<T, TReturn>, TError>, options: ConsumeEventIteratorOptions<T, TReturn, TError>): () => Promise<void>;
+declare function safe<TOutput, TError = ThrowableError>(promise: PromiseWithError<TOutput, TError>): Promise<SafeResult<TOutput, TError>>;
 
 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;
@@ -113,11 +91,11 @@ 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, definedError, isSuccess } = await safeClient.doSomething({ id: '123' })
+ * // or const [error, data, definedError, isSuccess] = await safeClient.doSomething({ id: '123' })
  * ```
  *
- * @see {@link https://orpc.dev/docs/client/error-handling#using-createsafeclient Safe Client Docs}
+ * @see {@link https://orpc.dev/docs/client/error-handling#safe-client | Client Error Handling - Safe Client}
  */
 declare function createSafeClient<T extends AnyNestedClient>(client: T): SafeClient<T>;
 
@@ -136,7 +114,7 @@ declare const RECURSIVE_CLIENT_UNWRAP_KEYS: Set<string>;
  * 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.dev/docs/client/dynamic-link Dynamic Link Docs}
+ * @see {@link https://orpc.dev/docs/client/dynamic-link | DynamicLink}
  */
 declare class DynamicLink<TClientContext extends ClientContext> implements ClientLink<TClientContext> {
     private readonly linkResolver;
@@ -144,12 +122,35 @@ declare class DynamicLink<TClientContext extends ClientContext> implements Clien
     call(path: string[], input: unknown, options: ClientOptions<TClientContext>): Promise<unknown>;
 }
 
-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.
+ * Checks if an error is an `ORPCError` that matches a definition in the procedure's `.errors` map,
+ * narrowing it so `code` and `data` are fully typed.
+ *
+ * @see {@link https://orpc.dev/docs/client/error-handling#using-safe-and-isdefinederror | Client Error Handling - Using safe and isDefinedError}
+ */
+declare function isDefinedError<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>;
+/**
+ * Creates the `MALFORMED_ORPC_RESPONSE` `ORPCError` used when a response
+ * does not follow the expected oRPC format. Unless overridden via `options.message`,
+ * the message is inferred from the response body or status. The `cause` is a
+ * `MalformedResponseError` carrying the resolved response.
+ *
+ * @see {@link https://orpc.dev/docs/rpc/link#malformed-responses | RPC Link - Malformed Responses}
+ * @see {@link https://orpc.dev/docs/openapi/link#malformed-responses | OpenAPI Link - Malformed Responses}
+ */
+declare function createORPCErrorFromMalformedResponse(options: MalformedResponseErrorOptions): ORPCError<'MALFORMED_ORPC_RESPONSE', StandardResponse>;
+/**
+ * Clones an `ORPCError` while preserving its prototype chain, so instances of
+ * `ORPCError` subclasses remain `instanceof` their class.
+ *
+ * Limitation: subclass constructors are not re-run, so private fields
+ * (`#field`) are not carried over and subclass members that read them
+ * will throw on the clone.
  */
-declare const isDefinedError: typeof isInferableError;
+declare function cloneORPCError<T extends AnyORPCError>(error: T): T;
 
-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 };
+export { AnyNestedClient, AnyORPCError, Client, ClientContext, ClientLink, ClientOptions, ClientRest, DynamicLink, FriendlyClientOptions, InferClientContext, InferClientError, InferClientError as InferClientErrorUnion, MalformedResponseErrorOptions, ORPCError, ORPCErrorCode, ORPCErrorJSON, RECURSIVE_CLIENT_UNWRAP_KEYS, cloneORPCError, createORPCClient, createORPCErrorFromJson, createORPCErrorFromMalformedResponse, createSafeClient, isDefinedError, isORPCErrorJson, resolveClientRest, resolveFriendlyClientOptions, safe, toORPCError, wrapAsyncIteratorPreservingEventMeta };
+export type { ORPCClientInterceptor, ORPCClientInterceptorOptions, ORPCClientOptions, ORPCClientScoped, ORPCClientScopedOptions, SafeClient, SafeResult };

package/dist/index.d.ts

@@ -1,15 +1,12 @@
-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.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.8ug8I-zu.js';
-import { Interceptor, PromiseWithError, ThrowableError, Promisable, WrapAsyncIteratorOptions, AsyncIteratorClass } from '@orpc/shared';
-export { AsyncCleanupFn, AsyncIteratorClass, AsyncIteratorClassNextFn, MaybeOptionalOptions, PromiseWithError, 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.js';
-export { ErrorEvent, EventMeta, getEventMeta, unwrapEvent, withEventMeta } from '@standardserver/core';
+import { WrapAsyncIteratorOptions, AsyncIteratorClass, Interceptor, PromiseWithError, ThrowableError, Promisable } from '@orpc/shared';
+export { AsyncCleanupFn, AsyncIteratorClass, AsyncIteratorClassNextFn, PromiseWithError as ClientPromiseResult, 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 ORPCErrorJSON, h as ORPCError, M as MalformedResponseErrorOptions } from './shared/client.BoXZCzuS.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, p as MalformedResponseError, N as NestedClient, q as ORPCErrorOptions } from './shared/client.BoXZCzuS.js';
+import { StandardResponse } from '@standard-server/core';
+export { ErrorEvent, EventMeta, StandardBody, StandardBodyHint, StandardHeaders, StandardLazyRequest, StandardLazyResponse, StandardMethod, StandardRequest, StandardResponse, StandardUrl, getEventMeta, unwrapEvent, withEventMeta } from '@standard-server/core';
+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.n8K9dFhY.js';
 
-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 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[];
@@ -41,68 +38,49 @@ interface ORPCClientOptions<T extends AnyNestedClient> {
      */
     scoped?: ORPCClientScoped<T>;
 }
+/**
+ * Creates a fully typed oRPC client from a link.
+ * The returned client mirrors the shape of your router or contract,
+ * so calling a procedure is as simple as calling a function.
+ *
+ * @see {@link https://orpc.dev/docs/client/client-side | Client-Side Clients}
+ */
 declare function createORPCClient<T extends AnyNestedClient>(link: ClientLink<InferClientContext<T>>, { path, ...options }?: NoInfer<ORPCClientOptions<T>>): T;
 
 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, definedError: null, isSuccess: true] & {
     error: null;
     data: TOutput;
-    inferableError: null;
+    definedError: null;
     isSuccess: true;
-} | [error: Exclude<TError, AnyORPCError>, data: undefined, inferableError: null, isSuccess: false] & {
+} | [error: Exclude<TError, AnyORPCError>, data: undefined, definedError: null, isSuccess: false] & {
     error: Exclude<TError, AnyORPCError>;
     data: undefined;
-    inferableError: null;
+    definedError: null;
     isSuccess: false;
-} | [error: Extract<TError, AnyORPCError>, data: undefined, inferableError: Extract<TError, AnyORPCError>, isSuccess: false] & {
+} | [error: Extract<TError, AnyORPCError>, data: undefined, definedError: Extract<TError, AnyORPCError>, isSuccess: false] & {
     error: Extract<TError, AnyORPCError>;
     data: undefined;
-    inferableError: Extract<TError, AnyORPCError>;
+    definedError: Extract<TError, AnyORPCError>;
     isSuccess: false;
 };
 /**
- * Works like try/catch, but help you infer the error type if it is inferable ORPCError.
+ * Works like try/catch, but help you infer the error type if it is a defined ORPCError.
  *
  * @example
  * ```ts
- * const [error, data, inferableError, isSuccess] = await safe(client(...))
- * // or const { error, data, inferableError, isSuccess } = await safe(client(...))
+ * const [error, data, definedError, isSuccess] = await safe(client(...))
+ * // or const { error, data, definedError, isSuccess } = await safe(client(...))
  *
- * if (inferableError) {
- *  console.log(inferableError) // or error, both are well typed
+ * if (definedError) {
+ *  console.log(definedError) // or error, both are well typed
  * }
- */
-declare function safe<TOutput, TError = ThrowableError>(promise: PromiseWithError<TOutput, TError>): Promise<SafeResult<TOutput, TError>>;
-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: [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, error will be thrown into unhandled rejection channel.
- * @return unsubscribe callback
+ * @see {@link https://orpc.dev/docs/client/error-handling#using-safe-and-isdefinederror | Client Error Handling - Using safe and isDefinedError}
  */
-declare function consumeEventIterator<T, TReturn, TError = ThrowableError>(iterator: AsyncIterator<T, TReturn> | PromiseWithError<AsyncIterator<T, TReturn>, TError>, options: ConsumeEventIteratorOptions<T, TReturn, TError>): () => Promise<void>;
+declare function safe<TOutput, TError = ThrowableError>(promise: PromiseWithError<TOutput, TError>): Promise<SafeResult<TOutput, TError>>;
 
 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;
@@ -113,11 +91,11 @@ 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, definedError, isSuccess } = await safeClient.doSomething({ id: '123' })
+ * // or const [error, data, definedError, isSuccess] = await safeClient.doSomething({ id: '123' })
  * ```
  *
- * @see {@link https://orpc.dev/docs/client/error-handling#using-createsafeclient Safe Client Docs}
+ * @see {@link https://orpc.dev/docs/client/error-handling#safe-client | Client Error Handling - Safe Client}
  */
 declare function createSafeClient<T extends AnyNestedClient>(client: T): SafeClient<T>;
 
@@ -136,7 +114,7 @@ declare const RECURSIVE_CLIENT_UNWRAP_KEYS: Set<string>;
  * 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.dev/docs/client/dynamic-link Dynamic Link Docs}
+ * @see {@link https://orpc.dev/docs/client/dynamic-link | DynamicLink}
  */
 declare class DynamicLink<TClientContext extends ClientContext> implements ClientLink<TClientContext> {
     private readonly linkResolver;
@@ -144,12 +122,35 @@ declare class DynamicLink<TClientContext extends ClientContext> implements Clien
     call(path: string[], input: unknown, options: ClientOptions<TClientContext>): Promise<unknown>;
 }
 
-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.
+ * Checks if an error is an `ORPCError` that matches a definition in the procedure's `.errors` map,
+ * narrowing it so `code` and `data` are fully typed.
+ *
+ * @see {@link https://orpc.dev/docs/client/error-handling#using-safe-and-isdefinederror | Client Error Handling - Using safe and isDefinedError}
+ */
+declare function isDefinedError<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>;
+/**
+ * Creates the `MALFORMED_ORPC_RESPONSE` `ORPCError` used when a response
+ * does not follow the expected oRPC format. Unless overridden via `options.message`,
+ * the message is inferred from the response body or status. The `cause` is a
+ * `MalformedResponseError` carrying the resolved response.
+ *
+ * @see {@link https://orpc.dev/docs/rpc/link#malformed-responses | RPC Link - Malformed Responses}
+ * @see {@link https://orpc.dev/docs/openapi/link#malformed-responses | OpenAPI Link - Malformed Responses}
+ */
+declare function createORPCErrorFromMalformedResponse(options: MalformedResponseErrorOptions): ORPCError<'MALFORMED_ORPC_RESPONSE', StandardResponse>;
+/**
+ * Clones an `ORPCError` while preserving its prototype chain, so instances of
+ * `ORPCError` subclasses remain `instanceof` their class.
+ *
+ * Limitation: subclass constructors are not re-run, so private fields
+ * (`#field`) are not carried over and subclass members that read them
+ * will throw on the clone.
  */
-declare const isDefinedError: typeof isInferableError;
+declare function cloneORPCError<T extends AnyORPCError>(error: T): T;
 
-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 };
+export { AnyNestedClient, AnyORPCError, Client, ClientContext, ClientLink, ClientOptions, ClientRest, DynamicLink, FriendlyClientOptions, InferClientContext, InferClientError, InferClientError as InferClientErrorUnion, MalformedResponseErrorOptions, ORPCError, ORPCErrorCode, ORPCErrorJSON, RECURSIVE_CLIENT_UNWRAP_KEYS, cloneORPCError, createORPCClient, createORPCErrorFromJson, createORPCErrorFromMalformedResponse, createSafeClient, isDefinedError, isORPCErrorJson, resolveClientRest, resolveFriendlyClientOptions, safe, toORPCError, wrapAsyncIteratorPreservingEventMeta };
+export type { ORPCClientInterceptor, ORPCClientInterceptorOptions, ORPCClientOptions, ORPCClientScoped, ORPCClientScopedOptions, SafeClient, SafeResult };

package/dist/index.mjs

@@ -1,9 +1,9 @@
-import { a as isInferableError } from './shared/client.DMXKFDyV.mjs';
-export { b as RPCJsonSerializer, R as RPCSerializer, d as cloneORPCError, c as createORPCErrorFromJson, i as isORPCErrorJson, t as toORPCError, w as wrapEventIteratorPreservingMeta } from './shared/client.DMXKFDyV.mjs';
-import { getOrBind, toArray, intercept, isTypescriptObject } from '@orpc/shared';
-export { AsyncIteratorClass, asyncIteratorToStream as eventIteratorToStream, asyncIteratorToUnproxiedDataStream as eventIteratorToUnproxiedDataStream, onError, onFinish, onStart, onSuccess, streamToAsyncIteratorClass 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 { b as isDefinedError } from './shared/client.BYHnU_Z3.mjs';
+export { d as RPCJsonSerializer, R as RPCSerializer, e as cloneORPCError, a as createORPCErrorFromJson, c as createORPCErrorFromMalformedResponse, i as isORPCErrorJson, t as toORPCError, w as wrapAsyncIteratorPreservingEventMeta } from './shared/client.BYHnU_Z3.mjs';
+import { 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, M as MalformedResponseError, O as ORPCError } from './shared/client.Dtv1JPkU.mjs';
+export { ErrorEvent, getEventMeta, unwrapEvent, withEventMeta } from '@standard-server/core';
 
 const RECURSIVE_CLIENT_UNWRAP_KEYS = /* @__PURE__ */ new Set([
   /**
@@ -16,6 +16,16 @@ const RECURSIVE_CLIENT_UNWRAP_KEYS = /* @__PURE__ */ new Set([
    * context.
    */
   "bind",
+  /**
+   * Commonly used by libraries to invoke functions with a specific `this`
+   * context.
+   */
+  "call",
+  /**
+   * Commonly used by libraries to invoke functions with a specific `this`
+   * context and an arguments array.
+   */
+  "apply",
   /**
    * Commonly accessed during primitive conversion, inspection, and logging.
    */
@@ -50,51 +60,22 @@ async function safe(promise) {
     const output = await promise;
     return Object.assign(
       [null, output, null, true],
-      { error: null, data: output, inferableError: null, isSuccess: true }
+      { error: null, data: output, definedError: null, 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, data: void 0, definedError: error, isSuccess: false }
       );
     }
     return Object.assign(
       [error, void 0, null, false],
-      { error, data: void 0, inferableError: null, isSuccess: false }
+      { error, data: void 0, definedError: null, isSuccess: false }
     );
   }
 }
-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) => {
@@ -109,30 +90,44 @@ function createORPCClient(link, { path = [], ...options } = {}) {
       ({ path: path2, input: input2, ...callOptions2 }) => link.call(path2, input2, callOptions2)
     );
   };
+  const cache = /* @__PURE__ */ new Map();
   const recursive = new Proxy(procedureClient, {
     get(target, key) {
       if (typeof key !== "string" || RECURSIVE_CLIENT_UNWRAP_KEYS.has(key)) {
-        return getOrBind(target, key);
+        return Reflect.get(target, key);
+      }
+      let client = cache.get(key);
+      if (client === void 0) {
+        client = createORPCClient(link, {
+          ...options,
+          path: [...path, key],
+          scoped: options.scoped?.[key]
+        });
+        cache.set(key, client);
       }
-      const scoped = options.scoped === void 0 ? void 0 : options.scoped[key];
-      return createORPCClient(link, {
-        ...options,
-        path: [...path, key],
-        scoped
-      });
+      return client;
     }
   });
   return recursive;
 }
 
 function createSafeClient(client) {
+  const cache = /* @__PURE__ */ new Map();
   const proxy = new Proxy((...args) => safe(client(...args)), {
-    get(_, prop) {
-      const value = getOrBind(client, prop);
-      if (!isTypescriptObject(value)) {
-        return value;
+    get(target, prop) {
+      if (typeof prop !== "string" || RECURSIVE_CLIENT_UNWRAP_KEYS.has(prop)) {
+        return Reflect.get(target, prop);
       }
-      return createSafeClient(value);
+      let safeClient = cache.get(prop);
+      if (safeClient === void 0) {
+        const value = client[prop];
+        if (!isTypescriptObject(value)) {
+          return value;
+        }
+        safeClient = createSafeClient(value);
+        cache.set(prop, safeClient);
+      }
+      return safeClient;
     }
   });
   return proxy;
@@ -149,6 +144,4 @@ class DynamicLink {
   }
 }
 
-const isDefinedError = isInferableError;
-
-export { DynamicLink, RECURSIVE_CLIENT_UNWRAP_KEYS, consumeEventIterator, createORPCClient, createSafeClient, isDefinedError, isInferableError, resolveClientRest, resolveFriendlyClientOptions, safe };
+export { DynamicLink, RECURSIVE_CLIENT_UNWRAP_KEYS, createORPCClient, createSafeClient, isDefinedError, resolveClientRest, resolveFriendlyClientOptions, safe };