@orpc/client 1.14.11 → 1.14.12

package/dist/plugins/index.mjs

@@ -1,626 +1,270 @@
-import { toArray, value, splitInHalf, stringifyJSON, isAsyncIteratorObject, defer, loadBytes, allAbortSignal, replicateAsyncIterator, replicateReadableStream, isCompressibleContentType, override, AsyncIteratorClass, sleep, AbortError, anyAbortSignal } from '@orpc/shared';
-import { parseStandardUrl, flattenStandardHeader, generateContentDisposition, getEventMeta } from '@standardserver/core';
-import { ClientPeer, isServerPeerSendMessage, decodePeerMessage } from '@standardserver/peer';
-import { toFetchHeaders, toStandardBody } from '@standardserver/fetch';
-import { C as COMMON_ERROR_STATUS_MAP } from '../shared/client.Dnfj8jnT.mjs';
+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.DrCRv_sG.mjs';
 
-class BatchLinkPluginError extends TypeError {
-}
 class BatchLinkPlugin {
-  name = "~batch";
   groups;
-  filter;
   maxSize;
-  mode;
   batchUrl;
   maxUrlLength;
   batchHeaders;
-  mapSubrequest;
-  mapSubresponse;
-  queue = /* @__PURE__ */ new Map();
+  mapRequestItem;
+  exclude;
+  mode;
+  pending;
+  order = 5e6;
   constructor(options) {
     this.groups = options.groups;
-    this.filter = options.filter ?? (() => true);
+    this.pending = /* @__PURE__ */ new Map();
     this.maxSize = options.maxSize ?? 10;
-    this.mode = options.mode ?? "streaming";
-    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;
-          }
+    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;
         }
       }
-      return commonHeaders;
+      return headers;
     });
-    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;
+    this.mapRequestItem = options.mapRequestItem ?? (({ request, batchHeaders }) => {
+      const headers = {};
+      for (const [key, value2] of Object.entries(request.headers)) {
+        if (batchHeaders[key] !== value2) {
+          headers[key] = value2;
         }
       }
       return {
-        ...request,
-        headers: subHeaders
+        method: request.method,
+        url: request.url,
+        headers,
+        body: request.body,
+        signal: request.signal
       };
     });
-    this.mapSubresponse = (subResponse, batchResponse) => {
-      return {
-        ...subResponse,
-        headers: {
-          ...batchResponse.headers,
-          // low-priority
-          ...subResponse.headers
-        }
-      };
-    };
+    this.exclude = options.exclude ?? (() => false);
   }
   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)) {
-        return interceptorOptions.next();
+    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 group = this.groups.find((group2) => value(group2.condition, interceptorOptions));
+      const group = this.groups.find((group2) => group2.condition(options2));
       if (!group) {
-        return interceptorOptions.next();
+        return options2.next();
       }
       return new Promise((resolve, reject) => {
-        const queue = this.queue.get(group) ?? [];
-        if (!this.queue.has(group)) {
-          this.queue.set(group, queue);
-        }
-        queue.push([interceptorOptions, resolve, reject]);
-        defer(() => this.processPendingBatches());
+        this.#enqueueRequest(group, options2, 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 = new Map(this.queue);
-    this.queue.clear();
+  async #processPendingBatches() {
+    const pending = this.pending;
+    this.pending = /* @__PURE__ */ new Map();
     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;
     }
-    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)
-      ]);
+    const batchItems = groupItems;
+    if (batchItems.length === 1) {
+      batchItems[0][0].next().then(batchItems[0][1]).catch(batchItems[0][2]);
       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();
-      }
-      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);
-          }
-        })();
+    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;
       }
-    });
-    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 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
       });
-    });
-  }
-}
-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 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;
       }
-      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;
+      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) });
         }
-        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.");
+      } catch (err) {
+        if (batchRequest.signal?.aborted && batchRequest.signal.reason === err) {
+          for (const [{ signal }, , reject] of batchItems) {
+            if (signal?.aborted) {
+              reject(signal.reason);
+            }
+          }
         }
-        await peer.message(result.message);
+        throw err;
       }
-      if (done) {
-        break;
+      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);
       }
     }
-  } finally {
-    reader.releaseLock();
   }
 }
 
-class DedupeLinkPlugin {
-  name = "~dedupe";
-  before = ["~batch"];
-  groups;
-  filter;
-  queue = /* @__PURE__ */ new Map();
+class DedupeRequestsPlugin {
+  #groups;
+  #filter;
+  order = 4e6;
+  // make sure execute before batch plugin
+  #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) {
-    const transportInterceptor = (interceptorOptions) => {
-      if (!canDedupeRequest(interceptorOptions.request) || !value(this.filter, interceptorOptions)) {
-        return interceptorOptions.next();
+    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 group = this.groups.find((group2) => value(group2.condition, interceptorOptions));
+      const group = this.#groups.find((group2) => group2.condition(options2));
       if (!group) {
-        return interceptorOptions.next();
+        return options2.next();
       }
       return new Promise((resolve, reject) => {
-        this.enqueue(group, interceptorOptions, resolve, reject);
-        defer(() => {
-          this.processPendingRequests();
-        });
+        this.#enqueue(group, options2, resolve, reject);
+        defer(() => this.#dequeue());
       });
-    };
-    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) {
-      queue = [];
-      this.queue.set(group, queue);
+      this.#queue.set(group, queue = []);
     }
-    const requestKey = createRequestKey(options.path, options.request);
-    const matched = queue.find((item) => item.requestKey === requestKey);
+    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;
+    });
     if (matched) {
-      matched.matchedOptions.push(options);
       matched.signals.push(options.request.signal);
       matched.resolves.push(resolve);
       matched.rejects.push(reject);
-      return;
+    } else {
+      queue.push({
+        options,
+        signals: [options.request.signal],
+        resolves: [resolve],
+        rejects: [reject]
+      });
     }
-    queue.push({
-      requestKey,
-      options,
-      matchedOptions: [options],
-      signals: [options.request.signal],
-      resolves: [resolve],
-      rejects: [reject]
-    });
   }
-  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));
+  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)
+        );
       }
     }
-    await Promise.all(executions);
+    this.#queue.clear();
+    await Promise.all(promises);
   }
-  async execute(group, item) {
+  async #execute(group, options, signals, resolves, rejects) {
     try {
-      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 dedupedRequest = {
+        ...options.request,
+        signal: toBatchAbortSignal(signals)
       };
-      const response = await item.options.next({
-        ...item.options,
-        request,
-        signal: request.signal,
-        context
+      const response = await options.next({
+        ...options,
+        request: dedupedRequest,
+        signal: dedupedRequest.signal,
+        context: group.context
       });
-      const replicatedResponses = replicateLazyResponse(response, item.resolves.length);
-      for (const resolve of item.resolves) {
-        resolve(replicatedResponses.pop());
+      const replicatedResponses = replicateStandardLazyResponse(response, resolves.length);
+      for (const resolve of resolves) {
+        resolve(replicatedResponses.shift());
       }
     } catch (error) {
-      for (const reject of item.rejects) {
+      for (const reject of 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;
-}
-
-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;
-  constructor(options = {}) {
-    this.encoding = options.encoding ?? "gzip";
-    this.threshold = options.threshold ?? 1024;
-  }
-  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) && isCompressibleContentType(flattenStandardHeader(request.headers["content-type"]))) {
-          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) && isCompressibleContentType(request.body.type)) {
-          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 (!isCompressibleContentType(value.type)) {
-                contentLength = -Infinity;
-                break;
-              }
-              contentLength = Infinity;
-            } else {
-              contentLength += isCompressibleContentType(value.type) ? 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
-      ]
-    };
-  }
-}
 
-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;
-          }
-          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
-      ]
-    };
-  }
+class ClientRetryPluginInvalidEventIteratorRetryResponse extends Error {
 }
-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 {
+class ClientRetryPlugin {
   defaultRetry;
   defaultRetryDelay;
   defaultShouldRetry;
   defaultOnRetry;
-  name = "~retry";
+  order = 18e5;
   constructor(options = {}) {
     this.defaultRetry = options.default?.retry ?? 0;
     this.defaultRetryDelay = options.default?.retryDelay ?? ((o) => o.lastEventRetry ?? 2e3);
@@ -628,33 +272,33 @@ class RetryLinkPlugin {
     this.defaultOnRetry = options.default?.onRetry;
   }
   init(options) {
-    const interceptor = async (interceptorOptions) => {
-      const { next, ...callOptions } = interceptorOptions;
+    options.interceptors ??= [];
+    options.interceptors.push(async (interceptorOptions) => {
       const maxAttempts = await value(
-        callOptions.context.retry ?? this.defaultRetry,
-        callOptions
+        interceptorOptions.context.retry ?? this.defaultRetry,
+        interceptorOptions
       );
-      const retryDelay = callOptions.context.retryDelay ?? this.defaultRetryDelay;
-      const shouldRetry = callOptions.context.shouldRetry ?? this.defaultShouldRetry;
-      const onRetry = callOptions.context.onRetry ?? this.defaultOnRetry;
+      const retryDelay = interceptorOptions.context.retryDelay ?? this.defaultRetryDelay;
+      const shouldRetry = interceptorOptions.context.shouldRetry ?? this.defaultShouldRetry;
+      const onRetry = interceptorOptions.context.onRetry ?? this.defaultOnRetry;
       if (maxAttempts <= 0) {
-        return next(callOptions);
+        return interceptorOptions.next();
       }
-      let lastEventId = callOptions.lastEventId;
+      let lastEventId = interceptorOptions.lastEventId;
       let lastEventRetry;
       let callback;
-      let attempt = 1;
-      const callNext = async (initialError) => {
+      let attemptIndex = 0;
+      const next = async (initialError) => {
         let currentError = initialError;
         while (true) {
-          const updatedCallOptions = { ...callOptions, lastEventId };
+          const updatedInterceptorOptions = { ...interceptorOptions, lastEventId };
           if (currentError) {
-            if (attempt > maxAttempts) {
+            if (attemptIndex >= maxAttempts) {
               throw currentError.error;
             }
             const attemptOptions = {
-              ...updatedCallOptions,
-              attempt,
+              ...updatedInterceptorOptions,
+              attemptIndex,
               error: currentError.error,
               lastEventRetry
             };
@@ -666,23 +310,16 @@ class RetryLinkPlugin {
               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 next(updatedCallOptions);
+            return await interceptorOptions.next(updatedInterceptorOptions);
           } catch (error) {
             currentError = { error };
-            if (updatedCallOptions.signal?.aborted) {
+            if (updatedInterceptorOptions.signal?.aborted) {
               throw error;
             }
           } finally {
@@ -691,13 +328,13 @@ class RetryLinkPlugin {
           }
         }
       };
-      const output = await callNext();
+      const output = await next();
       if (!isAsyncIteratorObject(output)) {
         return output;
       }
       let current = output;
       let isIteratorAborted = false;
-      return override(() => current, new AsyncIteratorClass(
+      return overlayProxy(() => current, new AsyncIteratorClass(
         async () => {
           while (true) {
             try {
@@ -710,13 +347,13 @@ class RetryLinkPlugin {
               const meta = getEventMeta(error);
               lastEventId = meta?.id ?? lastEventId;
               lastEventRetry = meta?.retry ?? lastEventRetry;
-              const asyncIteratorObject = await callNext({ error });
-              if (!isAsyncIteratorObject(asyncIteratorObject)) {
-                throw new TypeError(
-                  "RetryLinkPlugin: Expected an AsyncIteratorObject, got a different type."
+              const maybeEventIterator = await next({ error });
+              if (!isAsyncIteratorObject(maybeEventIterator)) {
+                throw new ClientRetryPluginInvalidEventIteratorRetryResponse(
+                  "RetryPlugin: Expected an Event Iterator, got a non-Event Iterator"
                 );
               }
-              current = asyncIteratorObject;
+              current = maybeEventIterator;
               if (isIteratorAborted) {
                 await current.return?.();
                 throw error;
@@ -724,30 +361,30 @@ class RetryLinkPlugin {
             }
           }
         },
-        async ({ kind }) => {
+        async (reason) => {
           isIteratorAborted = true;
-          if (kind === "cancelled") {
+          if (reason !== "next") {
             await current.return?.();
           }
         }
       ));
-    };
-    return { ...options, interceptors: [interceptor, ...toArray(options.interceptors)] };
+    });
   }
 }
 
-class RetryAfterLinkPlugin {
+class RetryAfterPlugin {
   condition;
   maxAttempts;
   timeout;
-  name = "~retry-after";
+  order = 19e5;
   constructor(options = {}) {
-    this.condition = options.condition ?? ((response) => response.status === COMMON_ERROR_STATUS_MAP.TOO_MANY_REQUESTS || response.status === COMMON_ERROR_STATUS_MAP.SERVICE_UNAVAILABLE);
+    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.maxAttempts = options.maxAttempts ?? 3;
     this.timeout = options.timeout ?? 5 * 60 * 1e3;
   }
   init(options) {
-    const interceptor = async (interceptorOptions) => {
+    options.clientInterceptors ??= [];
+    options.clientInterceptors.push(async (interceptorOptions) => {
       const startTime = Date.now();
       let attemptCount = 0;
       while (true) {
@@ -756,8 +393,8 @@ class RetryAfterLinkPlugin {
         if (!value(this.condition, response, interceptorOptions)) {
           return response;
         }
-        const retryAfterHeader = flattenStandardHeader(response.headers["retry-after"]);
-        const retryAfterMs = parseRetryAfterHeader(retryAfterHeader);
+        const retryAfterHeader = flattenHeader(response.headers["retry-after"]);
+        const retryAfterMs = this.parseRetryAfterHeader(retryAfterHeader);
         if (retryAfterMs === void 0) {
           return response;
         }
@@ -769,63 +406,80 @@ class RetryAfterLinkPlugin {
         if (elapsedTime + retryAfterMs > timeoutMs) {
           return response;
         }
-        try {
-          await sleep(retryAfterMs, { signal: interceptorOptions.signal });
-        } catch {
-        }
+        await this.delayExecution(retryAfterMs, interceptorOptions.signal);
         if (interceptorOptions.signal?.aborted) {
           return response;
         }
       }
-    };
-    return { ...options, transportInterceptors: [interceptor, ...toArray(options.transportInterceptors)] };
+    });
   }
-}
-function parseRetryAfterHeader(value2) {
-  value2 = value2?.trim();
-  if (!value2) {
+  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());
+    }
     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());
+  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);
+    });
   }
-  return void 0;
 }
 
-class TimeoutLinkPlugin {
-  timeout;
-  name = "~timeout";
-  /**
-   * Should abort if the total retry time exceeds the configured timeout
-   */
-  after = ["~retry"];
-  constructor(options) {
-    this.timeout = options.timeout;
+class SimpleCsrfProtectionLinkPlugin {
+  headerName;
+  headerValue;
+  exclude;
+  constructor(options = {}) {
+    this.headerName = options.headerName ?? "x-csrf-token";
+    this.headerValue = options.headerValue ?? "orpc";
+    this.exclude = options.exclude ?? false;
   }
+  order = 8e6;
   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);
+    options.clientInterceptors ??= [];
+    options.clientInterceptors.push(async (options2) => {
+      const excluded = await value(this.exclude, options2);
+      if (excluded) {
+        return options2.next();
       }
-    };
-    return { ...options, interceptors: [interceptor, ...toArray(options.interceptors)] };
+      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
+          }
+        }
+      });
+    });
   }
 }
 
-export { BatchLinkPlugin, BatchLinkPluginError, DedupeLinkPlugin, RequestCompressionLinkPlugin, ResponseCompressionLinkPlugin, RetryAfterLinkPlugin, RetryLinkPlugin, TimeoutLinkPlugin };
+export { BatchLinkPlugin, ClientRetryPlugin, ClientRetryPluginInvalidEventIteratorRetryResponse, DedupeRequestsPlugin, RetryAfterPlugin, SimpleCsrfProtectionLinkPlugin };