@orpc/client 1.0.0-beta.3 → 1.0.0-beta.5

package/dist/plugins/index.d.ts

@@ -1,7 +1,6 @@
-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 { S as StandardLinkPlugin, a as StandardLinkOptions } from '../shared/client.grRbC25r.js';
+import { b as ClientOptions } from '../shared/client.C0lT7w02.js';
 import '@orpc/standard-server';
 
 interface ClientRetryPluginAttemptOptions {
@@ -25,7 +24,7 @@ interface ClientRetryPluginContext {
      */
     retryDelay?: Value<number, [
         attemptOptions: ClientRetryPluginAttemptOptions,
-        clientOptions: ClientOptionsOut<ClientRetryPluginContext>,
+        clientOptions: ClientOptions<ClientRetryPluginContext>,
         path: readonly string[],
         input: unknown
     ]>;
@@ -36,21 +35,21 @@ interface ClientRetryPluginContext {
      */
     shouldRetry?: Value<boolean, [
         attemptOptions: ClientRetryPluginAttemptOptions,
-        clientOptions: ClientOptionsOut<ClientRetryPluginContext>,
+        clientOptions: ClientOptions<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);
+    onRetry?: (options: ClientRetryPluginAttemptOptions, clientOptions: ClientOptions<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> {
+declare class ClientRetryPlugin<T extends ClientRetryPluginContext> implements StandardLinkPlugin<T> {
     private readonly defaultRetry;
     private readonly defaultRetryDelay;
     private readonly defaultShouldRetry;
@@ -59,4 +58,4 @@ declare class ClientRetryPlugin<T extends ClientContext & ClientRetryPluginConte
     init(options: StandardLinkOptions<T>): void;
 }
 
-export { ClientPlugin, ClientRetryPlugin, type ClientRetryPluginAttemptOptions, type ClientRetryPluginContext, ClientRetryPluginInvalidEventIteratorRetryResponse, type ClientRetryPluginOptions };
+export { ClientRetryPlugin, type ClientRetryPluginAttemptOptions, type ClientRetryPluginContext, ClientRetryPluginInvalidEventIteratorRetryResponse, type ClientRetryPluginOptions };

package/dist/plugins/index.mjs

@@ -1,4 +1,3 @@
-export { C as CompositeClientPlugin } from '../shared/client.CvnV7_uV.mjs';
 import { isAsyncIteratorObject, value } from '@orpc/shared';
 import { getEventMeta } from '@orpc/standard-server';
 

package/dist/shared/{client.aGal-uGY.d.ts → client.5813Ufvs.d.mts}

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

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

@@ -0,0 +1,103 @@
+import { a as ClientContext, b as ClientOptions, d as HTTPMethod } from './client.C0lT7w02.mjs';
+import { c as StandardLinkCodec, a as StandardLinkOptions } from './client.5813Ufvs.mjs';
+import { Segment, Value } from '@orpc/shared';
+import { StandardHeaders, StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
+
+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;
+}
+interface StandardRPCJsonSerializerOptions {
+    customJsonSerializers?: readonly StandardRPCCustomJsonSerializer[];
+}
+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 StandardRPCSerializer {
+    #private;
+    private readonly jsonSerializer;
+    constructor(jsonSerializer: StandardRPCJsonSerializer);
+    serialize(data: unknown): object;
+    deserialize(data: unknown): unknown;
+}
+
+interface StandardRPCLinkCodecOptions<T extends ClientContext> {
+    /**
+     * Base url for all requests.
+     */
+    url: Value<string | URL, [
+        options: ClientOptions<T>,
+        path: readonly string[],
+        input: unknown
+    ]>;
+    /**
+     * The maximum length of the URL.
+     *
+     * @default 2083
+     */
+    maxUrlLength?: Value<number, [
+        options: ClientOptions<T>,
+        path: readonly string[],
+        input: unknown
+    ]>;
+    /**
+     * The method used to make the request.
+     *
+     * @default 'POST'
+     */
+    method?: Value<HTTPMethod, [
+        options: ClientOptions<T>,
+        path: readonly string[],
+        input: unknown
+    ]>;
+    /**
+     * The method to use when the payload cannot safely pass to the server with method return from method function.
+     * GET is not allowed, it's very dangerous.
+     *
+     * @default 'POST'
+     */
+    fallbackMethod?: Exclude<HTTPMethod, 'GET'>;
+    /**
+     * Inject headers to the request.
+     */
+    headers?: Value<StandardHeaders, [
+        options: ClientOptions<T>,
+        path: readonly string[],
+        input: unknown
+    ]>;
+}
+declare class StandardRPCLinkCodec<T extends ClientContext> implements StandardLinkCodec<T> {
+    private readonly serializer;
+    private readonly baseUrl;
+    private readonly maxUrlLength;
+    private readonly fallbackMethod;
+    private readonly expectedMethod;
+    private readonly headers;
+    constructor(serializer: StandardRPCSerializer, options: StandardRPCLinkCodecOptions<T>);
+    encode(path: readonly string[], input: unknown, options: ClientOptions<T>): Promise<StandardRequest>;
+    decode(response: StandardLazyResponse): Promise<unknown>;
+}
+
+interface StandardRPCLinkOptions<T extends ClientContext> extends StandardLinkOptions<T>, StandardRPCLinkCodecOptions<T>, StandardRPCJsonSerializerOptions {
+}
+
+export { STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES as S, type StandardRPCJsonSerializedMetaItem as a, type StandardRPCJsonSerialized as b, type StandardRPCCustomJsonSerializer as c, type StandardRPCJsonSerializerOptions as d, StandardRPCJsonSerializer as e, type StandardRPCLinkOptions as f, type StandardRPCLinkCodecOptions as g, StandardRPCLinkCodec as h, StandardRPCSerializer as i };

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

@@ -0,0 +1,30 @@
+import { PromiseWithError } from '@orpc/shared';
+
+type HTTPPath = `/${string}`;
+type HTTPMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+type ClientContext = Record<PropertyKey, any>;
+type FriendlyClientOptions<TClientContext extends ClientContext> = {
+    signal?: AbortSignal;
+    lastEventId?: string | undefined;
+} & (Record<never, never> extends TClientContext ? {
+    context?: TClientContext;
+} : {
+    context: TClientContext;
+});
+type ClientRest<TClientContext extends ClientContext, TInput> = Record<never, never> extends TClientContext ? undefined extends TInput ? [input?: TInput, options?: FriendlyClientOptions<TClientContext>] : [input: TInput, options?: FriendlyClientOptions<TClientContext>] : [input: TInput, options: FriendlyClientOptions<TClientContext>];
+type ClientPromiseResult<TOutput, TError> = PromiseWithError<TOutput, TError>;
+interface Client<TClientContext extends ClientContext, TInput, TOutput, TError> {
+    (...rest: ClientRest<TClientContext, TInput>): ClientPromiseResult<TOutput, TError>;
+}
+type NestedClient<TClientContext extends ClientContext> = Client<TClientContext, any, any, any> | {
+    [k: string]: NestedClient<TClientContext>;
+};
+type InferClientContext<T extends NestedClient<any>> = T extends NestedClient<infer U> ? U : never;
+type ClientOptions<TClientContext extends ClientContext> = FriendlyClientOptions<TClientContext> & {
+    context: TClientContext;
+};
+interface ClientLink<TClientContext extends ClientContext> {
+    call: (path: readonly string[], input: unknown, options: ClientOptions<TClientContext>) => Promise<unknown>;
+}
+
+export type { ClientLink as C, FriendlyClientOptions as F, HTTPPath as H, InferClientContext as I, NestedClient as N, ClientContext as a, ClientOptions as b, ClientPromiseResult as c, HTTPMethod as d, ClientRest as e, Client as f };

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

@@ -0,0 +1,30 @@
+import { PromiseWithError } from '@orpc/shared';
+
+type HTTPPath = `/${string}`;
+type HTTPMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+type ClientContext = Record<PropertyKey, any>;
+type FriendlyClientOptions<TClientContext extends ClientContext> = {
+    signal?: AbortSignal;
+    lastEventId?: string | undefined;
+} & (Record<never, never> extends TClientContext ? {
+    context?: TClientContext;
+} : {
+    context: TClientContext;
+});
+type ClientRest<TClientContext extends ClientContext, TInput> = Record<never, never> extends TClientContext ? undefined extends TInput ? [input?: TInput, options?: FriendlyClientOptions<TClientContext>] : [input: TInput, options?: FriendlyClientOptions<TClientContext>] : [input: TInput, options: FriendlyClientOptions<TClientContext>];
+type ClientPromiseResult<TOutput, TError> = PromiseWithError<TOutput, TError>;
+interface Client<TClientContext extends ClientContext, TInput, TOutput, TError> {
+    (...rest: ClientRest<TClientContext, TInput>): ClientPromiseResult<TOutput, TError>;
+}
+type NestedClient<TClientContext extends ClientContext> = Client<TClientContext, any, any, any> | {
+    [k: string]: NestedClient<TClientContext>;
+};
+type InferClientContext<T extends NestedClient<any>> = T extends NestedClient<infer U> ? U : never;
+type ClientOptions<TClientContext extends ClientContext> = FriendlyClientOptions<TClientContext> & {
+    context: TClientContext;
+};
+interface ClientLink<TClientContext extends ClientContext> {
+    call: (path: readonly string[], input: unknown, options: ClientOptions<TClientContext>) => Promise<unknown>;
+}
+
+export type { ClientLink as C, FriendlyClientOptions as F, HTTPPath as H, InferClientContext as I, NestedClient as N, ClientContext as a, ClientOptions as b, ClientPromiseResult as c, HTTPMethod as d, ClientRest as e, Client as f };

package/dist/shared/client.D-jrSuDb.d.ts

@@ -0,0 +1,103 @@
+import { a as ClientContext, b as ClientOptions, d as HTTPMethod } from './client.C0lT7w02.js';
+import { c as StandardLinkCodec, a as StandardLinkOptions } from './client.grRbC25r.js';
+import { Segment, Value } from '@orpc/shared';
+import { StandardHeaders, StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
+
+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;
+}
+interface StandardRPCJsonSerializerOptions {
+    customJsonSerializers?: readonly StandardRPCCustomJsonSerializer[];
+}
+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 StandardRPCSerializer {
+    #private;
+    private readonly jsonSerializer;
+    constructor(jsonSerializer: StandardRPCJsonSerializer);
+    serialize(data: unknown): object;
+    deserialize(data: unknown): unknown;
+}
+
+interface StandardRPCLinkCodecOptions<T extends ClientContext> {
+    /**
+     * Base url for all requests.
+     */
+    url: Value<string | URL, [
+        options: ClientOptions<T>,
+        path: readonly string[],
+        input: unknown
+    ]>;
+    /**
+     * The maximum length of the URL.
+     *
+     * @default 2083
+     */
+    maxUrlLength?: Value<number, [
+        options: ClientOptions<T>,
+        path: readonly string[],
+        input: unknown
+    ]>;
+    /**
+     * The method used to make the request.
+     *
+     * @default 'POST'
+     */
+    method?: Value<HTTPMethod, [
+        options: ClientOptions<T>,
+        path: readonly string[],
+        input: unknown
+    ]>;
+    /**
+     * The method to use when the payload cannot safely pass to the server with method return from method function.
+     * GET is not allowed, it's very dangerous.
+     *
+     * @default 'POST'
+     */
+    fallbackMethod?: Exclude<HTTPMethod, 'GET'>;
+    /**
+     * Inject headers to the request.
+     */
+    headers?: Value<StandardHeaders, [
+        options: ClientOptions<T>,
+        path: readonly string[],
+        input: unknown
+    ]>;
+}
+declare class StandardRPCLinkCodec<T extends ClientContext> implements StandardLinkCodec<T> {
+    private readonly serializer;
+    private readonly baseUrl;
+    private readonly maxUrlLength;
+    private readonly fallbackMethod;
+    private readonly expectedMethod;
+    private readonly headers;
+    constructor(serializer: StandardRPCSerializer, options: StandardRPCLinkCodecOptions<T>);
+    encode(path: readonly string[], input: unknown, options: ClientOptions<T>): Promise<StandardRequest>;
+    decode(response: StandardLazyResponse): Promise<unknown>;
+}
+
+interface StandardRPCLinkOptions<T extends ClientContext> extends StandardLinkOptions<T>, StandardRPCLinkCodecOptions<T>, StandardRPCJsonSerializerOptions {
+}
+
+export { STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES as S, type StandardRPCJsonSerializedMetaItem as a, type StandardRPCJsonSerialized as b, type StandardRPCCustomJsonSerializer as c, type StandardRPCJsonSerializerOptions as d, StandardRPCJsonSerializer as e, type StandardRPCLinkOptions as f, type StandardRPCLinkCodecOptions as g, StandardRPCLinkCodec as h, StandardRPCSerializer as i };

package/dist/shared/{client.3Q53fveR.mjs → client.DhAxdT4W.mjs}

@@ -1,7 +1,6 @@
-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';
+import { toArray, intercept, isObject, value, isAsyncIteratorObject, stringifyJSON } from '@orpc/shared';
+import { mergeStandardHeaders, ErrorEvent } from '@orpc/standard-server';
+import { C as COMMON_ORPC_ERROR_DEFS, b as isORPCErrorStatus, O as ORPCError, m as mapEventIterator, t as toORPCError } from './client.jKEwIsRd.mjs';
 
 class InvalidEventIteratorRetryResponse extends Error {
 }
@@ -9,10 +8,11 @@ class StandardLink {
   constructor(codec, sender, options = {}) {
     this.codec = codec;
     this.sender = sender;
-    const plugin = new CompositeClientPlugin(options.plugins);
-    plugin.init(options);
-    this.interceptors = options.interceptors ?? [];
-    this.clientInterceptors = options.clientInterceptors ?? [];
+    for (const plugin of toArray(options.plugins)) {
+      plugin.init?.(options);
+    }
+    this.interceptors = toArray(options.interceptors);
+    this.clientInterceptors = toArray(options.clientInterceptors);
   }
   interceptors;
   clientInterceptors;
@@ -180,6 +180,13 @@ class StandardRPCJsonSerializer {
   }
 }
 
+function toHttpPath(path) {
+  return `/${path.map(encodeURIComponent).join("/")}`;
+}
+function getMalformedResponseErrorCode(status) {
+  return Object.entries(COMMON_ORPC_ERROR_DEFS).find(([, def]) => def.status === status)?.[0] ?? "MALFORMED_ORPC_ERROR_RESPONSE";
+}
+
 class StandardRPCLinkCodec {
   constructor(serializer, options) {
     this.serializer = serializer;
@@ -196,17 +203,11 @@ 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) };
+    let headers = await value(this.headers, options, path, input);
     const baseUrl = await value(this.baseUrl, options, path, input);
-    const url = new URL(`${trim(baseUrl.toString(), "/")}/${path.map(encodeURIComponent).join("/")}`);
+    const url = new URL(`${baseUrl.toString().replace(/\/$/, "")}${toHttpPath(path)}`);
     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;
-      }
+      headers = mergeStandardHeaders(headers, { "last-event-id": options.lastEventId });
     }
     const serialized = this.serializer.serialize(input);
     if (expectedMethod === "GET" && !(serialized instanceof FormData) && !isAsyncIteratorObject(serialized)) {
@@ -232,7 +233,7 @@ class StandardRPCLinkCodec {
     };
   }
   async decode(response) {
-    const isOk = response.status >= 200 && response.status < 300;
+    const isOk = !isORPCErrorStatus(response.status);
     const deserialized = await (async () => {
       let isBodyOk = false;
       try {
@@ -254,8 +255,9 @@ class StandardRPCLinkCodec {
       if (ORPCError.isValidJSON(deserialized)) {
         throw ORPCError.fromJSON(deserialized);
       }
-      throw new Error("Invalid RPC error response format.", {
-        cause: deserialized
+      throw new ORPCError(getMalformedResponseErrorCode(response.status), {
+        status: response.status,
+        data: deserialized
       });
     }
     return deserialized;
@@ -331,4 +333,4 @@ class StandardRPCSerializer {
   }
 }
 
-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 };
+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, getMalformedResponseErrorCode as g, toHttpPath as t };

package/dist/shared/{client.DrOAzyMB.d.mts → client.grRbC25r.d.ts}

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

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

@@ -91,8 +91,8 @@ class ORPCError extends Error {
   status;
   data;
   constructor(code, ...[options]) {
-    if (options?.status && (options.status < 400 || options.status >= 600)) {
-      throw new Error("[ORPCError] The error status code must be in the 400-599 range.");
+    if (options?.status && !isORPCErrorStatus(options.status)) {
+      throw new Error("[ORPCError] Invalid error status code.");
     }
     const message = fallbackORPCErrorMessage(code, options?.message);
     super(message, options);
@@ -136,6 +136,9 @@ function toORPCError(error) {
     cause: error
   });
 }
+function isORPCErrorStatus(status) {
+  return status < 200 || status >= 400;
+}
 
 function mapEventIterator(iterator, maps) {
   return async function* () {
@@ -169,4 +172,4 @@ function mapEventIterator(iterator, maps) {
   }();
 }
 
-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 };
+export { COMMON_ORPC_ERROR_DEFS as C, ORPCError as O, fallbackORPCErrorMessage as a, isORPCErrorStatus as b, fallbackORPCErrorStatus as f, isDefinedError as i, mapEventIterator as m, toORPCError as t };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/client",
   "type": "module",
-  "version": "1.0.0-beta.3",
+  "version": "1.0.0-beta.5",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -39,9 +39,9 @@
     "dist"
   ],
   "dependencies": {
-    "@orpc/shared": "1.0.0-beta.3",
-    "@orpc/standard-server": "1.0.0-beta.3",
-    "@orpc/standard-server-fetch": "1.0.0-beta.3"
+    "@orpc/shared": "1.0.0-beta.5",
+    "@orpc/standard-server-fetch": "1.0.0-beta.5",
+    "@orpc/standard-server": "1.0.0-beta.5"
   },
   "devDependencies": {
     "zod": "^3.24.2"

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

@@ -1,30 +0,0 @@
-type ClientContext = Record<string, any>;
-type ClientOptions<TClientContext extends ClientContext> = {
-    signal?: AbortSignal;
-    lastEventId?: string | undefined;
-} & (Record<never, never> extends TClientContext ? {
-    context?: TClientContext;
-} : {
-    context: TClientContext;
-});
-type ClientRest<TClientContext extends ClientContext, TInput> = Record<never, never> extends TClientContext ? undefined extends TInput ? [input?: TInput, options?: ClientOptions<TClientContext>] : [input: TInput, options?: ClientOptions<TClientContext>] : [input: TInput, options: ClientOptions<TClientContext>];
-type ClientPromiseResult<TOutput, TError extends Error> = Promise<TOutput> & {
-    __error?: {
-        type: TError;
-    };
-};
-interface Client<TClientContext extends ClientContext, TInput, TOutput, TError extends Error> {
-    (...rest: ClientRest<TClientContext, TInput>): ClientPromiseResult<TOutput, TError>;
-}
-type NestedClient<TClientContext extends ClientContext> = Client<TClientContext, any, any, any> | {
-    [k: string]: NestedClient<TClientContext>;
-};
-type InferClientContext<T extends NestedClient<any>> = T extends NestedClient<infer U> ? U : never;
-type ClientOptionsOut<TClientContext extends ClientContext> = ClientOptions<TClientContext> & {
-    context: TClientContext;
-};
-interface ClientLink<TClientContext extends ClientContext> {
-    call: (path: readonly string[], input: unknown, options: ClientOptionsOut<TClientContext>) => Promise<unknown>;
-}
-
-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.CupM8eRP.d.ts

@@ -1,30 +0,0 @@
-type ClientContext = Record<string, any>;
-type ClientOptions<TClientContext extends ClientContext> = {
-    signal?: AbortSignal;
-    lastEventId?: string | undefined;
-} & (Record<never, never> extends TClientContext ? {
-    context?: TClientContext;
-} : {
-    context: TClientContext;
-});
-type ClientRest<TClientContext extends ClientContext, TInput> = Record<never, never> extends TClientContext ? undefined extends TInput ? [input?: TInput, options?: ClientOptions<TClientContext>] : [input: TInput, options?: ClientOptions<TClientContext>] : [input: TInput, options: ClientOptions<TClientContext>];
-type ClientPromiseResult<TOutput, TError extends Error> = Promise<TOutput> & {
-    __error?: {
-        type: TError;
-    };
-};
-interface Client<TClientContext extends ClientContext, TInput, TOutput, TError extends Error> {
-    (...rest: ClientRest<TClientContext, TInput>): ClientPromiseResult<TOutput, TError>;
-}
-type NestedClient<TClientContext extends ClientContext> = Client<TClientContext, any, any, any> | {
-    [k: string]: NestedClient<TClientContext>;
-};
-type InferClientContext<T extends NestedClient<any>> = T extends NestedClient<infer U> ? U : never;
-type ClientOptionsOut<TClientContext extends ClientContext> = ClientOptions<TClientContext> & {
-    context: TClientContext;
-};
-interface ClientLink<TClientContext extends ClientContext> {
-    call: (path: readonly string[], input: unknown, options: ClientOptionsOut<TClientContext>) => Promise<unknown>;
-}
-
-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 };