@orpc/client 0.52.0 → 0.54.0

package/dist/plugins/index.mjs

@@ -1,6 +1,152 @@
-import { isAsyncIteratorObject, value } from '@orpc/shared';
+import { isAsyncIteratorObject, value, splitInHalf, toArray } from '@orpc/shared';
+import { toBatchRequest, parseBatchResponse } from '@orpc/standard-server/batch';
 import { getEventMeta } from '@orpc/standard-server';
 
+class BatchLinkPlugin {
+  groups;
+  maxSize;
+  batchUrl;
+  maxUrlLength;
+  batchHeaders;
+  mapRequestItem;
+  exclude;
+  pending;
+  order = 5e6;
+  constructor(options) {
+    this.groups = options.groups;
+    this.pending = /* @__PURE__ */ new Map();
+    this.maxSize = options.maxSize ?? 10;
+    this.maxUrlLength = options.maxUrlLength ?? 2083;
+    this.batchUrl = options.url ?? (([options2]) => `${options2.request.url.origin}${options2.request.url.pathname}/__batch__`);
+    this.batchHeaders = options.headers ?? (([options2, ...rest]) => {
+      const headers = {};
+      for (const [key, value2] of Object.entries(options2.request.headers)) {
+        if (rest.every((item) => item.request.headers[key] === value2)) {
+          headers[key] = value2;
+        }
+      }
+      return headers;
+    });
+    this.mapRequestItem = options.mapRequestItem ?? (({ request, batchHeaders }) => {
+      const headers = {};
+      for (const [key, value2] of Object.entries(request.headers)) {
+        if (batchHeaders[key] !== value2) {
+          headers[key] = value2;
+        }
+      }
+      return {
+        method: request.method,
+        url: request.url,
+        headers,
+        body: request.body,
+        signal: request.signal
+      };
+    });
+    this.exclude = options.exclude ?? (() => false);
+  }
+  init(options) {
+    options.clientInterceptors ??= [];
+    options.clientInterceptors.push((options2) => {
+      if (options2.request.headers["x-orpc-batch"] !== "1") {
+        return options2.next();
+      }
+      return options2.next({
+        ...options2,
+        request: {
+          ...options2.request,
+          headers: {
+            ...options2.request.headers,
+            "x-orpc-batch": void 0
+          }
+        }
+      });
+    });
+    options.clientInterceptors.push((options2) => {
+      if (this.exclude(options2) || options2.request.body instanceof Blob || options2.request.body instanceof FormData || isAsyncIteratorObject(options2.request.body)) {
+        return options2.next();
+      }
+      const group = this.groups.find((group2) => group2.condition(options2));
+      if (!group) {
+        return options2.next();
+      }
+      return new Promise((resolve, reject) => {
+        this.#enqueueRequest(group, options2, resolve, reject);
+        setTimeout(() => this.#processPendingBatches());
+      });
+    });
+  }
+  #enqueueRequest(group, options, resolve, reject) {
+    const items = this.pending.get(group);
+    if (items) {
+      items.push([options, resolve, reject]);
+    } else {
+      this.pending.set(group, [[options, resolve, reject]]);
+    }
+  }
+  async #processPendingBatches() {
+    const pending = this.pending;
+    this.pending = /* @__PURE__ */ new Map();
+    for (const [group, items] of pending) {
+      const getItems = items.filter(([options]) => options.request.method === "GET");
+      const restItems = items.filter(([options]) => options.request.method !== "GET");
+      this.#executeBatch("GET", group, getItems);
+      this.#executeBatch("POST", group, restItems);
+    }
+  }
+  async #executeBatch(method, group, groupItems) {
+    if (!groupItems.length) {
+      return;
+    }
+    const batchItems = groupItems;
+    if (batchItems.length === 1) {
+      batchItems[0][0].next().then(batchItems[0][1]).catch(batchItems[0][2]);
+      return;
+    }
+    try {
+      const options = batchItems.map(([options2]) => options2);
+      const maxSize = await value(this.maxSize, options);
+      if (batchItems.length > maxSize) {
+        const [first, second] = splitInHalf(batchItems);
+        this.#executeBatch(method, group, first);
+        this.#executeBatch(method, group, second);
+        return;
+      }
+      const batchUrl = new URL(await value(this.batchUrl, options));
+      const batchHeaders = await value(this.batchHeaders, options);
+      const mappedItems = batchItems.map(([options2]) => this.mapRequestItem({ ...options2, batchUrl, batchHeaders }));
+      const batchRequest = toBatchRequest({
+        method,
+        url: batchUrl,
+        headers: batchHeaders,
+        requests: mappedItems
+      });
+      const maxUrlLength = await value(this.maxUrlLength, options);
+      if (batchRequest.url.toString().length > maxUrlLength) {
+        const [first, second] = splitInHalf(batchItems);
+        this.#executeBatch(method, group, first);
+        this.#executeBatch(method, group, second);
+        return;
+      }
+      const lazyResponse = await options[0].next({
+        request: { ...batchRequest, headers: { ...batchRequest.headers, "x-orpc-batch": "1" } },
+        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) });
+      }
+      throw new Error("Something went wrong make batch response not contains enough responses. This can be a bug please report it.");
+    } catch (error) {
+      for (const [, , reject] of batchItems) {
+        reject(error);
+      }
+    }
+  }
+}
+
 class ClientRetryPluginInvalidEventIteratorRetryResponse extends Error {
 }
 class ClientRetryPlugin {
@@ -17,71 +163,57 @@ class ClientRetryPlugin {
   init(options) {
     options.interceptors ??= [];
     options.interceptors.push(async (interceptorOptions) => {
-      const maxAttempts = interceptorOptions.options.context.retry ?? this.defaultRetry;
-      const retryDelay = interceptorOptions.options.context.retryDelay ?? this.defaultRetryDelay;
-      const shouldRetry = interceptorOptions.options.context.shouldRetry ?? this.defaultShouldRetry;
-      const onRetry = interceptorOptions.options.context.onRetry ?? this.defaultOnRetry;
+      const maxAttempts = await value(
+        interceptorOptions.context.retry ?? this.defaultRetry,
+        interceptorOptions
+      );
+      const retryDelay = interceptorOptions.context.retryDelay ?? this.defaultRetryDelay;
+      const shouldRetry = interceptorOptions.context.shouldRetry ?? this.defaultShouldRetry;
+      const onRetry = interceptorOptions.context.onRetry ?? this.defaultOnRetry;
       if (maxAttempts <= 0) {
         return interceptorOptions.next();
       }
-      let lastEventId = interceptorOptions.options.lastEventId;
+      let lastEventId = interceptorOptions.lastEventId;
       let lastEventRetry;
-      let unsubscribe;
+      let callback;
       let attemptIndex = 0;
-      const next = async (initial) => {
-        let current = initial;
+      const next = async (initialError) => {
+        let currentError = initialError;
         while (true) {
-          const newClientOptions = { ...interceptorOptions.options, lastEventId };
-          if (current) {
+          const updatedInterceptorOptions = { ...interceptorOptions, lastEventId };
+          if (currentError) {
             if (attemptIndex >= maxAttempts) {
-              throw current.error;
+              throw currentError.error;
             }
             const attemptOptions = {
+              ...updatedInterceptorOptions,
               attemptIndex,
-              error: current.error,
-              lastEventId,
+              error: currentError.error,
               lastEventRetry
             };
             const shouldRetryBool = await value(
               shouldRetry,
-              attemptOptions,
-              newClientOptions,
-              interceptorOptions.path,
-              interceptorOptions.input
+              attemptOptions
             );
             if (!shouldRetryBool) {
-              throw current.error;
+              throw currentError.error;
             }
-            unsubscribe = onRetry?.(
-              attemptOptions,
-              newClientOptions,
-              interceptorOptions.path,
-              interceptorOptions.input
-            );
-            const retryDelayMs = await value(
-              retryDelay,
-              attemptOptions,
-              newClientOptions,
-              interceptorOptions.path,
-              interceptorOptions.input
-            );
+            callback = onRetry?.(attemptOptions);
+            const retryDelayMs = await value(retryDelay, attemptOptions);
             await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
             attemptIndex++;
           }
           try {
-            const output2 = await interceptorOptions.next({
-              ...interceptorOptions,
-              options: newClientOptions
-            });
-            return output2;
+            currentError = void 0;
+            return await interceptorOptions.next(updatedInterceptorOptions);
           } catch (error) {
-            if (newClientOptions.signal?.aborted === true) {
+            currentError = { error };
+            if (updatedInterceptorOptions.signal?.aborted === true) {
               throw error;
             }
-            current = { error };
           } finally {
-            unsubscribe?.();
-            unsubscribe = void 0;
+            callback?.(!currentError);
+            callback = void 0;
           }
         }
       };
@@ -123,4 +255,37 @@ class ClientRetryPlugin {
   }
 }
 
-export { ClientRetryPlugin, ClientRetryPluginInvalidEventIteratorRetryResponse };
+class SimpleCsrfProtectionLinkPlugin {
+  headerName;
+  headerValue;
+  exclude;
+  constructor(options = {}) {
+    this.headerName = options.headerName ?? "x-csrf-token";
+    this.headerValue = options.headerValue ?? "orpc";
+    this.exclude = options.exclude ?? false;
+  }
+  order = 8e6;
+  init(options) {
+    options.clientInterceptors ??= [];
+    options.clientInterceptors.push(async (options2) => {
+      const excluded = await value(this.exclude, options2);
+      if (excluded) {
+        return options2.next();
+      }
+      const headerName = await value(this.headerName, options2);
+      const headerValue = await value(this.headerValue, options2);
+      return options2.next({
+        ...options2,
+        request: {
+          ...options2.request,
+          headers: {
+            ...options2.request.headers,
+            [headerName]: headerValue
+          }
+        }
+      });
+    });
+  }
+}
+
+export { BatchLinkPlugin, ClientRetryPlugin, ClientRetryPluginInvalidEventIteratorRetryResponse, SimpleCsrfProtectionLinkPlugin };

package/dist/shared/{client.D-jrSuDb.d.ts → client.8TjrVhkC.d.ts}

@@ -1,5 +1,5 @@
-import { a as ClientContext, b as ClientOptions, d as HTTPMethod } from './client.C0lT7w02.js';
-import { c as StandardLinkCodec, a as StandardLinkOptions } from './client.grRbC25r.js';
+import { a as ClientContext, b as ClientOptions, d as HTTPMethod } from './client.CipPQkhk.js';
+import { e as StandardLinkCodec, b as StandardLinkOptions, d as StandardLink, f as StandardLinkClient } from './client.C9U9n1f3.js';
 import { Segment, Value } from '@orpc/shared';
 import { StandardHeaders, StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
 
@@ -44,31 +44,19 @@ interface StandardRPCLinkCodecOptions<T extends ClientContext> {
     /**
      * Base url for all requests.
      */
-    url: Value<string | URL, [
-        options: ClientOptions<T>,
-        path: readonly string[],
-        input: unknown
-    ]>;
+    url: Value<string | URL, [options: ClientOptions<T>, path: readonly string[], input: unknown]>;
     /**
      * The maximum length of the URL.
      *
      * @default 2083
      */
-    maxUrlLength?: Value<number, [
-        options: ClientOptions<T>,
-        path: readonly string[],
-        input: unknown
-    ]>;
+    maxUrlLength?: Value<number, [options: ClientOptions<T>, path: readonly string[], input: unknown]>;
     /**
      * The method used to make the request.
      *
      * @default 'POST'
      */
-    method?: Value<HTTPMethod, [
-        options: ClientOptions<T>,
-        path: readonly string[],
-        input: unknown
-    ]>;
+    method?: Value<HTTPMethod, [options: ClientOptions<T>, path: readonly 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.
@@ -79,11 +67,7 @@ interface StandardRPCLinkCodecOptions<T extends ClientContext> {
     /**
      * Inject headers to the request.
      */
-    headers?: Value<StandardHeaders, [
-        options: ClientOptions<T>,
-        path: readonly string[],
-        input: unknown
-    ]>;
+    headers?: Value<StandardHeaders, [options: ClientOptions<T>, path: readonly string[], input: unknown]>;
 }
 declare class StandardRPCLinkCodec<T extends ClientContext> implements StandardLinkCodec<T> {
     private readonly serializer;
@@ -99,5 +83,9 @@ declare class StandardRPCLinkCodec<T extends ClientContext> implements StandardL
 
 interface StandardRPCLinkOptions<T extends ClientContext> extends StandardLinkOptions<T>, StandardRPCLinkCodecOptions<T>, StandardRPCJsonSerializerOptions {
 }
+declare class StandardRPCLink<T extends ClientContext> extends StandardLink<T> {
+    constructor(linkClient: StandardLinkClient<T>, options: StandardRPCLinkOptions<T>);
+}
 
-export { STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES as S, type StandardRPCJsonSerializedMetaItem as a, type StandardRPCJsonSerialized as b, type StandardRPCCustomJsonSerializer as c, type StandardRPCJsonSerializerOptions as d, StandardRPCJsonSerializer as e, type StandardRPCLinkOptions as f, type StandardRPCLinkCodecOptions as g, StandardRPCLinkCodec as h, StandardRPCSerializer as i };
+export { STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES as S, StandardRPCJsonSerializer as e, StandardRPCLink as g, StandardRPCLinkCodec as i, StandardRPCSerializer as j };
+export type { StandardRPCJsonSerializedMetaItem as a, StandardRPCJsonSerialized as b, StandardRPCCustomJsonSerializer as c, StandardRPCJsonSerializerOptions as d, StandardRPCLinkOptions as f, StandardRPCLinkCodecOptions as h };

package/dist/shared/{client.Bt94sjrK.d.mts → client.BjJBZryq.d.mts}

@@ -1,5 +1,5 @@
-import { a as ClientContext, b as ClientOptions, d as HTTPMethod } from './client.C0lT7w02.mjs';
-import { c as StandardLinkCodec, a as StandardLinkOptions } from './client.5813Ufvs.mjs';
+import { a as ClientContext, b as ClientOptions, d as HTTPMethod } from './client.CipPQkhk.mjs';
+import { e as StandardLinkCodec, b as StandardLinkOptions, d as StandardLink, f as StandardLinkClient } from './client.FXep-a3a.mjs';
 import { Segment, Value } from '@orpc/shared';
 import { StandardHeaders, StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
 
@@ -44,31 +44,19 @@ interface StandardRPCLinkCodecOptions<T extends ClientContext> {
     /**
      * Base url for all requests.
      */
-    url: Value<string | URL, [
-        options: ClientOptions<T>,
-        path: readonly string[],
-        input: unknown
-    ]>;
+    url: Value<string | URL, [options: ClientOptions<T>, path: readonly string[], input: unknown]>;
     /**
      * The maximum length of the URL.
      *
      * @default 2083
      */
-    maxUrlLength?: Value<number, [
-        options: ClientOptions<T>,
-        path: readonly string[],
-        input: unknown
-    ]>;
+    maxUrlLength?: Value<number, [options: ClientOptions<T>, path: readonly string[], input: unknown]>;
     /**
      * The method used to make the request.
      *
      * @default 'POST'
      */
-    method?: Value<HTTPMethod, [
-        options: ClientOptions<T>,
-        path: readonly string[],
-        input: unknown
-    ]>;
+    method?: Value<HTTPMethod, [options: ClientOptions<T>, path: readonly 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.
@@ -79,11 +67,7 @@ interface StandardRPCLinkCodecOptions<T extends ClientContext> {
     /**
      * Inject headers to the request.
      */
-    headers?: Value<StandardHeaders, [
-        options: ClientOptions<T>,
-        path: readonly string[],
-        input: unknown
-    ]>;
+    headers?: Value<StandardHeaders, [options: ClientOptions<T>, path: readonly string[], input: unknown]>;
 }
 declare class StandardRPCLinkCodec<T extends ClientContext> implements StandardLinkCodec<T> {
     private readonly serializer;
@@ -99,5 +83,9 @@ declare class StandardRPCLinkCodec<T extends ClientContext> implements StandardL
 
 interface StandardRPCLinkOptions<T extends ClientContext> extends StandardLinkOptions<T>, StandardRPCLinkCodecOptions<T>, StandardRPCJsonSerializerOptions {
 }
+declare class StandardRPCLink<T extends ClientContext> extends StandardLink<T> {
+    constructor(linkClient: StandardLinkClient<T>, options: StandardRPCLinkOptions<T>);
+}
 
-export { STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES as S, type StandardRPCJsonSerializedMetaItem as a, type StandardRPCJsonSerialized as b, type StandardRPCCustomJsonSerializer as c, type StandardRPCJsonSerializerOptions as d, StandardRPCJsonSerializer as e, type StandardRPCLinkOptions as f, type StandardRPCLinkCodecOptions as g, StandardRPCLinkCodec as h, StandardRPCSerializer as i };
+export { STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES as S, StandardRPCJsonSerializer as e, StandardRPCLink as g, StandardRPCLinkCodec as i, StandardRPCSerializer as j };
+export type { StandardRPCJsonSerializedMetaItem as a, StandardRPCJsonSerialized as b, StandardRPCCustomJsonSerializer as c, StandardRPCJsonSerializerOptions as d, StandardRPCLinkOptions as f, StandardRPCLinkCodecOptions as h };

package/dist/shared/{client.5813Ufvs.d.mts → client.C9U9n1f3.d.ts}

@@ -1,6 +1,16 @@
 import { Interceptor, ThrowableError } from '@orpc/shared';
 import { StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
-import { a as ClientContext, b as ClientOptions, C as ClientLink } from './client.C0lT7w02.mjs';
+import { a as ClientContext, b as ClientOptions, C as ClientLink } from './client.CipPQkhk.js';
+
+interface StandardLinkPlugin<T extends ClientContext> {
+    order?: number;
+    init?(options: StandardLinkOptions<T>): void;
+}
+declare class CompositeStandardLinkPlugin<T extends ClientContext, TPlugin extends StandardLinkPlugin<T>> implements StandardLinkPlugin<T> {
+    protected readonly plugins: TPlugin[];
+    constructor(plugins?: readonly TPlugin[]);
+    init(options: StandardLinkOptions<T>): void;
+}
 
 interface StandardLinkCodec<T extends ClientContext> {
     encode(path: readonly string[], input: unknown, options: ClientOptions<T>): Promise<StandardRequest>;
@@ -10,20 +20,16 @@ interface StandardLinkClient<T extends ClientContext> {
     call(request: StandardRequest, options: ClientOptions<T>, path: readonly string[], input: unknown): Promise<StandardLazyResponse>;
 }
 
-declare class InvalidEventIteratorRetryResponse extends Error {
+interface StandardLinkInterceptorOptions<T extends ClientContext> extends ClientOptions<T> {
+    path: readonly string[];
+    input: unknown;
 }
-interface StandardLinkPlugin<T extends ClientContext> {
-    init?(options: StandardLinkOptions<T>): void;
+interface StandardLinkClientInterceptorOptions<T extends ClientContext> extends StandardLinkInterceptorOptions<T> {
+    request: StandardRequest;
 }
 interface StandardLinkOptions<T extends ClientContext> {
-    interceptors?: Interceptor<{
-        path: readonly string[];
-        input: unknown;
-        options: ClientOptions<T>;
-    }, unknown, ThrowableError>[];
-    clientInterceptors?: Interceptor<{
-        request: StandardRequest;
-    }, StandardLazyResponse, ThrowableError>[];
+    interceptors?: Interceptor<StandardLinkInterceptorOptions<T>, unknown, ThrowableError>[];
+    clientInterceptors?: Interceptor<StandardLinkClientInterceptorOptions<T>, StandardLazyResponse, ThrowableError>[];
     plugins?: StandardLinkPlugin<T>[];
 }
 declare class StandardLink<T extends ClientContext> implements ClientLink<T> {
@@ -36,4 +42,5 @@ declare class StandardLink<T extends ClientContext> implements ClientLink<T> {
     call(path: readonly string[], input: unknown, options: ClientOptions<T>): Promise<unknown>;
 }
 
-export { InvalidEventIteratorRetryResponse as I, type StandardLinkPlugin as S, type StandardLinkOptions as a, StandardLink as b, type StandardLinkCodec as c, type StandardLinkClient as d };
+export { CompositeStandardLinkPlugin as C, StandardLink as d };
+export type { StandardLinkClientInterceptorOptions as S, StandardLinkPlugin as a, StandardLinkOptions as b, StandardLinkInterceptorOptions as c, StandardLinkCodec as e, StandardLinkClient as f };

package/dist/shared/{client.jKEwIsRd.mjs → client.CRWEpqLB.mjs}

@@ -110,22 +110,6 @@ class ORPCError extends Error {
       data: this.data
     };
   }
-  static fromJSON(json, options) {
-    return new ORPCError(json.code, {
-      ...options,
-      ...json
-    });
-  }
-  static isValidJSON(json) {
-    if (!isObject(json)) {
-      return false;
-    }
-    const validKeys = ["defined", "code", "status", "message", "data"];
-    if (Object.keys(json).some((k) => !validKeys.includes(k))) {
-      return false;
-    }
-    return "defined" in json && typeof json.defined === "boolean" && "code" in json && typeof json.code === "string" && "status" in json && typeof json.status === "number" && "message" in json && typeof json.message === "string";
-  }
 }
 function isDefinedError(error) {
   return error instanceof ORPCError && error.defined;
@@ -139,6 +123,22 @@ function toORPCError(error) {
 function isORPCErrorStatus(status) {
   return status < 200 || status >= 400;
 }
+function isORPCErrorJson(json) {
+  if (!isObject(json)) {
+    return false;
+  }
+  const validKeys = ["defined", "code", "status", "message", "data"];
+  if (Object.keys(json).some((k) => !validKeys.includes(k))) {
+    return false;
+  }
+  return "defined" in json && typeof json.defined === "boolean" && "code" in json && typeof json.code === "string" && "status" in json && typeof json.status === "number" && isORPCErrorStatus(json.status) && "message" in json && typeof json.message === "string";
+}
+function createORPCErrorFromJson(json, options = {}) {
+  return new ORPCError(json.code, {
+    ...options,
+    ...json
+  });
+}
 
 function mapEventIterator(iterator, maps) {
   return async function* () {
@@ -172,4 +172,4 @@ function mapEventIterator(iterator, maps) {
   }();
 }
 
-export { COMMON_ORPC_ERROR_DEFS as C, ORPCError as O, fallbackORPCErrorMessage as a, isORPCErrorStatus as b, fallbackORPCErrorStatus as f, isDefinedError as i, mapEventIterator as m, toORPCError as t };
+export { COMMON_ORPC_ERROR_DEFS as C, ORPCError as O, fallbackORPCErrorMessage as a, isORPCErrorStatus as b, isORPCErrorJson as c, createORPCErrorFromJson as d, fallbackORPCErrorStatus as f, isDefinedError as i, mapEventIterator as m, toORPCError as t };

package/dist/shared/{client.C0lT7w02.d.mts → client.CipPQkhk.d.mts}

@@ -3,13 +3,15 @@ import { PromiseWithError } from '@orpc/shared';
 type HTTPPath = `/${string}`;
 type HTTPMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
 type ClientContext = Record<PropertyKey, any>;
-type FriendlyClientOptions<TClientContext extends ClientContext> = {
+interface ClientOptions<T extends ClientContext> {
     signal?: AbortSignal;
     lastEventId?: string | undefined;
-} & (Record<never, never> extends TClientContext ? {
-    context?: TClientContext;
+    context: T;
+}
+type FriendlyClientOptions<T extends ClientContext> = Omit<ClientOptions<T>, 'context'> & (Record<never, never> extends T ? {
+    context?: T;
 } : {
-    context: TClientContext;
+    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>;
@@ -20,9 +22,6 @@ type NestedClient<TClientContext extends ClientContext> = Client<TClientContext,
     [k: string]: NestedClient<TClientContext>;
 };
 type InferClientContext<T extends NestedClient<any>> = T extends NestedClient<infer U> ? U : never;
-type ClientOptions<TClientContext extends ClientContext> = FriendlyClientOptions<TClientContext> & {
-    context: TClientContext;
-};
 interface ClientLink<TClientContext extends ClientContext> {
     call: (path: readonly string[], input: unknown, options: ClientOptions<TClientContext>) => Promise<unknown>;
 }

package/dist/shared/{client.C0lT7w02.d.ts → client.CipPQkhk.d.ts}

@@ -3,13 +3,15 @@ import { PromiseWithError } from '@orpc/shared';
 type HTTPPath = `/${string}`;
 type HTTPMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
 type ClientContext = Record<PropertyKey, any>;
-type FriendlyClientOptions<TClientContext extends ClientContext> = {
+interface ClientOptions<T extends ClientContext> {
     signal?: AbortSignal;
     lastEventId?: string | undefined;
-} & (Record<never, never> extends TClientContext ? {
-    context?: TClientContext;
+    context: T;
+}
+type FriendlyClientOptions<T extends ClientContext> = Omit<ClientOptions<T>, 'context'> & (Record<never, never> extends T ? {
+    context?: T;
 } : {
-    context: TClientContext;
+    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>;
@@ -20,9 +22,6 @@ type NestedClient<TClientContext extends ClientContext> = Client<TClientContext,
     [k: string]: NestedClient<TClientContext>;
 };
 type InferClientContext<T extends NestedClient<any>> = T extends NestedClient<infer U> ? U : never;
-type ClientOptions<TClientContext extends ClientContext> = FriendlyClientOptions<TClientContext> & {
-    context: TClientContext;
-};
 interface ClientLink<TClientContext extends ClientContext> {
     call: (path: readonly string[], input: unknown, options: ClientOptions<TClientContext>) => Promise<unknown>;
 }