@orpc/client 2.0.0-beta.3 → 2.0.0-beta.30

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

@@ -1,10 +1,9 @@
-import { f as StandardLinkCodec, g as StandardLinkCodecDecodedResponse } from '../../shared/client.Cby_-GGh.mjs';
-export { C as CompositeStandardLinkPlugin, a as StandardLink, h as StandardLinkInterceptor, e as StandardLinkInterceptorOptions, b as StandardLinkOptions, c as StandardLinkPlugin, S as StandardLinkTransport, i as StandardLinkTransportInterceptor, d as StandardLinkTransportInterceptorOptions } from '../../shared/client.Cby_-GGh.mjs';
+import { f as StandardLinkCodec, g as StandardLinkCodecDecodedResponse } from '../../shared/client.B0-4UDVl.mjs';
+export { C as CompositeStandardLinkPlugin, a as StandardLink, h as StandardLinkInterceptor, e as StandardLinkInterceptorOptions, b as StandardLinkOptions, c as StandardLinkPlugin, S as StandardLinkTransport, i as StandardLinkTransportInterceptor, d as StandardLinkTransportInterceptorOptions } from '../../shared/client.B0-4UDVl.mjs';
 import { Value, Promisable } from '@orpc/shared';
 import { StandardUrl, StandardHeaders, StandardRequest, StandardLazyResponse } from '@standardserver/core';
-export { StandardBody, StandardBodyHint, StandardHeaders, StandardLazyRequest, StandardLazyResponse, StandardMethod, StandardRequest, StandardResponse, StandardUrl } from '@standardserver/core';
-import { C as ClientContext, a as ClientOptions } from '../../shared/client.8ug8I-zu.mjs';
-import { e as RPCSerializer } from '../../shared/client.BdItY5DT.mjs';
+import { ClientContext, ClientOptions } from '../../index.mjs';
+import { RPCSerializer } from '../../index.mjs';
 
 interface RPCLinkCodecOptions<T extends ClientContext> {
     /**
@@ -28,14 +27,14 @@ interface RPCLinkCodecOptions<T extends ClientContext> {
      *
      * @default 'POST'
      */
-    method?: Value<Promisable<'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE'>, [options: ClientOptions<T>, path: string[], input: unknown]>;
+    method?: Value<Promisable<'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'QUERY'>, [options: ClientOptions<T>, path: string[], input: unknown]>;
     /**
      * The method to use when the payload cannot safely pass to the server with method return from method function.
      * GET is not allowed, it's very dangerous.
      *
      * @default 'POST'
      */
-    fallbackMethod?: 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    fallbackMethod?: 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'QUERY';
     /**
      * Inject headers to the request.
      */

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

@@ -1,10 +1,9 @@
-import { f as StandardLinkCodec, g as StandardLinkCodecDecodedResponse } from '../../shared/client.CPF3hX6O.js';
-export { C as CompositeStandardLinkPlugin, a as StandardLink, h as StandardLinkInterceptor, e as StandardLinkInterceptorOptions, b as StandardLinkOptions, c as StandardLinkPlugin, S as StandardLinkTransport, i as StandardLinkTransportInterceptor, d as StandardLinkTransportInterceptorOptions } from '../../shared/client.CPF3hX6O.js';
+import { f as StandardLinkCodec, g as StandardLinkCodecDecodedResponse } from '../../shared/client.BhTyskpV.js';
+export { C as CompositeStandardLinkPlugin, a as StandardLink, h as StandardLinkInterceptor, e as StandardLinkInterceptorOptions, b as StandardLinkOptions, c as StandardLinkPlugin, S as StandardLinkTransport, i as StandardLinkTransportInterceptor, d as StandardLinkTransportInterceptorOptions } from '../../shared/client.BhTyskpV.js';
 import { Value, Promisable } from '@orpc/shared';
 import { StandardUrl, StandardHeaders, StandardRequest, StandardLazyResponse } from '@standardserver/core';
-export { StandardBody, StandardBodyHint, StandardHeaders, StandardLazyRequest, StandardLazyResponse, StandardMethod, StandardRequest, StandardResponse, StandardUrl } from '@standardserver/core';
-import { C as ClientContext, a as ClientOptions } from '../../shared/client.8ug8I-zu.js';
-import { e as RPCSerializer } from '../../shared/client.BdItY5DT.js';
+import { ClientContext, ClientOptions } from '../../index.js';
+import { RPCSerializer } from '../../index.js';
 
 interface RPCLinkCodecOptions<T extends ClientContext> {
     /**
@@ -28,14 +27,14 @@ interface RPCLinkCodecOptions<T extends ClientContext> {
      *
      * @default 'POST'
      */
-    method?: Value<Promisable<'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE'>, [options: ClientOptions<T>, path: string[], input: unknown]>;
+    method?: Value<Promisable<'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'QUERY'>, [options: ClientOptions<T>, path: string[], input: unknown]>;
     /**
      * The method to use when the payload cannot safely pass to the server with method return from method function.
      * GET is not allowed, it's very dangerous.
      *
      * @default 'POST'
      */
-    fallbackMethod?: 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    fallbackMethod?: 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'QUERY';
     /**
      * Inject headers to the request.
      */

package/dist/adapters/standard/index.mjs

@@ -1,6 +1,6 @@
-export { C as CompositeStandardLinkPlugin, R as RPCLinkCodec, S as StandardLink } from '../../shared/client.DXhchJ84.mjs';
+export { C as CompositeStandardLinkPlugin, R as RPCLinkCodec, S as StandardLink } from '../../shared/client.vEM0O_Eg.mjs';
 import '@orpc/shared';
 import '@standardserver/core';
 import '@standardserver/fetch';
-import '../../shared/client.Dnfj8jnT.mjs';
-import '../../shared/client.DMXKFDyV.mjs';
+import '../../shared/client.BnATe4Ob.mjs';
+import '../../shared/client.DcoDDrD4.mjs';

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

@@ -1,13 +1,13 @@
-import { C as ClientContext, a as ClientOptions } from '../../shared/client.8ug8I-zu.mjs';
+import { ClientContext, ClientOptions } from '../../index.mjs';
 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.Cby_-GGh.mjs';
+import { StandardLinkTransport, StandardLink, StandardLinkOptions } from '../standard/index.mjs';
 import { RPCLinkCodecOptions } from '../standard/index.mjs';
-import '../../shared/client.BdItY5DT.mjs';
+import '../../shared/client.Qwo2aQOm.mjs';
 
 type WebSocketLike = Pick<WebSocket, 'addEventListener' | 'removeEventListener' | 'send' | 'readyState'>;
-interface WebsocketLinkTransportAttemptInfo {
+interface WebSocketLinkTransportAttemptInfo {
     /**
      * Total number of connection attempts for this transport's lifetime.
      * Starts at 1 on the first attempt, increments on every subsequent
@@ -21,7 +21,7 @@ interface WebsocketLinkTransportAttemptInfo {
      */
     attempt: number;
 }
-interface WebsocketLinkTransportReconnectOptions {
+interface WebSocketLinkTransportReconnectOptions {
     /**
      * Whether to automatically reconnect when the connection is lost.
      *
@@ -33,7 +33,7 @@ interface WebsocketLinkTransportReconnectOptions {
      *
      * @default info => info.attempt === 1 ? 0 : 2_000
      */
-    delay?: undefined | ((info: WebsocketLinkTransportAttemptInfo) => number);
+    delay?: undefined | ((info: WebSocketLinkTransportAttemptInfo) => number);
     /**
      * Maximum number of consecutive failed attempts before giving up.
      * When exceeded, `getConnectedPeer` throws instead of retrying.
@@ -66,12 +66,12 @@ interface WebsocketLinkTransportReconnectOptions {
         delay?: number;
     };
 }
-interface WebsocketLinkTransportOptions<_T extends ClientContext> {
+interface WebSocketLinkTransportOptions<_T extends ClientContext> {
     /**
      * Returns a WebSocket instance for peer communication.
      * Can be async for lazy resolution.
      */
-    connect: (info: WebsocketLinkTransportAttemptInfo) => Promisable<WebSocketLike>;
+    connect: (info: WebSocketLinkTransportAttemptInfo) => Promisable<WebSocketLike>;
     /**
      * Whether to connect immediately on initialization, instead of waiting
      * for the first call. Reduces latency for the first request.
@@ -84,7 +84,7 @@ interface WebsocketLinkTransportOptions<_T extends ClientContext> {
      *
      * @default { enabled: false }
      */
-    reconnect?: undefined | WebsocketLinkTransportReconnectOptions;
+    reconnect?: undefined | WebSocketLinkTransportReconnectOptions;
     /**
      * Options for encoding peer messages. such as `prefix` for distinguishing messages on the same channel..
      */
@@ -94,7 +94,7 @@ interface WebsocketLinkTransportOptions<_T extends ClientContext> {
      */
     decodePeerMessage?: DecodePeerMessageOptions | undefined;
 }
-declare class WebsocketLinkTransport<T extends ClientContext> implements StandardLinkTransport<T> {
+declare class WebSocketLinkTransport<T extends ClientContext> implements StandardLinkTransport<T> {
     private readonly connect;
     private readonly reconnectEnabled;
     private readonly reconnectDelay;
@@ -103,7 +103,7 @@ declare class WebsocketLinkTransport<T extends ClientContext> implements Standar
     private readonly reconnectOnCloseDelay;
     private readonly encodePeerMessageOptions;
     private readonly decodePeerMessageOptions;
-    constructor(options: WebsocketLinkTransportOptions<T>);
+    constructor(options: WebSocketLinkTransportOptions<T>);
     send(standardRequest: StandardRequest, _path: string[], _options: ClientOptions<T>): Promise<StandardLazyResponse>;
     private totalAttempt;
     private attempt;
@@ -111,11 +111,16 @@ declare class WebsocketLinkTransport<T extends ClientContext> implements Standar
     private getConnectedPeer;
 }
 
-interface RPCLinkOptions<T extends ClientContext> extends StandardLinkOptions<T>, WebsocketLinkTransportOptions<T>, RPCLinkCodecOptions<T> {
+interface RPCLinkOptions<T extends ClientContext> extends StandardLinkOptions<T>, WebSocketLinkTransportOptions<T>, RPCLinkCodecOptions<T> {
 }
+/**
+ * Client link that communicates with an RPC Handler over a WebSocket connection.
+ *
+ * @see {@link https://orpc.dev/docs/adapters/websocket | WebSocket Adapters}
+ */
 declare class RPCLink<T extends ClientContext> extends StandardLink<T> {
     constructor(options: RPCLinkOptions<T>);
 }
 
-export { RPCLink, WebsocketLinkTransport };
-export type { RPCLinkOptions, WebSocketLike, WebsocketLinkTransportAttemptInfo, WebsocketLinkTransportOptions, WebsocketLinkTransportReconnectOptions };
+export { RPCLink, WebSocketLinkTransport };
+export type { RPCLinkOptions, WebSocketLike, WebSocketLinkTransportAttemptInfo, WebSocketLinkTransportOptions, WebSocketLinkTransportReconnectOptions };

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

@@ -1,13 +1,13 @@
-import { C as ClientContext, a as ClientOptions } from '../../shared/client.8ug8I-zu.js';
+import { ClientContext, ClientOptions } from '../../index.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 { StandardLinkTransport, StandardLink, StandardLinkOptions } from '../standard/index.js';
 import { RPCLinkCodecOptions } from '../standard/index.js';
-import '../../shared/client.BdItY5DT.js';
+import '../../shared/client.Qwo2aQOm.js';
 
 type WebSocketLike = Pick<WebSocket, 'addEventListener' | 'removeEventListener' | 'send' | 'readyState'>;
-interface WebsocketLinkTransportAttemptInfo {
+interface WebSocketLinkTransportAttemptInfo {
     /**
      * Total number of connection attempts for this transport's lifetime.
      * Starts at 1 on the first attempt, increments on every subsequent
@@ -21,7 +21,7 @@ interface WebsocketLinkTransportAttemptInfo {
      */
     attempt: number;
 }
-interface WebsocketLinkTransportReconnectOptions {
+interface WebSocketLinkTransportReconnectOptions {
     /**
      * Whether to automatically reconnect when the connection is lost.
      *
@@ -33,7 +33,7 @@ interface WebsocketLinkTransportReconnectOptions {
      *
      * @default info => info.attempt === 1 ? 0 : 2_000
      */
-    delay?: undefined | ((info: WebsocketLinkTransportAttemptInfo) => number);
+    delay?: undefined | ((info: WebSocketLinkTransportAttemptInfo) => number);
     /**
      * Maximum number of consecutive failed attempts before giving up.
      * When exceeded, `getConnectedPeer` throws instead of retrying.
@@ -66,12 +66,12 @@ interface WebsocketLinkTransportReconnectOptions {
         delay?: number;
     };
 }
-interface WebsocketLinkTransportOptions<_T extends ClientContext> {
+interface WebSocketLinkTransportOptions<_T extends ClientContext> {
     /**
      * Returns a WebSocket instance for peer communication.
      * Can be async for lazy resolution.
      */
-    connect: (info: WebsocketLinkTransportAttemptInfo) => Promisable<WebSocketLike>;
+    connect: (info: WebSocketLinkTransportAttemptInfo) => Promisable<WebSocketLike>;
     /**
      * Whether to connect immediately on initialization, instead of waiting
      * for the first call. Reduces latency for the first request.
@@ -84,7 +84,7 @@ interface WebsocketLinkTransportOptions<_T extends ClientContext> {
      *
      * @default { enabled: false }
      */
-    reconnect?: undefined | WebsocketLinkTransportReconnectOptions;
+    reconnect?: undefined | WebSocketLinkTransportReconnectOptions;
     /**
      * Options for encoding peer messages. such as `prefix` for distinguishing messages on the same channel..
      */
@@ -94,7 +94,7 @@ interface WebsocketLinkTransportOptions<_T extends ClientContext> {
      */
     decodePeerMessage?: DecodePeerMessageOptions | undefined;
 }
-declare class WebsocketLinkTransport<T extends ClientContext> implements StandardLinkTransport<T> {
+declare class WebSocketLinkTransport<T extends ClientContext> implements StandardLinkTransport<T> {
     private readonly connect;
     private readonly reconnectEnabled;
     private readonly reconnectDelay;
@@ -103,7 +103,7 @@ declare class WebsocketLinkTransport<T extends ClientContext> implements Standar
     private readonly reconnectOnCloseDelay;
     private readonly encodePeerMessageOptions;
     private readonly decodePeerMessageOptions;
-    constructor(options: WebsocketLinkTransportOptions<T>);
+    constructor(options: WebSocketLinkTransportOptions<T>);
     send(standardRequest: StandardRequest, _path: string[], _options: ClientOptions<T>): Promise<StandardLazyResponse>;
     private totalAttempt;
     private attempt;
@@ -111,11 +111,16 @@ declare class WebsocketLinkTransport<T extends ClientContext> implements Standar
     private getConnectedPeer;
 }
 
-interface RPCLinkOptions<T extends ClientContext> extends StandardLinkOptions<T>, WebsocketLinkTransportOptions<T>, RPCLinkCodecOptions<T> {
+interface RPCLinkOptions<T extends ClientContext> extends StandardLinkOptions<T>, WebSocketLinkTransportOptions<T>, RPCLinkCodecOptions<T> {
 }
+/**
+ * Client link that communicates with an RPC Handler over a WebSocket connection.
+ *
+ * @see {@link https://orpc.dev/docs/adapters/websocket | WebSocket Adapters}
+ */
 declare class RPCLink<T extends ClientContext> extends StandardLink<T> {
     constructor(options: RPCLinkOptions<T>);
 }
 
-export { RPCLink, WebsocketLinkTransport };
-export type { RPCLinkOptions, WebSocketLike, WebsocketLinkTransportAttemptInfo, WebsocketLinkTransportOptions, WebsocketLinkTransportReconnectOptions };
+export { RPCLink, WebSocketLinkTransport };
+export type { RPCLinkOptions, WebSocketLike, WebSocketLinkTransportAttemptInfo, WebSocketLinkTransportOptions, WebSocketLinkTransportReconnectOptions };

package/dist/adapters/websocket/index.mjs

@@ -1,14 +1,14 @@
-import { runWithSignal, AbortError, sleep, promiseWithResolvers, toStringOrBytes } from '@orpc/shared';
+import { runWithSignal, AbortError, sleep, promiseWithResolvers, sequential, loadBytes, 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 { S as StandardLink, R as RPCLinkCodec } from '../../shared/client.vEM0O_Eg.mjs';
 import '@standardserver/core';
 import '@standardserver/fetch';
-import '../../shared/client.Dnfj8jnT.mjs';
-import '../../shared/client.DMXKFDyV.mjs';
+import '../../shared/client.BnATe4Ob.mjs';
+import '../../shared/client.DcoDDrD4.mjs';
 
 const WEBSOCKET_CONNECTING = 0;
 const WEBSOCKET_OPEN = 1;
-class WebsocketLinkTransport {
+class WebSocketLinkTransport {
   connect;
   reconnectEnabled;
   reconnectDelay;
@@ -71,13 +71,13 @@ class WebsocketLinkTransport {
           connectingResolvers?.resolve();
         });
       }
-      websocket.addEventListener("message", async (event) => {
-        const message = await toStringOrBytes(event.data);
+      websocket.addEventListener("message", sequential(async (event) => {
+        const message = event.data instanceof Blob ? await loadBytes(event.data) : toStringOrBytes(event.data);
         const result = decodePeerMessage(message, this.decodePeerMessageOptions);
         if (result.matched && isServerPeerSendMessage(result.message)) {
-          await peer.message(result.message);
+          peer.message(result.message);
         }
-      });
+      }));
       websocket.addEventListener("close", async (event) => {
         connectingResolvers?.resolve();
         if (this.reconnectOnCloseEnabled) {
@@ -102,9 +102,9 @@ class WebsocketLinkTransport {
 class RPCLink extends StandardLink {
   constructor(options) {
     const codec = new RPCLinkCodec(options);
-    const transport = new WebsocketLinkTransport(options);
+    const transport = new WebSocketLinkTransport(options);
     super(codec, transport, options);
   }
 }
 
-export { RPCLink, WebsocketLinkTransport };
+export { RPCLink, WebSocketLinkTransport };

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.CFVTHyN6.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.CFVTHyN6.mjs';
+import { StandardResponse } from '@standardserver/core';
+export { ErrorEvent, EventMeta, StandardBody, StandardBodyHint, StandardHeaders, StandardLazyRequest, StandardLazyResponse, StandardMethod, StandardRequest, StandardResponse, StandardUrl, getEventMeta, unwrapEvent, withEventMeta } from '@standardserver/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.Qwo2aQOm.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,6 +38,13 @@ 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>;
@@ -72,37 +76,11 @@ type SafeResult<TOutput, TError> = [error: null, data: TOutput, inferableError:
  * if (inferableError) {
  *  console.log(inferableError) // 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-isinferableerror | Client Error Handling - Using safe and isInferableError}
  */
-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;
@@ -117,7 +95,7 @@ type SafeClient<T extends AnyNestedClient> = T extends Client<infer UContext, in
  * // 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}
+ * @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` whose type is inferable at the TypeScript level,
+ * narrowing it so `code` and `data` are fully typed.
+ *
+ * @see {@link https://orpc.dev/docs/client/error-handling#using-safe-and-isinferableerror | Client Error Handling - Using safe and isInferableError}
+ */
+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>;
+/**
+ * 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, isInferableError as isDefinedError, isInferableError, 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.CFVTHyN6.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.CFVTHyN6.js';
+import { StandardResponse } from '@standardserver/core';
+export { ErrorEvent, EventMeta, StandardBody, StandardBodyHint, StandardHeaders, StandardLazyRequest, StandardLazyResponse, StandardMethod, StandardRequest, StandardResponse, StandardUrl, getEventMeta, unwrapEvent, withEventMeta } from '@standardserver/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.Qwo2aQOm.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,6 +38,13 @@ 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>;
@@ -72,37 +76,11 @@ type SafeResult<TOutput, TError> = [error: null, data: TOutput, inferableError:
  * if (inferableError) {
  *  console.log(inferableError) // 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-isinferableerror | Client Error Handling - Using safe and isInferableError}
  */
-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;
@@ -117,7 +95,7 @@ type SafeClient<T extends AnyNestedClient> = T extends Client<infer UContext, in
  * // 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}
+ * @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` whose type is inferable at the TypeScript level,
+ * narrowing it so `code` and `data` are fully typed.
+ *
+ * @see {@link https://orpc.dev/docs/client/error-handling#using-safe-and-isinferableerror | Client Error Handling - Using safe and isInferableError}
+ */
+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>;
+/**
+ * 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, isInferableError as isDefinedError, isInferableError, isORPCErrorJson, resolveClientRest, resolveFriendlyClientOptions, safe, toORPCError, wrapAsyncIteratorPreservingEventMeta };
+export type { ORPCClientInterceptor, ORPCClientInterceptorOptions, ORPCClientOptions, ORPCClientScoped, ORPCClientScopedOptions, SafeClient, SafeResult };