@orpc/client 0.0.0-next.6c13765 → 0.0.0-next.6c1c681

package/dist/shared/client.CPmBUYbj.mjs

@@ -0,0 +1,351 @@
+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';
+
+class InvalidEventIteratorRetryResponse extends Error {
+}
+class StandardLink {
+  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 ?? [];
+  }
+  eventIteratorMaxRetries;
+  eventIteratorRetryDelay;
+  eventIteratorShouldRetry;
+  interceptors;
+  clientInterceptors;
+  call(path, input, options) {
+    return intercept(this.interceptors, { path, input, options }, async ({ path: path2, input: input2, options: 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);
+    });
+  }
+  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)
+    );
+    const output = await this.codec.decode(response, options, path, input);
+    return output;
+  }
+}
+
+const STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES = {
+  BIGINT: 0,
+  DATE: 1,
+  NAN: 2,
+  UNDEFINED: 3,
+  URL: 4,
+  REGEXP: 5,
+  SET: 6,
+  MAP: 7
+};
+class StandardRPCJsonSerializer {
+  customSerializers;
+  constructor(options = {}) {
+    this.customSerializers = options.customJsonSerializers ?? [];
+    if (this.customSerializers.length !== new Set(this.customSerializers.map((custom) => custom.type)).size) {
+      throw new Error("Custom serializer type must be unique.");
+    }
+  }
+  serialize(data, segments = [], meta = [], maps = [], blobs = []) {
+    for (const custom of this.customSerializers) {
+      if (custom.condition(data)) {
+        const result = this.serialize(custom.serialize(data), segments, meta, maps, blobs);
+        meta.push([custom.type, ...segments]);
+        return result;
+      }
+    }
+    if (data instanceof Blob) {
+      maps.push(segments);
+      blobs.push(data);
+      return [data, meta, maps, blobs];
+    }
+    if (typeof data === "bigint") {
+      meta.push([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]);
+      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]);
+      return [null, meta, maps, blobs];
+    }
+    if (data instanceof URL) {
+      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]);
+      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]);
+      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]);
+      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]);
+          return v;
+        }
+        return this.serialize(v, [...segments, i], meta, maps, blobs)[0];
+      });
+      return [json, meta, maps, blobs];
+    }
+    if (isObject(data)) {
+      const json = {};
+      for (const k in data) {
+        json[k] = this.serialize(data[k], [...segments, k], meta, maps, blobs)[0];
+      }
+      return [json, meta, maps, blobs];
+    }
+    return [data, meta, maps, blobs];
+  }
+  deserialize(json, meta, maps, getBlob) {
+    const ref = { data: json };
+    if (maps && getBlob) {
+      maps.forEach((segments, i) => {
+        let currentRef = ref;
+        let preSegment = "data";
+        segments.forEach((segment) => {
+          currentRef = currentRef[preSegment];
+          preSegment = segment;
+        });
+        currentRef[preSegment] = getBlob(i);
+      });
+    }
+    for (const item of meta) {
+      const type = item[0];
+      let currentRef = ref;
+      let preSegment = "data";
+      for (let i = 1; i < item.length; i++) {
+        currentRef = currentRef[preSegment];
+        preSegment = item[i];
+      }
+      for (const custom of this.customSerializers) {
+        if (custom.type === type) {
+          currentRef[preSegment] = custom.deserialize(currentRef[preSegment]);
+          break;
+        }
+      }
+      switch (type) {
+        case STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.BIGINT:
+          currentRef[preSegment] = BigInt(currentRef[preSegment]);
+          break;
+        case STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.DATE:
+          currentRef[preSegment] = new Date(currentRef[preSegment] ?? "Invalid Date");
+          break;
+        case STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.NAN:
+          currentRef[preSegment] = Number.NaN;
+          break;
+        case STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.UNDEFINED:
+          currentRef[preSegment] = void 0;
+          break;
+        case STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.URL:
+          currentRef[preSegment] = new URL(currentRef[preSegment]);
+          break;
+        case STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.REGEXP: {
+          const [, pattern, flags] = currentRef[preSegment].match(/^\/(.*)\/([a-z]*)$/);
+          currentRef[preSegment] = new RegExp(pattern, flags);
+          break;
+        }
+        case STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.SET:
+          currentRef[preSegment] = new Set(currentRef[preSegment]);
+          break;
+        case STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES.MAP:
+          currentRef[preSegment] = new Map(currentRef[preSegment]);
+          break;
+      }
+    }
+    return ref.data;
+  }
+}
+
+class StandardRPCLinkCodec {
+  constructor(serializer, options) {
+    this.serializer = serializer;
+    this.baseUrl = options.url;
+    this.maxUrlLength = options.maxUrlLength ?? 2083;
+    this.fallbackMethod = options.fallbackMethod ?? "POST";
+    this.expectedMethod = options.method ?? this.fallbackMethod;
+    this.headers = options.headers ?? {};
+  }
+  baseUrl;
+  maxUrlLength;
+  fallbackMethod;
+  expectedMethod;
+  headers;
+  async encode(path, input, options) {
+    const expectedMethod = await value(this.expectedMethod, options, path, input);
+    const headers = await value(this.headers, options, path, input);
+    const baseUrl = await value(this.baseUrl, options, path, input);
+    const url = new URL(`${trim(baseUrl.toString(), "/")}/${path.map(encodeURIComponent).join("/")}`);
+    const serialized = this.serializer.serialize(input);
+    if (expectedMethod === "GET" && !(serialized instanceof FormData) && !(serialized instanceof Blob) && !isAsyncIteratorObject(serialized)) {
+      const maxUrlLength = await value(this.maxUrlLength, options, path, input);
+      const getUrl = new URL(url);
+      getUrl.searchParams.append("data", stringifyJSON(serialized) ?? "");
+      if (getUrl.toString().length <= maxUrlLength) {
+        return {
+          body: void 0,
+          method: expectedMethod,
+          headers,
+          url: getUrl,
+          signal: options.signal
+        };
+      }
+    }
+    return {
+      url,
+      method: expectedMethod === "GET" ? this.fallbackMethod : expectedMethod,
+      headers,
+      body: serialized,
+      signal: options.signal
+    };
+  }
+  async decode(response) {
+    const isOk = response.status >= 200 && response.status < 300;
+    const deserialized = await (async () => {
+      let isBodyOk = false;
+      try {
+        const body = await response.body();
+        isBodyOk = true;
+        return this.serializer.deserialize(body);
+      } catch (error) {
+        if (!isBodyOk) {
+          throw new Error("Cannot parse response body, please check the response body and content-type.", {
+            cause: error
+          });
+        }
+        throw new Error("Invalid RPC response format.", {
+          cause: error
+        });
+      }
+    })();
+    if (!isOk) {
+      if (ORPCError.isValidJSON(deserialized)) {
+        throw ORPCError.fromJSON(deserialized);
+      }
+      throw new Error("Invalid RPC error response format.", {
+        cause: deserialized
+      });
+    }
+    return deserialized;
+  }
+}
+
+class StandardRPCSerializer {
+  constructor(jsonSerializer) {
+    this.jsonSerializer = jsonSerializer;
+  }
+  serialize(data) {
+    if (isAsyncIteratorObject(data)) {
+      return mapEventIterator(data, {
+        value: async (value) => this.#serialize(value, false),
+        error: async (e) => {
+          return new ErrorEvent({
+            data: this.#serialize(toORPCError(e).toJSON(), false),
+            cause: e
+          });
+        }
+      });
+    }
+    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) {
+      return {
+        json,
+        meta
+      };
+    }
+    const form = new FormData();
+    form.set("data", stringifyJSON({ json, meta, maps }));
+    blobs.forEach((blob, i) => {
+      form.set(i.toString(), blob);
+    });
+    return form;
+  }
+  deserialize(data) {
+    if (isAsyncIteratorObject(data)) {
+      return mapEventIterator(data, {
+        value: async (value) => this.#deserialize(value),
+        error: async (e) => {
+          if (!(e instanceof ErrorEvent)) {
+            return e;
+          }
+          const deserialized = this.#deserialize(e.data);
+          if (ORPCError.isValidJSON(deserialized)) {
+            return ORPCError.fromJSON(deserialized, { cause: e });
+          }
+          return new ErrorEvent({
+            data: deserialized,
+            cause: e
+          });
+        }
+      });
+    }
+    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 ?? []);
+    }
+    const serialized = JSON.parse(data.get("data"));
+    return this.jsonSerializer.deserialize(
+      serialized.json,
+      serialized.meta ?? [],
+      serialized.maps,
+      (i) => data.get(i.toString())
+    );
+  }
+}
+
+export { InvalidEventIteratorRetryResponse as I, StandardLink as S, STANDARD_RPC_JSON_SERIALIZER_BUILT_IN_TYPES as a, StandardRPCJsonSerializer as b, StandardRPCLinkCodec as c, StandardRPCSerializer as d };

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

@@ -0,0 +1,42 @@
+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>;
+}
+
+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>;
+interface EventIteratorReconnectOptions {
+    lastRetry: number | undefined;
+    lastEventId: string | undefined;
+    retryTimes: number;
+    error: unknown;
+}
+declare function createAutoRetryEventIterator<TYield, TReturn>(initial: AsyncIterator<TYield, TReturn, void>, reconnect: (options: EventIteratorReconnectOptions) => Promise<AsyncIterator<TYield, TReturn, void> | null>, initialLastEventId: string | undefined): AsyncGenerator<TYield, TReturn, void>;
+
+export { type ClientContext as C, type EventIteratorReconnectOptions as E, type InferClientContext as I, type NestedClient as N, type ClientOptionsOut as a, type ClientLink as b, type ClientPromiseResult as c, createAutoRetryEventIterator as d, type ClientOptions as e, type ClientRest as f, type Client as g, mapEventIterator as m };

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

@@ -0,0 +1,42 @@
+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>;
+}
+
+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>;
+interface EventIteratorReconnectOptions {
+    lastRetry: number | undefined;
+    lastEventId: string | undefined;
+    retryTimes: number;
+    error: unknown;
+}
+declare function createAutoRetryEventIterator<TYield, TReturn>(initial: AsyncIterator<TYield, TReturn, void>, reconnect: (options: EventIteratorReconnectOptions) => Promise<AsyncIterator<TYield, TReturn, void> | null>, initialLastEventId: string | undefined): AsyncGenerator<TYield, TReturn, void>;
+
+export { type ClientContext as C, type EventIteratorReconnectOptions as E, type InferClientContext as I, type NestedClient as N, type ClientOptionsOut as a, type ClientLink as b, type ClientPromiseResult as c, createAutoRetryEventIterator as d, type ClientOptions as e, type ClientRest as f, type Client as g, mapEventIterator as m };

package/dist/{chunk-2UPNYYFF.js → shared/client.XAn8cDTM.mjs}

@@ -1,12 +1,7 @@
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
+import { isObject, isTypescriptObject, retry } from '@orpc/shared';
+import { getEventMeta, withEventMeta } from '@orpc/standard-server';
 
-// src/error.ts
-import { isObject } from "@orpc/shared";
-var COMMON_ORPC_ERROR_DEFS = {
+const COMMON_ORPC_ERROR_DEFS = {
   BAD_REQUEST: {
     status: 400,
     message: "Bad Request"
@@ -90,7 +85,7 @@ function fallbackORPCErrorStatus(code, status) {
 function fallbackORPCErrorMessage(code, message) {
   return message || COMMON_ORPC_ERROR_DEFS[code]?.message || code;
 }
-var ORPCError = class _ORPCError extends Error {
+class ORPCError extends Error {
   defined;
   code;
   status;
@@ -116,7 +111,7 @@ var ORPCError = class _ORPCError extends Error {
     };
   }
   static fromJSON(json, options) {
-    return new _ORPCError(json.code, {
+    return new ORPCError(json.code, {
       ...options,
       ...json
     });
@@ -131,7 +126,7 @@ var ORPCError = class _ORPCError extends Error {
     }
     return "defined" in json && typeof json.defined === "boolean" && "code" in json && typeof json.code === "string" && "status" in json && typeof json.status === "number" && "message" in json && typeof json.message === "string";
   }
-};
+}
 function isDefinedError(error) {
   return error instanceof ORPCError && error.defined;
 }
@@ -142,8 +137,7 @@ function toORPCError(error) {
   });
 }
 
-// src/event-iterator-state.ts
-var iteratorStates = /* @__PURE__ */ new WeakMap();
+const iteratorStates = /* @__PURE__ */ new WeakMap();
 function registerEventIteratorState(iterator, state) {
   iteratorStates.set(iterator, state);
 }
@@ -153,7 +147,8 @@ function updateEventIteratorStatus(state, status) {
     state.listeners.forEach((cb) => cb(status));
   }
 }
-function onEventIteratorStatusChange(iterator, callback, notifyImmediately = true) {
+function onEventIteratorStatusChange(iterator, callback, options = {}) {
+  const notifyImmediately = options.notifyImmediately ?? true;
   const state = iteratorStates.get(iterator);
   if (!state) {
     throw new Error("Iterator is not registered.");
@@ -170,9 +165,6 @@ function onEventIteratorStatusChange(iterator, callback, notifyImmediately = tru
   };
 }
 
-// src/event-iterator.ts
-import { getEventMeta, isEventMetaContainer, withEventMeta } from "@orpc/server-standard";
-import { retry } from "@orpc/shared";
 function mapEventIterator(iterator, maps) {
   return async function* () {
     try {
@@ -181,7 +173,7 @@ function mapEventIterator(iterator, maps) {
         let mappedValue = await maps.value(value, done);
         if (mappedValue !== value) {
           const meta = getEventMeta(value);
-          if (meta && isEventMetaContainer(mappedValue)) {
+          if (meta && isTypescriptObject(mappedValue)) {
             mappedValue = withEventMeta(mappedValue, meta);
           }
         }
@@ -194,7 +186,7 @@ function mapEventIterator(iterator, maps) {
       let mappedError = await maps.error(error);
       if (mappedError !== error) {
         const meta = getEventMeta(error);
-        if (meta && isEventMetaContainer(mappedError)) {
+        if (meta && isTypescriptObject(mappedError)) {
           mappedError = withEventMeta(mappedError, meta);
         }
       }
@@ -204,7 +196,7 @@ function mapEventIterator(iterator, maps) {
     }
   }();
 }
-var MAX_ALLOWED_RETRY_TIMES = 99;
+const MAX_ALLOWED_RETRY_TIMES = 99;
 function createAutoRetryEventIterator(initial, reconnect, initialLastEventId) {
   const state = {
     status: "connected",
@@ -238,7 +230,7 @@ function createAutoRetryEventIterator(initial, reconnect, initialLastEventId) {
             retryTimes += 1;
             if (retryTimes > MAX_ALLOWED_RETRY_TIMES) {
               throw exit(new Error(
-                `Exceeded maximum retry attempts (${MAX_ALLOWED_RETRY_TIMES}) for event source. Possible infinite retry loop detected. Please review the retry logic.`,
+                `Exceeded maximum retry attempts (${MAX_ALLOWED_RETRY_TIMES}) for event iterator. Possible infinite retry loop detected. Please review the retry logic.`,
                 { cause: currentError }
               ));
             }
@@ -271,18 +263,4 @@ function createAutoRetryEventIterator(initial, reconnect, initialLastEventId) {
   return iterator;
 }
 
-export {
-  __export,
-  COMMON_ORPC_ERROR_DEFS,
-  fallbackORPCErrorStatus,
-  fallbackORPCErrorMessage,
-  ORPCError,
-  isDefinedError,
-  toORPCError,
-  registerEventIteratorState,
-  updateEventIteratorStatus,
-  onEventIteratorStatusChange,
-  mapEventIterator,
-  createAutoRetryEventIterator
-};
-//# sourceMappingURL=chunk-2UPNYYFF.js.map
+export { COMMON_ORPC_ERROR_DEFS as C, ORPCError as O, fallbackORPCErrorMessage as a, createAutoRetryEventIterator as c, fallbackORPCErrorStatus as f, isDefinedError as i, mapEventIterator as m, onEventIteratorStatusChange as o, registerEventIteratorState as r, toORPCError as t, updateEventIteratorStatus as u };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@orpc/client",
   "type": "module",
-  "version": "0.0.0-next.6c13765",
+  "version": "0.0.0-next.6c1c681",
   "license": "MIT",
   "homepage": "https://orpc.unnoq.com",
   "repository": {
@@ -15,44 +15,34 @@
   ],
   "exports": {
     ".": {
-      "types": "./dist/src/index.d.ts",
-      "import": "./dist/index.js",
-      "default": "./dist/index.js"
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
     },
-    "./openapi": {
-      "types": "./dist/src/openapi/index.d.ts",
-      "import": "./dist/openapi.js",
-      "default": "./dist/openapi.js"
-    },
-    "./rpc": {
-      "types": "./dist/src/rpc/index.d.ts",
-      "import": "./dist/rpc.js",
-      "default": "./dist/rpc.js"
+    "./standard": {
+      "types": "./dist/adapters/standard/index.d.mts",
+      "import": "./dist/adapters/standard/index.mjs",
+      "default": "./dist/adapters/standard/index.mjs"
     },
     "./fetch": {
-      "types": "./dist/src/adapters/fetch/index.d.ts",
-      "import": "./dist/fetch.js",
-      "default": "./dist/fetch.js"
-    },
-    "./🔒/*": {
-      "types": "./dist/src/*.d.ts"
+      "types": "./dist/adapters/fetch/index.d.mts",
+      "import": "./dist/adapters/fetch/index.mjs",
+      "default": "./dist/adapters/fetch/index.mjs"
     }
   },
   "files": [
-    "!**/*.map",
-    "!**/*.tsbuildinfo",
     "dist"
   ],
   "dependencies": {
-    "@orpc/server-standard": "^0.4.0",
-    "@orpc/server-standard-fetch": "^0.4.0",
-    "@orpc/shared": "0.0.0-next.6c13765"
+    "@orpc/shared": "0.0.0-next.6c1c681",
+    "@orpc/standard-server": "0.0.0-next.6c1c681",
+    "@orpc/standard-server-fetch": "0.0.0-next.6c1c681"
   },
   "devDependencies": {
-    "zod": "^3.24.1"
+    "zod": "^3.24.2"
   },
   "scripts": {
-    "build": "tsup --onSuccess='tsc -b --noCheck'",
+    "build": "unbuild",
     "build:watch": "pnpm run build --watch",
     "type:check": "tsc -b"
   }