@orpc/client 0.47.0 → 0.49.0

package/README.md

@@ -32,7 +32,7 @@
 - **Contract-First Development 📜**: (Optional) Define your API contract upfront and implement it with confidence.
 - **Exceptional Developer Experience ✨**: Enjoy a streamlined workflow with robust typing and clear, in-code documentation.
 - **Multi-Runtime Support 🌍**: Run your code seamlessly on Cloudflare, Deno, Bun, Node.js, and more.
-- **Framework Integrations 🧩**: Supports Tanstack Query (React, Vue), Pinia Colada, and more.
+- **Framework Integrations 🧩**: Supports Tanstack Query (React, Vue, Solid, Svelte), Pinia Colada, and more.
 - **Server Actions ⚡️**: Fully compatible with React Server Actions on Next.js, TanStack Start, and more.
 - **Standard Schema Support 🗂️**: Effortlessly work with Zod, Valibot, ArkType, and others right out of the box.
 - **Fast & Lightweight 💨**: Built on native APIs across all runtimes – optimized for speed and efficiency.
@@ -55,9 +55,13 @@ You can find the full documentation [here](https://orpc.unnoq.com).
 - [@orpc/client](https://www.npmjs.com/package/@orpc/client): Consume your API on the client with type-safety.
 - [@orpc/react-query](https://www.npmjs.com/package/@orpc/react-query): Integration with [React Query](https://tanstack.com/query/latest/docs/framework/react/overview).
 - [@orpc/vue-query](https://www.npmjs.com/package/@orpc/vue-query): Integration with [Vue Query](https://tanstack.com/query/latest/docs/framework/vue/overview).
+- [@orpc/solid-query](https://www.npmjs.com/package/@orpc/solid-query): Integration with [Solid Query](https://tanstack.com/query/latest/docs/framework/solid/overview).
+- [@orpc/svelte-query](https://www.npmjs.com/package/@orpc/svelte-query): Integration with [Svelte Query](https://tanstack.com/query/latest/docs/framework/svelte/overview).
 - [@orpc/vue-colada](https://www.npmjs.com/package/@orpc/vue-colada): Integration with [Pinia Colada](https://pinia-colada.esm.dev/).
 - [@orpc/openapi](https://www.npmjs.com/package/@orpc/openapi): Generate OpenAPI specs and handle OpenAPI requests.
 - [@orpc/zod](https://www.npmjs.com/package/@orpc/zod): More schemas that [Zod](https://zod.dev/) doesn't support yet.
+- [@orpc/valibot](https://www.npmjs.com/package/@orpc/valibot): OpenAPI spec generation from [Valibot](https://valibot.dev/).
+- [@orpc/arktype](https://www.npmjs.com/package/@orpc/arktype): OpenAPI spec generation from [ArkType](https://arktype.io/).
 
 ## `@orpc/client`
 

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

@@ -1,7 +1,8 @@
 import { StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
 import { ToFetchRequestOptions } from '@orpc/standard-server-fetch';
-import { C as ClientContext, a as ClientOptionsOut, b as ClientLink } from '../../shared/client.D_CzLDyB.mjs';
-import { StandardLinkClient, StandardLinkOptions, StandardRPCLinkCodecOptions } from '../standard/index.mjs';
+import { a as ClientContext, C as ClientOptionsOut, b as ClientLink } from '../../shared/client.CupM8eRP.mjs';
+import { b as StandardLinkClient } from '../../shared/client.DrOAzyMB.mjs';
+import { StandardRPCLinkOptions } from '../standard/index.mjs';
 import '@orpc/shared';
 
 interface LinkFetchClientOptions<T extends ClientContext> extends ToFetchRequestOptions {
@@ -14,7 +15,7 @@ declare class LinkFetchClient<T extends ClientContext> implements StandardLinkCl
     call(request: StandardRequest, options: ClientOptionsOut<T>, path: readonly string[], input: unknown): Promise<StandardLazyResponse>;
 }
 
-interface RPCLinkOptions<T extends ClientContext> extends StandardLinkOptions<T>, StandardRPCLinkCodecOptions<T>, LinkFetchClientOptions<T> {
+interface RPCLinkOptions<T extends ClientContext> extends StandardRPCLinkOptions<T>, LinkFetchClientOptions<T> {
 }
 declare class RPCLink<T extends ClientContext> implements ClientLink<T> {
     private readonly standardLink;

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

@@ -1,7 +1,8 @@
 import { StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
 import { ToFetchRequestOptions } from '@orpc/standard-server-fetch';
-import { C as ClientContext, a as ClientOptionsOut, b as ClientLink } from '../../shared/client.D_CzLDyB.js';
-import { StandardLinkClient, StandardLinkOptions, StandardRPCLinkCodecOptions } from '../standard/index.js';
+import { a as ClientContext, C as ClientOptionsOut, b as ClientLink } from '../../shared/client.CupM8eRP.js';
+import { b as StandardLinkClient } from '../../shared/client.aGal-uGY.js';
+import { StandardRPCLinkOptions } from '../standard/index.js';
 import '@orpc/shared';
 
 interface LinkFetchClientOptions<T extends ClientContext> extends ToFetchRequestOptions {
@@ -14,7 +15,7 @@ declare class LinkFetchClient<T extends ClientContext> implements StandardLinkCl
     call(request: StandardRequest, options: ClientOptionsOut<T>, path: readonly string[], input: unknown): Promise<StandardLazyResponse>;
 }
 
-interface RPCLinkOptions<T extends ClientContext> extends StandardLinkOptions<T>, StandardRPCLinkCodecOptions<T>, LinkFetchClientOptions<T> {
+interface RPCLinkOptions<T extends ClientContext> extends StandardRPCLinkOptions<T>, LinkFetchClientOptions<T> {
 }
 declare class RPCLink<T extends ClientContext> implements ClientLink<T> {
     private readonly standardLink;

package/dist/adapters/fetch/index.mjs

@@ -1,8 +1,9 @@
 import { toFetchRequest, toStandardLazyResponse } from '@orpc/standard-server-fetch';
-import { a as StandardRPCLinkCodec, b as RPCSerializer, S as StandardLink } from '../../shared/client.BMw2gtvr.mjs';
+import { b as StandardRPCJsonSerializer, c as StandardRPCLinkCodec, d as StandardRPCSerializer, S as StandardLink } from '../../shared/client.Be-O_tdu.mjs';
 import '@orpc/shared';
-import '../../shared/client.DcaJQZfy.mjs';
+import '../../shared/client.CvnV7_uV.mjs';
 import '@orpc/standard-server';
+import '../../shared/client.BacCdg3F.mjs';
 
 class LinkFetchClient {
   fetch;
@@ -22,7 +23,8 @@ class LinkFetchClient {
 class RPCLink {
   standardLink;
   constructor(options) {
-    const serializer = new RPCSerializer();
+    const jsonSerializer = new StandardRPCJsonSerializer(options);
+    const serializer = new StandardRPCSerializer(jsonSerializer);
     const linkCodec = new StandardRPCLinkCodec(serializer, options);
     const linkClient = new LinkFetchClient(options);
     this.standardLink = new StandardLink(linkCodec, linkClient, options);

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

@@ -1,89 +1,43 @@
-import { Value, Interceptor, Segment } from '@orpc/shared';
-import { StandardRequest, StandardLazyResponse, StandardHeaders } from '@orpc/standard-server';
-import { C as ClientContext, a as ClientOptionsOut, E as EventIteratorReconnectOptions, b as ClientLink } from '../../shared/client.D_CzLDyB.mjs';
+import { c as StandardLinkCodec, S as StandardLinkOptions } from '../../shared/client.DrOAzyMB.mjs';
+export { I as InvalidEventIteratorRetryResponse, d as StandardLink, b as StandardLinkClient } from '../../shared/client.DrOAzyMB.mjs';
+import { Segment, Value } from '@orpc/shared';
+import { a as ClientContext, C as ClientOptionsOut } from '../../shared/client.CupM8eRP.mjs';
+import { StandardHeaders, StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
 
-interface StandardLinkCodec<T extends ClientContext> {
-    encode(path: readonly string[], input: unknown, options: ClientOptionsOut<any>): Promise<StandardRequest>;
-    decode(response: StandardLazyResponse, options: ClientOptionsOut<T>, path: readonly string[], input: unknown): Promise<unknown>;
-}
-interface StandardLinkClient<T extends ClientContext> {
-    call(request: StandardRequest, options: ClientOptionsOut<T>, path: readonly string[], input: unknown): Promise<StandardLazyResponse>;
-}
-
-declare class InvalidEventIteratorRetryResponse extends Error {
-}
-interface StandardLinkOptions<T extends ClientContext> {
-    /**
-     * Maximum number of retry attempts for event iterator errors before throwing.
-     *
-     * @default 5
-     */
-    eventIteratorMaxRetries?: Value<number, [
-        reconnectOptions: EventIteratorReconnectOptions,
-        options: ClientOptionsOut<T>,
-        path: readonly string[],
-        input: unknown
-    ]>;
-    /**
-     * Delay (in ms) before retrying an event iterator call.
-     *
-     * @default (o) => o.lastRetry ?? (1000 * 2 ** o.retryTimes)
-     */
-    eventIteratorRetryDelay?: Value<number, [
-        reconnectOptions: EventIteratorReconnectOptions,
-        options: ClientOptionsOut<T>,
-        path: readonly string[],
-        input: unknown
-    ]>;
-    /**
-     * Function to determine if an error is retryable.
-     *
-     * @default true
-     */
-    eventIteratorShouldRetry?: Value<boolean, [
-        reconnectOptions: EventIteratorReconnectOptions,
-        options: ClientOptionsOut<T>,
-        path: readonly string[],
-        input: unknown
-    ]>;
-    interceptors?: Interceptor<{
-        path: readonly string[];
-        input: unknown;
-        options: ClientOptionsOut<T>;
-    }, unknown, unknown>[];
-    clientInterceptors?: Interceptor<{
-        request: StandardRequest;
-    }, StandardLazyResponse, unknown>[];
+declare const STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES: {
+    readonly BIGINT: 0;
+    readonly DATE: 1;
+    readonly NAN: 2;
+    readonly UNDEFINED: 3;
+    readonly URL: 4;
+    readonly REGEXP: 5;
+    readonly SET: 6;
+    readonly MAP: 7;
+};
+type StandardRPCJsonSerializedMetaItem = readonly [type: number, ...path: Segment[]];
+type StandardRPCJsonSerialized = [json: unknown, meta: StandardRPCJsonSerializedMetaItem[], maps: Segment[][], blobs: Blob[]];
+interface StandardRPCCustomJsonSerializer {
+    type: number;
+    condition(data: unknown): boolean;
+    serialize(data: any): unknown;
+    deserialize(serialized: any): unknown;
 }
-declare class StandardLink<T extends ClientContext> implements ClientLink<T> {
-    #private;
-    readonly codec: StandardLinkCodec<T>;
-    readonly sender: StandardLinkClient<T>;
-    private readonly eventIteratorMaxRetries;
-    private readonly eventIteratorRetryDelay;
-    private readonly eventIteratorShouldRetry;
-    private readonly interceptors;
-    private readonly clientInterceptors;
-    constructor(codec: StandardLinkCodec<T>, sender: StandardLinkClient<T>, options: StandardLinkOptions<T>);
-    call(path: readonly string[], input: unknown, options: ClientOptionsOut<T>): Promise<unknown>;
+interface StandardRPCJsonSerializerOptions {
+    customJsonSerializers?: readonly StandardRPCCustomJsonSerializer[];
 }
-
-type RPCJsonSerializedMeta = [
-    0 | 1 | 2 | 3 | 4 | 5 | 6 | 7,
-    Segment[]
-][];
-type RPCJsonSerialized = [json: unknown, meta: RPCJsonSerializedMeta, maps: Segment[][], blobs: Blob[]];
-declare class RPCJsonSerializer {
-    serialize(data: unknown, segments?: Segment[], meta?: RPCJsonSerializedMeta, maps?: Segment[][], blobs?: Blob[]): RPCJsonSerialized;
-    deserialize(json: unknown, meta: RPCJsonSerializedMeta): unknown;
-    deserialize(json: unknown, meta: RPCJsonSerializedMeta, maps: Segment[][], getBlob: (index: number) => Blob): unknown;
+declare class StandardRPCJsonSerializer {
+    private readonly customSerializers;
+    constructor(options?: StandardRPCJsonSerializerOptions);
+    serialize(data: unknown, segments?: Segment[], meta?: StandardRPCJsonSerializedMetaItem[], maps?: Segment[][], blobs?: Blob[]): StandardRPCJsonSerialized;
+    deserialize(json: unknown, meta: readonly StandardRPCJsonSerializedMetaItem[]): unknown;
+    deserialize(json: unknown, meta: readonly StandardRPCJsonSerializedMetaItem[], maps: readonly Segment[][], getBlob: (index: number) => Blob): unknown;
 }
 
-declare class RPCSerializer {
+declare class StandardRPCSerializer {
     #private;
     private readonly jsonSerializer;
-    constructor(jsonSerializer?: RPCJsonSerializer);
-    serialize(data: unknown): unknown;
+    constructor(jsonSerializer: StandardRPCJsonSerializer);
+    serialize(data: unknown): object;
     deserialize(data: unknown): unknown;
 }
 
@@ -140,9 +94,12 @@ declare class StandardRPCLinkCodec<T extends ClientContext> implements StandardL
     private readonly fallbackMethod;
     private readonly expectedMethod;
     private readonly headers;
-    constructor(serializer: RPCSerializer, options: StandardRPCLinkCodecOptions<T>);
+    constructor(serializer: StandardRPCSerializer, options: StandardRPCLinkCodecOptions<T>);
     encode(path: readonly string[], input: unknown, options: ClientOptionsOut<any>): Promise<StandardRequest>;
     decode(response: StandardLazyResponse): Promise<unknown>;
 }
 
-export { InvalidEventIteratorRetryResponse, type RPCJsonSerialized, type RPCJsonSerializedMeta, RPCJsonSerializer, RPCSerializer, StandardLink, type StandardLinkClient, type StandardLinkCodec, type StandardLinkOptions, StandardRPCLinkCodec, type StandardRPCLinkCodecOptions };
+interface StandardRPCLinkOptions<T extends ClientContext> extends StandardLinkOptions<T>, StandardRPCLinkCodecOptions<T>, StandardRPCJsonSerializerOptions {
+}
+
+export { STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES, StandardLinkCodec, StandardLinkOptions, type StandardRPCCustomJsonSerializer, type StandardRPCJsonSerialized, type StandardRPCJsonSerializedMetaItem, StandardRPCJsonSerializer, type StandardRPCJsonSerializerOptions, StandardRPCLinkCodec, type StandardRPCLinkCodecOptions, type StandardRPCLinkOptions, StandardRPCSerializer };

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

@@ -1,89 +1,43 @@
-import { Value, Interceptor, Segment } from '@orpc/shared';
-import { StandardRequest, StandardLazyResponse, StandardHeaders } from '@orpc/standard-server';
-import { C as ClientContext, a as ClientOptionsOut, E as EventIteratorReconnectOptions, b as ClientLink } from '../../shared/client.D_CzLDyB.js';
+import { c as StandardLinkCodec, S as StandardLinkOptions } from '../../shared/client.aGal-uGY.js';
+export { I as InvalidEventIteratorRetryResponse, d as StandardLink, b as StandardLinkClient } from '../../shared/client.aGal-uGY.js';
+import { Segment, Value } from '@orpc/shared';
+import { a as ClientContext, C as ClientOptionsOut } from '../../shared/client.CupM8eRP.js';
+import { StandardHeaders, StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
 
-interface StandardLinkCodec<T extends ClientContext> {
-    encode(path: readonly string[], input: unknown, options: ClientOptionsOut<any>): Promise<StandardRequest>;
-    decode(response: StandardLazyResponse, options: ClientOptionsOut<T>, path: readonly string[], input: unknown): Promise<unknown>;
-}
-interface StandardLinkClient<T extends ClientContext> {
-    call(request: StandardRequest, options: ClientOptionsOut<T>, path: readonly string[], input: unknown): Promise<StandardLazyResponse>;
-}
-
-declare class InvalidEventIteratorRetryResponse extends Error {
-}
-interface StandardLinkOptions<T extends ClientContext> {
-    /**
-     * Maximum number of retry attempts for event iterator errors before throwing.
-     *
-     * @default 5
-     */
-    eventIteratorMaxRetries?: Value<number, [
-        reconnectOptions: EventIteratorReconnectOptions,
-        options: ClientOptionsOut<T>,
-        path: readonly string[],
-        input: unknown
-    ]>;
-    /**
-     * Delay (in ms) before retrying an event iterator call.
-     *
-     * @default (o) => o.lastRetry ?? (1000 * 2 ** o.retryTimes)
-     */
-    eventIteratorRetryDelay?: Value<number, [
-        reconnectOptions: EventIteratorReconnectOptions,
-        options: ClientOptionsOut<T>,
-        path: readonly string[],
-        input: unknown
-    ]>;
-    /**
-     * Function to determine if an error is retryable.
-     *
-     * @default true
-     */
-    eventIteratorShouldRetry?: Value<boolean, [
-        reconnectOptions: EventIteratorReconnectOptions,
-        options: ClientOptionsOut<T>,
-        path: readonly string[],
-        input: unknown
-    ]>;
-    interceptors?: Interceptor<{
-        path: readonly string[];
-        input: unknown;
-        options: ClientOptionsOut<T>;
-    }, unknown, unknown>[];
-    clientInterceptors?: Interceptor<{
-        request: StandardRequest;
-    }, StandardLazyResponse, unknown>[];
+declare const STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES: {
+    readonly BIGINT: 0;
+    readonly DATE: 1;
+    readonly NAN: 2;
+    readonly UNDEFINED: 3;
+    readonly URL: 4;
+    readonly REGEXP: 5;
+    readonly SET: 6;
+    readonly MAP: 7;
+};
+type StandardRPCJsonSerializedMetaItem = readonly [type: number, ...path: Segment[]];
+type StandardRPCJsonSerialized = [json: unknown, meta: StandardRPCJsonSerializedMetaItem[], maps: Segment[][], blobs: Blob[]];
+interface StandardRPCCustomJsonSerializer {
+    type: number;
+    condition(data: unknown): boolean;
+    serialize(data: any): unknown;
+    deserialize(serialized: any): unknown;
 }
-declare class StandardLink<T extends ClientContext> implements ClientLink<T> {
-    #private;
-    readonly codec: StandardLinkCodec<T>;
-    readonly sender: StandardLinkClient<T>;
-    private readonly eventIteratorMaxRetries;
-    private readonly eventIteratorRetryDelay;
-    private readonly eventIteratorShouldRetry;
-    private readonly interceptors;
-    private readonly clientInterceptors;
-    constructor(codec: StandardLinkCodec<T>, sender: StandardLinkClient<T>, options: StandardLinkOptions<T>);
-    call(path: readonly string[], input: unknown, options: ClientOptionsOut<T>): Promise<unknown>;
+interface StandardRPCJsonSerializerOptions {
+    customJsonSerializers?: readonly StandardRPCCustomJsonSerializer[];
 }
-
-type RPCJsonSerializedMeta = [
-    0 | 1 | 2 | 3 | 4 | 5 | 6 | 7,
-    Segment[]
-][];
-type RPCJsonSerialized = [json: unknown, meta: RPCJsonSerializedMeta, maps: Segment[][], blobs: Blob[]];
-declare class RPCJsonSerializer {
-    serialize(data: unknown, segments?: Segment[], meta?: RPCJsonSerializedMeta, maps?: Segment[][], blobs?: Blob[]): RPCJsonSerialized;
-    deserialize(json: unknown, meta: RPCJsonSerializedMeta): unknown;
-    deserialize(json: unknown, meta: RPCJsonSerializedMeta, maps: Segment[][], getBlob: (index: number) => Blob): unknown;
+declare class StandardRPCJsonSerializer {
+    private readonly customSerializers;
+    constructor(options?: StandardRPCJsonSerializerOptions);
+    serialize(data: unknown, segments?: Segment[], meta?: StandardRPCJsonSerializedMetaItem[], maps?: Segment[][], blobs?: Blob[]): StandardRPCJsonSerialized;
+    deserialize(json: unknown, meta: readonly StandardRPCJsonSerializedMetaItem[]): unknown;
+    deserialize(json: unknown, meta: readonly StandardRPCJsonSerializedMetaItem[], maps: readonly Segment[][], getBlob: (index: number) => Blob): unknown;
 }
 
-declare class RPCSerializer {
+declare class StandardRPCSerializer {
     #private;
     private readonly jsonSerializer;
-    constructor(jsonSerializer?: RPCJsonSerializer);
-    serialize(data: unknown): unknown;
+    constructor(jsonSerializer: StandardRPCJsonSerializer);
+    serialize(data: unknown): object;
     deserialize(data: unknown): unknown;
 }
 
@@ -140,9 +94,12 @@ declare class StandardRPCLinkCodec<T extends ClientContext> implements StandardL
     private readonly fallbackMethod;
     private readonly expectedMethod;
     private readonly headers;
-    constructor(serializer: RPCSerializer, options: StandardRPCLinkCodecOptions<T>);
+    constructor(serializer: StandardRPCSerializer, options: StandardRPCLinkCodecOptions<T>);
     encode(path: readonly string[], input: unknown, options: ClientOptionsOut<any>): Promise<StandardRequest>;
     decode(response: StandardLazyResponse): Promise<unknown>;
 }
 
-export { InvalidEventIteratorRetryResponse, type RPCJsonSerialized, type RPCJsonSerializedMeta, RPCJsonSerializer, RPCSerializer, StandardLink, type StandardLinkClient, type StandardLinkCodec, type StandardLinkOptions, StandardRPCLinkCodec, type StandardRPCLinkCodecOptions };
+interface StandardRPCLinkOptions<T extends ClientContext> extends StandardLinkOptions<T>, StandardRPCLinkCodecOptions<T>, StandardRPCJsonSerializerOptions {
+}
+
+export { STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES, StandardLinkCodec, StandardLinkOptions, type StandardRPCCustomJsonSerializer, type StandardRPCJsonSerialized, type StandardRPCJsonSerializedMetaItem, StandardRPCJsonSerializer, type StandardRPCJsonSerializerOptions, StandardRPCLinkCodec, type StandardRPCLinkCodecOptions, type StandardRPCLinkOptions, StandardRPCSerializer };

package/dist/adapters/standard/index.mjs

@@ -1,4 +1,5 @@
-export { I as InvalidEventIteratorRetryResponse, R as RPCJsonSerializer, b as RPCSerializer, S as StandardLink, a as StandardRPCLinkCodec } from '../../shared/client.BMw2gtvr.mjs';
+export { I as InvalidEventIteratorRetryResponse, a as STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES, S as StandardLink, b as StandardRPCJsonSerializer, c as StandardRPCLinkCodec, d as StandardRPCSerializer } from '../../shared/client.Be-O_tdu.mjs';
 import '@orpc/shared';
-import '../../shared/client.DcaJQZfy.mjs';
+import '../../shared/client.CvnV7_uV.mjs';
 import '@orpc/standard-server';
+import '../../shared/client.BacCdg3F.mjs';

package/dist/index.d.mts

@@ -1,6 +1,7 @@
-import { N as NestedClient, b as ClientLink, I as InferClientContext, C as ClientContext, a as ClientOptionsOut, c as ClientPromiseResult } from './shared/client.D_CzLDyB.mjs';
-export { g as Client, e as ClientOptions, f as ClientRest, E as EventIteratorReconnectOptions, d as createAutoRetryEventIterator, m as mapEventIterator } from './shared/client.D_CzLDyB.mjs';
+import { N as NestedClient, b as ClientLink, I as InferClientContext, a as ClientContext, C as ClientOptionsOut, c as ClientPromiseResult } from './shared/client.CupM8eRP.mjs';
+export { f as Client, d as ClientOptions, e as ClientRest } from './shared/client.CupM8eRP.mjs';
 import { Promisable, MaybeOptionalOptions } from '@orpc/shared';
+export { onError, onFinish, onStart, onSuccess } from '@orpc/shared';
 export { ErrorEvent } from '@orpc/standard-server';
 
 interface createORPCClientOptions {
@@ -126,14 +127,10 @@ type ORPCErrorJSON<TCode extends string, TData> = Pick<ORPCError<TCode, TData>,
 declare function isDefinedError<T>(error: T): error is Extract<T, ORPCError<any, any>>;
 declare function toORPCError(error: unknown): ORPCError<any, any>;
 
-type ConnectionStatus = 'reconnecting' | 'connected' | 'closed';
-interface EventIteratorState {
-    status: ConnectionStatus;
-    listeners: Array<(newStatus: ConnectionStatus) => void>;
-}
-declare function registerEventIteratorState(iterator: AsyncIteratorObject<unknown, unknown, void>, state: EventIteratorState): void;
-declare function updateEventIteratorStatus(state: EventIteratorState, status: ConnectionStatus): void;
-declare function onEventIteratorStatusChange(iterator: AsyncIteratorObject<unknown, unknown, void>, callback: (status: ConnectionStatus) => void, notifyImmediately?: boolean): () => void;
+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>;
 
 type SafeResult<TOutput, TError extends Error> = [error: null, data: TOutput, isDefined: false] & {
     error: null;
@@ -150,4 +147,4 @@ type SafeResult<TOutput, TError extends Error> = [error: null, data: TOutput, is
 };
 declare function safe<TOutput, TError extends Error>(promise: ClientPromiseResult<TOutput, TError>): Promise<SafeResult<TOutput, TError>>;
 
-export { COMMON_ORPC_ERROR_DEFS, ClientContext, ClientLink, ClientOptionsOut, ClientPromiseResult, type CommonORPCErrorCode, type ConnectionStatus, DynamicLink, type EventIteratorState, InferClientContext, NestedClient, ORPCError, type ORPCErrorCode, type ORPCErrorJSON, type ORPCErrorOptions, type SafeResult, createORPCClient, type createORPCClientOptions, fallbackORPCErrorMessage, fallbackORPCErrorStatus, isDefinedError, onEventIteratorStatusChange, registerEventIteratorState, safe, toORPCError, updateEventIteratorStatus };
+export { COMMON_ORPC_ERROR_DEFS, ClientContext, ClientLink, ClientOptionsOut, ClientPromiseResult, type CommonORPCErrorCode, DynamicLink, InferClientContext, NestedClient, ORPCError, type ORPCErrorCode, type ORPCErrorJSON, type ORPCErrorOptions, type SafeResult, createORPCClient, type createORPCClientOptions, fallbackORPCErrorMessage, fallbackORPCErrorStatus, isDefinedError, mapEventIterator, safe, toORPCError };

package/dist/index.d.ts

@@ -1,6 +1,7 @@
-import { N as NestedClient, b as ClientLink, I as InferClientContext, C as ClientContext, a as ClientOptionsOut, c as ClientPromiseResult } from './shared/client.D_CzLDyB.js';
-export { g as Client, e as ClientOptions, f as ClientRest, E as EventIteratorReconnectOptions, d as createAutoRetryEventIterator, m as mapEventIterator } from './shared/client.D_CzLDyB.js';
+import { N as NestedClient, b as ClientLink, I as InferClientContext, a as ClientContext, C as ClientOptionsOut, c as ClientPromiseResult } from './shared/client.CupM8eRP.js';
+export { f as Client, d as ClientOptions, e as ClientRest } from './shared/client.CupM8eRP.js';
 import { Promisable, MaybeOptionalOptions } from '@orpc/shared';
+export { onError, onFinish, onStart, onSuccess } from '@orpc/shared';
 export { ErrorEvent } from '@orpc/standard-server';
 
 interface createORPCClientOptions {
@@ -126,14 +127,10 @@ type ORPCErrorJSON<TCode extends string, TData> = Pick<ORPCError<TCode, TData>,
 declare function isDefinedError<T>(error: T): error is Extract<T, ORPCError<any, any>>;
 declare function toORPCError(error: unknown): ORPCError<any, any>;
 
-type ConnectionStatus = 'reconnecting' | 'connected' | 'closed';
-interface EventIteratorState {
-    status: ConnectionStatus;
-    listeners: Array<(newStatus: ConnectionStatus) => void>;
-}
-declare function registerEventIteratorState(iterator: AsyncIteratorObject<unknown, unknown, void>, state: EventIteratorState): void;
-declare function updateEventIteratorStatus(state: EventIteratorState, status: ConnectionStatus): void;
-declare function onEventIteratorStatusChange(iterator: AsyncIteratorObject<unknown, unknown, void>, callback: (status: ConnectionStatus) => void, notifyImmediately?: boolean): () => void;
+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>;
 
 type SafeResult<TOutput, TError extends Error> = [error: null, data: TOutput, isDefined: false] & {
     error: null;
@@ -150,4 +147,4 @@ type SafeResult<TOutput, TError extends Error> = [error: null, data: TOutput, is
 };
 declare function safe<TOutput, TError extends Error>(promise: ClientPromiseResult<TOutput, TError>): Promise<SafeResult<TOutput, TError>>;
 
-export { COMMON_ORPC_ERROR_DEFS, ClientContext, ClientLink, ClientOptionsOut, ClientPromiseResult, type CommonORPCErrorCode, type ConnectionStatus, DynamicLink, type EventIteratorState, InferClientContext, NestedClient, ORPCError, type ORPCErrorCode, type ORPCErrorJSON, type ORPCErrorOptions, type SafeResult, createORPCClient, type createORPCClientOptions, fallbackORPCErrorMessage, fallbackORPCErrorStatus, isDefinedError, onEventIteratorStatusChange, registerEventIteratorState, safe, toORPCError, updateEventIteratorStatus };
+export { COMMON_ORPC_ERROR_DEFS, ClientContext, ClientLink, ClientOptionsOut, ClientPromiseResult, type CommonORPCErrorCode, DynamicLink, InferClientContext, NestedClient, ORPCError, type ORPCErrorCode, type ORPCErrorJSON, type ORPCErrorOptions, type SafeResult, createORPCClient, type createORPCClientOptions, fallbackORPCErrorMessage, fallbackORPCErrorStatus, isDefinedError, mapEventIterator, safe, toORPCError };

package/dist/index.mjs

@@ -1,7 +1,7 @@
-import { i as isDefinedError } from './shared/client.DcaJQZfy.mjs';
-export { C as COMMON_ORPC_ERROR_DEFS, O as ORPCError, c as createAutoRetryEventIterator, a as fallbackORPCErrorMessage, f as fallbackORPCErrorStatus, m as mapEventIterator, o as onEventIteratorStatusChange, r as registerEventIteratorState, t as toORPCError, u as updateEventIteratorStatus } from './shared/client.DcaJQZfy.mjs';
+import { i as isDefinedError } from './shared/client.BacCdg3F.mjs';
+export { C as COMMON_ORPC_ERROR_DEFS, O as ORPCError, a as fallbackORPCErrorMessage, f as fallbackORPCErrorStatus, m as mapEventIterator, t as toORPCError } from './shared/client.BacCdg3F.mjs';
+export { onError, onFinish, onStart, onSuccess } from '@orpc/shared';
 export { ErrorEvent } from '@orpc/standard-server';
-import '@orpc/shared';
 
 function createORPCClient(link, options) {
   const path = options?.path ?? [];

package/dist/plugins/index.d.mts

@@ -0,0 +1,62 @@
+import { C as ClientPlugin, S as StandardLinkOptions } from '../shared/client.DrOAzyMB.mjs';
+export { a as CompositeClientPlugin } from '../shared/client.DrOAzyMB.mjs';
+import { Value } from '@orpc/shared';
+import { C as ClientOptionsOut, a as ClientContext } from '../shared/client.CupM8eRP.mjs';
+import '@orpc/standard-server';
+
+interface ClientRetryPluginAttemptOptions {
+    eventIteratorLastRetry: number | undefined;
+    eventIteratorLastEventId: string | undefined;
+    attemptIndex: number;
+    error: unknown;
+}
+interface ClientRetryPluginContext {
+    /**
+     * Maximum retry attempts before throwing
+     * Use `Number.POSITIVE_INFINITY` for infinite retries (e.g., when handling Server-Sent Events).
+     *
+     * @default 0
+     */
+    retry?: number;
+    /**
+     * Delay (in ms) before retrying.
+     *
+     * @default (o) => o.eventIteratorLastRetry ?? 2000
+     */
+    retryDelay?: Value<number, [
+        attemptOptions: ClientRetryPluginAttemptOptions,
+        clientOptions: ClientOptionsOut<ClientRetryPluginContext>,
+        path: readonly string[],
+        input: unknown
+    ]>;
+    /**
+     * Determine should retry or not.
+     *
+     * @default true
+     */
+    shouldRetry?: Value<boolean, [
+        attemptOptions: ClientRetryPluginAttemptOptions,
+        clientOptions: ClientOptionsOut<ClientRetryPluginContext>,
+        path: readonly string[],
+        input: unknown
+    ]>;
+    /**
+     * The hook called when retrying, and return the unsubscribe function.
+     */
+    onRetry?: (options: ClientRetryPluginAttemptOptions, clientOptions: ClientOptionsOut<ClientRetryPluginContext>, path: readonly string[], input: unknown) => void | (() => void);
+}
+declare class ClientRetryPluginInvalidEventIteratorRetryResponse extends Error {
+}
+interface ClientRetryPluginOptions {
+    default?: ClientRetryPluginContext;
+}
+declare class ClientRetryPlugin<T extends ClientContext & ClientRetryPluginContext> implements ClientPlugin<T> {
+    private readonly defaultRetry;
+    private readonly defaultRetryDelay;
+    private readonly defaultShouldRetry;
+    private readonly defaultOnRetry;
+    constructor(options?: ClientRetryPluginOptions);
+    init(options: StandardLinkOptions<T>): void;
+}
+
+export { ClientPlugin, ClientRetryPlugin, type ClientRetryPluginAttemptOptions, type ClientRetryPluginContext, ClientRetryPluginInvalidEventIteratorRetryResponse, type ClientRetryPluginOptions };

package/dist/plugins/index.d.ts

@@ -0,0 +1,62 @@
+import { C as ClientPlugin, S as StandardLinkOptions } from '../shared/client.aGal-uGY.js';
+export { a as CompositeClientPlugin } from '../shared/client.aGal-uGY.js';
+import { Value } from '@orpc/shared';
+import { C as ClientOptionsOut, a as ClientContext } from '../shared/client.CupM8eRP.js';
+import '@orpc/standard-server';
+
+interface ClientRetryPluginAttemptOptions {
+    eventIteratorLastRetry: number | undefined;
+    eventIteratorLastEventId: string | undefined;
+    attemptIndex: number;
+    error: unknown;
+}
+interface ClientRetryPluginContext {
+    /**
+     * Maximum retry attempts before throwing
+     * Use `Number.POSITIVE_INFINITY` for infinite retries (e.g., when handling Server-Sent Events).
+     *
+     * @default 0
+     */
+    retry?: number;
+    /**
+     * Delay (in ms) before retrying.
+     *
+     * @default (o) => o.eventIteratorLastRetry ?? 2000
+     */
+    retryDelay?: Value<number, [
+        attemptOptions: ClientRetryPluginAttemptOptions,
+        clientOptions: ClientOptionsOut<ClientRetryPluginContext>,
+        path: readonly string[],
+        input: unknown
+    ]>;
+    /**
+     * Determine should retry or not.
+     *
+     * @default true
+     */
+    shouldRetry?: Value<boolean, [
+        attemptOptions: ClientRetryPluginAttemptOptions,
+        clientOptions: ClientOptionsOut<ClientRetryPluginContext>,
+        path: readonly string[],
+        input: unknown
+    ]>;
+    /**
+     * The hook called when retrying, and return the unsubscribe function.
+     */
+    onRetry?: (options: ClientRetryPluginAttemptOptions, clientOptions: ClientOptionsOut<ClientRetryPluginContext>, path: readonly string[], input: unknown) => void | (() => void);
+}
+declare class ClientRetryPluginInvalidEventIteratorRetryResponse extends Error {
+}
+interface ClientRetryPluginOptions {
+    default?: ClientRetryPluginContext;
+}
+declare class ClientRetryPlugin<T extends ClientContext & ClientRetryPluginContext> implements ClientPlugin<T> {
+    private readonly defaultRetry;
+    private readonly defaultRetryDelay;
+    private readonly defaultShouldRetry;
+    private readonly defaultOnRetry;
+    constructor(options?: ClientRetryPluginOptions);
+    init(options: StandardLinkOptions<T>): void;
+}
+
+export { ClientPlugin, ClientRetryPlugin, type ClientRetryPluginAttemptOptions, type ClientRetryPluginContext, ClientRetryPluginInvalidEventIteratorRetryResponse, type ClientRetryPluginOptions };

package/dist/plugins/index.mjs

@@ -0,0 +1,127 @@
+export { C as CompositeClientPlugin } from '../shared/client.CvnV7_uV.mjs';
+import { isAsyncIteratorObject, value } from '@orpc/shared';
+import { getEventMeta } from '@orpc/standard-server';
+
+class ClientRetryPluginInvalidEventIteratorRetryResponse extends Error {
+}
+class ClientRetryPlugin {
+  defaultRetry;
+  defaultRetryDelay;
+  defaultShouldRetry;
+  defaultOnRetry;
+  constructor(options = {}) {
+    this.defaultRetry = options.default?.retry ?? 0;
+    this.defaultRetryDelay = options.default?.retryDelay ?? ((o) => o.eventIteratorLastRetry ?? 2e3);
+    this.defaultShouldRetry = options.default?.shouldRetry ?? true;
+    this.defaultOnRetry = options.default?.onRetry;
+  }
+  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;
+      if (maxAttempts <= 0) {
+        return interceptorOptions.next();
+      }
+      let eventIteratorLastEventId = interceptorOptions.options.lastEventId;
+      let eventIteratorLastRetry;
+      let unsubscribe;
+      let attemptIndex = 0;
+      const next = async (initial) => {
+        let current = initial;
+        while (true) {
+          if (current) {
+            if (attemptIndex >= maxAttempts) {
+              throw current.error;
+            }
+            const attemptOptions = {
+              attemptIndex,
+              error: current.error,
+              eventIteratorLastEventId,
+              eventIteratorLastRetry
+            };
+            const shouldRetryBool = await value(
+              shouldRetry,
+              attemptOptions,
+              interceptorOptions.options,
+              interceptorOptions.path,
+              interceptorOptions.input
+            );
+            if (!shouldRetryBool) {
+              throw current.error;
+            }
+            unsubscribe = onRetry?.(
+              attemptOptions,
+              interceptorOptions.options,
+              interceptorOptions.path,
+              interceptorOptions.input
+            );
+            const retryDelayMs = await value(
+              retryDelay,
+              attemptOptions,
+              interceptorOptions.options,
+              interceptorOptions.path,
+              interceptorOptions.input
+            );
+            await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+            attemptIndex++;
+          }
+          try {
+            const newClientOptions = { ...interceptorOptions.options, lastEventId: eventIteratorLastEventId };
+            const output2 = await interceptorOptions.next({
+              ...interceptorOptions,
+              options: newClientOptions
+            });
+            return output2;
+          } catch (error) {
+            if (interceptorOptions.options.signal?.aborted === true) {
+              throw error;
+            }
+            current = { error };
+          } finally {
+            unsubscribe?.();
+            unsubscribe = void 0;
+          }
+        }
+      };
+      const output = await next();
+      if (!isAsyncIteratorObject(output)) {
+        return output;
+      }
+      return async function* () {
+        let current = output;
+        try {
+          while (true) {
+            try {
+              const item = await current.next();
+              const meta = getEventMeta(item.value);
+              eventIteratorLastEventId = meta?.id ?? eventIteratorLastEventId;
+              eventIteratorLastRetry = meta?.retry ?? eventIteratorLastRetry;
+              if (item.done) {
+                return item.value;
+              }
+              yield item.value;
+            } catch (error) {
+              const meta = getEventMeta(error);
+              eventIteratorLastEventId = meta?.id ?? eventIteratorLastEventId;
+              eventIteratorLastRetry = meta?.retry ?? eventIteratorLastRetry;
+              const maybeEventIterator = await next({ error });
+              if (!isAsyncIteratorObject(maybeEventIterator)) {
+                throw new ClientRetryPluginInvalidEventIteratorRetryResponse(
+                  "RetryPlugin: Expected an Event Iterator, got a non-Event Iterator"
+                );
+              }
+              current = maybeEventIterator;
+            }
+          }
+        } finally {
+          await current.return?.();
+        }
+      }();
+    });
+  }
+}
+
+export { ClientRetryPlugin, ClientRetryPluginInvalidEventIteratorRetryResponse };

package/dist/shared/{client.DcaJQZfy.mjs → client.BacCdg3F.mjs}

@@ -1,4 +1,4 @@
-import { isObject, isTypescriptObject, retry } from '@orpc/shared';
+import { isObject, isTypescriptObject } from '@orpc/shared';
 import { getEventMeta, withEventMeta } from '@orpc/standard-server';
 
 const COMMON_ORPC_ERROR_DEFS = {
@@ -137,33 +137,6 @@ function toORPCError(error) {
   });
 }
 
-const iteratorStates = /* @__PURE__ */ new WeakMap();
-function registerEventIteratorState(iterator, state) {
-  iteratorStates.set(iterator, state);
-}
-function updateEventIteratorStatus(state, status) {
-  if (state.status !== status) {
-    state.status = status;
-    state.listeners.forEach((cb) => cb(status));
-  }
-}
-function onEventIteratorStatusChange(iterator, callback, notifyImmediately = true) {
-  const state = iteratorStates.get(iterator);
-  if (!state) {
-    throw new Error("Iterator is not registered.");
-  }
-  if (notifyImmediately) {
-    callback(state.status);
-  }
-  state.listeners.push(callback);
-  return () => {
-    const index = state.listeners.indexOf(callback);
-    if (index !== -1) {
-      state.listeners.splice(index, 1);
-    }
-  };
-}
-
 function mapEventIterator(iterator, maps) {
   return async function* () {
     try {
@@ -195,71 +168,5 @@ function mapEventIterator(iterator, maps) {
     }
   }();
 }
-const MAX_ALLOWED_RETRY_TIMES = 99;
-function createAutoRetryEventIterator(initial, reconnect, initialLastEventId) {
-  const state = {
-    status: "connected",
-    listeners: []
-  };
-  const iterator = async function* () {
-    let current = initial;
-    let lastEventId = initialLastEventId;
-    let lastRetry;
-    let retryTimes = 0;
-    try {
-      while (true) {
-        try {
-          updateEventIteratorStatus(state, "connected");
-          const { done, value } = await current.next();
-          const meta = getEventMeta(value);
-          lastEventId = meta?.id ?? lastEventId;
-          lastRetry = meta?.retry ?? lastRetry;
-          retryTimes = 0;
-          if (done) {
-            return value;
-          }
-          yield value;
-        } catch (e) {
-          updateEventIteratorStatus(state, "reconnecting");
-          const meta = getEventMeta(e);
-          lastEventId = meta?.id ?? lastEventId;
-          lastRetry = meta?.retry ?? lastRetry;
-          let currentError = e;
-          current = await retry({ times: MAX_ALLOWED_RETRY_TIMES }, async (exit) => {
-            retryTimes += 1;
-            if (retryTimes > MAX_ALLOWED_RETRY_TIMES) {
-              throw exit(new Error(
-                `Exceeded maximum retry attempts (${MAX_ALLOWED_RETRY_TIMES}) for event iterator. Possible infinite retry loop detected. Please review the retry logic.`,
-                { cause: currentError }
-              ));
-            }
-            const reconnected = await (async () => {
-              try {
-                return await reconnect({
-                  lastRetry,
-                  lastEventId,
-                  retryTimes,
-                  error: currentError
-                });
-              } catch (e2) {
-                currentError = e2;
-                throw e2;
-              }
-            })();
-            if (!reconnected) {
-              throw exit(currentError);
-            }
-            return reconnected;
-          });
-        }
-      }
-    } finally {
-      updateEventIteratorStatus(state, "closed");
-      await current.return?.();
-    }
-  }();
-  registerEventIteratorState(iterator, state);
-  return iterator;
-}
 
-export { COMMON_ORPC_ERROR_DEFS as C, ORPCError as O, fallbackORPCErrorMessage as a, createAutoRetryEventIterator as c, fallbackORPCErrorStatus as f, isDefinedError as i, mapEventIterator as m, onEventIteratorStatusChange as o, registerEventIteratorState as r, toORPCError as t, updateEventIteratorStatus as u };
+export { COMMON_ORPC_ERROR_DEFS as C, ORPCError as O, fallbackORPCErrorMessage as a, fallbackORPCErrorStatus as f, isDefinedError as i, mapEventIterator as m, toORPCError as t };

package/dist/shared/{client.BMw2gtvr.mjs → client.Be-O_tdu.mjs}

@@ -1,48 +1,25 @@
-import { intercept, isAsyncIteratorObject, value, isObject, trim, stringifyJSON } from '@orpc/shared';
-import { c as createAutoRetryEventIterator, O as ORPCError, m as mapEventIterator, t as toORPCError } from './client.DcaJQZfy.mjs';
+import { intercept, isObject, value, trim, isAsyncIteratorObject, stringifyJSON } from '@orpc/shared';
+import { C as CompositeClientPlugin } from './client.CvnV7_uV.mjs';
 import { ErrorEvent } from '@orpc/standard-server';
+import { O as ORPCError, m as mapEventIterator, t as toORPCError } from './client.BacCdg3F.mjs';
 
 class InvalidEventIteratorRetryResponse extends Error {
 }
 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;
+    const plugin = new CompositeClientPlugin(options.plugins);
+    plugin.init(options);
     this.interceptors = options.interceptors ?? [];
     this.clientInterceptors = 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 }) => {
       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) {
@@ -57,50 +34,74 @@ class StandardLink {
   }
 }
 
-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];
@@ -129,38 +130,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;
       }
@@ -185,14 +193,23 @@ class StandardRPCLinkCodec {
   headers;
   async encode(path, input, options) {
     const expectedMethod = await value(this.expectedMethod, options, path, input);
-    const headers = await value(this.headers, 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("/")}`);
+    if (options.lastEventId !== void 0) {
+      if (Array.isArray(headers["last-event-id"])) {
+        headers["last-event-id"] = [...headers["last-event-id"], options.lastEventId];
+      } else if (headers["last-event-id"] !== void 0) {
+        headers["last-event-id"] = [headers["last-event-id"], options.lastEventId];
+      } else {
+        headers["last-event-id"] = options.lastEventId;
+      }
+    }
     const serialized = this.serializer.serialize(input);
-    if (expectedMethod === "GET" && !(serialized instanceof FormData) && !(serialized instanceof Blob) && !isAsyncIteratorObject(serialized)) {
+    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) ?? "");
+      getUrl.searchParams.append("data", stringifyJSON(serialized));
       if (getUrl.toString().length <= maxUrlLength) {
         return {
           body: void 0,
@@ -242,8 +259,8 @@ class StandardRPCLinkCodec {
   }
 }
 
-class RPCSerializer {
-  constructor(jsonSerializer = new RPCJsonSerializer()) {
+class StandardRPCSerializer {
+  constructor(jsonSerializer) {
     this.jsonSerializer = jsonSerializer;
   }
   serialize(data) {
@@ -261,9 +278,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) {
@@ -301,9 +315,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 ?? []);
     }
@@ -317,4 +328,4 @@ class RPCSerializer {
   }
 }
 
-export { InvalidEventIteratorRetryResponse as I, RPCJsonSerializer as R, StandardLink as S, StandardRPCLinkCodec as a, RPCSerializer as b };
+export { InvalidEventIteratorRetryResponse as I, StandardLink as S, STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES as a, StandardRPCJsonSerializer as b, StandardRPCLinkCodec as c, StandardRPCSerializer as d };

package/dist/shared/{client.D_CzLDyB.d.mts → client.CupM8eRP.d.mts}

@@ -27,16 +27,4 @@ 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 };
+export type { ClientOptionsOut as C, InferClientContext as I, NestedClient as N, ClientContext as a, ClientLink as b, ClientPromiseResult as c, ClientOptions as d, ClientRest as e, Client as f };

package/dist/shared/{client.D_CzLDyB.d.ts → client.CupM8eRP.d.ts}

@@ -27,16 +27,4 @@ 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 };
+export type { ClientOptionsOut as C, InferClientContext as I, NestedClient as N, ClientContext as a, ClientLink as b, ClientPromiseResult as c, ClientOptions as d, ClientRest as e, Client as f };

package/dist/shared/client.CvnV7_uV.mjs

@@ -0,0 +1,12 @@
+class CompositeClientPlugin {
+  constructor(plugins = []) {
+    this.plugins = plugins;
+  }
+  init(options) {
+    for (const plugin of this.plugins) {
+      plugin.init?.(options);
+    }
+  }
+}
+
+export { CompositeClientPlugin as C };

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

@@ -0,0 +1,45 @@
+import { Interceptor } from '@orpc/shared';
+import { StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
+import { a as ClientContext, C as ClientOptionsOut, b as ClientLink } from './client.CupM8eRP.mjs';
+
+interface StandardLinkCodec<T extends ClientContext> {
+    encode(path: readonly string[], input: unknown, options: ClientOptionsOut<any>): Promise<StandardRequest>;
+    decode(response: StandardLazyResponse, options: ClientOptionsOut<T>, path: readonly string[], input: unknown): Promise<unknown>;
+}
+interface StandardLinkClient<T extends ClientContext> {
+    call(request: StandardRequest, options: ClientOptionsOut<T>, path: readonly string[], input: unknown): Promise<StandardLazyResponse>;
+}
+
+declare class InvalidEventIteratorRetryResponse extends Error {
+}
+interface StandardLinkOptions<T extends ClientContext> {
+    interceptors?: Interceptor<{
+        path: readonly string[];
+        input: unknown;
+        options: ClientOptionsOut<T>;
+    }, unknown, unknown>[];
+    clientInterceptors?: Interceptor<{
+        request: StandardRequest;
+    }, StandardLazyResponse, unknown>[];
+    plugins?: ClientPlugin<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: ClientOptionsOut<T>): Promise<unknown>;
+}
+
+interface ClientPlugin<T extends ClientContext> {
+    init?(options: StandardLinkOptions<T>): void;
+}
+declare class CompositeClientPlugin<T extends ClientContext> implements ClientPlugin<T> {
+    private readonly plugins;
+    constructor(plugins?: ClientPlugin<T>[]);
+    init(options: StandardLinkOptions<T>): void;
+}
+
+export { type ClientPlugin as C, InvalidEventIteratorRetryResponse as I, type StandardLinkOptions as S, CompositeClientPlugin as a, type StandardLinkClient as b, type StandardLinkCodec as c, StandardLink as d };

package/dist/shared/client.aGal-uGY.d.ts

@@ -0,0 +1,45 @@
+import { Interceptor } from '@orpc/shared';
+import { StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
+import { a as ClientContext, C as ClientOptionsOut, b as ClientLink } from './client.CupM8eRP.js';
+
+interface StandardLinkCodec<T extends ClientContext> {
+    encode(path: readonly string[], input: unknown, options: ClientOptionsOut<any>): Promise<StandardRequest>;
+    decode(response: StandardLazyResponse, options: ClientOptionsOut<T>, path: readonly string[], input: unknown): Promise<unknown>;
+}
+interface StandardLinkClient<T extends ClientContext> {
+    call(request: StandardRequest, options: ClientOptionsOut<T>, path: readonly string[], input: unknown): Promise<StandardLazyResponse>;
+}
+
+declare class InvalidEventIteratorRetryResponse extends Error {
+}
+interface StandardLinkOptions<T extends ClientContext> {
+    interceptors?: Interceptor<{
+        path: readonly string[];
+        input: unknown;
+        options: ClientOptionsOut<T>;
+    }, unknown, unknown>[];
+    clientInterceptors?: Interceptor<{
+        request: StandardRequest;
+    }, StandardLazyResponse, unknown>[];
+    plugins?: ClientPlugin<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: ClientOptionsOut<T>): Promise<unknown>;
+}
+
+interface ClientPlugin<T extends ClientContext> {
+    init?(options: StandardLinkOptions<T>): void;
+}
+declare class CompositeClientPlugin<T extends ClientContext> implements ClientPlugin<T> {
+    private readonly plugins;
+    constructor(plugins?: ClientPlugin<T>[]);
+    init(options: StandardLinkOptions<T>): void;
+}
+
+export { type ClientPlugin as C, InvalidEventIteratorRetryResponse as I, type StandardLinkOptions as S, CompositeClientPlugin as a, type StandardLinkClient as b, type StandardLinkCodec as c, StandardLink as d };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/client",
   "type": "module",
-  "version": "0.47.0",
+  "version": "0.49.0",
   "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,9 +39,9 @@
     "dist"
   ],
   "dependencies": {
-    "@orpc/standard-server": "0.47.0",
-    "@orpc/shared": "0.47.0",
-    "@orpc/standard-server-fetch": "0.47.0"
+    "@orpc/standard-server-fetch": "0.49.0",
+    "@orpc/standard-server": "0.49.0",
+    "@orpc/shared": "0.49.0"
   },
   "devDependencies": {
     "zod": "^3.24.2"