@orpc/client 0.0.0-next.f17a1a0 → 0.0.0-next.f47352c

package/README.md

@@ -1,5 +1,5 @@
 <div align="center">
-  <image align="center" src="https://orpc.unnoq.com/logo.webp" width=280 />
+  <image align="center" src="https://orpc.unnoq.com/logo.webp" width=280 alt="oRPC logo" />
 </div>
 
 <h1></h1>
@@ -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.
@@ -53,11 +53,16 @@ You can find the full documentation [here](https://orpc.unnoq.com).
 - [@orpc/contract](https://www.npmjs.com/package/@orpc/contract): Build your API contract.
 - [@orpc/server](https://www.npmjs.com/package/@orpc/server): Build your API or implement API contract.
 - [@orpc/client](https://www.npmjs.com/package/@orpc/client): Consume your API on the client with type-safety.
+- [@orpc/react](https://www.npmjs.com/package/@orpc/react): Utilities for integrating oRPC with React and React Server Actions.
 - [@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`
 
@@ -83,6 +88,14 @@ const client: RouterClient<typeof router> = createORPCClient(link)
 const client: ContractRouterClient<typeof contract> = createORPCClient(link)
 ```
 
+## Sponsors
+
+<p align="center">
+  <a href="https://cdn.jsdelivr.net/gh/unnoq/unnoq/sponsors.svg">
+    <img src='https://cdn.jsdelivr.net/gh/unnoq/unnoq/sponsors.svg'/>
+  </a>
+</p>
+
 ## License
 
 Distributed under the MIT License. See [LICENSE](https://github.com/unnoq/orpc/blob/main/LICENSE) for more information.

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

@@ -0,0 +1,26 @@
+import { StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
+import { ToFetchRequestOptions } from '@orpc/standard-server-fetch';
+import { a as ClientContext, b as ClientOptions } from '../../shared/client.C0lT7w02.mjs';
+import { d as StandardLinkClient, b as StandardLink } from '../../shared/client.5813Ufvs.mjs';
+import { f as StandardRPCLinkOptions } from '../../shared/client.Bt94sjrK.mjs';
+import '@orpc/shared';
+
+interface LinkFetchClientOptions<T extends ClientContext> extends ToFetchRequestOptions {
+    fetch?: (request: Request, init: {
+        redirect?: Request['redirect'];
+    }, options: ClientOptions<T>, path: readonly string[], input: unknown) => Promise<Response>;
+}
+declare class LinkFetchClient<T extends ClientContext> implements StandardLinkClient<T> {
+    private readonly fetch;
+    private readonly toFetchRequestOptions;
+    constructor(options: LinkFetchClientOptions<T>);
+    call(request: StandardRequest, options: ClientOptions<T>, path: readonly string[], input: unknown): Promise<StandardLazyResponse>;
+}
+
+interface RPCLinkOptions<T extends ClientContext> extends StandardRPCLinkOptions<T>, LinkFetchClientOptions<T> {
+}
+declare class RPCLink<T extends ClientContext> extends StandardLink<T> {
+    constructor(options: RPCLinkOptions<T>);
+}
+
+export { LinkFetchClient, type LinkFetchClientOptions, RPCLink, type RPCLinkOptions };

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

@@ -0,0 +1,26 @@
+import { StandardRequest, StandardLazyResponse } from '@orpc/standard-server';
+import { ToFetchRequestOptions } from '@orpc/standard-server-fetch';
+import { a as ClientContext, b as ClientOptions } from '../../shared/client.C0lT7w02.js';
+import { d as StandardLinkClient, b as StandardLink } from '../../shared/client.grRbC25r.js';
+import { f as StandardRPCLinkOptions } from '../../shared/client.D-jrSuDb.js';
+import '@orpc/shared';
+
+interface LinkFetchClientOptions<T extends ClientContext> extends ToFetchRequestOptions {
+    fetch?: (request: Request, init: {
+        redirect?: Request['redirect'];
+    }, options: ClientOptions<T>, path: readonly string[], input: unknown) => Promise<Response>;
+}
+declare class LinkFetchClient<T extends ClientContext> implements StandardLinkClient<T> {
+    private readonly fetch;
+    private readonly toFetchRequestOptions;
+    constructor(options: LinkFetchClientOptions<T>);
+    call(request: StandardRequest, options: ClientOptions<T>, path: readonly string[], input: unknown): Promise<StandardLazyResponse>;
+}
+
+interface RPCLinkOptions<T extends ClientContext> extends StandardRPCLinkOptions<T>, LinkFetchClientOptions<T> {
+}
+declare class RPCLink<T extends ClientContext> extends StandardLink<T> {
+    constructor(options: RPCLinkOptions<T>);
+}
+
+export { LinkFetchClient, type LinkFetchClientOptions, RPCLink, type RPCLinkOptions };

package/dist/adapters/fetch/index.mjs

@@ -0,0 +1,32 @@
+import { toFetchRequest, toStandardLazyResponse } from '@orpc/standard-server-fetch';
+import { S as StandardLink, b as StandardRPCJsonSerializer, c as StandardRPCLinkCodec, d as StandardRPCSerializer } from '../../shared/client.DhAxdT4W.mjs';
+import '@orpc/shared';
+import '@orpc/standard-server';
+import '../../shared/client.jKEwIsRd.mjs';
+
+class LinkFetchClient {
+  fetch;
+  toFetchRequestOptions;
+  constructor(options) {
+    this.fetch = options?.fetch ?? globalThis.fetch.bind(globalThis);
+    this.toFetchRequestOptions = options;
+  }
+  async call(request, options, path, input) {
+    const fetchRequest = toFetchRequest(request, this.toFetchRequestOptions);
+    const fetchResponse = await this.fetch(fetchRequest, { redirect: "manual" }, options, path, input);
+    const lazyResponse = toStandardLazyResponse(fetchResponse);
+    return lazyResponse;
+  }
+}
+
+class RPCLink extends StandardLink {
+  constructor(options) {
+    const jsonSerializer = new StandardRPCJsonSerializer(options);
+    const serializer = new StandardRPCSerializer(jsonSerializer);
+    const linkCodec = new StandardRPCLinkCodec(serializer, options);
+    const linkClient = new LinkFetchClient(options);
+    super(linkCodec, linkClient, options);
+  }
+}
+
+export { LinkFetchClient, RPCLink };

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

@@ -0,0 +1,10 @@
+export { I as InvalidEventIteratorRetryResponse, b as StandardLink, d as StandardLinkClient, c as StandardLinkCodec, a as StandardLinkOptions, S as StandardLinkPlugin } from '../../shared/client.5813Ufvs.mjs';
+export { S as STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES, c as StandardRPCCustomJsonSerializer, b as StandardRPCJsonSerialized, a as StandardRPCJsonSerializedMetaItem, e as StandardRPCJsonSerializer, d as StandardRPCJsonSerializerOptions, h as StandardRPCLinkCodec, g as StandardRPCLinkCodecOptions, f as StandardRPCLinkOptions, i as StandardRPCSerializer } from '../../shared/client.Bt94sjrK.mjs';
+import { H as HTTPPath } from '../../shared/client.C0lT7w02.mjs';
+import '@orpc/shared';
+import '@orpc/standard-server';
+
+declare function toHttpPath(path: readonly string[]): HTTPPath;
+declare function getMalformedResponseErrorCode(status: number): string;
+
+export { getMalformedResponseErrorCode, toHttpPath };

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

@@ -0,0 +1,10 @@
+export { I as InvalidEventIteratorRetryResponse, b as StandardLink, d as StandardLinkClient, c as StandardLinkCodec, a as StandardLinkOptions, S as StandardLinkPlugin } from '../../shared/client.grRbC25r.js';
+export { S as STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES, c as StandardRPCCustomJsonSerializer, b as StandardRPCJsonSerialized, a as StandardRPCJsonSerializedMetaItem, e as StandardRPCJsonSerializer, d as StandardRPCJsonSerializerOptions, h as StandardRPCLinkCodec, g as StandardRPCLinkCodecOptions, f as StandardRPCLinkOptions, i as StandardRPCSerializer } from '../../shared/client.D-jrSuDb.js';
+import { H as HTTPPath } from '../../shared/client.C0lT7w02.js';
+import '@orpc/shared';
+import '@orpc/standard-server';
+
+declare function toHttpPath(path: readonly string[]): HTTPPath;
+declare function getMalformedResponseErrorCode(status: number): string;
+
+export { getMalformedResponseErrorCode, toHttpPath };

package/dist/adapters/standard/index.mjs

@@ -0,0 +1,4 @@
+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, g as getMalformedResponseErrorCode, t as toHttpPath } from '../../shared/client.DhAxdT4W.mjs';
+import '@orpc/shared';
+import '@orpc/standard-server';
+import '../../shared/client.jKEwIsRd.mjs';

package/dist/index.d.mts

@@ -0,0 +1,155 @@
+import { N as NestedClient, C as ClientLink, I as InferClientContext, a as ClientContext, b as ClientOptions, c as ClientPromiseResult, F as FriendlyClientOptions } from './shared/client.C0lT7w02.mjs';
+export { f as Client, e as ClientRest, d as HTTPMethod, H as HTTPPath } from './shared/client.C0lT7w02.mjs';
+import { Promisable, MaybeOptionalOptions, ThrowableError } from '@orpc/shared';
+export { Registry, ThrowableError, onError, onFinish, onStart, onSuccess } from '@orpc/shared';
+export { ErrorEvent } from '@orpc/standard-server';
+
+interface createORPCClientOptions {
+    /**
+     * Use as base path for all procedure, useful when you only want to call a subset of the procedure.
+     */
+    path?: string[];
+}
+declare function createORPCClient<T extends NestedClient<any>>(link: ClientLink<InferClientContext<T>>, options?: createORPCClientOptions): T;
+
+/**
+ * DynamicLink provides a way to dynamically resolve and delegate calls to other ClientLinks
+ * based on the request path, input, and context.
+ */
+declare class DynamicLink<TClientContext extends ClientContext> implements ClientLink<TClientContext> {
+    private readonly linkResolver;
+    constructor(linkResolver: (options: ClientOptions<TClientContext>, path: readonly string[], input: unknown) => Promisable<ClientLink<TClientContext>>);
+    call(path: readonly string[], input: unknown, options: ClientOptions<TClientContext>): Promise<unknown>;
+}
+
+declare const COMMON_ORPC_ERROR_DEFS: {
+    readonly BAD_REQUEST: {
+        readonly status: 400;
+        readonly message: "Bad Request";
+    };
+    readonly UNAUTHORIZED: {
+        readonly status: 401;
+        readonly message: "Unauthorized";
+    };
+    readonly FORBIDDEN: {
+        readonly status: 403;
+        readonly message: "Forbidden";
+    };
+    readonly NOT_FOUND: {
+        readonly status: 404;
+        readonly message: "Not Found";
+    };
+    readonly METHOD_NOT_SUPPORTED: {
+        readonly status: 405;
+        readonly message: "Method Not Supported";
+    };
+    readonly NOT_ACCEPTABLE: {
+        readonly status: 406;
+        readonly message: "Not Acceptable";
+    };
+    readonly TIMEOUT: {
+        readonly status: 408;
+        readonly message: "Request Timeout";
+    };
+    readonly CONFLICT: {
+        readonly status: 409;
+        readonly message: "Conflict";
+    };
+    readonly PRECONDITION_FAILED: {
+        readonly status: 412;
+        readonly message: "Precondition Failed";
+    };
+    readonly PAYLOAD_TOO_LARGE: {
+        readonly status: 413;
+        readonly message: "Payload Too Large";
+    };
+    readonly UNSUPPORTED_MEDIA_TYPE: {
+        readonly status: 415;
+        readonly message: "Unsupported Media Type";
+    };
+    readonly UNPROCESSABLE_CONTENT: {
+        readonly status: 422;
+        readonly message: "Unprocessable Content";
+    };
+    readonly TOO_MANY_REQUESTS: {
+        readonly status: 429;
+        readonly message: "Too Many Requests";
+    };
+    readonly CLIENT_CLOSED_REQUEST: {
+        readonly status: 499;
+        readonly message: "Client Closed Request";
+    };
+    readonly INTERNAL_SERVER_ERROR: {
+        readonly status: 500;
+        readonly message: "Internal Server Error";
+    };
+    readonly NOT_IMPLEMENTED: {
+        readonly status: 501;
+        readonly message: "Not Implemented";
+    };
+    readonly BAD_GATEWAY: {
+        readonly status: 502;
+        readonly message: "Bad Gateway";
+    };
+    readonly SERVICE_UNAVAILABLE: {
+        readonly status: 503;
+        readonly message: "Service Unavailable";
+    };
+    readonly GATEWAY_TIMEOUT: {
+        readonly status: 504;
+        readonly message: "Gateway Timeout";
+    };
+};
+type CommonORPCErrorCode = keyof typeof COMMON_ORPC_ERROR_DEFS;
+type ORPCErrorCode = CommonORPCErrorCode | (string & {});
+declare function fallbackORPCErrorStatus(code: ORPCErrorCode, status: number | undefined): number;
+declare function fallbackORPCErrorMessage(code: ORPCErrorCode, message: string | undefined): string;
+type ORPCErrorOptions<TData> = ErrorOptions & {
+    defined?: boolean;
+    status?: number;
+    message?: string;
+} & (undefined extends TData ? {
+    data?: TData;
+} : {
+    data: TData;
+});
+declare class ORPCError<TCode extends ORPCErrorCode, TData> extends Error {
+    readonly defined: boolean;
+    readonly code: TCode;
+    readonly status: number;
+    readonly data: TData;
+    constructor(code: TCode, ...[options]: MaybeOptionalOptions<ORPCErrorOptions<TData>>);
+    toJSON(): ORPCErrorJSON<TCode, TData>;
+    static fromJSON<TCode extends ORPCErrorCode, TData>(json: ORPCErrorJSON<TCode, TData>, options?: ErrorOptions): ORPCError<TCode, TData>;
+    static isValidJSON(json: unknown): json is ORPCErrorJSON<ORPCErrorCode, unknown>;
+}
+type ORPCErrorJSON<TCode extends string, TData> = Pick<ORPCError<TCode, TData>, 'defined' | 'code' | 'status' | 'message' | 'data'>;
+declare function isDefinedError<T>(error: T): error is Extract<T, ORPCError<any, any>>;
+declare function toORPCError(error: unknown): ORPCError<any, any>;
+declare function isORPCErrorStatus(status: number): boolean;
+
+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> = [error: null, data: TOutput, isDefined: false, success: true] & {
+    error: null;
+    data: TOutput;
+    isDefined: false;
+    success: true;
+} | [error: Exclude<TError, ORPCError<any, any>>, data: undefined, isDefined: false, success: false] & {
+    error: Exclude<TError, ORPCError<any, any>>;
+    data: undefined;
+    isDefined: false;
+    success: false;
+} | [error: Extract<TError, ORPCError<any, any>>, data: undefined, isDefined: true, success: false] & {
+    error: Extract<TError, ORPCError<any, any>>;
+    data: undefined;
+    isDefined: true;
+    success: false;
+};
+declare function safe<TOutput, TError = ThrowableError>(promise: ClientPromiseResult<TOutput, TError>): Promise<SafeResult<TOutput, TError>>;
+declare function resolveFriendlyClientOptions<T extends ClientContext>(options: FriendlyClientOptions<T>): ClientOptions<T>;
+
+export { COMMON_ORPC_ERROR_DEFS, ClientContext, ClientLink, ClientOptions, ClientPromiseResult, type CommonORPCErrorCode, DynamicLink, FriendlyClientOptions, InferClientContext, NestedClient, ORPCError, type ORPCErrorCode, type ORPCErrorJSON, type ORPCErrorOptions, type SafeResult, createORPCClient, type createORPCClientOptions, fallbackORPCErrorMessage, fallbackORPCErrorStatus, isDefinedError, isORPCErrorStatus, mapEventIterator, resolveFriendlyClientOptions, safe, toORPCError };

package/dist/index.d.ts

@@ -0,0 +1,155 @@
+import { N as NestedClient, C as ClientLink, I as InferClientContext, a as ClientContext, b as ClientOptions, c as ClientPromiseResult, F as FriendlyClientOptions } from './shared/client.C0lT7w02.js';
+export { f as Client, e as ClientRest, d as HTTPMethod, H as HTTPPath } from './shared/client.C0lT7w02.js';
+import { Promisable, MaybeOptionalOptions, ThrowableError } from '@orpc/shared';
+export { Registry, ThrowableError, onError, onFinish, onStart, onSuccess } from '@orpc/shared';
+export { ErrorEvent } from '@orpc/standard-server';
+
+interface createORPCClientOptions {
+    /**
+     * Use as base path for all procedure, useful when you only want to call a subset of the procedure.
+     */
+    path?: string[];
+}
+declare function createORPCClient<T extends NestedClient<any>>(link: ClientLink<InferClientContext<T>>, options?: createORPCClientOptions): T;
+
+/**
+ * DynamicLink provides a way to dynamically resolve and delegate calls to other ClientLinks
+ * based on the request path, input, and context.
+ */
+declare class DynamicLink<TClientContext extends ClientContext> implements ClientLink<TClientContext> {
+    private readonly linkResolver;
+    constructor(linkResolver: (options: ClientOptions<TClientContext>, path: readonly string[], input: unknown) => Promisable<ClientLink<TClientContext>>);
+    call(path: readonly string[], input: unknown, options: ClientOptions<TClientContext>): Promise<unknown>;
+}
+
+declare const COMMON_ORPC_ERROR_DEFS: {
+    readonly BAD_REQUEST: {
+        readonly status: 400;
+        readonly message: "Bad Request";
+    };
+    readonly UNAUTHORIZED: {
+        readonly status: 401;
+        readonly message: "Unauthorized";
+    };
+    readonly FORBIDDEN: {
+        readonly status: 403;
+        readonly message: "Forbidden";
+    };
+    readonly NOT_FOUND: {
+        readonly status: 404;
+        readonly message: "Not Found";
+    };
+    readonly METHOD_NOT_SUPPORTED: {
+        readonly status: 405;
+        readonly message: "Method Not Supported";
+    };
+    readonly NOT_ACCEPTABLE: {
+        readonly status: 406;
+        readonly message: "Not Acceptable";
+    };
+    readonly TIMEOUT: {
+        readonly status: 408;
+        readonly message: "Request Timeout";
+    };
+    readonly CONFLICT: {
+        readonly status: 409;
+        readonly message: "Conflict";
+    };
+    readonly PRECONDITION_FAILED: {
+        readonly status: 412;
+        readonly message: "Precondition Failed";
+    };
+    readonly PAYLOAD_TOO_LARGE: {
+        readonly status: 413;
+        readonly message: "Payload Too Large";
+    };
+    readonly UNSUPPORTED_MEDIA_TYPE: {
+        readonly status: 415;
+        readonly message: "Unsupported Media Type";
+    };
+    readonly UNPROCESSABLE_CONTENT: {
+        readonly status: 422;
+        readonly message: "Unprocessable Content";
+    };
+    readonly TOO_MANY_REQUESTS: {
+        readonly status: 429;
+        readonly message: "Too Many Requests";
+    };
+    readonly CLIENT_CLOSED_REQUEST: {
+        readonly status: 499;
+        readonly message: "Client Closed Request";
+    };
+    readonly INTERNAL_SERVER_ERROR: {
+        readonly status: 500;
+        readonly message: "Internal Server Error";
+    };
+    readonly NOT_IMPLEMENTED: {
+        readonly status: 501;
+        readonly message: "Not Implemented";
+    };
+    readonly BAD_GATEWAY: {
+        readonly status: 502;
+        readonly message: "Bad Gateway";
+    };
+    readonly SERVICE_UNAVAILABLE: {
+        readonly status: 503;
+        readonly message: "Service Unavailable";
+    };
+    readonly GATEWAY_TIMEOUT: {
+        readonly status: 504;
+        readonly message: "Gateway Timeout";
+    };
+};
+type CommonORPCErrorCode = keyof typeof COMMON_ORPC_ERROR_DEFS;
+type ORPCErrorCode = CommonORPCErrorCode | (string & {});
+declare function fallbackORPCErrorStatus(code: ORPCErrorCode, status: number | undefined): number;
+declare function fallbackORPCErrorMessage(code: ORPCErrorCode, message: string | undefined): string;
+type ORPCErrorOptions<TData> = ErrorOptions & {
+    defined?: boolean;
+    status?: number;
+    message?: string;
+} & (undefined extends TData ? {
+    data?: TData;
+} : {
+    data: TData;
+});
+declare class ORPCError<TCode extends ORPCErrorCode, TData> extends Error {
+    readonly defined: boolean;
+    readonly code: TCode;
+    readonly status: number;
+    readonly data: TData;
+    constructor(code: TCode, ...[options]: MaybeOptionalOptions<ORPCErrorOptions<TData>>);
+    toJSON(): ORPCErrorJSON<TCode, TData>;
+    static fromJSON<TCode extends ORPCErrorCode, TData>(json: ORPCErrorJSON<TCode, TData>, options?: ErrorOptions): ORPCError<TCode, TData>;
+    static isValidJSON(json: unknown): json is ORPCErrorJSON<ORPCErrorCode, unknown>;
+}
+type ORPCErrorJSON<TCode extends string, TData> = Pick<ORPCError<TCode, TData>, 'defined' | 'code' | 'status' | 'message' | 'data'>;
+declare function isDefinedError<T>(error: T): error is Extract<T, ORPCError<any, any>>;
+declare function toORPCError(error: unknown): ORPCError<any, any>;
+declare function isORPCErrorStatus(status: number): boolean;
+
+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> = [error: null, data: TOutput, isDefined: false, success: true] & {
+    error: null;
+    data: TOutput;
+    isDefined: false;
+    success: true;
+} | [error: Exclude<TError, ORPCError<any, any>>, data: undefined, isDefined: false, success: false] & {
+    error: Exclude<TError, ORPCError<any, any>>;
+    data: undefined;
+    isDefined: false;
+    success: false;
+} | [error: Extract<TError, ORPCError<any, any>>, data: undefined, isDefined: true, success: false] & {
+    error: Extract<TError, ORPCError<any, any>>;
+    data: undefined;
+    isDefined: true;
+    success: false;
+};
+declare function safe<TOutput, TError = ThrowableError>(promise: ClientPromiseResult<TOutput, TError>): Promise<SafeResult<TOutput, TError>>;
+declare function resolveFriendlyClientOptions<T extends ClientContext>(options: FriendlyClientOptions<T>): ClientOptions<T>;
+
+export { COMMON_ORPC_ERROR_DEFS, ClientContext, ClientLink, ClientOptions, ClientPromiseResult, type CommonORPCErrorCode, DynamicLink, FriendlyClientOptions, InferClientContext, NestedClient, ORPCError, type ORPCErrorCode, type ORPCErrorJSON, type ORPCErrorOptions, type SafeResult, createORPCClient, type createORPCClientOptions, fallbackORPCErrorMessage, fallbackORPCErrorStatus, isDefinedError, isORPCErrorStatus, mapEventIterator, resolveFriendlyClientOptions, safe, toORPCError };

package/dist/index.mjs

@@ -0,0 +1,65 @@
+import { i as isDefinedError } from './shared/client.jKEwIsRd.mjs';
+export { C as COMMON_ORPC_ERROR_DEFS, O as ORPCError, a as fallbackORPCErrorMessage, f as fallbackORPCErrorStatus, b as isORPCErrorStatus, m as mapEventIterator, t as toORPCError } from './shared/client.jKEwIsRd.mjs';
+export { onError, onFinish, onStart, onSuccess } from '@orpc/shared';
+export { ErrorEvent } from '@orpc/standard-server';
+
+async function safe(promise) {
+  try {
+    const output = await promise;
+    return Object.assign(
+      [null, output, false, true],
+      { error: null, data: output, isDefined: false, success: true }
+    );
+  } catch (e) {
+    const error = e;
+    if (isDefinedError(error)) {
+      return Object.assign(
+        [error, void 0, true, false],
+        { error, data: void 0, isDefined: true, success: false }
+      );
+    }
+    return Object.assign(
+      [error, void 0, false, false],
+      { error, data: void 0, isDefined: false, success: false }
+    );
+  }
+}
+function resolveFriendlyClientOptions(options) {
+  return {
+    ...options,
+    context: options?.context ?? {}
+    // Context only optional if all fields are optional
+  };
+}
+
+function createORPCClient(link, options) {
+  const path = options?.path ?? [];
+  const procedureClient = async (...[input, options2 = {}]) => {
+    return await link.call(path, input, resolveFriendlyClientOptions(options2));
+  };
+  const recursive = new Proxy(procedureClient, {
+    get(target, key) {
+      if (typeof key !== "string") {
+        return Reflect.get(target, key);
+      }
+      return createORPCClient(link, {
+        ...options,
+        path: [...path, key]
+      });
+    }
+  });
+  return recursive;
+}
+
+class DynamicLink {
+  constructor(linkResolver) {
+    this.linkResolver = linkResolver;
+  }
+  async call(path, input, options) {
+    const resolvedLink = await this.linkResolver(options, path, input);
+    const output = await resolvedLink.call(path, input, options);
+    return output;
+  }
+}
+
+export { DynamicLink, createORPCClient, isDefinedError, resolveFriendlyClientOptions, safe };

package/dist/plugins/index.d.mts

@@ -0,0 +1,65 @@
+import { Value } from '@orpc/shared';
+import { S as StandardLinkPlugin, a as StandardLinkOptions } from '../shared/client.5813Ufvs.mjs';
+import { b as ClientOptions } from '../shared/client.C0lT7w02.mjs';
+import '@orpc/standard-server';
+
+interface ClientRetryPluginAttemptOptions {
+    lastEventRetry: number | undefined;
+    lastEventId: 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?: Value<number, [
+        clientOptions: ClientOptions<ClientRetryPluginContext>,
+        path: readonly string[],
+        input: unknown
+    ]>;
+    /**
+     * Delay (in ms) before retrying.
+     *
+     * @default (o) => o.lastEventRetry ?? 2000
+     */
+    retryDelay?: Value<number, [
+        attemptOptions: ClientRetryPluginAttemptOptions,
+        clientOptions: ClientOptions<ClientRetryPluginContext>,
+        path: readonly string[],
+        input: unknown
+    ]>;
+    /**
+     * Determine should retry or not.
+     *
+     * @default true
+     */
+    shouldRetry?: Value<boolean, [
+        attemptOptions: ClientRetryPluginAttemptOptions,
+        clientOptions: ClientOptions<ClientRetryPluginContext>,
+        path: readonly string[],
+        input: unknown
+    ]>;
+    /**
+     * The hook called when retrying, and return the unsubscribe function.
+     */
+    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 ClientRetryPluginContext> implements StandardLinkPlugin<T> {
+    private readonly defaultRetry;
+    private readonly defaultRetryDelay;
+    private readonly defaultShouldRetry;
+    private readonly defaultOnRetry;
+    constructor(options?: ClientRetryPluginOptions);
+    init(options: StandardLinkOptions<T>): void;
+}
+
+export { ClientRetryPlugin, type ClientRetryPluginAttemptOptions, type ClientRetryPluginContext, ClientRetryPluginInvalidEventIteratorRetryResponse, type ClientRetryPluginOptions };