@orpc/client 2.0.0-beta.40 → 2.0.0-beta.42

package/dist/plugins/index.mjs

@@ -1,14 +1,16 @@
-import { toArray, value, splitInHalf, safeEncodeURIComponent, stringifyJSON, once, isAsyncIteratorObject, defer, loadBytes, allAbortSignal, replicateAsyncIterator, replicateReadableStream, isCompressibleContentType, override, AsyncIteratorClass, sleep, AbortError, anyAbortSignal } from '@orpc/shared';
+import { toArray, value, splitInHalf, promiseWithResolvers, safeEncodeURIComponent, stringifyJSON, once, isAsyncIteratorObject, defer, captureAsyncContext, loadBytes, allAbortSignal, runWithSignal, replicateAsyncIterator, replicateReadableStream, wrapAsyncIterator, throwIfAborted, isCompressibleContentType, override, AsyncIteratorClass, sleep, AbortError, anyAbortSignal } from '@orpc/shared';
 import { parseStandardUrl, flattenStandardHeader, generateContentDisposition, getEventMeta } from '@standard-server/core';
 import { ClientPeer, isServerPeerSendMessage, decodePeerMessage } from '@standard-server/peer';
 import { toFetchHeaders, toStandardBody } from '@standard-server/fetch';
-import { C as COMMON_ERROR_STATUS_MAP } from '../shared/client.Dtv1JPkU.mjs';
+import { C as COMMON_ERROR_STATUS_MAP } from '../shared/client.DD2eNne_.mjs';
 
 class BatchLinkPlugin {
   name = "~batch";
   groups;
   filter;
+  scope;
   maxSize;
+  wait;
   mode;
   batchUrl;
   maxUrlLength;
@@ -19,7 +21,9 @@ class BatchLinkPlugin {
   constructor(options) {
     this.groups = options.groups;
     this.filter = options.filter ?? (() => true);
+    this.scope = options.scope ?? (() => void 0);
     this.maxSize = options.maxSize ?? 10;
+    this.wait = options.wait ?? 0;
     this.mode = options.mode ?? "streaming";
     this.batchUrl = options.url ?? ((options2) => {
       const [pathname] = parseStandardUrl(options2[0].request.url);
@@ -65,20 +69,30 @@ class BatchLinkPlugin {
   }
   init(options) {
     const transportInterceptor = async (interceptorOptions) => {
-      if (interceptorOptions.request.body instanceof Blob || interceptorOptions.request.body instanceof ReadableStream || isAsyncIteratorObject(interceptorOptions.request.body) || interceptorOptions.request.signal?.aborted || !value(this.filter, interceptorOptions)) {
+      const { body, signal } = interceptorOptions.request;
+      if (body instanceof Blob || body instanceof FormData || body instanceof ReadableStream || isAsyncIteratorObject(body) || signal?.aborted || !value(this.filter, interceptorOptions)) {
         return interceptorOptions.next();
       }
       const group = this.groups.find((group2) => value(group2.condition, interceptorOptions));
       if (!group) {
         return interceptorOptions.next();
       }
+      const scope = this.scope(interceptorOptions);
       return new Promise((resolve, reject) => {
-        const queue = this.queue.get(group) ?? [];
-        if (!this.queue.has(group)) {
-          this.queue.set(group, queue);
+        if (!this.queue.size) {
+          defer(() => this.processPendingBatches(), this.wait);
         }
-        queue.push([interceptorOptions, resolve, reject]);
-        defer(() => this.processPendingBatches());
+        let groups = this.queue.get(scope);
+        if (!groups) {
+          groups = /* @__PURE__ */ new Map();
+          this.queue.set(scope, groups);
+        }
+        let queue = groups.get(group);
+        if (!queue) {
+          queue = [];
+          groups.set(group, queue);
+        }
+        queue.push([interceptorOptions, resolve, reject, captureAsyncContext()]);
       });
     };
     return {
@@ -86,120 +100,170 @@ class BatchLinkPlugin {
       transportInterceptors: [...toArray(options.transportInterceptors), transportInterceptor]
     };
   }
-  async processPendingBatches() {
-    const pending = new Map(this.queue);
+  processPendingBatches() {
+    const pending = [...this.queue.values()];
     this.queue.clear();
-    for (const [group, items] of pending) {
-      const getItems = items.filter(([options]) => options.request.method === "GET");
-      const queryItems = items.filter(([options]) => options.request.method === "QUERY");
-      const unsafeItems = items.filter(([options]) => options.request.method !== "GET" && options.request.method !== "QUERY");
-      this.executeBatch("GET", group, getItems);
-      this.executeBatch("QUERY", group, queryItems);
-      this.executeBatch("POST", group, unsafeItems);
+    for (const groups of pending) {
+      for (const [group, items] of groups) {
+        const getItems = items.filter(([options]) => options.request.method === "GET");
+        const queryItems = items.filter(([options]) => options.request.method === "QUERY");
+        const unsafeItems = items.filter(([options]) => options.request.method !== "GET" && options.request.method !== "QUERY");
+        this.executeBatchInOwnContext("GET", group, getItems);
+        this.executeBatchInOwnContext("QUERY", group, queryItems);
+        this.executeBatchInOwnContext("POST", group, unsafeItems);
+      }
     }
   }
+  /**
+   * Runs the batch in the async context of its first request instead of the timer's,
+   * so the transport and batch options see that caller's request state.
+   * `executeBatch` always runs in the context of its first request.
+   */
+  async executeBatchInOwnContext(method, group, groupItems) {
+    await groupItems[0]?.[3](() => this.executeBatch(method, group, groupItems));
+  }
   async executeBatch(method, group, groupItems) {
-    if (!groupItems.length) {
-      return;
-    }
-    if (groupItems.length === 1) {
-      const [options, resolve, reject] = groupItems[0];
-      options.next().then(resolve).catch(reject);
-      return;
-    }
-    const subOptionsList = groupItems.map(([options]) => options);
-    const maxSize = await value(this.maxSize, subOptionsList);
-    if (groupItems.length > maxSize) {
-      const [first, second] = splitInHalf(groupItems);
-      await Promise.all([
-        this.executeBatch(method, group, first),
-        this.executeBatch(method, group, second)
-      ]);
-      return;
-    }
-    const url = await value(this.batchUrl, subOptionsList);
-    const headers = await value(this.batchHeaders, subOptionsList);
-    const mode = value(this.mode, subOptionsList);
-    let suppressErrorFromCurrentBatch = false;
-    const controller = new AbortController();
-    const pendingMessages = [];
-    let batchResponse;
-    const peer = new ClientPeer(async (message) => {
-      pendingMessages.push(message);
-      if (message.kind === "cancel" && pendingMessages.filter((m) => m.kind === "cancel").length === groupItems.length) {
-        controller.abort();
+    try {
+      if (groupItems.length === 1) {
+        const [options, resolve, reject] = groupItems[0];
+        options.next().then(resolve).catch(reject);
+        return;
       }
-      if (message.kind === "request" && pendingMessages.filter((m) => m.kind === "request").length === groupItems.length) {
-        (async () => {
-          try {
-            const request = {
-              url,
-              method,
-              headers: { ...headers, "orpc-batch": mode },
-              signal: controller.signal
-            };
-            if (method === "GET") {
-              const [pathname, search, hash] = parseStandardUrl(url);
-              const dataParam = `data=${safeEncodeURIComponent(stringifyJSON(pendingMessages))}`;
-              const newUrl = search ? `${pathname}${search}&${dataParam}${hash ?? ""}` : `${pathname}?${dataParam}${hash ?? ""}`;
-              const maxUrlLength = await value(this.maxUrlLength, subOptionsList);
-              if (newUrl.length > maxUrlLength) {
-                const [first, second] = splitInHalf(groupItems);
-                suppressErrorFromCurrentBatch = true;
-                await Promise.all([
-                  this.executeBatch(method, group, first),
-                  this.executeBatch(method, group, second),
-                  peer.close()
-                ]);
-                return;
-              }
-              request.url = newUrl;
-            } else {
-              request.body = pendingMessages;
-            }
-            batchResponse = await groupItems[0][0].next({
-              ...subOptionsList[0],
-              context: value(group.context, subOptionsList),
-              path: value(group.path, subOptionsList) ?? [],
-              request,
-              signal: controller.signal
-            });
-            if (batchResponse.status >= 400) {
-              suppressErrorFromCurrentBatch = true;
-              const resolveBody = once(() => batchResponse.resolveBody());
-              const errorResponse = { ...batchResponse, resolveBody };
-              groupItems.forEach(([subOptions, resolve]) => {
-                resolve(this.mapSubresponse(errorResponse, batchResponse, subOptions));
-              });
-              await peer.close();
-              return;
-            }
-            const body = await batchResponse.resolveBody();
-            if (Array.isArray(body) && body.every((v) => isServerPeerSendMessage(v))) {
-              for (const message2 of body) {
-                await peer.message(message2);
-              }
-            } else if (body instanceof Blob) {
-              await decodeLengthPrefixedBlob(body, peer);
-            } else if (body instanceof ReadableStream) {
-              await decodeLengthPrefixedStream(body, peer);
-            } else {
-              throw new TypeError("Invalid batch response format.");
-            }
-            await peer.close(new TypeError("Batch response is incomplete."));
-          } catch (error) {
-            await peer.close(error);
-          }
-        })();
+      const subOptionsList = groupItems.map(([options]) => options);
+      const maxSize = await value(this.maxSize, subOptionsList);
+      if (groupItems.length > maxSize) {
+        const [first, second] = splitInHalf(groupItems);
+        await Promise.all([
+          this.executeBatch(method, group, first),
+          this.executeBatchInOwnContext(method, group, second)
+        ]);
+        return;
       }
-    });
-    groupItems.forEach(([subOptions, resolve, reject]) => {
-      peer.request(this.mapSubrequest(subOptions, { url, headers })).then((subResponse) => resolve(this.mapSubresponse(subResponse, batchResponse, subOptions))).catch((error) => {
-        if (!suppressErrorFromCurrentBatch) {
-          reject(error);
+      const url = await value(this.batchUrl, subOptionsList);
+      const headers = await value(this.batchHeaders, subOptionsList);
+      const mode = value(this.mode, subOptionsList);
+      let suppressErrorFromCurrentBatch = false;
+      const controller = new AbortController();
+      const pendingMessages = [];
+      const subrequests = groupItems.map(([subOptions]) => this.mapSubrequest(subOptions, { url, headers }));
+      let batchResponse;
+      let markRequestSent;
+      const openRequestIds = /* @__PURE__ */ new Set();
+      const cancelledRunningRequestIds = /* @__PURE__ */ new Set();
+      let isBatchSent = false;
+      const abortIfOnlyCancelledRemain = () => {
+        if (openRequestIds.size === 0 && cancelledRunningRequestIds.size > 0) {
+          controller.abort();
+        }
+      };
+      const peer = new ClientPeer(async (message) => {
+        pendingMessages.push(message);
+        if (message.kind === "request") {
+          openRequestIds.add(message.id);
+          markRequestSent?.();
+        } else if (message.kind === "cancel" && openRequestIds.delete(message.id) && isBatchSent) {
+          cancelledRunningRequestIds.add(message.id);
+          abortIfOnlyCancelledRemain();
         }
       });
-    });
+      for (const [index, [subOptions, resolve, reject]] of groupItems.entries()) {
+        const sent = promiseWithResolvers();
+        markRequestSent = sent.resolve;
+        peer.request(subrequests[index]).then((subResponse) => resolve(this.mapSubresponse(subResponse, batchResponse, subOptions))).catch((error) => {
+          if (!suppressErrorFromCurrentBatch) {
+            reject(error);
+          }
+        }).then(sent.resolve);
+        await sent.promise;
+      }
+      if (openRequestIds.size === 0) {
+        return;
+      }
+      isBatchSent = true;
+      const outgoingMessages = pendingMessages.filter((message) => openRequestIds.has(message.id));
+      try {
+        const request = {
+          url,
+          method,
+          headers: { ...headers, "orpc-batch": mode },
+          signal: controller.signal
+        };
+        if (method === "GET") {
+          const [pathname, search, hash] = parseStandardUrl(url);
+          const dataParam = `data=${safeEncodeURIComponent(stringifyJSON(outgoingMessages))}`;
+          const newUrl = search ? `${pathname}${search}&${dataParam}${hash ?? ""}` : `${pathname}?${dataParam}${hash ?? ""}`;
+          const maxUrlLength = await value(this.maxUrlLength, subOptionsList);
+          if (newUrl.length > maxUrlLength) {
+            const [first, second] = splitInHalf(groupItems);
+            suppressErrorFromCurrentBatch = true;
+            await Promise.all([
+              this.executeBatch(method, group, first),
+              this.executeBatchInOwnContext(method, group, second),
+              peer.close()
+            ]);
+            return;
+          }
+          request.url = newUrl;
+        } else {
+          request.body = outgoingMessages;
+        }
+        batchResponse = await groupItems[0][0].next({
+          ...subOptionsList[0],
+          context: value(group.context, subOptionsList),
+          path: value(group.path, subOptionsList) ?? [],
+          request,
+          signal: controller.signal
+        });
+        if (batchResponse.status >= 400) {
+          const resolveBody = once(() => batchResponse.resolveBody());
+          const errorResponse = { ...batchResponse, resolveBody };
+          groupItems.forEach(([subOptions, resolve]) => {
+            resolve(this.mapSubresponse(errorResponse, batchResponse, subOptions));
+          });
+          suppressErrorFromCurrentBatch = true;
+          await peer.close();
+          return;
+        }
+        const body = await batchResponse.resolveBody();
+        if (Array.isArray(body) && body.every((v) => isServerPeerSendMessage(v))) {
+          for (const message of body) {
+            await peer.message(message);
+          }
+        } else if (body instanceof Blob) {
+          await decodeLengthPrefixedBlob(body, peer);
+        } else if (body instanceof ReadableStream) {
+          await decodeLengthPrefixedStream(body, async (message) => {
+            await peer.message(message);
+            if (isLastServerMessage(message)) {
+              openRequestIds.delete(message.id);
+              cancelledRunningRequestIds.delete(message.id);
+              abortIfOnlyCancelledRemain();
+            }
+          });
+        } else {
+          throw new TypeError("Invalid batch response format.");
+        }
+        await peer.close(new TypeError("Batch response is incomplete."));
+      } catch (error) {
+        await peer.close(error);
+      }
+    } catch (error) {
+      groupItems.forEach(([, , reject]) => reject(error));
+    }
+  }
+}
+function isLastServerMessage(message) {
+  switch (message.kind) {
+    case "response":
+      return message.json.body !== void 0 || message.binary !== void 0 || message.json.headers?.["content-type"] === void 0 && message.json.headers?.["standard-server"] === void 0;
+    case "event-stream":
+      return message.json.event === "close" || message.json.event === "error";
+    case "octet-stream":
+      return message.json.close === true;
+    case "cancel":
+      return true;
+    default:
+      return false;
   }
 }
 async function decodeLengthPrefixedBlob(blob, peer) {
@@ -224,7 +288,7 @@ async function decodeLengthPrefixedBlob(blob, peer) {
     await peer.message(result.message);
   }
 }
-async function decodeLengthPrefixedStream(stream, peer) {
+async function decodeLengthPrefixedStream(stream, receive) {
   const reader = stream.getReader();
   let buffer = new Uint8Array(0);
   try {
@@ -252,7 +316,7 @@ async function decodeLengthPrefixedStream(stream, peer) {
         if (!result.matched || !isServerPeerSendMessage(result.message)) {
           throw new TypeError("Invalid batch response: invalid message.");
         }
-        await peer.message(result.message);
+        await receive(result.message);
       }
       if (done) {
         break;
@@ -268,10 +332,14 @@ class DedupeLinkPlugin {
   before = ["~batch"];
   groups;
   filter;
+  scope;
+  wait;
   queue = /* @__PURE__ */ new Map();
   constructor(options) {
     this.groups = options.groups;
     this.filter = options.filter ?? (({ request }) => request.method === "GET" || request.method === "QUERY");
+    this.scope = options.scope ?? (() => void 0);
+    this.wait = options.wait ?? 0;
   }
   init(options) {
     const transportInterceptor = (interceptorOptions) => {
@@ -282,78 +350,81 @@ class DedupeLinkPlugin {
       if (!group) {
         return interceptorOptions.next();
       }
-      return new Promise((resolve, reject) => {
-        this.enqueue(group, interceptorOptions, resolve, reject);
-        defer(() => {
-          this.processPendingRequests();
-        });
-      });
+      const scope = this.scope(interceptorOptions);
+      return runWithSignal(interceptorOptions.request.signal, () => new Promise((resolve, reject) => {
+        if (!this.queue.size) {
+          defer(() => this.processPendingRequests(), this.wait);
+        }
+        this.enqueue(scope, group, { options: interceptorOptions, resolve, reject, runInOwnContext: captureAsyncContext() });
+      }));
     };
     return {
       ...options,
       transportInterceptors: [...toArray(options.transportInterceptors), transportInterceptor]
     };
   }
-  enqueue(group, options, resolve, reject) {
-    let queue = this.queue.get(group);
+  enqueue(scope, group, caller) {
+    let groups = this.queue.get(scope);
+    if (!groups) {
+      groups = /* @__PURE__ */ new Map();
+      this.queue.set(scope, groups);
+    }
+    let queue = groups.get(group);
     if (!queue) {
-      queue = [];
-      this.queue.set(group, queue);
+      queue = /* @__PURE__ */ new Map();
+      groups.set(group, queue);
     }
-    const requestKey = createRequestKey(options.path, options.request);
-    const matched = queue.find((item) => item.requestKey === requestKey);
+    const requestKey = createRequestKey(caller.options.path, caller.options.request);
+    const matched = queue.get(requestKey);
     if (matched) {
-      matched.matchedOptions.push(options);
-      matched.signals.push(options.request.signal);
-      matched.resolves.push(resolve);
-      matched.rejects.push(reject);
+      matched.push(caller);
       return;
     }
-    queue.push({
-      requestKey,
-      options,
-      matchedOptions: [options],
-      signals: [options.request.signal],
-      resolves: [resolve],
-      rejects: [reject]
-    });
+    queue.set(requestKey, [caller]);
   }
   async processPendingRequests() {
-    const pending = new Map(this.queue);
+    const pending = [...this.queue.values()];
     this.queue.clear();
     const executions = [];
-    for (const [group, items] of pending) {
-      for (const item of items) {
-        executions.push(this.execute(group, item));
+    for (const groups of pending) {
+      for (const [group, items] of groups) {
+        for (const callers of items.values()) {
+          const activeCallers = callers.filter((caller) => !caller.options.request.signal?.aborted);
+          const [first] = activeCallers;
+          if (first) {
+            executions.push(first.runInOwnContext(() => this.execute(group, activeCallers)));
+          }
+        }
       }
     }
     await Promise.all(executions);
   }
-  async execute(group, item) {
+  async execute(group, activeCallers) {
+    const first = activeCallers[0];
+    const matchedOptions = activeCallers.map((caller) => caller.options);
     try {
-      if (!shouldDedupe(item.matchedOptions)) {
-        const response2 = await item.options.next(item.options);
-        item.resolves[0]?.(response2);
+      if (!shouldDedupe(matchedOptions)) {
+        const response2 = await first.options.next(first.options);
+        first.resolve(response2);
         return;
       }
-      const context = value(group.context, item.matchedOptions);
+      const context = value(group.context, matchedOptions);
+      const signals = matchedOptions.map((options) => options.request.signal);
       const request = {
-        ...item.options.request,
-        signal: allAbortSignal(item.signals)
+        ...first.options.request,
+        signal: allAbortSignal(signals)
       };
-      const response = await item.options.next({
-        ...item.options,
+      const response = await first.options.next({
+        ...first.options,
         request,
         signal: request.signal,
         context
       });
-      const replicatedResponses = replicateLazyResponse(response, item.resolves.length);
-      for (const resolve of item.resolves) {
-        resolve(replicatedResponses.pop());
-      }
+      const replicatedResponses = replicateLazyResponse(response, signals);
+      activeCallers.forEach((caller, index) => caller.resolve(replicatedResponses[index]));
     } catch (error) {
-      for (const reject of item.rejects) {
-        reject(error);
+      for (const caller of activeCallers) {
+        caller.reject(error);
       }
     }
   }
@@ -370,35 +441,76 @@ function createRequestKey(path, request) {
     url: request.url
   });
 }
-function replicateLazyResponse(response, count) {
-  const replicated = [];
-  let bodyPromise;
-  let replicatedAsyncIterators;
-  let replicatedReadableStream;
-  for (let i = 0; i < count; i++) {
-    let resolvedBody;
-    replicated.push({
-      ...response,
-      resolveBody: async (hint) => {
-        if (resolvedBody) {
-          return resolvedBody.body;
-        }
-        bodyPromise ??= response.resolveBody(hint);
-        const body = await bodyPromise;
+function replicateLazyResponse(response, signals) {
+  let bodiesPromise;
+  return signals.map((signal, i) => ({
+    ...response,
+    resolveBody: (hint) => runWithSignal(signal, async () => {
+      bodiesPromise ??= response.resolveBody(hint).then((body) => {
         if (isAsyncIteratorObject(body)) {
-          replicatedAsyncIterators ??= replicateAsyncIterator(body, count);
-          resolvedBody = { body: replicatedAsyncIterators.pop() };
-        } else if (body instanceof ReadableStream) {
-          replicatedReadableStream ??= replicateReadableStream(body, count);
-          resolvedBody = { body: replicatedReadableStream.pop() };
+          return replicateAsyncIterator(body, signals.length).map((replica, index) => closeAsyncIteratorOnAbort(replica, signals[index]));
+        }
+        if (body instanceof ReadableStream) {
+          return replicateReadableStream(body, signals.length).map((replica, index) => closeReadableStreamOnAbort(replica, signals[index]));
+        }
+        return signals.map(() => body);
+      });
+      return (await bodiesPromise)[i];
+    })
+  }));
+}
+function closeAsyncIteratorOnAbort(replica, signal) {
+  if (!signal) {
+    return replica;
+  }
+  const abort = () => replica.return().catch(() => {
+  });
+  if (signal.aborted) {
+    void abort();
+  } else {
+    signal.addEventListener("abort", abort, { once: true });
+  }
+  return wrapAsyncIterator(replica, {
+    mapResult(result) {
+      throwIfAborted(signal);
+      return result;
+    },
+    onFinish: () => signal.removeEventListener("abort", abort)
+  });
+}
+function closeReadableStreamOnAbort(replica, signal) {
+  if (!signal) {
+    return replica;
+  }
+  const reader = replica.getReader();
+  const abort = () => reader.cancel(signal.reason).catch(() => {
+  });
+  if (signal.aborted) {
+    void abort();
+  } else {
+    signal.addEventListener("abort", abort, { once: true });
+  }
+  return new ReadableStream({
+    async pull(controller) {
+      try {
+        const result = await reader.read();
+        throwIfAborted(signal);
+        if (result.done) {
+          signal.removeEventListener("abort", abort);
+          controller.close();
         } else {
-          resolvedBody = { body };
+          controller.enqueue(result.value);
         }
-        return resolvedBody.body;
+      } catch (error) {
+        signal.removeEventListener("abort", abort);
+        throw error;
       }
-    });
-  }
-  return replicated;
+    },
+    async cancel(reason) {
+      signal.removeEventListener("abort", abort);
+      await reader.cancel(reason);
+    }
+  }, { highWaterMark: 0 });
 }
 function shouldDedupe(items) {
   return items.length >= 2;
@@ -554,6 +666,7 @@ class RequestCompressionLinkPlugin {
   }
 }
 
+const MAX_CONTENT_ENCODINGS = 5;
 class ResponseCompressionLinkPlugin {
   name = "~response-compression";
   /**
@@ -596,6 +709,9 @@ class ResponseCompressionLinkPlugin {
           if (!(stream instanceof ReadableStream)) {
             return stream;
           }
+          if (encodings.length > MAX_CONTENT_ENCODINGS) {
+            throw new TypeError("Too many content encodings.");
+          }
           let decompressedStream = stream;
           for (let i = encodings.length - 1; i >= 0; i--) {
             decompressedStream = decompressedStream.pipeThrough(
@@ -662,6 +778,7 @@ class RetryLinkPlugin {
         let currentError = initialError;
         while (true) {
           const updatedCallOptions = { ...callOptions, lastEventId };
+          let retryDelayMs = 0;
           if (currentError) {
             if (attempt > maxAttempts) {
               throw currentError.error;
@@ -679,16 +796,11 @@ class RetryLinkPlugin {
             if (!shouldRetryBool) {
               throw currentError.error;
             }
+            retryDelayMs = await value(retryDelay, attemptOptions);
             callback = onRetry?.(attemptOptions);
           }
           try {
             if (currentError) {
-              const retryDelayMs = await value(retryDelay, {
-                ...updatedCallOptions,
-                attempt,
-                error: currentError.error,
-                lastEventRetry
-              });
               await sleep(retryDelayMs, { signal: updatedCallOptions.signal });
               attempt++;
             }

package/dist/shared/{client.n8K9dFhY.d.mts → client.BPa_Mmuh.d.mts}

@@ -66,7 +66,7 @@ interface RPCJsonSerializerOptions {
      * handlers: { url: undefined }
      * ```
      *
-     * Built-in type keys: `undefined`, `bigint`, `date`, `nan`, `url`, `set`, `map`.
+     * Built-in type keys: `undefined`, `bigint`, `date`, `nan`, `infinity`, `url`, `set`, `map`.
      */
     handlers?: Record<string, undefined | RPCJsonSerializerHandler> | undefined;
     /**

package/dist/shared/{client.n8K9dFhY.d.ts → client.BPa_Mmuh.d.ts}

@@ -66,7 +66,7 @@ interface RPCJsonSerializerOptions {
      * handlers: { url: undefined }
      * ```
      *
-     * Built-in type keys: `undefined`, `bigint`, `date`, `nan`, `url`, `set`, `map`.
+     * Built-in type keys: `undefined`, `bigint`, `date`, `nan`, `infinity`, `url`, `set`, `map`.
      */
     handlers?: Record<string, undefined | RPCJsonSerializerHandler> | undefined;
     /**

package/dist/shared/{client.BWkR2vPU.d.mts → client.BjbdW5Rj.d.mts}

@@ -1,6 +1,6 @@
 import { Promisable, OrderablePlugin, Interceptor } from '@orpc/shared';
 import { StandardRequest, StandardLazyResponse } from '@standard-server/core';
-import { C as ClientContext, a as ClientOptions, A as AnyORPCError, b as ClientLink } from './client.BoXZCzuS.mjs';
+import { C as ClientContext, a as ClientOptions, A as AnyORPCError, b as ClientLink } from './client.Dw9_40WO.mjs';
 
 type StandardLinkCodecDecodedResponse = {
     kind: 'output';