@orpc/client 0.0.0-next.e1b0a55 → 0.0.0-next.e27e0c1

package/dist/index.d.ts

@@ -1,7 +1,7 @@
-import { N as NestedClient, C as ClientLink, I as InferClientContext, a as ClientPromiseResult, b as ClientContext, F as FriendlyClientOptions, c as ClientOptions, d as Client, e as ClientRest } from './shared/client.BOYsZIRq.js';
-export { f as HTTPMethod, H as HTTPPath } from './shared/client.BOYsZIRq.js';
-import { MaybeOptionalOptions, ThrowableError, Promisable, AsyncIteratorClass } from '@orpc/shared';
-export { EventPublisher, EventPublisherOptions, EventPublisherSubscribeIteratorOptions, Registry, ThrowableError, onError, onFinish, onStart, onSuccess } from '@orpc/shared';
+import { N as NestedClient, C as ClientLink, I as InferClientContext, a as ClientPromiseResult, b as ClientContext, F as FriendlyClientOptions, c as ClientOptions, d as Client, e as ClientRest } from './shared/client.BH1AYT_p.js';
+export { f as HTTPMethod, H as HTTPPath, h as InferClientBodyInputs, j as InferClientBodyOutputs, l as InferClientErrorUnion, k as InferClientErrors, g as InferClientInputs, i as InferClientOutputs } from './shared/client.BH1AYT_p.js';
+import { MaybeOptionalOptions, ThrowableError, OnFinishState, Promisable, AsyncIteratorClass } from '@orpc/shared';
+export { AsyncIteratorClass, EventPublisher, EventPublisherOptions, EventPublisherSubscribeIteratorOptions, Registry, ThrowableError, asyncIteratorToStream as eventIteratorToStream, asyncIteratorToUnproxiedDataStream as eventIteratorToUnproxiedDataStream, onError, onFinish, onStart, onSuccess, streamToAsyncIteratorClass as streamToEventIterator } from '@orpc/shared';
 export { ErrorEvent } from '@orpc/standard-server';
 
 interface createORPCClientOptions {
@@ -113,8 +113,21 @@ declare class ORPCError<TCode extends ORPCErrorCode, TData> extends Error {
     readonly code: TCode;
     readonly status: number;
     readonly data: TData;
-    constructor(code: TCode, ...[options]: MaybeOptionalOptions<ORPCErrorOptions<TData>>);
+    constructor(code: TCode, ...rest: MaybeOptionalOptions<ORPCErrorOptions<TData>>);
     toJSON(): ORPCErrorJSON<TCode, TData>;
+    /**
+     * Workaround for Next.js where different contexts use separate
+     * dependency graphs, causing multiple ORPCError constructors existing and breaking
+     * `instanceof` checks across contexts.
+     *
+     * This is particularly problematic with "Optimized SSR", where orpc-client
+     * executes in one context but is invoked from another. When an error is thrown
+     * in the execution context, `instanceof ORPCError` checks fail in the
+     * invocation context due to separate class constructors.
+     *
+     * @todo Remove this and related code if Next.js resolves the multiple dependency graph issue.
+     */
+    static [Symbol.hasInstance](instance: unknown): boolean;
 }
 type ORPCErrorJSON<TCode extends string, TData> = Pick<ORPCError<TCode, TData>, 'defined' | 'code' | 'status' | 'message' | 'data'>;
 declare function isDefinedError<T>(error: T): error is Extract<T, ORPCError<any, any>>;
@@ -147,6 +160,35 @@ type SafeResult<TOutput, TError> = [error: null, data: TOutput, isDefined: false
  */
 declare function safe<TOutput, TError = ThrowableError>(promise: ClientPromiseResult<TOutput, TError>): Promise<SafeResult<TOutput, TError>>;
 declare function resolveFriendlyClientOptions<T extends ClientContext>(options: FriendlyClientOptions<T>): ClientOptions<T>;
+interface ConsumeEventIteratorOptions<T, TReturn, TError> {
+    /**
+     * Called on each event
+     */
+    onEvent: (event: T) => void;
+    /**
+     * Called once error happens
+     */
+    onError?: (error: TError) => void;
+    /**
+     * Called once event iterator is done
+     *
+     * @info If iterator is canceled, `undefined` can be passed on success
+     */
+    onSuccess?: (value: TReturn | undefined) => void;
+    /**
+     * Called once after onError or onSuccess
+     *
+     * @info If iterator is canceled, `undefined` can be passed on success
+     */
+    onFinish?: (state: OnFinishState<TReturn | undefined, TError>) => void;
+}
+/**
+ * Consumes an event iterator with lifecycle callbacks
+ *
+ * @warning If no `onError` or `onFinish` is provided, unhandled rejections will be thrown
+ * @return unsubscribe callback
+ */
+declare function consumeEventIterator<T, TReturn, TError = ThrowableError>(iterator: AsyncIterator<T, TReturn> | ClientPromiseResult<AsyncIterator<T, TReturn>, TError>, options: ConsumeEventIteratorOptions<T, TReturn, TError>): () => Promise<void>;
 
 type SafeClient<T extends NestedClient<any>> = T extends Client<infer UContext, infer UInput, infer UOutput, infer UError> ? (...rest: ClientRest<UContext, UInput>) => Promise<SafeResult<UOutput, UError>> : {
     [K in keyof T]: T[K] extends NestedClient<any> ? SafeClient<T[K]> : never;
@@ -164,6 +206,9 @@ type SafeClient<T extends NestedClient<any>> = T extends Client<infer UContext,
  */
 declare function createSafeClient<T extends NestedClient<any>>(client: T): SafeClient<T>;
 
+declare const ORPC_CLIENT_PACKAGE_NAME = "@orpc/client";
+declare const ORPC_CLIENT_PACKAGE_VERSION = "0.0.0-next.e27e0c1";
+
 /**
  * DynamicLink provides a way to dynamically resolve and delegate calls to other ClientLinks
  * based on the request path, input, and context.
@@ -181,5 +226,5 @@ declare function mapEventIterator<TYield, TReturn, TNext, TMap = TYield | TRetur
     error: (error: unknown) => Promise<unknown>;
 }): AsyncIteratorClass<TMap, TMap, TNext>;
 
-export { COMMON_ORPC_ERROR_DEFS, Client, ClientContext, ClientLink, ClientOptions, ClientPromiseResult, ClientRest, DynamicLink, FriendlyClientOptions, InferClientContext, NestedClient, ORPCError, createORPCClient, createORPCErrorFromJson, createSafeClient, fallbackORPCErrorMessage, fallbackORPCErrorStatus, isDefinedError, isORPCErrorJson, isORPCErrorStatus, mapEventIterator, resolveFriendlyClientOptions, safe, toORPCError };
-export type { CommonORPCErrorCode, ORPCErrorCode, ORPCErrorJSON, ORPCErrorOptions, SafeClient, SafeResult, createORPCClientOptions };
+export { COMMON_ORPC_ERROR_DEFS, Client, ClientContext, ClientLink, ClientOptions, ClientPromiseResult, ClientRest, DynamicLink, FriendlyClientOptions, InferClientContext, NestedClient, ORPCError, ORPC_CLIENT_PACKAGE_NAME, ORPC_CLIENT_PACKAGE_VERSION, consumeEventIterator, createORPCClient, createORPCErrorFromJson, createSafeClient, fallbackORPCErrorMessage, fallbackORPCErrorStatus, isDefinedError, isORPCErrorJson, isORPCErrorStatus, mapEventIterator, resolveFriendlyClientOptions, safe, toORPCError };
+export type { CommonORPCErrorCode, ConsumeEventIteratorOptions, ORPCErrorCode, ORPCErrorJSON, ORPCErrorOptions, SafeClient, SafeResult, createORPCClientOptions };

package/dist/index.mjs

@@ -1,7 +1,7 @@
-import { i as isDefinedError } from './shared/client.DHOfWE0c.mjs';
-export { C as COMMON_ORPC_ERROR_DEFS, O as ORPCError, d as createORPCErrorFromJson, a as fallbackORPCErrorMessage, f as fallbackORPCErrorStatus, c as isORPCErrorJson, b as isORPCErrorStatus, m as mapEventIterator, t as toORPCError } from './shared/client.DHOfWE0c.mjs';
-import { isTypescriptObject } from '@orpc/shared';
-export { EventPublisher, onError, onFinish, onStart, onSuccess } from '@orpc/shared';
+import { preventNativeAwait, isTypescriptObject } from '@orpc/shared';
+export { AsyncIteratorClass, EventPublisher, asyncIteratorToStream as eventIteratorToStream, asyncIteratorToUnproxiedDataStream as eventIteratorToUnproxiedDataStream, onError, onFinish, onStart, onSuccess, streamToAsyncIteratorClass as streamToEventIterator } from '@orpc/shared';
+import { i as isDefinedError } from './shared/client.DhC7qN6c.mjs';
+export { C as COMMON_ORPC_ERROR_DEFS, c as ORPCError, O as ORPC_CLIENT_PACKAGE_NAME, a as ORPC_CLIENT_PACKAGE_VERSION, g as createORPCErrorFromJson, b as fallbackORPCErrorMessage, f as fallbackORPCErrorStatus, e as isORPCErrorJson, d as isORPCErrorStatus, m as mapEventIterator, t as toORPCError } from './shared/client.DhC7qN6c.mjs';
 export { ErrorEvent } from '@orpc/standard-server';
 
 async function safe(promise) {
@@ -32,6 +32,35 @@ function resolveFriendlyClientOptions(options) {
     // Context only optional if all fields are optional
   };
 }
+function consumeEventIterator(iterator, options) {
+  void (async () => {
+    let onFinishState;
+    try {
+      const resolvedIterator = await iterator;
+      while (true) {
+        const { done, value } = await resolvedIterator.next();
+        if (done) {
+          const realValue = value;
+          onFinishState = [null, realValue, true];
+          options.onSuccess?.(realValue);
+          break;
+        }
+        options.onEvent(value);
+      }
+    } catch (error) {
+      onFinishState = [error, void 0, false];
+      if (!options.onError && !options.onFinish) {
+        throw error;
+      }
+      options.onError?.(error);
+    } finally {
+      options.onFinish?.(onFinishState);
+    }
+  })();
+  return async () => {
+    await (await iterator)?.return?.();
+  };
+}
 
 function createORPCClient(link, options = {}) {
   const path = options.path ?? [];
@@ -49,7 +78,7 @@ function createORPCClient(link, options = {}) {
       });
     }
   });
-  return recursive;
+  return preventNativeAwait(recursive);
 }
 
 function createSafeClient(client) {
@@ -79,4 +108,4 @@ class DynamicLink {
   }
 }
 
-export { DynamicLink, createORPCClient, createSafeClient, isDefinedError, resolveFriendlyClientOptions, safe };
+export { DynamicLink, consumeEventIterator, createORPCClient, createSafeClient, isDefinedError, resolveFriendlyClientOptions, safe };

package/dist/plugins/index.d.mts

@@ -1,8 +1,8 @@
 import { Value, Promisable } from '@orpc/shared';
 import { StandardHeaders, StandardRequest } from '@orpc/standard-server';
 import { BatchResponseMode } from '@orpc/standard-server/batch';
-import { S as StandardLinkClientInterceptorOptions, a as StandardLinkPlugin, b as StandardLinkOptions, c as StandardLinkInterceptorOptions } from '../shared/client.C4VxIexA.mjs';
-import { b as ClientContext } from '../shared/client.BOYsZIRq.mjs';
+import { S as StandardLinkClientInterceptorOptions, a as StandardLinkPlugin, b as StandardLinkOptions, c as StandardLinkInterceptorOptions } from '../shared/client.CPgZaUox.mjs';
+import { b as ClientContext } from '../shared/client.BH1AYT_p.mjs';
 
 interface BatchLinkPluginGroup<T extends ClientContext> {
     condition(options: StandardLinkClientInterceptorOptions<T>): boolean;
@@ -157,6 +157,7 @@ declare class ClientRetryPlugin<T extends ClientRetryPluginContext> implements S
     private readonly defaultRetryDelay;
     private readonly defaultShouldRetry;
     private readonly defaultOnRetry;
+    order: number;
     constructor(options?: ClientRetryPluginOptions);
     init(options: StandardLinkOptions<T>): void;
 }

package/dist/plugins/index.d.ts

@@ -1,8 +1,8 @@
 import { Value, Promisable } from '@orpc/shared';
 import { StandardHeaders, StandardRequest } from '@orpc/standard-server';
 import { BatchResponseMode } from '@orpc/standard-server/batch';
-import { S as StandardLinkClientInterceptorOptions, a as StandardLinkPlugin, b as StandardLinkOptions, c as StandardLinkInterceptorOptions } from '../shared/client.CXXEPIbK.js';
-import { b as ClientContext } from '../shared/client.BOYsZIRq.js';
+import { S as StandardLinkClientInterceptorOptions, a as StandardLinkPlugin, b as StandardLinkOptions, c as StandardLinkInterceptorOptions } from '../shared/client.De8SW4Kw.js';
+import { b as ClientContext } from '../shared/client.BH1AYT_p.js';
 
 interface BatchLinkPluginGroup<T extends ClientContext> {
     condition(options: StandardLinkClientInterceptorOptions<T>): boolean;
@@ -157,6 +157,7 @@ declare class ClientRetryPlugin<T extends ClientRetryPluginContext> implements S
     private readonly defaultRetryDelay;
     private readonly defaultShouldRetry;
     private readonly defaultOnRetry;
+    order: number;
     constructor(options?: ClientRetryPluginOptions);
     init(options: StandardLinkOptions<T>): void;
 }

package/dist/plugins/index.mjs

@@ -1,4 +1,4 @@
-import { isAsyncIteratorObject, defer, value, splitInHalf, toArray, stringifyJSON } from '@orpc/shared';
+import { isAsyncIteratorObject, defer, value, splitInHalf, toArray, stringifyJSON, overlayProxy, AsyncIteratorClass } from '@orpc/shared';
 import { toBatchRequest, parseBatchResponse, toBatchAbortSignal } from '@orpc/standard-server/batch';
 import { replicateStandardLazyResponse, getEventMeta } from '@orpc/standard-server';
 
@@ -64,7 +64,7 @@ class BatchLinkPlugin {
       });
     });
     options.clientInterceptors.push((options2) => {
-      if (this.exclude(options2) || options2.request.body instanceof Blob || options2.request.body instanceof FormData || isAsyncIteratorObject(options2.request.body)) {
+      if (this.exclude(options2) || options2.request.body instanceof Blob || options2.request.body instanceof FormData || isAsyncIteratorObject(options2.request.body) || options2.request.signal?.aborted) {
         return options2.next();
       }
       const group = this.groups.find((group2) => group2.condition(options2));
@@ -130,16 +130,27 @@ class BatchLinkPlugin {
         return;
       }
       const mode = value(this.mode, options);
-      const lazyResponse = await options[0].next({
-        request: { ...batchRequest, headers: { ...batchRequest.headers, "x-orpc-batch": mode } },
-        signal: batchRequest.signal,
-        context: group.context,
-        input: group.input,
-        path: toArray(group.path)
-      });
-      const parsed = parseBatchResponse({ ...lazyResponse, body: await lazyResponse.body() });
-      for await (const item of parsed) {
-        batchItems[item.index]?.[1]({ ...item, body: () => Promise.resolve(item.body) });
+      try {
+        const lazyResponse = await options[0].next({
+          request: { ...batchRequest, headers: { ...batchRequest.headers, "x-orpc-batch": mode } },
+          signal: batchRequest.signal,
+          context: group.context,
+          input: group.input,
+          path: toArray(group.path)
+        });
+        const parsed = parseBatchResponse({ ...lazyResponse, body: await lazyResponse.body() });
+        for await (const item of parsed) {
+          batchItems[item.index]?.[1]({ ...item, body: () => Promise.resolve(item.body) });
+        }
+      } catch (err) {
+        if (batchRequest.signal?.aborted && batchRequest.signal.reason === err) {
+          for (const [{ signal }, , reject] of batchItems) {
+            if (signal?.aborted) {
+              reject(signal.reason);
+            }
+          }
+        }
+        throw err;
       }
       throw new Error("Something went wrong make batch response not contains enough responses. This can be a bug please report it.");
     } catch (error) {
@@ -252,6 +263,7 @@ class ClientRetryPlugin {
   defaultRetryDelay;
   defaultShouldRetry;
   defaultOnRetry;
+  order = 18e5;
   constructor(options = {}) {
     this.defaultRetry = options.default?.retry ?? 0;
     this.defaultRetryDelay = options.default?.retryDelay ?? ((o) => o.lastEventRetry ?? 2e3);
@@ -306,7 +318,7 @@ class ClientRetryPlugin {
             return await interceptorOptions.next(updatedInterceptorOptions);
           } catch (error) {
             currentError = { error };
-            if (updatedInterceptorOptions.signal?.aborted === true) {
+            if (updatedInterceptorOptions.signal?.aborted) {
               throw error;
             }
           } finally {
@@ -319,19 +331,17 @@ class ClientRetryPlugin {
       if (!isAsyncIteratorObject(output)) {
         return output;
       }
-      return async function* () {
-        let current = output;
-        try {
+      let current = output;
+      let isIteratorAborted = false;
+      return overlayProxy(() => current, new AsyncIteratorClass(
+        async () => {
           while (true) {
             try {
               const item = await current.next();
               const meta = getEventMeta(item.value);
               lastEventId = meta?.id ?? lastEventId;
               lastEventRetry = meta?.retry ?? lastEventRetry;
-              if (item.done) {
-                return item.value;
-              }
-              yield item.value;
+              return item;
             } catch (error) {
               const meta = getEventMeta(error);
               lastEventId = meta?.id ?? lastEventId;
@@ -343,12 +353,20 @@ class ClientRetryPlugin {
                 );
               }
               current = maybeEventIterator;
+              if (isIteratorAborted) {
+                await current.return?.();
+                throw error;
+              }
             }
           }
-        } finally {
-          await current.return?.();
+        },
+        async (reason) => {
+          isIteratorAborted = true;
+          if (reason !== "next") {
+            await current.return?.();
+          }
         }
-      }();
+      ));
     });
   }
 }

package/dist/shared/client.BH1AYT_p.d.mts

@@ -0,0 +1,83 @@
+import { PromiseWithError } from '@orpc/shared';
+
+type HTTPPath = `/${string}`;
+type HTTPMethod = 'HEAD' | 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+type ClientContext = Record<PropertyKey, any>;
+interface ClientOptions<T extends ClientContext> {
+    signal?: AbortSignal;
+    lastEventId?: string | undefined;
+    context: T;
+}
+type FriendlyClientOptions<T extends ClientContext> = Omit<ClientOptions<T>, 'context'> & (Record<never, never> extends T ? {
+    context?: T;
+} : {
+    context: T;
+});
+type ClientRest<TClientContext extends ClientContext, TInput> = Record<never, never> extends TClientContext ? undefined extends TInput ? [input?: TInput, options?: FriendlyClientOptions<TClientContext>] : [input: TInput, options?: FriendlyClientOptions<TClientContext>] : [input: TInput, options: FriendlyClientOptions<TClientContext>];
+type ClientPromiseResult<TOutput, TError> = PromiseWithError<TOutput, TError>;
+interface Client<TClientContext extends ClientContext, TInput, TOutput, TError> {
+    (...rest: ClientRest<TClientContext, TInput>): ClientPromiseResult<TOutput, TError>;
+}
+type NestedClient<TClientContext extends ClientContext> = Client<TClientContext, any, any, any> | {
+    [k: string]: NestedClient<TClientContext>;
+};
+type InferClientContext<T extends NestedClient<any>> = T extends NestedClient<infer U> ? U : never;
+interface ClientLink<TClientContext extends ClientContext> {
+    call: (path: readonly string[], input: unknown, options: ClientOptions<TClientContext>) => Promise<unknown>;
+}
+/**
+ * Recursively infers the **input types** from a client.
+ *
+ * Produces a nested map where each endpoint's input type is preserved.
+ */
+type InferClientInputs<T extends NestedClient<any>> = T extends Client<any, infer U, any, any> ? U : {
+    [K in keyof T]: T[K] extends NestedClient<any> ? InferClientInputs<T[K]> : never;
+};
+/**
+ * Recursively infers the **body input types** from a client.
+ *
+ * If an endpoint's input includes `{ body: ... }`, only the `body` portion is extracted.
+ * Produces a nested map of body input types.
+ */
+type InferClientBodyInputs<T extends NestedClient<any>> = T extends Client<any, infer U, any, any> ? U extends {
+    body: infer UBody;
+} ? UBody : U : {
+    [K in keyof T]: T[K] extends NestedClient<any> ? InferClientBodyInputs<T[K]> : never;
+};
+/**
+ * Recursively infers the **output types** from a client.
+ *
+ * Produces a nested map where each endpoint's output type is preserved.
+ */
+type InferClientOutputs<T extends NestedClient<any>> = T extends Client<any, any, infer U, any> ? U : {
+    [K in keyof T]: T[K] extends NestedClient<any> ? InferClientOutputs<T[K]> : never;
+};
+/**
+ * Recursively infers the **body output types** from a client.
+ *
+ * If an endpoint's output includes `{ body: ... }`, only the `body` portion is extracted.
+ * Produces a nested map of body output types.
+ */
+type InferClientBodyOutputs<T extends NestedClient<any>> = T extends Client<any, any, infer U, any> ? U extends {
+    body: infer UBody;
+} ? UBody : U : {
+    [K in keyof T]: T[K] extends NestedClient<any> ? InferClientBodyOutputs<T[K]> : never;
+};
+/**
+ * Recursively infers the **error types** from a client when you use [type-safe errors](https://orpc.unnoq.com/docs/error-handling#type‐safe-error-handling).
+ *
+ * Produces a nested map where each endpoint's error type is preserved.
+ */
+type InferClientErrors<T extends NestedClient<any>> = T extends Client<any, any, any, infer U> ? U : {
+    [K in keyof T]: T[K] extends NestedClient<any> ? InferClientErrors<T[K]> : never;
+};
+/**
+ * Recursively infers a **union of all error types** from a client when you use [type-safe errors](https://orpc.unnoq.com/docs/error-handling#type‐safe-error-handling).
+ *
+ * Useful when you want to handle all possible errors from any endpoint at once.
+ */
+type InferClientErrorUnion<T extends NestedClient<any>> = T extends Client<any, any, any, infer U> ? U : {
+    [K in keyof T]: T[K] extends NestedClient<any> ? InferClientErrorUnion<T[K]> : never;
+}[keyof T];
+
+export type { ClientLink as C, FriendlyClientOptions as F, HTTPPath as H, InferClientContext as I, NestedClient as N, ClientPromiseResult as a, ClientContext as b, ClientOptions as c, Client as d, ClientRest as e, HTTPMethod as f, InferClientInputs as g, InferClientBodyInputs as h, InferClientOutputs as i, InferClientBodyOutputs as j, InferClientErrors as k, InferClientErrorUnion as l };

package/dist/shared/client.BH1AYT_p.d.ts

@@ -0,0 +1,83 @@
+import { PromiseWithError } from '@orpc/shared';
+
+type HTTPPath = `/${string}`;
+type HTTPMethod = 'HEAD' | 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+type ClientContext = Record<PropertyKey, any>;
+interface ClientOptions<T extends ClientContext> {
+    signal?: AbortSignal;
+    lastEventId?: string | undefined;
+    context: T;
+}
+type FriendlyClientOptions<T extends ClientContext> = Omit<ClientOptions<T>, 'context'> & (Record<never, never> extends T ? {
+    context?: T;
+} : {
+    context: T;
+});
+type ClientRest<TClientContext extends ClientContext, TInput> = Record<never, never> extends TClientContext ? undefined extends TInput ? [input?: TInput, options?: FriendlyClientOptions<TClientContext>] : [input: TInput, options?: FriendlyClientOptions<TClientContext>] : [input: TInput, options: FriendlyClientOptions<TClientContext>];
+type ClientPromiseResult<TOutput, TError> = PromiseWithError<TOutput, TError>;
+interface Client<TClientContext extends ClientContext, TInput, TOutput, TError> {
+    (...rest: ClientRest<TClientContext, TInput>): ClientPromiseResult<TOutput, TError>;
+}
+type NestedClient<TClientContext extends ClientContext> = Client<TClientContext, any, any, any> | {
+    [k: string]: NestedClient<TClientContext>;
+};
+type InferClientContext<T extends NestedClient<any>> = T extends NestedClient<infer U> ? U : never;
+interface ClientLink<TClientContext extends ClientContext> {
+    call: (path: readonly string[], input: unknown, options: ClientOptions<TClientContext>) => Promise<unknown>;
+}
+/**
+ * Recursively infers the **input types** from a client.
+ *
+ * Produces a nested map where each endpoint's input type is preserved.
+ */
+type InferClientInputs<T extends NestedClient<any>> = T extends Client<any, infer U, any, any> ? U : {
+    [K in keyof T]: T[K] extends NestedClient<any> ? InferClientInputs<T[K]> : never;
+};
+/**
+ * Recursively infers the **body input types** from a client.
+ *
+ * If an endpoint's input includes `{ body: ... }`, only the `body` portion is extracted.
+ * Produces a nested map of body input types.
+ */
+type InferClientBodyInputs<T extends NestedClient<any>> = T extends Client<any, infer U, any, any> ? U extends {
+    body: infer UBody;
+} ? UBody : U : {
+    [K in keyof T]: T[K] extends NestedClient<any> ? InferClientBodyInputs<T[K]> : never;
+};
+/**
+ * Recursively infers the **output types** from a client.
+ *
+ * Produces a nested map where each endpoint's output type is preserved.
+ */
+type InferClientOutputs<T extends NestedClient<any>> = T extends Client<any, any, infer U, any> ? U : {
+    [K in keyof T]: T[K] extends NestedClient<any> ? InferClientOutputs<T[K]> : never;
+};
+/**
+ * Recursively infers the **body output types** from a client.
+ *
+ * If an endpoint's output includes `{ body: ... }`, only the `body` portion is extracted.
+ * Produces a nested map of body output types.
+ */
+type InferClientBodyOutputs<T extends NestedClient<any>> = T extends Client<any, any, infer U, any> ? U extends {
+    body: infer UBody;
+} ? UBody : U : {
+    [K in keyof T]: T[K] extends NestedClient<any> ? InferClientBodyOutputs<T[K]> : never;
+};
+/**
+ * Recursively infers the **error types** from a client when you use [type-safe errors](https://orpc.unnoq.com/docs/error-handling#type‐safe-error-handling).
+ *
+ * Produces a nested map where each endpoint's error type is preserved.
+ */
+type InferClientErrors<T extends NestedClient<any>> = T extends Client<any, any, any, infer U> ? U : {
+    [K in keyof T]: T[K] extends NestedClient<any> ? InferClientErrors<T[K]> : never;
+};
+/**
+ * Recursively infers a **union of all error types** from a client when you use [type-safe errors](https://orpc.unnoq.com/docs/error-handling#type‐safe-error-handling).
+ *
+ * Useful when you want to handle all possible errors from any endpoint at once.
+ */
+type InferClientErrorUnion<T extends NestedClient<any>> = T extends Client<any, any, any, infer U> ? U : {
+    [K in keyof T]: T[K] extends NestedClient<any> ? InferClientErrorUnion<T[K]> : never;
+}[keyof T];
+
+export type { ClientLink as C, FriendlyClientOptions as F, HTTPPath as H, InferClientContext as I, NestedClient as N, ClientPromiseResult as a, ClientContext as b, ClientOptions as c, Client as d, ClientRest as e, HTTPMethod as f, InferClientInputs as g, InferClientBodyInputs as h, InferClientOutputs as i, InferClientBodyOutputs as j, InferClientErrors as k, InferClientErrorUnion as l };

package/dist/shared/{client.DwfV9Oyl.mjs → client.BRztoawb.mjs}

@@ -1,6 +1,7 @@
-import { toArray, intercept, isObject, value, isAsyncIteratorObject, stringifyJSON } from '@orpc/shared';
+import { toArray, runWithSpan, ORPC_NAME, isAsyncIteratorObject, asyncIteratorWithSpan, intercept, getGlobalOtelConfig, isObject, value, stringifyJSON } from '@orpc/shared';
 import { mergeStandardHeaders, ErrorEvent } from '@orpc/standard-server';
-import { C as COMMON_ORPC_ERROR_DEFS, b as isORPCErrorStatus, c as isORPCErrorJson, d as createORPCErrorFromJson, O as ORPCError, m as mapEventIterator, t as toORPCError } from './client.DHOfWE0c.mjs';
+import { C as COMMON_ORPC_ERROR_DEFS, d as isORPCErrorStatus, e as isORPCErrorJson, g as createORPCErrorFromJson, c as ORPCError, m as mapEventIterator, t as toORPCError } from './client.DhC7qN6c.mjs';
+import { toStandardHeaders as toStandardHeaders$1 } from '@orpc/standard-server-fetch';
 
 class CompositeStandardLinkPlugin {
   plugins;
@@ -26,20 +27,52 @@ class StandardLink {
   interceptors;
   clientInterceptors;
   call(path, input, options) {
-    return intercept(this.interceptors, { ...options, path, input }, async ({ path: path2, input: input2, ...options2 }) => {
-      const output = await this.#call(path2, input2, options2);
-      return output;
-    });
-  }
-  async #call(path, input, options) {
-    const request = await this.codec.encode(path, input, options);
-    const response = await intercept(
-      this.clientInterceptors,
-      { ...options, input, path, request },
-      ({ input: input2, path: path2, request: request2, ...options2 }) => this.sender.call(request2, options2, path2, input2)
+    return runWithSpan(
+      { name: `${ORPC_NAME}.${path.join("/")}`, signal: options.signal },
+      (span) => {
+        span?.setAttribute("rpc.system", ORPC_NAME);
+        span?.setAttribute("rpc.method", path.join("."));
+        if (isAsyncIteratorObject(input)) {
+          input = asyncIteratorWithSpan(
+            { name: "consume_event_iterator_input", signal: options.signal },
+            input
+          );
+        }
+        return intercept(this.interceptors, { ...options, path, input }, async ({ path: path2, input: input2, ...options2 }) => {
+          const otelConfig = getGlobalOtelConfig();
+          let otelContext;
+          const currentSpan = otelConfig?.trace.getActiveSpan() ?? span;
+          if (currentSpan && otelConfig) {
+            otelContext = otelConfig?.trace.setSpan(otelConfig.context.active(), currentSpan);
+          }
+          const request = await runWithSpan(
+            { name: "encode_request", context: otelContext },
+            () => this.codec.encode(path2, input2, options2)
+          );
+          const response = await intercept(
+            this.clientInterceptors,
+            { ...options2, input: input2, path: path2, request },
+            ({ input: input3, path: path3, request: request2, ...options3 }) => {
+              return runWithSpan(
+                { name: "send_request", signal: options3.signal, context: otelContext },
+                () => this.sender.call(request2, options3, path3, input3)
+              );
+            }
+          );
+          const output = await runWithSpan(
+            { name: "decode_response", context: otelContext },
+            () => this.codec.decode(response, options2, path2, input2)
+          );
+          if (isAsyncIteratorObject(output)) {
+            return asyncIteratorWithSpan(
+              { name: "consume_event_iterator_output", signal: options2.signal },
+              output
+            );
+          }
+          return output;
+        });
+      }
     );
-    const output = await this.codec.decode(response, options, path, input);
-    return output;
   }
 }
 
@@ -192,6 +225,12 @@ class StandardRPCJsonSerializer {
 function toHttpPath(path) {
   return `/${path.map(encodeURIComponent).join("/")}`;
 }
+function toStandardHeaders(headers) {
+  if (typeof headers.forEach === "function") {
+    return toStandardHeaders$1(headers);
+  }
+  return headers;
+}
 function getMalformedResponseErrorCode(status) {
   return Object.entries(COMMON_ORPC_ERROR_DEFS).find(([, def]) => def.status === status)?.[0] ?? "MALFORMED_ORPC_ERROR_RESPONSE";
 }
@@ -211,14 +250,14 @@ class StandardRPCLinkCodec {
   expectedMethod;
   headers;
   async encode(path, input, options) {
+    let headers = toStandardHeaders(await value(this.headers, options, path, input));
+    if (options.lastEventId !== void 0) {
+      headers = mergeStandardHeaders(headers, { "last-event-id": options.lastEventId });
+    }
     const expectedMethod = await value(this.expectedMethod, options, path, input);
-    let headers = await value(this.headers, options, path, input);
     const baseUrl = await value(this.baseUrl, options, path, input);
     const url = new URL(baseUrl);
     url.pathname = `${url.pathname.replace(/\/$/, "")}${toHttpPath(path)}`;
-    if (options.lastEventId !== void 0) {
-      headers = mergeStandardHeaders(headers, { "last-event-id": options.lastEventId });
-    }
     const serialized = this.serializer.serialize(input);
     if (expectedMethod === "GET" && !(serialized instanceof FormData) && !isAsyncIteratorObject(serialized)) {
       const maxUrlLength = await value(this.maxUrlLength, options, path, input);
@@ -330,6 +369,9 @@ class StandardRPCSerializer {
     return this.#deserialize(data);
   }
   #deserialize(data) {
+    if (data === void 0) {
+      return void 0;
+    }
     if (!(data instanceof FormData)) {
       return this.jsonSerializer.deserialize(data.json, data.meta ?? []);
     }
@@ -352,4 +394,4 @@ class StandardRPCLink extends StandardLink {
   }
 }
 
-export { CompositeStandardLinkPlugin as C, StandardLink as S, STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES as a, StandardRPCJsonSerializer as b, StandardRPCLink as c, StandardRPCLinkCodec as d, StandardRPCSerializer as e, getMalformedResponseErrorCode as g, toHttpPath as t };
+export { CompositeStandardLinkPlugin as C, StandardLink as S, STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES as a, StandardRPCJsonSerializer as b, StandardRPCLink as c, StandardRPCLinkCodec as d, StandardRPCSerializer as e, toStandardHeaders as f, getMalformedResponseErrorCode as g, toHttpPath as t };

package/dist/shared/{client.WCinBImJ.d.ts → client.BxV-mzeR.d.ts}

@@ -1,5 +1,5 @@
-import { b as ClientContext, c as ClientOptions, f as HTTPMethod } from './client.BOYsZIRq.js';
-import { e as StandardLinkCodec, b as StandardLinkOptions, d as StandardLink, f as StandardLinkClient } from './client.CXXEPIbK.js';
+import { b as ClientContext, c as ClientOptions, f as HTTPMethod } from './client.BH1AYT_p.js';
+import { e as StandardLinkCodec, b as StandardLinkOptions, d as StandardLink, f as StandardLinkClient } from './client.De8SW4Kw.js';
 import { Segment, Value, Promisable } from '@orpc/shared';
 import { StandardHeaders, StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
 
@@ -67,7 +67,7 @@ interface StandardRPCLinkCodecOptions<T extends ClientContext> {
     /**
      * Inject headers to the request.
      */
-    headers?: Value<Promisable<StandardHeaders>, [options: ClientOptions<T>, path: readonly string[], input: unknown]>;
+    headers?: Value<Promisable<StandardHeaders | Headers>, [options: ClientOptions<T>, path: readonly string[], input: unknown]>;
 }
 declare class StandardRPCLinkCodec<T extends ClientContext> implements StandardLinkCodec<T> {
     private readonly serializer;

package/dist/shared/{client.CXXEPIbK.d.ts → client.CPgZaUox.d.mts}

@@ -1,6 +1,6 @@
 import { Interceptor } from '@orpc/shared';
 import { StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
-import { b as ClientContext, c as ClientOptions, C as ClientLink } from './client.BOYsZIRq.js';
+import { b as ClientContext, c as ClientOptions, C as ClientLink } from './client.BH1AYT_p.mjs';
 
 interface StandardLinkPlugin<T extends ClientContext> {
     order?: number;
@@ -33,7 +33,6 @@ interface StandardLinkOptions<T extends ClientContext> {
     plugins?: StandardLinkPlugin<T>[];
 }
 declare class StandardLink<T extends ClientContext> implements ClientLink<T> {
-    #private;
     readonly codec: StandardLinkCodec<T>;
     readonly sender: StandardLinkClient<T>;
     private readonly interceptors;

package/dist/shared/{client.aTp4sII-.d.mts → client.D8lMmWVC.d.mts}

@@ -1,5 +1,5 @@
-import { b as ClientContext, c as ClientOptions, f as HTTPMethod } from './client.BOYsZIRq.mjs';
-import { e as StandardLinkCodec, b as StandardLinkOptions, d as StandardLink, f as StandardLinkClient } from './client.C4VxIexA.mjs';
+import { b as ClientContext, c as ClientOptions, f as HTTPMethod } from './client.BH1AYT_p.mjs';
+import { e as StandardLinkCodec, b as StandardLinkOptions, d as StandardLink, f as StandardLinkClient } from './client.CPgZaUox.mjs';
 import { Segment, Value, Promisable } from '@orpc/shared';
 import { StandardHeaders, StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
 
@@ -67,7 +67,7 @@ interface StandardRPCLinkCodecOptions<T extends ClientContext> {
     /**
      * Inject headers to the request.
      */
-    headers?: Value<Promisable<StandardHeaders>, [options: ClientOptions<T>, path: readonly string[], input: unknown]>;
+    headers?: Value<Promisable<StandardHeaders | Headers>, [options: ClientOptions<T>, path: readonly string[], input: unknown]>;
 }
 declare class StandardRPCLinkCodec<T extends ClientContext> implements StandardLinkCodec<T> {
     private readonly serializer;