@orpc/client 0.0.0-next.32f3296 → 0.0.0-next.332ed21

package/dist/shared/client.DHOfWE0c.mjs

@@ -0,0 +1,172 @@
+import { isObject, AsyncIteratorClass, isTypescriptObject } from '@orpc/shared';
+import { getEventMeta, withEventMeta } from '@orpc/standard-server';
+
+const COMMON_ORPC_ERROR_DEFS = {
+  BAD_REQUEST: {
+    status: 400,
+    message: "Bad Request"
+  },
+  UNAUTHORIZED: {
+    status: 401,
+    message: "Unauthorized"
+  },
+  FORBIDDEN: {
+    status: 403,
+    message: "Forbidden"
+  },
+  NOT_FOUND: {
+    status: 404,
+    message: "Not Found"
+  },
+  METHOD_NOT_SUPPORTED: {
+    status: 405,
+    message: "Method Not Supported"
+  },
+  NOT_ACCEPTABLE: {
+    status: 406,
+    message: "Not Acceptable"
+  },
+  TIMEOUT: {
+    status: 408,
+    message: "Request Timeout"
+  },
+  CONFLICT: {
+    status: 409,
+    message: "Conflict"
+  },
+  PRECONDITION_FAILED: {
+    status: 412,
+    message: "Precondition Failed"
+  },
+  PAYLOAD_TOO_LARGE: {
+    status: 413,
+    message: "Payload Too Large"
+  },
+  UNSUPPORTED_MEDIA_TYPE: {
+    status: 415,
+    message: "Unsupported Media Type"
+  },
+  UNPROCESSABLE_CONTENT: {
+    status: 422,
+    message: "Unprocessable Content"
+  },
+  TOO_MANY_REQUESTS: {
+    status: 429,
+    message: "Too Many Requests"
+  },
+  CLIENT_CLOSED_REQUEST: {
+    status: 499,
+    message: "Client Closed Request"
+  },
+  INTERNAL_SERVER_ERROR: {
+    status: 500,
+    message: "Internal Server Error"
+  },
+  NOT_IMPLEMENTED: {
+    status: 501,
+    message: "Not Implemented"
+  },
+  BAD_GATEWAY: {
+    status: 502,
+    message: "Bad Gateway"
+  },
+  SERVICE_UNAVAILABLE: {
+    status: 503,
+    message: "Service Unavailable"
+  },
+  GATEWAY_TIMEOUT: {
+    status: 504,
+    message: "Gateway Timeout"
+  }
+};
+function fallbackORPCErrorStatus(code, status) {
+  return status ?? COMMON_ORPC_ERROR_DEFS[code]?.status ?? 500;
+}
+function fallbackORPCErrorMessage(code, message) {
+  return message || COMMON_ORPC_ERROR_DEFS[code]?.message || code;
+}
+class ORPCError extends Error {
+  defined;
+  code;
+  status;
+  data;
+  constructor(code, ...[options]) {
+    if (options?.status && !isORPCErrorStatus(options.status)) {
+      throw new Error("[ORPCError] Invalid error status code.");
+    }
+    const message = fallbackORPCErrorMessage(code, options?.message);
+    super(message, options);
+    this.code = code;
+    this.status = fallbackORPCErrorStatus(code, options?.status);
+    this.defined = options?.defined ?? false;
+    this.data = options?.data;
+  }
+  toJSON() {
+    return {
+      defined: this.defined,
+      code: this.code,
+      status: this.status,
+      message: this.message,
+      data: this.data
+    };
+  }
+}
+function isDefinedError(error) {
+  return error instanceof ORPCError && error.defined;
+}
+function toORPCError(error) {
+  return error instanceof ORPCError ? error : new ORPCError("INTERNAL_SERVER_ERROR", {
+    message: "Internal server error",
+    cause: error
+  });
+}
+function isORPCErrorStatus(status) {
+  return status < 200 || status >= 400;
+}
+function isORPCErrorJson(json) {
+  if (!isObject(json)) {
+    return false;
+  }
+  const validKeys = ["defined", "code", "status", "message", "data"];
+  if (Object.keys(json).some((k) => !validKeys.includes(k))) {
+    return false;
+  }
+  return "defined" in json && typeof json.defined === "boolean" && "code" in json && typeof json.code === "string" && "status" in json && typeof json.status === "number" && isORPCErrorStatus(json.status) && "message" in json && typeof json.message === "string";
+}
+function createORPCErrorFromJson(json, options = {}) {
+  return new ORPCError(json.code, {
+    ...options,
+    ...json
+  });
+}
+
+function mapEventIterator(iterator, maps) {
+  return new AsyncIteratorClass(async () => {
+    const { done, value } = await (async () => {
+      try {
+        return await iterator.next();
+      } catch (error) {
+        let mappedError = await maps.error(error);
+        if (mappedError !== error) {
+          const meta = getEventMeta(error);
+          if (meta && isTypescriptObject(mappedError)) {
+            mappedError = withEventMeta(mappedError, meta);
+          }
+        }
+        throw mappedError;
+      }
+    })();
+    let mappedValue = await maps.value(value, done);
+    if (mappedValue !== value) {
+      const meta = getEventMeta(value);
+      if (meta && isTypescriptObject(mappedValue)) {
+        mappedValue = withEventMeta(mappedValue, meta);
+      }
+    }
+    return { done, value: mappedValue };
+  }, async () => {
+    await iterator.return?.();
+  });
+}
+
+export { COMMON_ORPC_ERROR_DEFS as C, ORPCError as O, fallbackORPCErrorMessage as a, isORPCErrorStatus as b, isORPCErrorJson as c, createORPCErrorFromJson as d, fallbackORPCErrorStatus as f, isDefinedError as i, mapEventIterator as m, toORPCError as t };

package/dist/shared/{client.d_qAa5GQ.mjs → client.DwfV9Oyl.mjs}

@@ -1,56 +1,42 @@
-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 { ErrorEvent } from '@orpc/standard-server';
+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, c as isORPCErrorJson, d as createORPCErrorFromJson, O as ORPCError, m as mapEventIterator, t as toORPCError } from './client.DHOfWE0c.mjs';
 
-class InvalidEventIteratorRetryResponse extends Error {
+class CompositeStandardLinkPlugin {
+  plugins;
+  constructor(plugins = []) {
+    this.plugins = [...plugins].sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+  }
+  init(options) {
+    for (const plugin of this.plugins) {
+      plugin.init?.(options);
+    }
+  }
 }
+
 class StandardLink {
-  constructor(codec, sender, options) {
+  constructor(codec, sender, options = {}) {
     this.codec = codec;
     this.sender = sender;
-    this.eventIteratorMaxRetries = options.eventIteratorMaxRetries ?? 5;
-    this.eventIteratorRetryDelay = options.eventIteratorRetryDelay ?? ((o) => o.lastRetry ?? 1e3 * 2 ** o.retryTimes);
-    this.eventIteratorShouldRetry = options.eventIteratorShouldRetry ?? true;
-    this.interceptors = options.interceptors ?? [];
-    this.clientInterceptors = options.clientInterceptors ?? [];
+    const plugin = new CompositeStandardLinkPlugin(options.plugins);
+    plugin.init(options);
+    this.interceptors = toArray(options.interceptors);
+    this.clientInterceptors = toArray(options.clientInterceptors);
   }
-  eventIteratorMaxRetries;
-  eventIteratorRetryDelay;
-  eventIteratorShouldRetry;
   interceptors;
   clientInterceptors;
   call(path, input, options) {
-    return intercept(this.interceptors, { path, input, options }, async ({ path: path2, input: input2, options: options2 }) => {
+    return intercept(this.interceptors, { ...options, path, input }, async ({ path: path2, input: input2, ...options2 }) => {
       const output = await this.#call(path2, input2, options2);
-      if (!isAsyncIteratorObject(output)) {
-        return output;
-      }
-      return createAutoRetryEventIterator(output, async (reconnectOptions) => {
-        const maxRetries = await value(this.eventIteratorMaxRetries, reconnectOptions, options2, path2, input2);
-        if (options2.signal?.aborted || reconnectOptions.retryTimes > maxRetries) {
-          return null;
-        }
-        const shouldRetry = await value(this.eventIteratorShouldRetry, reconnectOptions, options2, path2, input2);
-        if (!shouldRetry) {
-          return null;
-        }
-        const retryDelay = await value(this.eventIteratorRetryDelay, reconnectOptions, options2, path2, input2);
-        await new Promise((resolve) => setTimeout(resolve, retryDelay));
-        const updatedOptions = { ...options2, lastEventId: reconnectOptions.lastEventId };
-        const maybeIterator = await this.#call(path2, input2, updatedOptions);
-        if (!isAsyncIteratorObject(maybeIterator)) {
-          throw new InvalidEventIteratorRetryResponse("Invalid Event Iterator retry response");
-        }
-        return maybeIterator;
-      }, options2.lastEventId);
+      return output;
     });
   }
   async #call(path, input, options) {
     const request = await this.codec.encode(path, input, options);
     const response = await intercept(
       this.clientInterceptors,
-      { request },
-      ({ request: request2 }) => this.sender.call(request2, options, path, input)
+      { ...options, input, path, request },
+      ({ input: input2, path: path2, request: request2, ...options2 }) => this.sender.call(request2, options2, path2, input2)
     );
     const output = await this.codec.decode(response, options, path, input);
     return output;
@@ -79,7 +65,7 @@ class StandardRPCJsonSerializer {
     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]);
+        meta.push([custom.type, ...segments]);
         return result;
       }
     }
@@ -89,42 +75,42 @@ class StandardRPCJsonSerializer {
       return [data, meta, maps, blobs];
     }
     if (typeof data === "bigint") {
-      meta.push([STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.BIGINT, segments]);
+      meta.push([STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.BIGINT, ...segments]);
       return [data.toString(), meta, maps, blobs];
     }
     if (data instanceof Date) {
-      meta.push([STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.DATE, 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([STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.NAN, segments]);
+      meta.push([STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.NAN, ...segments]);
       return [null, meta, maps, blobs];
     }
     if (data instanceof URL) {
-      meta.push([STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.URL, segments]);
+      meta.push([STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.URL, ...segments]);
       return [data.toString(), meta, maps, blobs];
     }
     if (data instanceof RegExp) {
-      meta.push([STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.REGEXP, 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([STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.SET, 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([STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.MAP, 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([STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.UNDEFINED, [...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];
@@ -134,6 +120,9 @@ class StandardRPCJsonSerializer {
     if (isObject(data)) {
       const json = {};
       for (const k in data) {
+        if (k === "toJSON" && typeof data[k] === "function") {
+          continue;
+        }
         json[k] = this.serialize(data[k], [...segments, k], meta, maps, blobs)[0];
       }
       return [json, meta, maps, blobs];
@@ -153,13 +142,14 @@ class StandardRPCJsonSerializer {
         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]);
@@ -199,6 +189,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;
@@ -215,14 +212,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);
+    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);
+    url.pathname = `${url.pathname.replace(/\/$/, "")}${toHttpPath(path)}`;
+    if (options.lastEventId !== void 0) {
+      headers = mergeStandardHeaders(headers, { "last-event-id": options.lastEventId });
+    }
     const serialized = this.serializer.serialize(input);
-    if (expectedMethod === "GET" && !(serialized instanceof FormData) && !(serialized instanceof Blob) && !isAsyncIteratorObject(serialized)) {
+    if (expectedMethod === "GET" && !(serialized instanceof FormData) && !isAsyncIteratorObject(serialized)) {
       const maxUrlLength = await value(this.maxUrlLength, options, path, input);
       const getUrl = new URL(url);
-      getUrl.searchParams.append("data", stringifyJSON(serialized) ?? "");
+      getUrl.searchParams.append("data", stringifyJSON(serialized));
       if (getUrl.toString().length <= maxUrlLength) {
         return {
           body: void 0,
@@ -242,7 +243,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 {
@@ -261,11 +262,12 @@ class StandardRPCLinkCodec {
       }
     })();
     if (!isOk) {
-      if (ORPCError.isValidJSON(deserialized)) {
-        throw ORPCError.fromJSON(deserialized);
+      if (isORPCErrorJson(deserialized)) {
+        throw createORPCErrorFromJson(deserialized);
       }
-      throw new Error("Invalid RPC error response format.", {
-        cause: deserialized
+      throw new ORPCError(getMalformedResponseErrorCode(response.status), {
+        status: response.status,
+        data: { ...response, body: deserialized }
       });
     }
     return deserialized;
@@ -291,9 +293,6 @@ class StandardRPCSerializer {
     return this.#serialize(data, true);
   }
   #serialize(data, enableFormData) {
-    if (data === void 0 || data instanceof Blob) {
-      return data;
-    }
     const [json, meta_, maps, blobs] = this.jsonSerializer.serialize(data);
     const meta = meta_.length === 0 ? void 0 : meta_;
     if (!enableFormData || blobs.length === 0) {
@@ -318,8 +317,8 @@ class StandardRPCSerializer {
             return e;
           }
           const deserialized = this.#deserialize(e.data);
-          if (ORPCError.isValidJSON(deserialized)) {
-            return ORPCError.fromJSON(deserialized, { cause: e });
+          if (isORPCErrorJson(deserialized)) {
+            return createORPCErrorFromJson(deserialized, { cause: e });
           }
           return new ErrorEvent({
             data: deserialized,
@@ -331,9 +330,6 @@ class StandardRPCSerializer {
     return this.#deserialize(data);
   }
   #deserialize(data) {
-    if (data === void 0 || data instanceof Blob) {
-      return data;
-    }
     if (!(data instanceof FormData)) {
       return this.jsonSerializer.deserialize(data.json, data.meta ?? []);
     }
@@ -347,4 +343,13 @@ 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 };
+class StandardRPCLink extends StandardLink {
+  constructor(linkClient, options) {
+    const jsonSerializer = new StandardRPCJsonSerializer(options);
+    const serializer = new StandardRPCSerializer(jsonSerializer);
+    const linkCodec = new StandardRPCLinkCodec(serializer, options);
+    super(linkCodec, linkClient, options);
+  }
+}
+
+export { CompositeStandardLinkPlugin as C, StandardLink as S, STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES as a, StandardRPCJsonSerializer as b, StandardRPCLink as c, StandardRPCLinkCodec as d, StandardRPCSerializer as e, getMalformedResponseErrorCode as g, toHttpPath as t };

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

@@ -0,0 +1,91 @@
+import { b as ClientContext, c as ClientOptions, f as HTTPMethod } from './client.BOYsZIRq.js';
+import { e as StandardLinkCodec, b as StandardLinkOptions, d as StandardLink, f as StandardLinkClient } from './client.CXXEPIbK.js';
+import { Segment, Value, Promisable } 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<Promisable<string | URL>, [options: ClientOptions<T>, path: readonly string[], input: unknown]>;
+    /**
+     * The maximum length of the URL.
+     *
+     * @default 2083
+     */
+    maxUrlLength?: Value<Promisable<number>, [options: ClientOptions<T>, path: readonly string[], input: unknown]>;
+    /**
+     * The method used to make the request.
+     *
+     * @default 'POST'
+     */
+    method?: Value<Promisable<Exclude<HTTPMethod, 'HEAD'>>, [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, 'HEAD' | 'GET'>;
+    /**
+     * Inject headers to the request.
+     */
+    headers?: Value<Promisable<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 {
+}
+declare class StandardRPCLink<T extends ClientContext> extends StandardLink<T> {
+    constructor(linkClient: StandardLinkClient<T>, options: StandardRPCLinkOptions<T>);
+}
+
+export { STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES as S, StandardRPCJsonSerializer as e, StandardRPCLink as g, StandardRPCLinkCodec as i, StandardRPCSerializer as j };
+export type { StandardRPCJsonSerializedMetaItem as a, StandardRPCJsonSerialized as b, StandardRPCCustomJsonSerializer as c, StandardRPCJsonSerializerOptions as d, StandardRPCLinkOptions as f, StandardRPCLinkCodecOptions as h };

package/dist/shared/client.aTp4sII-.d.mts

@@ -0,0 +1,91 @@
+import { b as ClientContext, c as ClientOptions, f as HTTPMethod } from './client.BOYsZIRq.mjs';
+import { e as StandardLinkCodec, b as StandardLinkOptions, d as StandardLink, f as StandardLinkClient } from './client.C4VxIexA.mjs';
+import { Segment, Value, Promisable } 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<Promisable<string | URL>, [options: ClientOptions<T>, path: readonly string[], input: unknown]>;
+    /**
+     * The maximum length of the URL.
+     *
+     * @default 2083
+     */
+    maxUrlLength?: Value<Promisable<number>, [options: ClientOptions<T>, path: readonly string[], input: unknown]>;
+    /**
+     * The method used to make the request.
+     *
+     * @default 'POST'
+     */
+    method?: Value<Promisable<Exclude<HTTPMethod, 'HEAD'>>, [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, 'HEAD' | 'GET'>;
+    /**
+     * Inject headers to the request.
+     */
+    headers?: Value<Promisable<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 {
+}
+declare class StandardRPCLink<T extends ClientContext> extends StandardLink<T> {
+    constructor(linkClient: StandardLinkClient<T>, options: StandardRPCLinkOptions<T>);
+}
+
+export { STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES as S, StandardRPCJsonSerializer as e, StandardRPCLink as g, StandardRPCLinkCodec as i, StandardRPCSerializer as j };
+export type { StandardRPCJsonSerializedMetaItem as a, StandardRPCJsonSerialized as b, StandardRPCCustomJsonSerializer as c, StandardRPCJsonSerializerOptions as d, StandardRPCLinkOptions as f, StandardRPCLinkCodecOptions as h };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/client",
   "type": "module",
-  "version": "0.0.0-next.32f3296",
+  "version": "0.0.0-next.332ed21",
   "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",
@@ -28,18 +33,29 @@
       "types": "./dist/adapters/fetch/index.d.mts",
       "import": "./dist/adapters/fetch/index.mjs",
       "default": "./dist/adapters/fetch/index.mjs"
+    },
+    "./websocket": {
+      "types": "./dist/adapters/websocket/index.d.mts",
+      "import": "./dist/adapters/websocket/index.mjs",
+      "default": "./dist/adapters/websocket/index.mjs"
+    },
+    "./message-port": {
+      "types": "./dist/adapters/message-port/index.d.mts",
+      "import": "./dist/adapters/message-port/index.mjs",
+      "default": "./dist/adapters/message-port/index.mjs"
     }
   },
   "files": [
     "dist"
   ],
   "dependencies": {
-    "@orpc/standard-server-fetch": "0.0.0-next.32f3296",
-    "@orpc/standard-server": "0.0.0-next.32f3296",
-    "@orpc/shared": "0.0.0-next.32f3296"
+    "@orpc/shared": "0.0.0-next.332ed21",
+    "@orpc/standard-server": "0.0.0-next.332ed21",
+    "@orpc/standard-server-fetch": "0.0.0-next.332ed21",
+    "@orpc/standard-server-peer": "0.0.0-next.332ed21"
   },
   "devDependencies": {
-    "zod": "^3.24.2"
+    "zod": "^4.0.5"
   },
   "scripts": {
     "build": "unbuild",