@orpc/client 1.14.6 → 2.0.0-beta.10

package/dist/plugins/index.mjs

@@ -1,270 +1,400 @@
-import { isAsyncIteratorObject, defer, value, splitInHalf, toArray, stringifyJSON, overlayProxy, AsyncIteratorClass } from '@orpc/shared';
-import { toBatchRequest, parseBatchResponse, toBatchAbortSignal } from '@orpc/standard-server/batch';
-import { replicateStandardLazyResponse, getEventMeta, flattenHeader } from '@orpc/standard-server';
-import { C as COMMON_ORPC_ERROR_DEFS } from '../shared/client.D9eWXdBV.mjs';
+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';
 
+class BatchLinkPluginError extends TypeError {
+}
 class BatchLinkPlugin {
+  name = "~batch";
   groups;
+  filter;
   maxSize;
+  mode;
   batchUrl;
   maxUrlLength;
   batchHeaders;
-  mapRequestItem;
-  exclude;
-  mode;
-  pending;
-  order = 5e6;
+  mapSubrequest;
+  mapSubresponse;
+  queue = /* @__PURE__ */ new Map();
   constructor(options) {
     this.groups = options.groups;
-    this.pending = /* @__PURE__ */ new Map();
+    this.filter = options.filter ?? (() => true);
     this.maxSize = options.maxSize ?? 10;
-    this.maxUrlLength = options.maxUrlLength ?? 2083;
     this.mode = options.mode ?? "streaming";
-    this.batchUrl = options.url ?? (([options2]) => `${options2.request.url.origin}${options2.request.url.pathname}/__batch__`);
-    this.batchHeaders = options.headers ?? (([options2, ...rest]) => {
-      const headers = {};
-      for (const [key, value2] of Object.entries(options2.request.headers)) {
-        if (rest.every((item) => item.request.headers[key] === value2)) {
-          headers[key] = value2;
+    this.batchUrl = options.url ?? ((options2) => {
+      const [pathname] = parseStandardUrl(options2[0].request.url);
+      return `${pathname}/__batch__`;
+    });
+    this.maxUrlLength = options.maxUrlLength ?? 2083;
+    this.batchHeaders = options.headers ?? (async (options2) => {
+      const headersList = options2.map((o) => o.request.headers);
+      const commonHeaders = {};
+      for (const headers of headersList) {
+        for (const [key, value2] of Object.entries(headers)) {
+          if (headersList.every((h) => h[key] === value2)) {
+            commonHeaders[key] = value2;
+          }
         }
       }
-      return headers;
+      return commonHeaders;
     });
-    this.mapRequestItem = options.mapRequestItem ?? (({ request, batchHeaders }) => {
-      const headers = {};
-      for (const [key, value2] of Object.entries(request.headers)) {
-        if (batchHeaders[key] !== value2) {
-          headers[key] = value2;
+    this.mapSubrequest = options.mapSubrequest ?? (({ request }, { headers }) => {
+      const subHeaders = { ...request.headers };
+      for (const [key, value2] of Object.entries(headers)) {
+        if (subHeaders[key] === value2) {
+          subHeaders[key] = void 0;
         }
       }
       return {
-        method: request.method,
-        url: request.url,
-        headers,
-        body: request.body,
-        signal: request.signal
+        ...request,
+        headers: subHeaders
       };
     });
-    this.exclude = options.exclude ?? (() => false);
+    this.mapSubresponse = (subResponse, batchResponse) => {
+      return {
+        ...subResponse,
+        headers: {
+          ...batchResponse.headers,
+          // low-priority
+          ...subResponse.headers
+        }
+      };
+    };
   }
   init(options) {
-    options.clientInterceptors ??= [];
-    options.clientInterceptors.push((options2) => {
-      if (options2.request.headers["x-orpc-batch"] !== "1") {
-        return options2.next();
-      }
-      return options2.next({
-        ...options2,
-        request: {
-          ...options2.request,
-          headers: {
-            ...options2.request.headers,
-            "x-orpc-batch": void 0
-          }
-        }
-      });
-    });
-    options.clientInterceptors.push((options2) => {
-      if (this.exclude(options2) || options2.request.body instanceof Blob || options2.request.body instanceof FormData || isAsyncIteratorObject(options2.request.body) || options2.request.signal?.aborted) {
-        return options2.next();
+    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)) {
+        return interceptorOptions.next();
       }
-      const group = this.groups.find((group2) => group2.condition(options2));
+      const group = this.groups.find((group2) => value(group2.condition, interceptorOptions));
       if (!group) {
-        return options2.next();
+        return interceptorOptions.next();
       }
       return new Promise((resolve, reject) => {
-        this.#enqueueRequest(group, options2, resolve, reject);
-        defer(() => this.#processPendingBatches());
+        const queue = this.queue.get(group) ?? [];
+        if (!this.queue.has(group)) {
+          this.queue.set(group, queue);
+        }
+        queue.push([interceptorOptions, resolve, reject]);
+        defer(() => this.processPendingBatches());
       });
-    });
+    };
+    return {
+      ...options,
+      transportInterceptors: [...toArray(options.transportInterceptors), transportInterceptor]
+    };
   }
-  #enqueueRequest(group, options, resolve, reject) {
-    const items = this.pending.get(group);
-    if (items) {
-      items.push([options, resolve, reject]);
-    } else {
-      this.pending.set(group, [[options, resolve, reject]]);
-    }
-  }
-  async #processPendingBatches() {
-    const pending = this.pending;
-    this.pending = /* @__PURE__ */ new Map();
+  async processPendingBatches() {
+    const pending = new Map(this.queue);
+    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);
+      this.executeBatch("GET", group, getItems);
+      this.executeBatch("POST", group, restItems);
     }
   }
-  async #executeBatch(method, group, groupItems) {
+  async executeBatch(method, group, groupItems) {
     if (!groupItems.length) {
       return;
     }
-    const batchItems = groupItems;
-    if (batchItems.length === 1) {
-      batchItems[0][0].next().then(batchItems[0][1]).catch(batchItems[0][2]);
+    if (groupItems.length === 1) {
+      const [options, resolve, reject] = groupItems[0];
+      options.next().then(resolve).catch(reject);
       return;
     }
-    try {
-      const options = batchItems.map(([options2]) => options2);
-      const maxSize = await value(this.maxSize, options);
-      if (batchItems.length > maxSize) {
-        const [first, second] = splitInHalf(batchItems);
-        this.#executeBatch(method, group, first);
-        this.#executeBatch(method, group, second);
-        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();
       }
-      const batchUrl = new URL(await value(this.batchUrl, options));
-      const batchHeaders = await value(this.batchHeaders, options);
-      const mappedItems = batchItems.map(([options2]) => this.mapRequestItem({ ...options2, batchUrl, batchHeaders }));
-      const batchRequest = toBatchRequest({
-        method,
-        url: batchUrl,
-        headers: batchHeaders,
-        requests: mappedItems
+      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);
+          }
+        })();
+      }
+    });
+    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 maxUrlLength = await value(this.maxUrlLength, options);
-      if (batchRequest.url.toString().length > maxUrlLength) {
-        const [first, second] = splitInHalf(batchItems);
-        this.#executeBatch(method, group, first);
-        this.#executeBatch(method, group, second);
-        return;
+    });
+  }
+}
+async function decodeLengthPrefixedBlob(blob, peer) {
+  const buffer = await loadBytes(blob);
+  let offset = 0;
+  while (offset < buffer.length) {
+    if (offset + 4 > buffer.length) {
+      throw new BatchLinkPluginError("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.");
+    }
+    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.");
+    }
+    await peer.message(result.message);
+  }
+}
+async function decodeLengthPrefixedStream(stream, peer) {
+  const reader = stream.getReader();
+  let buffer = new Uint8Array(0);
+  try {
+    while (true) {
+      const { done, value: chunk } = await reader.read();
+      if (chunk) {
+        const newBuffer = new Uint8Array(buffer.length + chunk.length);
+        newBuffer.set(buffer);
+        newBuffer.set(chunk, buffer.length);
+        buffer = newBuffer;
       }
-      const mode = value(this.mode, options);
-      try {
-        const lazyResponse = await options[0].next({
-          request: { ...batchRequest, headers: { ...batchRequest.headers, "x-orpc-batch": mode } },
-          signal: batchRequest.signal,
-          context: group.context,
-          input: group.input,
-          path: toArray(group.path)
-        });
-        const parsed = parseBatchResponse({ ...lazyResponse, body: await lazyResponse.body() });
-        for await (const item of parsed) {
-          batchItems[item.index]?.[1]({ ...item, body: () => Promise.resolve(item.body) });
+      while (buffer.length >= 4) {
+        const view = new DataView(buffer.buffer, buffer.byteOffset, 4);
+        const length = view.getUint32(0, false);
+        if (buffer.length < 4 + length) {
+          break;
         }
-      } catch (err) {
-        if (batchRequest.signal?.aborted && batchRequest.signal.reason === err) {
-          for (const [{ signal }, , reject] of batchItems) {
-            if (signal?.aborted) {
-              reject(signal.reason);
-            }
-          }
+        const messageBytes = buffer.subarray(4, 4 + length);
+        buffer = buffer.subarray(4 + length);
+        const result = decodePeerMessage(messageBytes);
+        if (!result.matched || !isServerPeerSendMessage(result.message)) {
+          throw new BatchLinkPluginError("Invalid batch response: invalid message.");
         }
-        throw err;
+        await peer.message(result.message);
       }
-      throw new Error("Something went wrong make batch response not contains enough responses. This can be a bug please report it.");
-    } catch (error) {
-      for (const [, , reject] of batchItems) {
-        reject(error);
+      if (done) {
+        break;
       }
     }
+  } finally {
+    reader.releaseLock();
   }
 }
 
-class DedupeRequestsPlugin {
-  #groups;
-  #filter;
-  order = 4e6;
-  // make sure execute before batch plugin
-  #queue = /* @__PURE__ */ new Map();
+class DedupeLinkPlugin {
+  name = "~dedupe";
+  before = ["~batch"];
+  groups;
+  filter;
+  queue = /* @__PURE__ */ new Map();
   constructor(options) {
-    this.#groups = options.groups;
-    this.#filter = options.filter ?? (({ request }) => request.method === "GET");
+    this.groups = options.groups;
+    this.filter = options.filter ?? (({ request }) => request.method === "GET");
   }
   init(options) {
-    options.clientInterceptors ??= [];
-    options.clientInterceptors.push((options2) => {
-      if (options2.request.body instanceof Blob || options2.request.body instanceof FormData || options2.request.body instanceof URLSearchParams || isAsyncIteratorObject(options2.request.body) || !this.#filter(options2)) {
-        return options2.next();
+    const transportInterceptor = (interceptorOptions) => {
+      if (!canDedupeRequest(interceptorOptions.request) || !value(this.filter, interceptorOptions)) {
+        return interceptorOptions.next();
       }
-      const group = this.#groups.find((group2) => group2.condition(options2));
+      const group = this.groups.find((group2) => value(group2.condition, interceptorOptions));
       if (!group) {
-        return options2.next();
+        return interceptorOptions.next();
       }
       return new Promise((resolve, reject) => {
-        this.#enqueue(group, options2, resolve, reject);
-        defer(() => this.#dequeue());
+        this.enqueue(group, interceptorOptions, resolve, reject);
+        defer(() => {
+          this.processPendingRequests();
+        });
       });
-    });
+    };
+    return {
+      ...options,
+      transportInterceptors: [...toArray(options.transportInterceptors), transportInterceptor]
+    };
   }
-  #enqueue(group, options, resolve, reject) {
-    let queue = this.#queue.get(group);
+  enqueue(group, options, resolve, reject) {
+    let queue = this.queue.get(group);
     if (!queue) {
-      this.#queue.set(group, queue = []);
+      queue = [];
+      this.queue.set(group, queue);
     }
-    const matched = queue.find((item) => {
-      const requestString1 = stringifyJSON({
-        body: item.options.request.body,
-        headers: item.options.request.headers,
-        method: item.options.request.method,
-        url: item.options.request.url
-      });
-      const requestString2 = stringifyJSON({
-        body: options.request.body,
-        headers: options.request.headers,
-        method: options.request.method,
-        url: options.request.url
-      });
-      return requestString1 === requestString2;
-    });
+    const requestKey = createRequestKey(options.path, options.request);
+    const matched = queue.find((item) => item.requestKey === requestKey);
     if (matched) {
+      matched.matchedOptions.push(options);
       matched.signals.push(options.request.signal);
       matched.resolves.push(resolve);
       matched.rejects.push(reject);
-    } else {
-      queue.push({
-        options,
-        signals: [options.request.signal],
-        resolves: [resolve],
-        rejects: [reject]
-      });
+      return;
     }
+    queue.push({
+      requestKey,
+      options,
+      matchedOptions: [options],
+      signals: [options.request.signal],
+      resolves: [resolve],
+      rejects: [reject]
+    });
   }
-  async #dequeue() {
-    const promises = [];
-    for (const [group, items] of this.#queue) {
-      for (const { options, signals, resolves, rejects } of items) {
-        promises.push(
-          this.#execute(group, options, signals, resolves, rejects)
-        );
+  async processPendingRequests() {
+    const pending = new Map(this.queue);
+    this.queue.clear();
+    const executions = [];
+    for (const [group, items] of pending) {
+      for (const item of items) {
+        executions.push(this.execute(group, item));
       }
     }
-    this.#queue.clear();
-    await Promise.all(promises);
+    await Promise.all(executions);
   }
-  async #execute(group, options, signals, resolves, rejects) {
+  async execute(group, item) {
     try {
-      const dedupedRequest = {
-        ...options.request,
-        signal: toBatchAbortSignal(signals)
+      if (!shouldDedupe(item.matchedOptions)) {
+        const response2 = await item.options.next(item.options);
+        item.resolves[0]?.(response2);
+        return;
+      }
+      const context = value(group.context, item.matchedOptions);
+      const request = {
+        ...item.options.request,
+        signal: allAbortSignal(item.signals)
       };
-      const response = await options.next({
-        ...options,
-        request: dedupedRequest,
-        signal: dedupedRequest.signal,
-        context: group.context
+      const response = await item.options.next({
+        ...item.options,
+        request,
+        signal: request.signal,
+        context
       });
-      const replicatedResponses = replicateStandardLazyResponse(response, resolves.length);
-      for (const resolve of resolves) {
-        resolve(replicatedResponses.shift());
+      const replicatedResponses = replicateLazyResponse(response, item.resolves.length);
+      for (const resolve of item.resolves) {
+        resolve(replicatedResponses.pop());
       }
     } catch (error) {
-      for (const reject of rejects) {
+      for (const reject of item.rejects) {
         reject(error);
       }
     }
   }
 }
+function canDedupeRequest(request) {
+  return !(request.body instanceof Blob || request.body instanceof FormData || request.body instanceof URLSearchParams || request.body instanceof ReadableStream || isAsyncIteratorObject(request.body) || request.signal?.aborted);
+}
+function createRequestKey(path, request) {
+  return stringifyJSON({
+    path,
+    body: request.body,
+    headers: request.headers,
+    method: request.method,
+    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;
+        if (isAsyncIteratorObject(body)) {
+          replicatedAsyncIterators ??= replicateAsyncIterator(body, count);
+          resolvedBody = { body: replicatedAsyncIterators.pop() };
+        } else if (body instanceof ReadableStream) {
+          replicatedReadableStream ??= replicateReadableStream(body, count);
+          resolvedBody = { body: replicatedReadableStream.pop() };
+        } else {
+          resolvedBody = { body };
+        }
+        return resolvedBody.body;
+      }
+    });
+  }
+  return replicated;
+}
+function shouldDedupe(items) {
+  return items.length >= 2;
+}
 
-class ClientRetryPluginInvalidEventIteratorRetryResponse extends Error {
+class RetryLinkPluginInvalidEventIteratorRetryResponse extends Error {
 }
-class ClientRetryPlugin {
+class RetryLinkPlugin {
   defaultRetry;
   defaultRetryDelay;
   defaultShouldRetry;
   defaultOnRetry;
-  order = 18e5;
+  name = "~retry";
   constructor(options = {}) {
     this.defaultRetry = options.default?.retry ?? 0;
     this.defaultRetryDelay = options.default?.retryDelay ?? ((o) => o.lastEventRetry ?? 2e3);
@@ -272,33 +402,33 @@ class ClientRetryPlugin {
     this.defaultOnRetry = options.default?.onRetry;
   }
   init(options) {
-    options.interceptors ??= [];
-    options.interceptors.push(async (interceptorOptions) => {
+    const interceptor = async (interceptorOptions) => {
+      const { next, ...callOptions } = interceptorOptions;
       const maxAttempts = await value(
-        interceptorOptions.context.retry ?? this.defaultRetry,
-        interceptorOptions
+        callOptions.context.retry ?? this.defaultRetry,
+        callOptions
       );
-      const retryDelay = interceptorOptions.context.retryDelay ?? this.defaultRetryDelay;
-      const shouldRetry = interceptorOptions.context.shouldRetry ?? this.defaultShouldRetry;
-      const onRetry = interceptorOptions.context.onRetry ?? this.defaultOnRetry;
+      const retryDelay = callOptions.context.retryDelay ?? this.defaultRetryDelay;
+      const shouldRetry = callOptions.context.shouldRetry ?? this.defaultShouldRetry;
+      const onRetry = callOptions.context.onRetry ?? this.defaultOnRetry;
       if (maxAttempts <= 0) {
-        return interceptorOptions.next();
+        return next(callOptions);
       }
-      let lastEventId = interceptorOptions.lastEventId;
+      let lastEventId = callOptions.lastEventId;
       let lastEventRetry;
       let callback;
-      let attemptIndex = 0;
-      const next = async (initialError) => {
+      let attempt = 1;
+      const callNext = async (initialError) => {
         let currentError = initialError;
         while (true) {
-          const updatedInterceptorOptions = { ...interceptorOptions, lastEventId };
+          const updatedCallOptions = { ...callOptions, lastEventId };
           if (currentError) {
-            if (attemptIndex >= maxAttempts) {
+            if (attempt > maxAttempts) {
               throw currentError.error;
             }
             const attemptOptions = {
-              ...updatedInterceptorOptions,
-              attemptIndex,
+              ...updatedCallOptions,
+              attempt,
               error: currentError.error,
               lastEventRetry
             };
@@ -310,16 +440,23 @@ class ClientRetryPlugin {
               throw currentError.error;
             }
             callback = onRetry?.(attemptOptions);
-            const retryDelayMs = await value(retryDelay, attemptOptions);
-            await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
-            attemptIndex++;
           }
           try {
+            if (currentError) {
+              const retryDelayMs = await value(retryDelay, {
+                ...updatedCallOptions,
+                attempt,
+                error: currentError.error,
+                lastEventRetry
+              });
+              await sleep(retryDelayMs, { signal: updatedCallOptions.signal });
+              attempt++;
+            }
             currentError = void 0;
-            return await interceptorOptions.next(updatedInterceptorOptions);
+            return await next(updatedCallOptions);
           } catch (error) {
             currentError = { error };
-            if (updatedInterceptorOptions.signal?.aborted) {
+            if (updatedCallOptions.signal?.aborted) {
               throw error;
             }
           } finally {
@@ -328,13 +465,13 @@ class ClientRetryPlugin {
           }
         }
       };
-      const output = await next();
+      const output = await callNext();
       if (!isAsyncIteratorObject(output)) {
         return output;
       }
       let current = output;
       let isIteratorAborted = false;
-      return overlayProxy(() => current, new AsyncIteratorClass(
+      return override(() => current, new AsyncIteratorClass(
         async () => {
           while (true) {
             try {
@@ -347,10 +484,10 @@ class ClientRetryPlugin {
               const meta = getEventMeta(error);
               lastEventId = meta?.id ?? lastEventId;
               lastEventRetry = meta?.retry ?? lastEventRetry;
-              const maybeEventIterator = await next({ error });
+              const maybeEventIterator = await callNext({ error });
               if (!isAsyncIteratorObject(maybeEventIterator)) {
-                throw new ClientRetryPluginInvalidEventIteratorRetryResponse(
-                  "RetryPlugin: Expected an Event Iterator, got a non-Event Iterator"
+                throw new RetryLinkPluginInvalidEventIteratorRetryResponse(
+                  "RetryLinkPlugin: Expected an Event Iterator, got a non-Event Iterator"
                 );
               }
               current = maybeEventIterator;
@@ -361,30 +498,30 @@ class ClientRetryPlugin {
             }
           }
         },
-        async (reason) => {
+        async ({ kind }) => {
           isIteratorAborted = true;
-          if (reason !== "next") {
+          if (kind === "cancelled") {
             await current.return?.();
           }
         }
       ));
-    });
+    };
+    return { ...options, interceptors: [interceptor, ...toArray(options.interceptors)] };
   }
 }
 
-class RetryAfterPlugin {
+class RetryAfterLinkPlugin {
   condition;
   maxAttempts;
   timeout;
-  order = 19e5;
+  name = "~retry-after";
   constructor(options = {}) {
-    this.condition = options.condition ?? ((response) => response.status === COMMON_ORPC_ERROR_DEFS.TOO_MANY_REQUESTS.status || response.status === COMMON_ORPC_ERROR_DEFS.SERVICE_UNAVAILABLE.status);
+    this.condition = options.condition ?? ((response) => response.status === COMMON_ERROR_STATUS_MAP.TOO_MANY_REQUESTS || response.status === COMMON_ERROR_STATUS_MAP.SERVICE_UNAVAILABLE);
     this.maxAttempts = options.maxAttempts ?? 3;
     this.timeout = options.timeout ?? 5 * 60 * 1e3;
   }
   init(options) {
-    options.clientInterceptors ??= [];
-    options.clientInterceptors.push(async (interceptorOptions) => {
+    const interceptor = async (interceptorOptions) => {
       const startTime = Date.now();
       let attemptCount = 0;
       while (true) {
@@ -393,8 +530,8 @@ class RetryAfterPlugin {
         if (!value(this.condition, response, interceptorOptions)) {
           return response;
         }
-        const retryAfterHeader = flattenHeader(response.headers["retry-after"]);
-        const retryAfterMs = this.parseRetryAfterHeader(retryAfterHeader);
+        const retryAfterHeader = flattenStandardHeader(response.headers["retry-after"]);
+        const retryAfterMs = parseRetryAfterHeader(retryAfterHeader);
         if (retryAfterMs === void 0) {
           return response;
         }
@@ -406,80 +543,32 @@ class RetryAfterPlugin {
         if (elapsedTime + retryAfterMs > timeoutMs) {
           return response;
         }
-        await this.delayExecution(retryAfterMs, interceptorOptions.signal);
+        try {
+          await sleep(retryAfterMs, { signal: interceptorOptions.signal });
+        } catch {
+        }
         if (interceptorOptions.signal?.aborted) {
           return response;
         }
       }
-    });
+    };
+    return { ...options, transportInterceptors: [interceptor, ...toArray(options.transportInterceptors)] };
   }
-  parseRetryAfterHeader(value2) {
-    value2 = value2?.trim();
-    if (!value2) {
-      return void 0;
-    }
-    const seconds = Number(value2);
-    if (Number.isFinite(seconds)) {
-      return Math.max(0, seconds * 1e3);
-    }
-    const retryDate = Date.parse(value2);
-    if (!Number.isNaN(retryDate)) {
-      return Math.max(0, retryDate - Date.now());
-    }
+}
+function parseRetryAfterHeader(value2) {
+  value2 = value2?.trim();
+  if (!value2) {
     return void 0;
   }
-  delayExecution(ms, signal) {
-    return new Promise((resolve) => {
-      if (signal?.aborted) {
-        resolve();
-        return;
-      }
-      let timeout;
-      const onAbort = () => {
-        clearTimeout(timeout);
-        timeout = void 0;
-        resolve();
-      };
-      signal?.addEventListener("abort", onAbort, { once: true });
-      timeout = setTimeout(() => {
-        signal?.removeEventListener("abort", onAbort);
-        resolve();
-      }, ms);
-    });
-  }
-}
-
-class SimpleCsrfProtectionLinkPlugin {
-  headerName;
-  headerValue;
-  exclude;
-  constructor(options = {}) {
-    this.headerName = options.headerName ?? "x-csrf-token";
-    this.headerValue = options.headerValue ?? "orpc";
-    this.exclude = options.exclude ?? false;
+  const seconds = Number(value2);
+  if (Number.isFinite(seconds)) {
+    return Math.max(0, seconds * 1e3);
   }
-  order = 8e6;
-  init(options) {
-    options.clientInterceptors ??= [];
-    options.clientInterceptors.push(async (options2) => {
-      const excluded = await value(this.exclude, options2);
-      if (excluded) {
-        return options2.next();
-      }
-      const headerName = await value(this.headerName, options2);
-      const headerValue = await value(this.headerValue, options2);
-      return options2.next({
-        ...options2,
-        request: {
-          ...options2.request,
-          headers: {
-            ...options2.request.headers,
-            [headerName]: headerValue
-          }
-        }
-      });
-    });
+  const retryDate = Date.parse(value2);
+  if (!Number.isNaN(retryDate)) {
+    return Math.max(0, retryDate - Date.now());
   }
+  return void 0;
 }
 
-export { BatchLinkPlugin, ClientRetryPlugin, ClientRetryPluginInvalidEventIteratorRetryResponse, DedupeRequestsPlugin, RetryAfterPlugin, SimpleCsrfProtectionLinkPlugin };
+export { BatchLinkPlugin, BatchLinkPluginError, DedupeLinkPlugin, RetryAfterLinkPlugin, RetryLinkPlugin, RetryLinkPluginInvalidEventIteratorRetryResponse };