@orpc/client 2.0.0-beta.4 → 2.0.0-beta.41

package/dist/plugins/index.mjs

@@ -1,15 +1,16 @@
-import { toArray, value, splitInHalf, stringifyJSON, isAsyncIteratorObject, defer, loadBytes, allAbortSignal, replicateAsyncIterator, replicateReadableStream, override, AsyncIteratorClass, sleep } from '@orpc/shared';
-import { parseStandardUrl, getEventMeta, flattenStandardHeader } from '@standardserver/core';
-import { ClientPeer, isServerPeerSendMessage, decodePeerMessage } from '@standardserver/peer';
-import { C as COMMON_ERROR_STATUS_MAP } from '../shared/client.Dnfj8jnT.mjs';
+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.DD2eNne_.mjs';
 
-class BatchLinkPluginError extends TypeError {
-}
 class BatchLinkPlugin {
   name = "~batch";
   groups;
   filter;
+  scope;
   maxSize;
+  wait;
   mode;
   batchUrl;
   maxUrlLength;
@@ -20,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);
@@ -31,7 +34,8 @@ class BatchLinkPlugin {
       const headersList = options2.map((o) => o.request.headers);
       const commonHeaders = {};
       for (const headers of headersList) {
-        for (const [key, value2] of Object.entries(headers)) {
+        for (const key of Object.keys(headers)) {
+          const value2 = headers[key];
           if (headersList.every((h) => h[key] === value2)) {
             commonHeaders[key] = value2;
           }
@@ -41,7 +45,8 @@ class BatchLinkPlugin {
     });
     this.mapSubrequest = options.mapSubrequest ?? (({ request }, { headers }) => {
       const subHeaders = { ...request.headers };
-      for (const [key, value2] of Object.entries(headers)) {
+      for (const key of Object.keys(headers)) {
+        const value2 = headers[key];
         if (subHeaders[key] === value2) {
           subHeaders[key] = void 0;
         }
@@ -51,7 +56,7 @@ class BatchLinkPlugin {
         headers: subHeaders
       };
     });
-    this.mapSubresponse = (subResponse, batchResponse) => {
+    this.mapSubresponse = options.mapSubresponse ?? ((subResponse, batchResponse) => {
       return {
         ...subResponse,
         headers: {
@@ -60,24 +65,34 @@ class BatchLinkPlugin {
           ...subResponse.headers
         }
       };
-    };
+    });
   }
   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);
+        }
+        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]);
-        defer(() => this.processPendingBatches());
+        queue.push([interceptorOptions, resolve, reject, captureAsyncContext()]);
       });
     };
     return {
@@ -85,108 +100,169 @@ 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 restItems = items.filter(([options]) => options.request.method !== "GET");
-      this.executeBatch("GET", group, getItems);
-      this.executeBatch("POST", group, restItems);
+    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=${encodeURIComponent(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
-            });
-            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 BatchLinkPluginError("Invalid batch response format.");
-            }
-            await peer.close(new BatchLinkPluginError("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;
+      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.executeBatchInOwnContext(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) {
+          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) {
@@ -194,24 +270,24 @@ async function decodeLengthPrefixedBlob(blob, peer) {
   let offset = 0;
   while (offset < buffer.length) {
     if (offset + 4 > buffer.length) {
-      throw new BatchLinkPluginError("Invalid batch response: incomplete length header.");
+      throw new TypeError("Invalid batch response: incomplete length header.");
     }
     const view = new DataView(buffer.buffer, buffer.byteOffset + offset, 4);
     const length = view.getUint32(0, false);
     offset += 4;
     if (offset + length > buffer.length) {
-      throw new BatchLinkPluginError("Invalid batch response: incomplete message.");
+      throw new TypeError("Invalid batch response: incomplete message.");
     }
     const messageBytes = buffer.subarray(offset, offset + length);
     offset += length;
     const result = decodePeerMessage(messageBytes);
     if (!result.matched || !isServerPeerSendMessage(result.message)) {
-      throw new BatchLinkPluginError("Invalid batch response: invalid message.");
+      throw new TypeError("Invalid batch response: invalid message.");
     }
     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 {
@@ -226,6 +302,10 @@ async function decodeLengthPrefixedStream(stream, peer) {
       while (buffer.length >= 4) {
         const view = new DataView(buffer.buffer, buffer.byteOffset, 4);
         const length = view.getUint32(0, false);
+        if (length === 0) {
+          buffer = buffer.subarray(4);
+          continue;
+        }
         if (buffer.length < 4 + length) {
           break;
         }
@@ -233,9 +313,9 @@ async function decodeLengthPrefixedStream(stream, peer) {
         buffer = buffer.subarray(4 + length);
         const result = decodePeerMessage(messageBytes);
         if (!result.matched || !isServerPeerSendMessage(result.message)) {
-          throw new BatchLinkPluginError("Invalid batch response: invalid message.");
+          throw new TypeError("Invalid batch response: invalid message.");
         }
-        await peer.message(result.message);
+        await receive(result.message);
       }
       if (done) {
         break;
@@ -251,10 +331,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");
+    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) => {
@@ -265,78 +349,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);
       }
     }
   }
@@ -353,42 +440,310 @@ 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;
 }
 
-class RetryLinkPluginInvalidEventIteratorRetryResponse extends Error {
+const AVG_BYTES_PER_CHAR = 1.2;
+class RequestCompressionLinkPlugin {
+  name = "~request-compression";
+  /**
+   * Compression should be done after batching, to compress the final request
+   */
+  after = ["~batch"];
+  encoding;
+  threshold;
+  isCompressibleContentType;
+  constructor(options = {}) {
+    this.encoding = options.encoding ?? "gzip";
+    this.threshold = options.threshold ?? 1024;
+    this.isCompressibleContentType = options.isCompressibleContentType ?? isCompressibleContentType;
+  }
+  init(options) {
+    const transportInterceptor = async ({ next, ...interceptorOptions }) => {
+      const request = interceptorOptions.request;
+      const contentEncoding = flattenStandardHeader(request.headers["content-encoding"])?.trim()?.toLowerCase();
+      if (contentEncoding !== void 0) {
+        return next();
+      }
+      if (request.body instanceof ReadableStream) {
+        const contentLength = Number(flattenStandardHeader(request.headers["content-length"]));
+        if ((!Number.isFinite(contentLength) || contentLength >= this.threshold) && this.isCompressibleContentType(flattenStandardHeader(request.headers["content-type"]), interceptorOptions)) {
+          const compressedStream = request.body.pipeThrough(new CompressionStream(this.encoding));
+          return next({
+            ...interceptorOptions,
+            request: {
+              ...interceptorOptions.request,
+              body: compressedStream,
+              headers: {
+                ...request.headers,
+                "standard-server": "octet-stream",
+                "content-length": [],
+                "content-encoding": this.encoding
+              }
+            }
+          });
+        }
+      } else if (request.body instanceof Blob) {
+        if ((!Number.isFinite(request.body.size) || request.body.size >= this.threshold) && this.isCompressibleContentType(request.body.type, interceptorOptions)) {
+          const compressedStream = request.body.stream().pipeThrough(new CompressionStream(this.encoding));
+          const contentDisposition = request.headers["content-disposition"] ?? generateContentDisposition(
+            request.body instanceof File ? request.body.name : "blob"
+          );
+          return next({
+            ...interceptorOptions,
+            request: {
+              ...interceptorOptions.request,
+              body: compressedStream,
+              headers: {
+                ...request.headers,
+                "standard-server": "file",
+                "content-type": request.body.type,
+                "content-length": [],
+                "content-disposition": contentDisposition,
+                "content-encoding": this.encoding
+              }
+            }
+          });
+        }
+      } else if (request.body instanceof FormData) {
+        const PART_OVERHEAD = 64;
+        let contentLength = 0;
+        for (const [key, value] of request.body) {
+          contentLength += PART_OVERHEAD + key.length;
+          if (value instanceof Blob) {
+            if (!Number.isFinite(value.size)) {
+              if (!this.isCompressibleContentType(value.type, interceptorOptions)) {
+                contentLength = -Infinity;
+                break;
+              }
+              contentLength = Infinity;
+            } else {
+              contentLength += this.isCompressibleContentType(value.type, interceptorOptions) ? value.size : -value.size;
+            }
+          } else {
+            contentLength += value.length * AVG_BYTES_PER_CHAR;
+          }
+        }
+        if (contentLength >= this.threshold) {
+          const res = new Response(request.body);
+          const compressedStream = res.body.pipeThrough(new CompressionStream(this.encoding));
+          return next({
+            ...interceptorOptions,
+            request: {
+              ...interceptorOptions.request,
+              body: compressedStream,
+              headers: {
+                ...request.headers,
+                "standard-server": [],
+                "content-type": res.headers.get("content-type"),
+                "content-length": [],
+                "content-encoding": this.encoding
+              }
+            }
+          });
+        }
+      } else if (request.body instanceof URLSearchParams) {
+        const string = request.body.toString();
+        if (string.length * AVG_BYTES_PER_CHAR >= this.threshold) {
+          const compressedStream = new Blob([string]).stream().pipeThrough(new CompressionStream(this.encoding));
+          return next({
+            ...interceptorOptions,
+            request: {
+              ...interceptorOptions.request,
+              body: compressedStream,
+              headers: {
+                ...request.headers,
+                "standard-server": [],
+                "content-type": "application/x-www-form-urlencoded",
+                "content-length": [],
+                "content-encoding": this.encoding
+              }
+            }
+          });
+        }
+      } else if (request.body !== void 0 && !isAsyncIteratorObject(request.body)) {
+        const string = stringifyJSON(request.body);
+        if (string.length * AVG_BYTES_PER_CHAR >= this.threshold) {
+          const compressedStream = new Blob([string]).stream().pipeThrough(new CompressionStream(this.encoding));
+          return next({
+            ...interceptorOptions,
+            request: {
+              ...interceptorOptions.request,
+              body: compressedStream,
+              headers: {
+                ...request.headers,
+                "standard-server": [],
+                "content-type": "application/json",
+                "content-length": [],
+                "content-encoding": this.encoding
+              }
+            }
+          });
+        }
+      }
+      return next();
+    };
+    return {
+      ...options,
+      transportInterceptors: [
+        ...toArray(options.transportInterceptors),
+        transportInterceptor
+      ]
+    };
+  }
+}
+
+const MAX_CONTENT_ENCODINGS = 5;
+class ResponseCompressionLinkPlugin {
+  name = "~response-compression";
+  /**
+   * Decompression should wrap the final batch response instead of sub-responses.
+   */
+  after = ["~batch"];
+  encodings;
+  constructor(options = {}) {
+    this.encodings = options.encodings ?? ["gzip", "deflate"];
+  }
+  init(options) {
+    const acceptEncodingHeader = this.encodings.join(", ");
+    const transportInterceptor = async ({ next, ...interceptorOptions }) => {
+      const response = await next({
+        ...interceptorOptions,
+        request: {
+          ...interceptorOptions.request,
+          headers: {
+            ...interceptorOptions.request.headers,
+            "accept-encoding": acceptEncodingHeader
+          }
+        }
+      });
+      const encodings = parseContentEncodings(
+        flattenStandardHeader(response.headers["content-encoding"])
+      );
+      if (encodings.length === 0 || !encodings.every(isSupportedEncoding)) {
+        return response;
+      }
+      const decompressedHeaders = {
+        ...response.headers,
+        "content-length": void 0,
+        "content-encoding": void 0
+      };
+      return {
+        ...response,
+        headers: decompressedHeaders,
+        async resolveBody(hint) {
+          const stream = await response.resolveBody("octet-stream");
+          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(
+              new DecompressionStream(encodings[i])
+            );
+          }
+          const fetchResponse = new Response(decompressedStream, {
+            headers: toFetchHeaders(decompressedHeaders)
+          });
+          return toStandardBody(fetchResponse, { hint });
+        }
+      };
+    };
+    return {
+      ...options,
+      transportInterceptors: [
+        ...toArray(options.transportInterceptors),
+        transportInterceptor
+      ]
+    };
+  }
+}
+const SUPPORTED_ENCODINGS = ["gzip", "deflate", "deflate-raw"];
+function isSupportedEncoding(encoding) {
+  return SUPPORTED_ENCODINGS.includes(encoding);
 }
+function parseContentEncodings(header) {
+  if (header === void 0) {
+    return [];
+  }
+  return header.split(",").map((part) => part.trim().toLowerCase());
+}
+
 class RetryLinkPlugin {
   defaultRetry;
   defaultRetryDelay;
@@ -422,6 +777,7 @@ class RetryLinkPlugin {
         let currentError = initialError;
         while (true) {
           const updatedCallOptions = { ...callOptions, lastEventId };
+          let retryDelayMs = 0;
           if (currentError) {
             if (attempt > maxAttempts) {
               throw currentError.error;
@@ -439,16 +795,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++;
             }
@@ -484,13 +835,13 @@ class RetryLinkPlugin {
               const meta = getEventMeta(error);
               lastEventId = meta?.id ?? lastEventId;
               lastEventRetry = meta?.retry ?? lastEventRetry;
-              const maybeEventIterator = await callNext({ error });
-              if (!isAsyncIteratorObject(maybeEventIterator)) {
-                throw new RetryLinkPluginInvalidEventIteratorRetryResponse(
-                  "RetryLinkPlugin: Expected an Event Iterator, got a non-Event Iterator"
+              const asyncIteratorObject = await callNext({ error });
+              if (!isAsyncIteratorObject(asyncIteratorObject)) {
+                throw new TypeError(
+                  "RetryLinkPlugin: Expected an AsyncIteratorObject, got a different type."
                 );
               }
-              current = maybeEventIterator;
+              current = asyncIteratorObject;
               if (isIteratorAborted) {
                 await current.return?.();
                 throw error;
@@ -571,4 +922,35 @@ function parseRetryAfterHeader(value2) {
   return void 0;
 }
 
-export { BatchLinkPlugin, BatchLinkPluginError, DedupeLinkPlugin, RetryAfterLinkPlugin, RetryLinkPlugin, RetryLinkPluginInvalidEventIteratorRetryResponse };
+class TimeoutLinkPlugin {
+  timeout;
+  name = "~timeout";
+  /**
+   * Should abort if the total retry time exceeds the configured timeout
+   */
+  after = ["~retry"];
+  constructor(options) {
+    this.timeout = options.timeout;
+  }
+  init(options) {
+    const interceptor = async (interceptorOptions) => {
+      const timeoutMs = value(this.timeout, interceptorOptions);
+      if (timeoutMs === null || timeoutMs === void 0) {
+        return interceptorOptions.next();
+      }
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => {
+        controller.abort(new AbortError(`Request timed out after ${timeoutMs}ms`));
+      }, timeoutMs);
+      const signal = anyAbortSignal([interceptorOptions.signal, controller.signal]);
+      try {
+        return await interceptorOptions.next({ ...interceptorOptions, signal });
+      } finally {
+        clearTimeout(timeoutId);
+      }
+    };
+    return { ...options, interceptors: [interceptor, ...toArray(options.interceptors)] };
+  }
+}
+
+export { BatchLinkPlugin, RetryLinkPlugin as ClientRetryPlugin, DedupeLinkPlugin, DedupeLinkPlugin as DedupeRequestsPlugin, RequestCompressionLinkPlugin, ResponseCompressionLinkPlugin, RetryAfterLinkPlugin, RetryAfterLinkPlugin as RetryAfterPlugin, RetryLinkPlugin, TimeoutLinkPlugin };