@orpc/client 0.0.0-next.9b9ade5 → 0.0.0-next.9e880d7

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, Solid), 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.
@@ -56,9 +56,12 @@ You can find the full documentation [here](https://orpc.unnoq.com).
 - [@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.45nqoGFI.mjs';
+import { b as StandardLinkClient } from '../../shared/client.CS0uVV6J.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.45nqoGFI.js';
+import { b as StandardLinkClient } from '../../shared/client.CmE0kcXu.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.Df5pd75N.mjs';
+import { b as StandardRPCJsonSerializer, c as StandardRPCLinkCodec, d as StandardRPCSerializer, S as StandardLink } from '../../shared/client.cZd8JfIk.mjs';
 import '@orpc/shared';
 import '../../shared/client.XAn8cDTM.mjs';
 import '@orpc/standard-server';
+import '../../shared/client.CvnV7_uV.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,88 +1,42 @@
-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.CS0uVV6J.mjs';
+export { I as InvalidEventIteratorRetryResponse, d as StandardLink, b as StandardLinkClient } from '../../shared/client.CS0uVV6J.mjs';
+import { Segment, Value } from '@orpc/shared';
+import { a as ClientContext, C as ClientOptionsOut } from '../../shared/client.45nqoGFI.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);
+    constructor(jsonSerializer: StandardRPCJsonSerializer);
     serialize(data: unknown): unknown;
     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,88 +1,42 @@
-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.CmE0kcXu.js';
+export { I as InvalidEventIteratorRetryResponse, d as StandardLink, b as StandardLinkClient } from '../../shared/client.CmE0kcXu.js';
+import { Segment, Value } from '@orpc/shared';
+import { a as ClientContext, C as ClientOptionsOut } from '../../shared/client.45nqoGFI.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);
+    constructor(jsonSerializer: StandardRPCJsonSerializer);
     serialize(data: unknown): unknown;
     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.Df5pd75N.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.cZd8JfIk.mjs';
 import '@orpc/shared';
 import '../../shared/client.XAn8cDTM.mjs';
 import '@orpc/standard-server';
+import '../../shared/client.CvnV7_uV.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.45nqoGFI.mjs';
+export { g as Client, e as ClientOptions, f as ClientRest, E as EventIteratorReconnectOptions, d as createAutoRetryEventIterator, m as mapEventIterator } from './shared/client.45nqoGFI.mjs';
 import { Promisable, MaybeOptionalOptions } from '@orpc/shared';
+export { onError, onFinish, onStart, onSuccess } from '@orpc/shared';
 export { ErrorEvent } from '@orpc/standard-server';
 
 interface createORPCClientOptions {

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.45nqoGFI.js';
+export { g as Client, e as ClientOptions, f as ClientRest, E as EventIteratorReconnectOptions, d as createAutoRetryEventIterator, m as mapEventIterator } from './shared/client.45nqoGFI.js';
 import { Promisable, MaybeOptionalOptions } from '@orpc/shared';
+export { onError, onFinish, onStart, onSuccess } from '@orpc/shared';
 export { ErrorEvent } from '@orpc/standard-server';
 
 interface createORPCClientOptions {

package/dist/index.mjs

@@ -1,7 +1,7 @@
 import { i as isDefinedError } from './shared/client.XAn8cDTM.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.XAn8cDTM.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.CS0uVV6J.mjs';
+export { a as CompositeClientPlugin } from '../shared/client.CS0uVV6J.mjs';
+import { Value } from '@orpc/shared';
+import { C as ClientOptionsOut, a as ClientContext } from '../shared/client.45nqoGFI.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.CmE0kcXu.js';
+export { a as CompositeClientPlugin } from '../shared/client.CmE0kcXu.js';
+import { Value } from '@orpc/shared';
+import { C as ClientOptionsOut, a as ClientContext } from '../shared/client.45nqoGFI.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.D_CzLDyB.d.mts → client.45nqoGFI.d.mts}

@@ -39,4 +39,4 @@ interface EventIteratorReconnectOptions {
 }
 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, type EventIteratorReconnectOptions as E, type InferClientContext as I, type NestedClient as N, type ClientContext 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 → client.45nqoGFI.d.ts}

@@ -39,4 +39,4 @@ interface EventIteratorReconnectOptions {
 }
 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, type EventIteratorReconnectOptions as E, type InferClientContext as I, type NestedClient as N, type ClientContext 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.CS0uVV6J.d.mts

@@ -0,0 +1,81 @@
+import { Value, Interceptor } from '@orpc/shared';
+import { StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
+import { a as ClientContext, C as ClientOptionsOut, E as EventIteratorReconnectOptions, b as ClientLink } from './client.45nqoGFI.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> {
+    /**
+     * Maximum retry attempts for **consecutive failures** 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>[];
+    plugins?: ClientPlugin<T>[];
+}
+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 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.CmE0kcXu.d.ts

@@ -0,0 +1,81 @@
+import { Value, Interceptor } from '@orpc/shared';
+import { StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
+import { a as ClientContext, C as ClientOptionsOut, E as EventIteratorReconnectOptions, b as ClientLink } from './client.45nqoGFI.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> {
+    /**
+     * Maximum retry attempts for **consecutive failures** 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>[];
+    plugins?: ClientPlugin<T>[];
+}
+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 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.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.Df5pd75N.mjs → client.cZd8JfIk.mjs}

@@ -1,5 +1,6 @@
 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.XAn8cDTM.mjs';
+import { C as CompositeClientPlugin } from './client.CvnV7_uV.mjs';
 import { ErrorEvent } from '@orpc/standard-server';
 
 class InvalidEventIteratorRetryResponse extends Error {
@@ -8,6 +9,8 @@ class StandardLink {
   constructor(codec, sender, options) {
     this.codec = codec;
     this.sender = sender;
+    const plugin = new CompositeClientPlugin(options.plugins);
+    plugin.init(options);
     this.eventIteratorMaxRetries = options.eventIteratorMaxRetries ?? 5;
     this.eventIteratorRetryDelay = options.eventIteratorRetryDelay ?? ((o) => o.lastRetry ?? 1e3 * 2 ** o.retryTimes);
     this.eventIteratorShouldRetry = options.eventIteratorShouldRetry ?? true;
@@ -57,50 +60,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 +156,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,9 +219,18 @@ 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)) {
       const maxUrlLength = await value(this.maxUrlLength, options, path, input);
@@ -242,8 +285,8 @@ class StandardRPCLinkCodec {
   }
 }
 
-class RPCSerializer {
-  constructor(jsonSerializer = new RPCJsonSerializer()) {
+class StandardRPCSerializer {
+  constructor(jsonSerializer) {
     this.jsonSerializer = jsonSerializer;
   }
   serialize(data) {
@@ -317,4 +360,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/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/client",
   "type": "module",
-  "version": "0.0.0-next.9b9ade5",
+  "version": "0.0.0-next.9e880d7",
   "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/shared": "0.0.0-next.9b9ade5",
-    "@orpc/standard-server": "0.0.0-next.9b9ade5",
-    "@orpc/standard-server-fetch": "0.0.0-next.9b9ade5"
+    "@orpc/shared": "0.0.0-next.9e880d7",
+    "@orpc/standard-server": "0.0.0-next.9e880d7",
+    "@orpc/standard-server-fetch": "0.0.0-next.9e880d7"
   },
   "devDependencies": {
     "zod": "^3.24.2"