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

package/dist/adapters/websocket/index.mjs

@@ -1,18 +1,19 @@
-import { runWithSignal, AbortError, sleep, promiseWithResolvers, toStringOrBytes } from '@orpc/shared';
-import { ClientPeer, encodePeerMessage, decodePeerMessage, isServerPeerSendMessage } from '@standardserver/peer';
-import { S as StandardLink, R as RPCLinkCodec } from '../../shared/client.DXhchJ84.mjs';
-import '@standardserver/core';
-import '@standardserver/fetch';
-import '../../shared/client.Dnfj8jnT.mjs';
-import '../../shared/client.DMXKFDyV.mjs';
+import { runWithSignal, AbortError, sleep, promiseWithResolvers, sequential, loadBytes, toStringOrBytes } from '@orpc/shared';
+import { ClientPeer, encodePeerMessage, decodePeerMessage, isServerPeerSendMessage } from '@standard-server/peer';
+import { S as StandardLink, R as RPCLinkCodec } from '../../shared/client.Bstqyaro.mjs';
+import '@standard-server/core';
+import '@standard-server/fetch';
+import '../../shared/client.DpkGsZt-.mjs';
+import '../../shared/client.DD2eNne_.mjs';
 
 const WEBSOCKET_CONNECTING = 0;
 const WEBSOCKET_OPEN = 1;
-class WebsocketLinkTransport {
+class WebSocketLinkTransport {
   connect;
   reconnectEnabled;
   reconnectDelay;
   reconnectMaxAttempt;
+  reconnectMaxTotalAttempt;
   reconnectOnCloseEnabled;
   reconnectOnCloseDelay;
   encodePeerMessageOptions;
@@ -22,6 +23,7 @@ class WebsocketLinkTransport {
     this.reconnectEnabled = options.reconnect?.enabled ?? false;
     this.reconnectDelay = options.reconnect?.delay ?? ((info) => info.attempt === 1 ? 0 : 2e3);
     this.reconnectMaxAttempt = options.reconnect?.maxAttempt ?? Infinity;
+    this.reconnectMaxTotalAttempt = options.reconnect?.maxTotalAttempt ?? Infinity;
     this.reconnectOnCloseEnabled = this.reconnectEnabled && (options.reconnect?.onClose?.enabled ?? false);
     this.reconnectOnCloseDelay = options.reconnect?.onClose?.delay ?? 0;
     this.encodePeerMessageOptions = options.encodePeerMessage;
@@ -45,14 +47,13 @@ class WebsocketLinkTransport {
     const current = this.current;
     const resolved = await current;
     if (resolved && (!this.reconnectEnabled || resolved.websocket.readyState === WEBSOCKET_OPEN)) {
-      this.attempt = 0;
       return resolved.peer;
     }
     if (current !== this.current) {
       return this.getConnectedPeer();
     }
-    if (this.attempt >= this.reconnectMaxAttempt) {
-      throw new AbortError(`WebSocket reconnect failed after ${this.attempt} attempt(s)`);
+    if (this.totalAttempt >= this.reconnectMaxTotalAttempt) {
+      throw new AbortError(`WebSocket reconnect stopped after ${this.totalAttempt} total attempt(s)`);
     }
     this.current = (async () => {
       this.totalAttempt += 1;
@@ -60,7 +61,14 @@ class WebsocketLinkTransport {
       const info = { totalAttempt: this.totalAttempt, attempt: this.attempt };
       await sleep(this.reconnectDelay(info));
       const websocket = await this.connect(info);
+      if (websocket.readyState !== WEBSOCKET_CONNECTING && websocket.readyState !== WEBSOCKET_OPEN) {
+        throw new AbortError("WebSocket is already closing or closed");
+      }
+      let closeReason;
       const peer = new ClientPeer(async (message) => {
+        if (closeReason) {
+          throw closeReason;
+        }
         const encoded = await encodePeerMessage(message, this.encodePeerMessageOptions);
         return websocket.send(encoded);
       });
@@ -71,29 +79,42 @@ 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) => {
+        closeReason = new AbortError(`WebSocket closed (code ${event.code}: ${event.reason})`);
         connectingResolvers?.resolve();
-        if (this.reconnectOnCloseEnabled) {
-          sleep(this.reconnectOnCloseDelay).then(() => this.getConnectedPeer()).catch(() => {
-          });
-        }
-        const reason = new AbortError(`WebSocket closed (code ${event.code}: ${event.reason})`);
-        await peer.close(reason);
+        await peer.close(closeReason);
+      });
+      websocket.addEventListener("error", () => {
       });
       await connectingResolvers?.promise;
-      connectingResolvers = void 0;
+      if (closeReason) {
+        throw closeReason;
+      }
+      if (this.reconnectOnCloseEnabled) {
+        websocket.addEventListener("close", () => {
+          sleep(this.reconnectOnCloseDelay).then(() => this.getConnectedPeer()).catch(() => {
+          });
+        });
+      }
+      this.attempt = 0;
       return { websocket, peer };
     })().catch((error) => {
       if (!this.reconnectEnabled) {
         throw error;
       }
+      if (this.attempt >= this.reconnectMaxAttempt) {
+        const attempt = this.attempt;
+        this.attempt = 0;
+        this.current = void 0;
+        throw new AbortError(`WebSocket reconnect failed after ${attempt} attempt(s)`, { cause: error });
+      }
     });
     return this.getConnectedPeer();
   }
@@ -102,9 +123,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.Dw9_40WO.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.Dw9_40WO.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.BPa_Mmuh.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.Dw9_40WO.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.Dw9_40WO.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.BPa_Mmuh.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 };