@orpc/client 0.0.0-next.df024bb → 0.0.0-next.e0f01a5

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

@@ -0,0 +1,29 @@
+import { PromiseWithError } from '@orpc/shared';
+
+type HTTPPath = `/${string}`;
+type HTTPMethod = '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>;
+}
+
+export type { ClientLink as C, FriendlyClientOptions as F, HTTPPath as H, InferClientContext as I, NestedClient as N, ClientContext as a, ClientOptions as b, ClientPromiseResult as c, HTTPMethod as d, ClientRest as e, Client as f };

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

@@ -0,0 +1,29 @@
+import { PromiseWithError } from '@orpc/shared';
+
+type HTTPPath = `/${string}`;
+type HTTPMethod = '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>;
+}
+
+export type { ClientLink as C, FriendlyClientOptions as F, HTTPPath as H, InferClientContext as I, NestedClient as N, ClientContext as a, ClientOptions as b, ClientPromiseResult as c, HTTPMethod as d, ClientRest as e, Client as f };

package/dist/shared/{client.Ch8Gzz9n.mjs → client.DpICn1BD.mjs}

@@ -1,106 +1,116 @@
-import { intercept, isAsyncIteratorObject, value, isObject, stringifyJSON, trim } from '@orpc/shared';
-import { c as createAutoRetryEventIterator, m as mapEventIterator, t as toORPCError, O as ORPCError } from './client.DcaJQZfy.mjs';
-import { ErrorEvent } from '@orpc/standard-server';
+import { toArray, intercept, isObject, value, isAsyncIteratorObject, 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.CRWEpqLB.mjs';
 
-class InvalidEventIteratorRetryResponse extends Error {
+class CompositeStandardLinkPlugin {
+  plugins;
+  constructor(plugins = []) {
+    this.plugins = [...plugins].sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+  }
+  init(options) {
+    for (const plugin of this.plugins) {
+      plugin.init?.(options);
+    }
+  }
 }
+
 class StandardLink {
-  constructor(codec, sender, options) {
+  constructor(codec, sender, options = {}) {
     this.codec = codec;
     this.sender = sender;
-    this.eventIteratorMaxRetries = options.eventIteratorMaxRetries ?? 5;
-    this.eventIteratorRetryDelay = options.eventIteratorRetryDelay ?? ((o) => o.lastRetry ?? 1e3 * 2 ** o.retryTimes);
-    this.eventIteratorShouldRetry = options.eventIteratorShouldRetry ?? true;
-    this.interceptors = options.interceptors ?? [];
-    this.clientInterceptors = options.clientInterceptors ?? [];
+    const plugin = new CompositeStandardLinkPlugin(options.plugins);
+    plugin.init(options);
+    this.interceptors = toArray(options.interceptors);
+    this.clientInterceptors = toArray(options.clientInterceptors);
   }
-  eventIteratorMaxRetries;
-  eventIteratorRetryDelay;
-  eventIteratorShouldRetry;
   interceptors;
   clientInterceptors;
   call(path, input, options) {
-    return intercept(this.interceptors, { path, input, options }, async ({ path: path2, input: input2, options: options2 }) => {
+    return intercept(this.interceptors, { ...options, path, input }, async ({ path: path2, input: input2, ...options2 }) => {
       const output = await this.#call(path2, input2, options2);
-      if (!isAsyncIteratorObject(output)) {
-        return output;
-      }
-      return createAutoRetryEventIterator(output, async (reconnectOptions) => {
-        const maxRetries = await value(this.eventIteratorMaxRetries, reconnectOptions, options2, path2, input2);
-        if (options2.signal?.aborted || reconnectOptions.retryTimes > maxRetries) {
-          return null;
-        }
-        const shouldRetry = await value(this.eventIteratorShouldRetry, reconnectOptions, options2, path2, input2);
-        if (!shouldRetry) {
-          return null;
-        }
-        const retryDelay = await value(this.eventIteratorRetryDelay, reconnectOptions, options2, path2, input2);
-        await new Promise((resolve) => setTimeout(resolve, retryDelay));
-        const updatedOptions = { ...options2, lastEventId: reconnectOptions.lastEventId };
-        const maybeIterator = await this.#call(path2, input2, updatedOptions);
-        if (!isAsyncIteratorObject(maybeIterator)) {
-          throw new InvalidEventIteratorRetryResponse("Invalid Event Iterator retry response");
-        }
-        return maybeIterator;
-      }, options2.lastEventId);
+      return output;
     });
   }
   async #call(path, input, options) {
     const request = await this.codec.encode(path, input, options);
     const response = await intercept(
       this.clientInterceptors,
-      { request },
-      ({ request: request2 }) => this.sender.call(request2, options, path, input)
+      { ...options, input, path, request },
+      ({ input: input2, path: path2, request: request2, ...options2 }) => this.sender.call(request2, options2, path2, input2)
     );
     const output = await this.codec.decode(response, options, path, input);
     return output;
   }
 }
 
-class RPCJsonSerializer {
+const STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES = {
+  BIGINT: 0,
+  DATE: 1,
+  NAN: 2,
+  UNDEFINED: 3,
+  URL: 4,
+  REGEXP: 5,
+  SET: 6,
+  MAP: 7
+};
+class StandardRPCJsonSerializer {
+  customSerializers;
+  constructor(options = {}) {
+    this.customSerializers = options.customJsonSerializers ?? [];
+    if (this.customSerializers.length !== new Set(this.customSerializers.map((custom) => custom.type)).size) {
+      throw new Error("Custom serializer type must be unique.");
+    }
+  }
   serialize(data, segments = [], meta = [], maps = [], blobs = []) {
+    for (const custom of this.customSerializers) {
+      if (custom.condition(data)) {
+        const result = this.serialize(custom.serialize(data), segments, meta, maps, blobs);
+        meta.push([custom.type, ...segments]);
+        return result;
+      }
+    }
     if (data instanceof Blob) {
       maps.push(segments);
       blobs.push(data);
       return [data, meta, maps, blobs];
     }
     if (typeof data === "bigint") {
-      meta.push([0, segments]);
+      meta.push([STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.BIGINT, ...segments]);
       return [data.toString(), meta, maps, blobs];
     }
     if (data instanceof Date) {
-      meta.push([1, segments]);
+      meta.push([STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.DATE, ...segments]);
       if (Number.isNaN(data.getTime())) {
         return [null, meta, maps, blobs];
       }
       return [data.toISOString(), meta, maps, blobs];
     }
     if (Number.isNaN(data)) {
-      meta.push([2, segments]);
+      meta.push([STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.NAN, ...segments]);
       return [null, meta, maps, blobs];
     }
     if (data instanceof URL) {
-      meta.push([4, segments]);
+      meta.push([STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.URL, ...segments]);
       return [data.toString(), meta, maps, blobs];
     }
     if (data instanceof RegExp) {
-      meta.push([5, segments]);
+      meta.push([STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.REGEXP, ...segments]);
       return [data.toString(), meta, maps, blobs];
     }
     if (data instanceof Set) {
       const result = this.serialize(Array.from(data), segments, meta, maps, blobs);
-      meta.push([6, segments]);
+      meta.push([STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.SET, ...segments]);
       return result;
     }
     if (data instanceof Map) {
       const result = this.serialize(Array.from(data.entries()), segments, meta, maps, blobs);
-      meta.push([7, segments]);
+      meta.push([STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.MAP, ...segments]);
       return result;
     }
     if (Array.isArray(data)) {
       const json = data.map((v, i) => {
         if (v === void 0) {
-          meta.push([3, [...segments, i]]);
+          meta.push([STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.UNDEFINED, ...segments, i]);
           return v;
         }
         return this.serialize(v, [...segments, i], meta, maps, blobs)[0];
@@ -110,6 +120,9 @@ class RPCJsonSerializer {
     if (isObject(data)) {
       const json = {};
       for (const k in data) {
+        if (k === "toJSON" && typeof data[k] === "function") {
+          continue;
+        }
         json[k] = this.serialize(data[k], [...segments, k], meta, maps, blobs)[0];
       }
       return [json, meta, maps, blobs];
@@ -129,38 +142,45 @@ class RPCJsonSerializer {
         currentRef[preSegment] = getBlob(i);
       });
     }
-    for (const [type, segments] of meta) {
+    for (const item of meta) {
+      const type = item[0];
       let currentRef = ref;
       let preSegment = "data";
-      segments.forEach((segment) => {
+      for (let i = 1; i < item.length; i++) {
         currentRef = currentRef[preSegment];
-        preSegment = segment;
-      });
+        preSegment = item[i];
+      }
+      for (const custom of this.customSerializers) {
+        if (custom.type === type) {
+          currentRef[preSegment] = custom.deserialize(currentRef[preSegment]);
+          break;
+        }
+      }
       switch (type) {
-        case 0:
+        case STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.BIGINT:
           currentRef[preSegment] = BigInt(currentRef[preSegment]);
           break;
-        case 1:
+        case STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.DATE:
           currentRef[preSegment] = new Date(currentRef[preSegment] ?? "Invalid Date");
           break;
-        case 2:
+        case STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.NAN:
           currentRef[preSegment] = Number.NaN;
           break;
-        case 3:
+        case STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.UNDEFINED:
           currentRef[preSegment] = void 0;
           break;
-        case 4:
+        case STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.URL:
           currentRef[preSegment] = new URL(currentRef[preSegment]);
           break;
-        case 5: {
+        case STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.REGEXP: {
           const [, pattern, flags] = currentRef[preSegment].match(/^\/(.*)\/([a-z]*)$/);
           currentRef[preSegment] = new RegExp(pattern, flags);
           break;
         }
-        case 6:
+        case STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.SET:
           currentRef[preSegment] = new Set(currentRef[preSegment]);
           break;
-        case 7:
+        case STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.MAP:
           currentRef[preSegment] = new Map(currentRef[preSegment]);
           break;
       }
@@ -169,8 +189,93 @@ class RPCJsonSerializer {
   }
 }
 
-class RPCSerializer {
-  constructor(jsonSerializer = new RPCJsonSerializer()) {
+function toHttpPath(path) {
+  return `/${path.map(encodeURIComponent).join("/")}`;
+}
+function getMalformedResponseErrorCode(status) {
+  return Object.entries(COMMON_ORPC_ERROR_DEFS).find(([, def]) => def.status === status)?.[0] ?? "MALFORMED_ORPC_ERROR_RESPONSE";
+}
+
+class StandardRPCLinkCodec {
+  constructor(serializer, options) {
+    this.serializer = serializer;
+    this.baseUrl = options.url;
+    this.maxUrlLength = options.maxUrlLength ?? 2083;
+    this.fallbackMethod = options.fallbackMethod ?? "POST";
+    this.expectedMethod = options.method ?? this.fallbackMethod;
+    this.headers = options.headers ?? {};
+  }
+  baseUrl;
+  maxUrlLength;
+  fallbackMethod;
+  expectedMethod;
+  headers;
+  async encode(path, input, options) {
+    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);
+      const getUrl = new URL(url);
+      getUrl.searchParams.append("data", stringifyJSON(serialized));
+      if (getUrl.toString().length <= maxUrlLength) {
+        return {
+          body: void 0,
+          method: expectedMethod,
+          headers,
+          url: getUrl,
+          signal: options.signal
+        };
+      }
+    }
+    return {
+      url,
+      method: expectedMethod === "GET" ? this.fallbackMethod : expectedMethod,
+      headers,
+      body: serialized,
+      signal: options.signal
+    };
+  }
+  async decode(response) {
+    const isOk = !isORPCErrorStatus(response.status);
+    const deserialized = await (async () => {
+      let isBodyOk = false;
+      try {
+        const body = await response.body();
+        isBodyOk = true;
+        return this.serializer.deserialize(body);
+      } catch (error) {
+        if (!isBodyOk) {
+          throw new Error("Cannot parse response body, please check the response body and content-type.", {
+            cause: error
+          });
+        }
+        throw new Error("Invalid RPC response format.", {
+          cause: error
+        });
+      }
+    })();
+    if (!isOk) {
+      if (isORPCErrorJson(deserialized)) {
+        throw createORPCErrorFromJson(deserialized);
+      }
+      throw new ORPCError(getMalformedResponseErrorCode(response.status), {
+        status: response.status,
+        data: { ...response, body: deserialized }
+      });
+    }
+    return deserialized;
+  }
+}
+
+class StandardRPCSerializer {
+  constructor(jsonSerializer) {
     this.jsonSerializer = jsonSerializer;
   }
   serialize(data) {
@@ -188,9 +293,6 @@ class RPCSerializer {
     return this.#serialize(data, true);
   }
   #serialize(data, enableFormData) {
-    if (data === void 0 || data instanceof Blob) {
-      return data;
-    }
     const [json, meta_, maps, blobs] = this.jsonSerializer.serialize(data);
     const meta = meta_.length === 0 ? void 0 : meta_;
     if (!enableFormData || blobs.length === 0) {
@@ -215,8 +317,8 @@ class RPCSerializer {
             return e;
           }
           const deserialized = this.#deserialize(e.data);
-          if (ORPCError.isValidJSON(deserialized)) {
-            return ORPCError.fromJSON(deserialized, { cause: e });
+          if (isORPCErrorJson(deserialized)) {
+            return createORPCErrorFromJson(deserialized, { cause: e });
           }
           return new ErrorEvent({
             data: deserialized,
@@ -228,9 +330,6 @@ class RPCSerializer {
     return this.#deserialize(data);
   }
   #deserialize(data) {
-    if (data === void 0 || data instanceof Blob) {
-      return data;
-    }
     if (!(data instanceof FormData)) {
       return this.jsonSerializer.deserialize(data.json, data.meta ?? []);
     }
@@ -244,78 +343,13 @@ class RPCSerializer {
   }
 }
 
-class StandardRPCLinkCodec {
-  baseUrl;
-  maxUrlLength;
-  fallbackMethod;
-  expectedMethod;
-  headers;
-  rpcSerializer;
-  constructor(options) {
-    this.baseUrl = options.url;
-    this.maxUrlLength = options.maxUrlLength ?? 2083;
-    this.fallbackMethod = options.fallbackMethod ?? "POST";
-    this.expectedMethod = options.method ?? this.fallbackMethod;
-    this.headers = options.headers ?? {};
-    this.rpcSerializer = options.rpcSerializer ?? new RPCSerializer();
-  }
-  async encode(path, input, options) {
-    const expectedMethod = await value(this.expectedMethod, options, path, input);
-    const headers = await value(this.headers, options, path, input);
-    const baseUrl = await value(this.baseUrl, options, path, input);
-    const url = new URL(`${trim(baseUrl.toString(), "/")}/${path.map(encodeURIComponent).join("/")}`);
-    const serialized = this.rpcSerializer.serialize(input);
-    if (expectedMethod === "GET" && !(serialized instanceof FormData) && !(serialized instanceof Blob) && !isAsyncIteratorObject(serialized)) {
-      const maxUrlLength = await value(this.maxUrlLength, options, path, input);
-      const getUrl = new URL(url);
-      getUrl.searchParams.append("data", stringifyJSON(serialized) ?? "");
-      if (getUrl.toString().length <= maxUrlLength) {
-        return {
-          body: void 0,
-          method: expectedMethod,
-          headers,
-          url: getUrl,
-          signal: options.signal
-        };
-      }
-    }
-    return {
-      url,
-      method: expectedMethod === "GET" ? this.fallbackMethod : expectedMethod,
-      headers,
-      body: serialized,
-      signal: options.signal
-    };
-  }
-  async decode(response) {
-    const isOk = response.status >= 200 && response.status < 300;
-    const deserialized = await (async () => {
-      let isBodyOk = false;
-      try {
-        const body = await response.body();
-        isBodyOk = true;
-        return this.rpcSerializer.deserialize(body);
-      } catch (error) {
-        if (!isBodyOk) {
-          throw new Error("Cannot parse response body, please check the response body and content-type.", {
-            cause: error
-          });
-        }
-        throw new Error("Invalid RPC response format.", {
-          cause: error
-        });
-      }
-    })();
-    if (!isOk) {
-      if (ORPCError.isValidJSON(deserialized)) {
-        throw ORPCError.fromJSON(deserialized);
-      }
-      throw new Error("Invalid RPC error response format.", {
-        cause: deserialized
-      });
-    }
-    return deserialized;
+class StandardRPCLink extends StandardLink {
+  constructor(linkClient, options) {
+    const jsonSerializer = new StandardRPCJsonSerializer(options);
+    const serializer = new StandardRPCSerializer(jsonSerializer);
+    const linkCodec = new StandardRPCLinkCodec(serializer, options);
+    super(linkCodec, linkClient, options);
   }
 }
 
-export { InvalidEventIteratorRetryResponse as I, RPCJsonSerializer as R, StandardLink as S, StandardRPCLinkCodec as a, RPCSerializer as b };
+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 };

package/dist/shared/client.FXep-a3a.d.mts

@@ -0,0 +1,46 @@
+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.CipPQkhk.mjs';
+
+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>;
+    decode(response: StandardLazyResponse, options: ClientOptions<T>, path: readonly string[], input: unknown): Promise<unknown>;
+}
+interface StandardLinkClient<T extends ClientContext> {
+    call(request: StandardRequest, options: ClientOptions<T>, path: readonly string[], input: unknown): Promise<StandardLazyResponse>;
+}
+
+interface StandardLinkInterceptorOptions<T extends ClientContext> extends ClientOptions<T> {
+    path: readonly string[];
+    input: unknown;
+}
+interface StandardLinkClientInterceptorOptions<T extends ClientContext> extends StandardLinkInterceptorOptions<T> {
+    request: StandardRequest;
+}
+interface StandardLinkOptions<T extends ClientContext> {
+    interceptors?: Interceptor<StandardLinkInterceptorOptions<T>, unknown, ThrowableError>[];
+    clientInterceptors?: Interceptor<StandardLinkClientInterceptorOptions<T>, StandardLazyResponse, ThrowableError>[];
+    plugins?: StandardLinkPlugin<T>[];
+}
+declare class StandardLink<T extends ClientContext> implements ClientLink<T> {
+    #private;
+    readonly codec: StandardLinkCodec<T>;
+    readonly sender: StandardLinkClient<T>;
+    private readonly interceptors;
+    private readonly clientInterceptors;
+    constructor(codec: StandardLinkCodec<T>, sender: StandardLinkClient<T>, options?: StandardLinkOptions<T>);
+    call(path: readonly string[], input: unknown, options: ClientOptions<T>): Promise<unknown>;
+}
+
+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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/client",
   "type": "module",
-  "version": "0.0.0-next.df024bb",
+  "version": "0.0.0-next.e0f01a5",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -19,6 +19,11 @@
       "import": "./dist/index.mjs",
       "default": "./dist/index.mjs"
     },
+    "./plugins": {
+      "types": "./dist/plugins/index.d.mts",
+      "import": "./dist/plugins/index.mjs",
+      "default": "./dist/plugins/index.mjs"
+    },
     "./standard": {
       "types": "./dist/adapters/standard/index.d.mts",
       "import": "./dist/adapters/standard/index.mjs",
@@ -34,12 +39,12 @@
     "dist"
   ],
   "dependencies": {
-    "@orpc/shared": "0.0.0-next.df024bb",
-    "@orpc/standard-server": "0.0.0-next.df024bb",
-    "@orpc/standard-server-fetch": "0.0.0-next.df024bb"
+    "@orpc/shared": "0.0.0-next.e0f01a5",
+    "@orpc/standard-server": "0.0.0-next.e0f01a5",
+    "@orpc/standard-server-fetch": "0.0.0-next.e0f01a5"
   },
   "devDependencies": {
-    "zod": "^3.24.1"
+    "zod": "^3.24.2"
   },
   "scripts": {
     "build": "unbuild",

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

@@ -1,42 +0,0 @@
-type ClientContext = Record<string, any>;
-type ClientOptions<TClientContext extends ClientContext> = {
-    signal?: AbortSignal;
-    lastEventId?: string | undefined;
-} & (Record<never, never> extends TClientContext ? {
-    context?: TClientContext;
-} : {
-    context: TClientContext;
-});
-type ClientRest<TClientContext extends ClientContext, TInput> = Record<never, never> extends TClientContext ? undefined extends TInput ? [input?: TInput, options?: ClientOptions<TClientContext>] : [input: TInput, options?: ClientOptions<TClientContext>] : [input: TInput, options: ClientOptions<TClientContext>];
-type ClientPromiseResult<TOutput, TError extends Error> = Promise<TOutput> & {
-    __error?: {
-        type: TError;
-    };
-};
-interface Client<TClientContext extends ClientContext, TInput, TOutput, TError extends Error> {
-    (...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;
-type ClientOptionsOut<TClientContext extends ClientContext> = ClientOptions<TClientContext> & {
-    context: TClientContext;
-};
-interface ClientLink<TClientContext extends ClientContext> {
-    call: (path: readonly string[], input: unknown, options: ClientOptionsOut<TClientContext>) => Promise<unknown>;
-}
-
-declare function mapEventIterator<TYield, TReturn, TNext, TMap = TYield | TReturn>(iterator: AsyncIterator<TYield, TReturn, TNext>, maps: {
-    value: (value: NoInfer<TYield | TReturn>, done: boolean | undefined) => Promise<TMap>;
-    error: (error: unknown) => Promise<unknown>;
-}): AsyncGenerator<TMap, TMap, TNext>;
-interface EventIteratorReconnectOptions {
-    lastRetry: number | undefined;
-    lastEventId: string | undefined;
-    retryTimes: number;
-    error: unknown;
-}
-declare function createAutoRetryEventIterator<TYield, TReturn>(initial: AsyncIterator<TYield, TReturn, void>, reconnect: (options: EventIteratorReconnectOptions) => Promise<AsyncIterator<TYield, TReturn, void> | null>, initialLastEventId: string | undefined): AsyncGenerator<TYield, TReturn, void>;
-
-export { type ClientContext as C, type EventIteratorReconnectOptions as E, type InferClientContext as I, type NestedClient as N, type ClientOptionsOut as a, type ClientLink as b, type ClientPromiseResult as c, createAutoRetryEventIterator as d, type ClientOptions as e, type ClientRest as f, type Client as g, mapEventIterator as m };

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

@@ -1,42 +0,0 @@
-type ClientContext = Record<string, any>;
-type ClientOptions<TClientContext extends ClientContext> = {
-    signal?: AbortSignal;
-    lastEventId?: string | undefined;
-} & (Record<never, never> extends TClientContext ? {
-    context?: TClientContext;
-} : {
-    context: TClientContext;
-});
-type ClientRest<TClientContext extends ClientContext, TInput> = Record<never, never> extends TClientContext ? undefined extends TInput ? [input?: TInput, options?: ClientOptions<TClientContext>] : [input: TInput, options?: ClientOptions<TClientContext>] : [input: TInput, options: ClientOptions<TClientContext>];
-type ClientPromiseResult<TOutput, TError extends Error> = Promise<TOutput> & {
-    __error?: {
-        type: TError;
-    };
-};
-interface Client<TClientContext extends ClientContext, TInput, TOutput, TError extends Error> {
-    (...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;
-type ClientOptionsOut<TClientContext extends ClientContext> = ClientOptions<TClientContext> & {
-    context: TClientContext;
-};
-interface ClientLink<TClientContext extends ClientContext> {
-    call: (path: readonly string[], input: unknown, options: ClientOptionsOut<TClientContext>) => Promise<unknown>;
-}
-
-declare function mapEventIterator<TYield, TReturn, TNext, TMap = TYield | TReturn>(iterator: AsyncIterator<TYield, TReturn, TNext>, maps: {
-    value: (value: NoInfer<TYield | TReturn>, done: boolean | undefined) => Promise<TMap>;
-    error: (error: unknown) => Promise<unknown>;
-}): AsyncGenerator<TMap, TMap, TNext>;
-interface EventIteratorReconnectOptions {
-    lastRetry: number | undefined;
-    lastEventId: string | undefined;
-    retryTimes: number;
-    error: unknown;
-}
-declare function createAutoRetryEventIterator<TYield, TReturn>(initial: AsyncIterator<TYield, TReturn, void>, reconnect: (options: EventIteratorReconnectOptions) => Promise<AsyncIterator<TYield, TReturn, void> | null>, initialLastEventId: string | undefined): AsyncGenerator<TYield, TReturn, void>;
-
-export { type ClientContext as C, type EventIteratorReconnectOptions as E, type InferClientContext as I, type NestedClient as N, type ClientOptionsOut as a, type ClientLink as b, type ClientPromiseResult as c, createAutoRetryEventIterator as d, type ClientOptions as e, type ClientRest as f, type Client as g, mapEventIterator as m };