@orpc/client 0.0.0-next.cd121e3 → 0.0.0-next.ce2f84d

package/README.md

@@ -32,7 +32,7 @@
 - **Contract-First Development 📜**: (Optional) Define your API contract upfront and implement it with confidence.
 - **Exceptional Developer Experience ✨**: Enjoy a streamlined workflow with robust typing and clear, in-code documentation.
 - **Multi-Runtime Support 🌍**: Run your code seamlessly on Cloudflare, Deno, Bun, Node.js, and more.
-- **Framework Integrations 🧩**: Supports Tanstack Query (React, Vue), Pinia Colada, and more.
+- **Framework Integrations 🧩**: Supports Tanstack Query (React, Vue, Solid, Svelte), Pinia Colada, and more.
 - **Server Actions ⚡️**: Fully compatible with React Server Actions on Next.js, TanStack Start, and more.
 - **Standard Schema Support 🗂️**: Effortlessly work with Zod, Valibot, ArkType, and others right out of the box.
 - **Fast & Lightweight 💨**: Built on native APIs across all runtimes – optimized for speed and efficiency.
@@ -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

@@ -1,103 +1,26 @@
-import { Value } from '@orpc/shared';
-import { ToFetchBodyOptions } from '@orpc/standard-server-fetch';
-import { C as ClientContext, a as ClientOptionsOut, E as EventIteratorReconnectOptions, b as ClientLink } from '../../shared/client.D_CzLDyB.mjs';
-import { RPCSerializer } from '../standard/index.mjs';
+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 FetchWithContext<TClientContext extends ClientContext> {
-    (url: URL, init: RequestInit, options: ClientOptionsOut<TClientContext>, path: readonly string[], input: unknown): Promise<Response>;
+interface LinkFetchClientOptions<T extends ClientContext> extends ToFetchRequestOptions {
+    fetch?: (request: Request, init: {
+        redirect?: Request['redirect'];
+    }, options: ClientOptions<T>, path: readonly string[], input: unknown) => Promise<Response>;
 }
-
-type HTTPMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
-declare class InvalidEventSourceRetryResponse extends Error {
+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<TClientContext extends ClientContext> extends ToFetchBodyOptions {
-    /**
-     * Base url for all requests.
-     */
-    url: string;
-    /**
-     * The maximum length of the URL.
-     *
-     * @default 2083
-     */
-    maxUrlLength?: number;
-    /**
-     * The method used to make the request.
-     *
-     * @default 'POST'
-     */
-    method?: Value<HTTPMethod, [
-        options: ClientOptionsOut<TClientContext>,
-        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<[string, string][] | Record<string, string> | Headers, [
-        options: ClientOptionsOut<TClientContext>,
-        path: readonly string[],
-        input: unknown
-    ]>;
-    /**
-     * Custom fetch implementation.
-     *
-     * @default globalThis.fetch.bind(globalThis)
-     */
-    fetch?: FetchWithContext<TClientContext>;
-    rpcSerializer?: RPCSerializer;
-    /**
-     * Maximum number of retry attempts for EventSource errors before throwing.
-     *
-     * @default 5
-     */
-    eventSourceMaxNumberOfRetries?: number;
-    /**
-     * Delay (in ms) before retrying an EventSource call.
-     *
-     * @default ({retryTimes, lastRetry}) => lastRetry ?? (1000 * 2 ** retryTimes)
-     */
-    eventSourceRetryDelay?: Value<number, [
-        reconnectOptions: EventIteratorReconnectOptions,
-        options: ClientOptionsOut<TClientContext>,
-        path: readonly string[],
-        input: unknown
-    ]>;
-    /**
-     * Function to determine if an error is retryable.
-     *
-     * @default true
-     */
-    eventSourceRetry?: Value<boolean, [
-        reconnectOptions: EventIteratorReconnectOptions,
-        options: ClientOptionsOut<TClientContext>,
-        path: readonly string[],
-        input: unknown
-    ]>;
+
+interface RPCLinkOptions<T extends ClientContext> extends StandardRPCLinkOptions<T>, LinkFetchClientOptions<T> {
 }
-declare class RPCLink<TClientContext extends ClientContext> implements ClientLink<TClientContext> {
-    private readonly fetch;
-    private readonly rpcSerializer;
-    private readonly maxUrlLength;
-    private readonly fallbackMethod;
-    private readonly method;
-    private readonly headers;
-    private readonly url;
-    private readonly eventSourceMaxNumberOfRetries;
-    private readonly eventSourceRetryDelay;
-    private readonly eventSourceRetry;
-    private readonly toFetchBodyOptions;
-    constructor(options: RPCLinkOptions<TClientContext>);
-    call(path: readonly string[], input: unknown, options: ClientOptionsOut<TClientContext>): Promise<unknown>;
-    private performCall;
-    private encodeRequest;
+declare class RPCLink<T extends ClientContext> extends StandardLink<T> {
+    constructor(options: RPCLinkOptions<T>);
 }
 
-export { type FetchWithContext, InvalidEventSourceRetryResponse, RPCLink, type RPCLinkOptions };
+export { LinkFetchClient, type LinkFetchClientOptions, RPCLink, type RPCLinkOptions };

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

@@ -1,103 +1,26 @@
-import { Value } from '@orpc/shared';
-import { ToFetchBodyOptions } from '@orpc/standard-server-fetch';
-import { C as ClientContext, a as ClientOptionsOut, E as EventIteratorReconnectOptions, b as ClientLink } from '../../shared/client.D_CzLDyB.js';
-import { RPCSerializer } from '../standard/index.js';
+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 FetchWithContext<TClientContext extends ClientContext> {
-    (url: URL, init: RequestInit, options: ClientOptionsOut<TClientContext>, path: readonly string[], input: unknown): Promise<Response>;
+interface LinkFetchClientOptions<T extends ClientContext> extends ToFetchRequestOptions {
+    fetch?: (request: Request, init: {
+        redirect?: Request['redirect'];
+    }, options: ClientOptions<T>, path: readonly string[], input: unknown) => Promise<Response>;
 }
-
-type HTTPMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
-declare class InvalidEventSourceRetryResponse extends Error {
+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<TClientContext extends ClientContext> extends ToFetchBodyOptions {
-    /**
-     * Base url for all requests.
-     */
-    url: string;
-    /**
-     * The maximum length of the URL.
-     *
-     * @default 2083
-     */
-    maxUrlLength?: number;
-    /**
-     * The method used to make the request.
-     *
-     * @default 'POST'
-     */
-    method?: Value<HTTPMethod, [
-        options: ClientOptionsOut<TClientContext>,
-        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<[string, string][] | Record<string, string> | Headers, [
-        options: ClientOptionsOut<TClientContext>,
-        path: readonly string[],
-        input: unknown
-    ]>;
-    /**
-     * Custom fetch implementation.
-     *
-     * @default globalThis.fetch.bind(globalThis)
-     */
-    fetch?: FetchWithContext<TClientContext>;
-    rpcSerializer?: RPCSerializer;
-    /**
-     * Maximum number of retry attempts for EventSource errors before throwing.
-     *
-     * @default 5
-     */
-    eventSourceMaxNumberOfRetries?: number;
-    /**
-     * Delay (in ms) before retrying an EventSource call.
-     *
-     * @default ({retryTimes, lastRetry}) => lastRetry ?? (1000 * 2 ** retryTimes)
-     */
-    eventSourceRetryDelay?: Value<number, [
-        reconnectOptions: EventIteratorReconnectOptions,
-        options: ClientOptionsOut<TClientContext>,
-        path: readonly string[],
-        input: unknown
-    ]>;
-    /**
-     * Function to determine if an error is retryable.
-     *
-     * @default true
-     */
-    eventSourceRetry?: Value<boolean, [
-        reconnectOptions: EventIteratorReconnectOptions,
-        options: ClientOptionsOut<TClientContext>,
-        path: readonly string[],
-        input: unknown
-    ]>;
+
+interface RPCLinkOptions<T extends ClientContext> extends StandardRPCLinkOptions<T>, LinkFetchClientOptions<T> {
 }
-declare class RPCLink<TClientContext extends ClientContext> implements ClientLink<TClientContext> {
-    private readonly fetch;
-    private readonly rpcSerializer;
-    private readonly maxUrlLength;
-    private readonly fallbackMethod;
-    private readonly method;
-    private readonly headers;
-    private readonly url;
-    private readonly eventSourceMaxNumberOfRetries;
-    private readonly eventSourceRetryDelay;
-    private readonly eventSourceRetry;
-    private readonly toFetchBodyOptions;
-    constructor(options: RPCLinkOptions<TClientContext>);
-    call(path: readonly string[], input: unknown, options: ClientOptionsOut<TClientContext>): Promise<unknown>;
-    private performCall;
-    private encodeRequest;
+declare class RPCLink<T extends ClientContext> extends StandardLink<T> {
+    constructor(options: RPCLinkOptions<T>);
 }
 
-export { type FetchWithContext, InvalidEventSourceRetryResponse, RPCLink, type RPCLinkOptions };
+export { LinkFetchClient, type LinkFetchClientOptions, RPCLink, type RPCLinkOptions };

package/dist/adapters/fetch/index.mjs

@@ -1,121 +1,32 @@
-import { isAsyncIteratorObject, value, trim, stringifyJSON } from '@orpc/shared';
-import { toFetchBody, toStandardBody } from '@orpc/standard-server-fetch';
-import { c as createAutoRetryEventIterator, O as ORPCError } from '../../shared/client.Ly4zGQrc.mjs';
-import { a as RPCSerializer } from '../../shared/client.DHJ8vRIG.mjs';
+import { toFetchRequest, toStandardLazyResponse } from '@orpc/standard-server-fetch';
+import { S as StandardLink, b as StandardRPCJsonSerializer, c as StandardRPCLinkCodec, d as StandardRPCSerializer } from '../../shared/client.DSPm2IGZ.mjs';
+import '@orpc/shared';
 import '@orpc/standard-server';
+import '../../shared/client.jKEwIsRd.mjs';
 
-class InvalidEventSourceRetryResponse extends Error {
-}
-class RPCLink {
+class LinkFetchClient {
   fetch;
-  rpcSerializer;
-  maxUrlLength;
-  fallbackMethod;
-  method;
-  headers;
-  url;
-  eventSourceMaxNumberOfRetries;
-  eventSourceRetryDelay;
-  eventSourceRetry;
-  toFetchBodyOptions;
+  toFetchRequestOptions;
   constructor(options) {
-    this.fetch = options.fetch ?? globalThis.fetch.bind(globalThis);
-    this.rpcSerializer = options.rpcSerializer ?? new RPCSerializer();
-    this.maxUrlLength = options.maxUrlLength ?? 2083;
-    this.fallbackMethod = options.fallbackMethod ?? "POST";
-    this.url = options.url;
-    this.eventSourceMaxNumberOfRetries = options.eventSourceMaxNumberOfRetries ?? 5;
-    this.method = options.method ?? this.fallbackMethod;
-    this.headers = options.headers ?? {};
-    this.eventSourceRetry = options.eventSourceRetry ?? true;
-    this.eventSourceRetryDelay = options.eventSourceRetryDelay ?? (({ retryTimes, lastRetry }) => lastRetry ?? 1e3 * 2 ** retryTimes);
-    this.toFetchBodyOptions = options;
-  }
-  async call(path, input, options) {
-    const output = await this.performCall(path, input, options);
-    if (!isAsyncIteratorObject(output)) {
-      return output;
-    }
-    return createAutoRetryEventIterator(output, async (reconnectOptions) => {
-      if (options.signal?.aborted || reconnectOptions.retryTimes > this.eventSourceMaxNumberOfRetries) {
-        return null;
-      }
-      if (!await value(this.eventSourceRetry, reconnectOptions, options, path, input)) {
-        return null;
-      }
-      const delay = await value(this.eventSourceRetryDelay, reconnectOptions, options, path, input);
-      await new Promise((resolve) => setTimeout(resolve, delay));
-      const updatedOptions = { ...options, lastEventId: reconnectOptions.lastEventId };
-      const maybeIterator = await this.performCall(path, input, updatedOptions);
-      if (!isAsyncIteratorObject(maybeIterator)) {
-        throw new InvalidEventSourceRetryResponse("Invalid EventSource retry response");
-      }
-      return maybeIterator;
-    }, void 0);
+    this.fetch = options?.fetch ?? globalThis.fetch.bind(globalThis);
+    this.toFetchRequestOptions = options;
   }
-  async performCall(path, input, options) {
-    const encoded = await this.encodeRequest(path, input, options);
-    const fetchBody = toFetchBody(encoded.body, encoded.headers, this.toFetchBodyOptions);
-    if (options.lastEventId !== void 0) {
-      encoded.headers.set("last-event-id", options.lastEventId);
-    }
-    const response = await this.fetch(encoded.url, {
-      method: encoded.method,
-      headers: encoded.headers,
-      body: fetchBody,
-      signal: options.signal
-    }, options, path, input);
-    const body = await toStandardBody(response);
-    const deserialized = (() => {
-      try {
-        return this.rpcSerializer.deserialize(body);
-      } catch (error) {
-        if (response.ok) {
-          throw new ORPCError("INTERNAL_SERVER_ERROR", {
-            message: "Invalid RPC response",
-            cause: error
-          });
-        }
-        throw new ORPCError(response.status.toString(), {
-          message: response.statusText
-        });
-      }
-    })();
-    if (!response.ok) {
-      if (ORPCError.isValidJSON(deserialized)) {
-        throw ORPCError.fromJSON(deserialized);
-      }
-      throw new ORPCError("INTERNAL_SERVER_ERROR", {
-        message: "Invalid RPC error response",
-        cause: deserialized
-      });
-    }
-    return deserialized;
+  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;
   }
-  async encodeRequest(path, input, options) {
-    const expectedMethod = await value(this.method, options, path, input);
-    const headers = new Headers(await value(this.headers, options, path, input));
-    const url = new URL(`${trim(this.url, "/")}/${path.map(encodeURIComponent).join("/")}`);
-    const serialized = this.rpcSerializer.serialize(input);
-    if (expectedMethod === "GET" && !(serialized instanceof FormData) && !(serialized instanceof Blob) && !isAsyncIteratorObject(serialized)) {
-      const getUrl = new URL(url);
-      getUrl.searchParams.append("data", stringifyJSON(serialized) ?? "");
-      if (getUrl.toString().length <= this.maxUrlLength) {
-        return {
-          body: void 0,
-          method: expectedMethod,
-          headers,
-          url: getUrl
-        };
-      }
-    }
-    return {
-      url,
-      method: expectedMethod === "GET" ? this.fallbackMethod : expectedMethod,
-      headers,
-      body: serialized
-    };
+}
+
+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 { InvalidEventSourceRetryResponse, RPCLink };
+export { LinkFetchClient, RPCLink };

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

@@ -1,22 +1,10 @@
-import { Segment } from '@orpc/shared';
+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';
 
-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 function toHttpPath(path: readonly string[]): HTTPPath;
+declare function getMalformedResponseErrorCode(status: number): string;
 
-declare class RPCSerializer {
-    #private;
-    private readonly jsonSerializer;
-    constructor(jsonSerializer?: RPCJsonSerializer);
-    serialize(data: unknown): unknown;
-    deserialize(data: unknown): unknown;
-}
-
-export { type RPCJsonSerialized, type RPCJsonSerializedMeta, RPCJsonSerializer, RPCSerializer };
+export { getMalformedResponseErrorCode, toHttpPath };

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

@@ -1,22 +1,10 @@
-import { Segment } from '@orpc/shared';
+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';
 
-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 function toHttpPath(path: readonly string[]): HTTPPath;
+declare function getMalformedResponseErrorCode(status: number): string;
 
-declare class RPCSerializer {
-    #private;
-    private readonly jsonSerializer;
-    constructor(jsonSerializer?: RPCJsonSerializer);
-    serialize(data: unknown): unknown;
-    deserialize(data: unknown): unknown;
-}
-
-export { type RPCJsonSerialized, type RPCJsonSerializedMeta, RPCJsonSerializer, RPCSerializer };
+export { getMalformedResponseErrorCode, toHttpPath };

package/dist/adapters/standard/index.mjs

@@ -1,4 +1,4 @@
-export { R as RPCJsonSerializer, a as RPCSerializer } from '../../shared/client.DHJ8vRIG.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, g as getMalformedResponseErrorCode, t as toHttpPath } from '../../shared/client.DSPm2IGZ.mjs';
 import '@orpc/shared';
 import '@orpc/standard-server';
-import '../../shared/client.Ly4zGQrc.mjs';
+import '../../shared/client.jKEwIsRd.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 { Promisable, MaybeOptionalOptions } from '@orpc/shared';
+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 {
@@ -17,8 +18,8 @@ declare function createORPCClient<T extends NestedClient<any>>(link: ClientLink<
  */
 declare class DynamicLink<TClientContext extends ClientContext> implements ClientLink<TClientContext> {
     private readonly linkResolver;
-    constructor(linkResolver: (options: ClientOptionsOut<TClientContext>, path: readonly string[], input: unknown) => Promisable<ClientLink<TClientContext>>);
-    call(path: readonly string[], input: unknown, options: ClientOptionsOut<TClientContext>): Promise<unknown>;
+    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: {
@@ -125,29 +126,30 @@ declare class ORPCError<TCode extends ORPCErrorCode, TData> extends Error {
 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;
 
-type ConnectionStatus = 'reconnecting' | 'connected' | 'closed';
-interface EventIteratorState {
-    status: ConnectionStatus;
-    listeners: Array<(newStatus: ConnectionStatus) => void>;
-}
-declare function registerEventIteratorState(iterator: AsyncIteratorObject<unknown, unknown, void>, state: EventIteratorState): void;
-declare function updateEventIteratorStatus(state: EventIteratorState, status: ConnectionStatus): void;
-declare function onEventIteratorStatusChange(iterator: AsyncIteratorObject<unknown, unknown, void>, callback: (status: ConnectionStatus) => void, notifyImmediately?: boolean): () => void;
+declare function mapEventIterator<TYield, TReturn, TNext, TMap = TYield | TReturn>(iterator: AsyncIterator<TYield, TReturn, TNext>, maps: {
+    value: (value: NoInfer<TYield | TReturn>, done: boolean | undefined) => Promise<TMap>;
+    error: (error: unknown) => Promise<unknown>;
+}): AsyncGenerator<TMap, TMap, TNext>;
 
-type SafeResult<TOutput, TError extends Error> = [error: null, data: TOutput, isDefined: false] & {
+type SafeResult<TOutput, TError> = [error: null, data: TOutput, isDefined: false, isSuccess: true] & {
     error: null;
     data: TOutput;
     isDefined: false;
-} | [error: Exclude<TError, ORPCError<any, any>>, data: undefined, isDefined: false] & {
+    isSuccess: true;
+} | [error: Exclude<TError, ORPCError<any, any>>, data: undefined, isDefined: false, isSuccess: false] & {
     error: Exclude<TError, ORPCError<any, any>>;
     data: undefined;
     isDefined: false;
-} | [error: Extract<TError, ORPCError<any, any>>, data: undefined, isDefined: true] & {
+    isSuccess: false;
+} | [error: Extract<TError, ORPCError<any, any>>, data: undefined, isDefined: true, isSuccess: false] & {
     error: Extract<TError, ORPCError<any, any>>;
     data: undefined;
     isDefined: true;
+    isSuccess: false;
 };
-declare function safe<TOutput, TError extends Error>(promise: ClientPromiseResult<TOutput, TError>): Promise<SafeResult<TOutput, TError>>;
+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, ClientOptionsOut, ClientPromiseResult, type CommonORPCErrorCode, type ConnectionStatus, DynamicLink, type EventIteratorState, InferClientContext, NestedClient, ORPCError, type ORPCErrorCode, type ORPCErrorJSON, type ORPCErrorOptions, type SafeResult, createORPCClient, type createORPCClientOptions, fallbackORPCErrorMessage, fallbackORPCErrorStatus, isDefinedError, onEventIteratorStatusChange, registerEventIteratorState, safe, toORPCError, updateEventIteratorStatus };
+export { COMMON_ORPC_ERROR_DEFS, ClientContext, ClientLink, 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 };