@orpc/server 2.0.0-beta.47 → 2.0.0-beta.49

package/dist/plugins/index.mjs

@@ -1,965 +0,0 @@
-import { ORPCError } from '@orpc/client';
-import { DEFAULT_BATCH_MAX_SIZE, BATCH_HEADER } from '@orpc/client/plugins';
-export { BATCH_HEADER, DEFAULT_BATCH_MAX_SIZE } from '@orpc/client/plugins';
-import { toArray, value, promiseWithResolvers, isAsyncIteratorObject, isCompressibleContentType, isNoTransformCacheControl, parseAcceptEncodingQualities, isAcceptableEncoding, varyByAcceptEncoding, anyAbortSignal, override, AsyncIteratorClass, runWithSignal, AbortError, wrapAsyncIterator, wrapReadableStream } from '@orpc/shared';
-import { flattenStandardHeader, parseStandardUrl, generateContentDisposition, mergeStandardHeaders } from '@standard-server/core';
-import { ServerPeer, isPeerMessage, isClientPeerSendMessage, encodePeerMessage } from '@standard-server/peer';
-import { toFetchHeaders, toStandardBody, toFetchBody, toStandardHeaders } from '@standard-server/fetch';
-export { R as RequestLimitHandlerPlugin } from '../shared/server.1ExWFMze.mjs';
-
-const BATCH_CONTENT_TYPE = "application/vnd.orpc.batch";
-const textEncoder = new TextEncoder();
-function encodeLengthPrefix(length) {
-  const prefix = new Uint8Array(4);
-  new DataView(prefix.buffer).setUint32(0, length, false);
-  return prefix;
-}
-async function encodeFrame(message) {
-  const encoded = await encodePeerMessage(message);
-  const bytes = typeof encoded === "string" ? textEncoder.encode(encoded) : encoded;
-  return [encodeLengthPrefix(bytes.byteLength), bytes];
-}
-function isBodyHeader(name) {
-  return name.startsWith("content-") || name === "standard-server";
-}
-function isClientPeerSendMessages(maybe) {
-  return Array.isArray(maybe) && maybe.every((m) => isPeerMessage(m) && isClientPeerSendMessage(m));
-}
-function internalError(err) {
-  Promise.reject(err);
-  return { status: 500, headers: {}, body: "Internal server error" };
-}
-function liftSubresponseHeaders(batchHeaders, subresponseHeaders) {
-  const [first = {}, ...rest] = subresponseHeaders;
-  const shared = {};
-  for (const [name, value2] of Object.entries(first)) {
-    if (value2 === void 0 || isBodyHeader(name)) {
-      continue;
-    }
-    const flattened = flattenStandardHeader(value2);
-    if (rest.every((other) => flattenStandardHeader(other[name]) === flattened)) {
-      shared[name] = value2;
-    }
-  }
-  const headers = { ...shared, ...batchHeaders };
-  const cookies = new Set([batchHeaders, ...subresponseHeaders].flatMap((other) => toArray(other["set-cookie"])));
-  if (cookies.size > 0) {
-    headers["set-cookie"] = [...cookies];
-  }
-  const varies = /* @__PURE__ */ new Map();
-  for (const value2 of [batchHeaders, ...subresponseHeaders].flatMap((other) => toArray(other.vary))) {
-    for (const field of value2.split(",")) {
-      const name = field.trim();
-      const key = name.toLowerCase();
-      if (name && !varies.has(key)) {
-        varies.set(key, name);
-      }
-    }
-  }
-  if (varies.size > 0) {
-    headers.vary = varies.has("*") ? "*" : [...varies.values()].join(", ");
-  }
-  return headers;
-}
-class BatchHandlerPlugin {
-  name = "~batch";
-  /**
-   * Run batch interceptors inside the tracing interceptors
-   * so each subrequest gets its own span instead of sharing one batch-level span.
-   */
-  after = ["~tracing"];
-  maxSize;
-  mapSubrequest;
-  mapSubresponse;
-  successStatus;
-  headers;
-  keepAliveEnabled;
-  keepAliveInterval;
-  constructor(options = {}) {
-    this.maxSize = options.maxSize ?? DEFAULT_BATCH_MAX_SIZE;
-    this.mapSubrequest = options.mapSubrequest ?? ((subRequest, { request: batchRequest }) => ({
-      ...subRequest,
-      headers: {
-        ...subRequest.headers,
-        /**
-         * The batch request headers win over the subrequest ones. They are the only ones the
-         * transport actually saw, so headers the browser injects on its own, such as `cookie`
-         * or `origin`, cannot be overridden by a subrequest, which is just request payload.
-         */
-        ...batchRequest.headers,
-        [BATCH_HEADER]: void 0
-        // useful in case batch plugin is used multiple times
-      }
-    }));
-    this.mapSubresponse = options.mapSubresponse ?? ((subresponse, { headers: batchHeaders }) => {
-      const headers = {};
-      for (const [name, value2] of Object.entries(subresponse.headers)) {
-        if (name !== "set-cookie" && flattenStandardHeader(value2) !== flattenStandardHeader(batchHeaders[name])) {
-          headers[name] = value2;
-        }
-      }
-      return { ...subresponse, headers };
-    });
-    this.successStatus = options.successStatus ?? 207;
-    this.headers = options.headers ?? {};
-    this.keepAliveEnabled = options.keepAlive?.enabled ?? true;
-    this.keepAliveInterval = options.keepAlive?.interval ?? 15e3;
-  }
-  init(options) {
-    const routingInterceptor = async (interceptorOptions) => {
-      if (flattenStandardHeader(interceptorOptions.request.headers[BATCH_HEADER]) === void 0) {
-        return interceptorOptions.next();
-      }
-      let messages;
-      try {
-        if (interceptorOptions.request.method === "GET") {
-          const [, search] = parseStandardUrl(interceptorOptions.request.url);
-          const params = new URLSearchParams(search);
-          const data = params.getAll("data").at(-1);
-          if (!data) {
-            return {
-              matched: true,
-              response: { status: 400, headers: {}, body: "Missing data parameter for batch request" }
-            };
-          }
-          const mightBeMessages = JSON.parse(data);
-          if (!isClientPeerSendMessages(mightBeMessages)) {
-            return {
-              matched: true,
-              response: { status: 400, headers: {}, body: "Invalid batch request data parameter" }
-            };
-          }
-          messages = mightBeMessages;
-        } else {
-          const mightBeMessages = await interceptorOptions.request.resolveBody();
-          if (!isClientPeerSendMessages(mightBeMessages)) {
-            return {
-              matched: true,
-              response: { status: 400, headers: {}, body: "Invalid batch request body" }
-            };
-          }
-          messages = mightBeMessages;
-        }
-      } catch (error) {
-        return {
-          matched: true,
-          response: {
-            status: 400,
-            headers: {},
-            body: error instanceof ORPCError ? error.message : "Invalid batch request"
-          }
-        };
-      }
-      const outerMethod = interceptorOptions.request.method;
-      if ((outerMethod === "GET" || outerMethod === "QUERY") && messages.some((message) => message.kind === "request" && message.json.method !== outerMethod)) {
-        return {
-          matched: true,
-          response: { status: 400, headers: {}, body: `${outerMethod} batch requests only accept ${outerMethod} sub-requests` }
-        };
-      }
-      const maxSize = await value(this.maxSize, interceptorOptions);
-      if (messages.length > maxSize) {
-        return {
-          matched: true,
-          response: { status: 413, headers: {}, body: "Batch request size exceeds the maximum allowed size" }
-        };
-      }
-      const status = await value(this.successStatus, interceptorOptions);
-      const headers = await value(this.headers, interceptorOptions);
-      const bufferedMessages = [];
-      let streamController;
-      let keepAliveTimer;
-      const ready = messages.map(() => promiseWithResolvers());
-      const lifting = Promise.all(ready.map(({ promise }) => promise)).then((all) => {
-        const heads = all.filter((head) => head !== void 0);
-        return {
-          batchHeaders: liftSubresponseHeaders(headers, heads.map((head) => head.headers)),
-          streams: heads.some((head) => head.stream)
-        };
-      });
-      const clearKeepAlive = () => {
-        if (keepAliveTimer !== void 0) {
-          clearInterval(keepAliveTimer);
-          keepAliveTimer = void 0;
-        }
-      };
-      const scheduleKeepAlive = () => {
-        if (!this.keepAliveEnabled) {
-          return;
-        }
-        clearKeepAlive();
-        keepAliveTimer = setInterval(() => {
-          try {
-            streamController.enqueue(encodeLengthPrefix(0));
-          } catch {
-            clearKeepAlive();
-          }
-        }, this.keepAliveInterval);
-      };
-      const enqueueMessage = async (message) => {
-        for (const chunk of await encodeFrame(message)) {
-          streamController.enqueue(chunk);
-        }
-        scheduleKeepAlive();
-      };
-      const peer = new ServerPeer(async (message) => {
-        if (streamController === void 0) {
-          bufferedMessages.push(message);
-        } else {
-          await enqueueMessage(message);
-        }
-      });
-      const handleIndividualRequest = async (request, markReady) => {
-        let response;
-        try {
-          request = this.mapSubrequest(request, interceptorOptions);
-          const result = await interceptorOptions.next({ ...interceptorOptions, request });
-          response = result.matched ? result.response : { status: 404, headers: {}, body: "No procedure matched" };
-        } catch (err) {
-          response = internalError(err);
-        }
-        markReady({
-          headers: response.headers,
-          stream: response.body instanceof ReadableStream || isAsyncIteratorObject(response.body)
-        });
-        const { batchHeaders: batchHeaders2 } = await lifting;
-        try {
-          return this.mapSubresponse(response, { status, headers: batchHeaders2 }, interceptorOptions);
-        } catch (err) {
-          return internalError(err);
-        }
-      };
-      const runSubrequests = async () => {
-        const promise = Promise.all(messages.map((msg, i) => {
-          const { resolve } = ready[i];
-          return peer.message(msg, (request) => handleIndividualRequest(request, resolve)).finally(() => resolve(void 0));
-        }));
-        const signal = interceptorOptions.request.signal;
-        const closePeer = () => peer.close(signal?.reason);
-        if (signal?.aborted) {
-          closePeer();
-        }
-        signal?.addEventListener("abort", closePeer);
-        try {
-          await promise;
-        } finally {
-          signal?.removeEventListener("abort", closePeer);
-        }
-      };
-      const subrequests = runSubrequests();
-      const { batchHeaders, streams } = await lifting;
-      const framedHeaders = { ...batchHeaders, "content-type": batchHeaders["content-type"] ?? BATCH_CONTENT_TYPE };
-      if (!streams) {
-        await subrequests;
-        await peer.close();
-        if (bufferedMessages.some((msg) => msg.binary !== void 0)) {
-          const chunks = (await Promise.all(bufferedMessages.map(encodeFrame))).flat();
-          return {
-            matched: true,
-            response: {
-              status,
-              headers: framedHeaders,
-              body: new Blob(chunks)
-            }
-          };
-        }
-        return {
-          matched: true,
-          response: { status, headers: batchHeaders, body: bufferedMessages }
-        };
-      }
-      const body = new ReadableStream({
-        start(controller) {
-          streamController = controller;
-          scheduleKeepAlive();
-        },
-        async cancel(reason) {
-          clearKeepAlive();
-          await peer.close(reason);
-        }
-      });
-      const flushed = Promise.all(bufferedMessages.splice(0).map(enqueueMessage));
-      Promise.all([flushed, subrequests]).then(async () => {
-        clearKeepAlive();
-        streamController.close();
-        await peer.close();
-      }).catch(async (error) => {
-        clearKeepAlive();
-        streamController.error(error);
-        await peer.close(error);
-      });
-      return {
-        matched: true,
-        response: {
-          status,
-          headers: framedHeaders,
-          body
-        }
-      };
-    };
-    return {
-      ...options,
-      routingInterceptors: [routingInterceptor, ...toArray(options.routingInterceptors)]
-    };
-  }
-}
-
-class CORSHandlerPlugin {
-  options;
-  name = "~cors";
-  /**
-   * - Do not create spans for CORS preflight requests.
-   * - Run CORS interceptors before batch interceptors so headers are applied to
-   *  the actual response rather than sub-responses.
-   */
-  after = ["~tracing", "~batch"];
-  constructor(options = {}) {
-    const defaults = {
-      origin: "*",
-      allowMethods: ["GET", "HEAD", "PUT", "POST", "DELETE", "PATCH", "QUERY"]
-    };
-    this.options = {
-      ...defaults,
-      ...options
-    };
-  }
-  init(options) {
-    const corsHeadersInterceptor = async (interceptorOptions) => {
-      const result = await interceptorOptions.next();
-      if (!result.matched) {
-        return result;
-      }
-      const resHeaders = { ...result.response.headers };
-      const origin = flattenStandardHeader(interceptorOptions.request.headers.origin);
-      const allowOrigin = await this.resolveOrigin(this.options.origin, origin, interceptorOptions);
-      const timingAllowOrigin = await this.resolveOrigin(this.options.timingOrigin, origin, interceptorOptions);
-      if (allowOrigin.value !== void 0) {
-        resHeaders["access-control-allow-origin"] = allowOrigin.value;
-      }
-      if (timingAllowOrigin.value !== void 0) {
-        resHeaders["timing-allow-origin"] = timingAllowOrigin.value;
-      }
-      if (allowOrigin.varies || timingAllowOrigin.varies) {
-        const existingVary = flattenStandardHeader(resHeaders.vary);
-        if (!existingVary?.split(",").some((v) => v.trim().toLowerCase() === "origin")) {
-          resHeaders.vary = existingVary ? `${existingVary}, Origin` : "Origin";
-        }
-      }
-      if (this.options.credentials) {
-        resHeaders["access-control-allow-credentials"] = "true";
-      }
-      if (this.options.exposeHeaders?.length) {
-        resHeaders["access-control-expose-headers"] = flattenStandardHeader(this.options.exposeHeaders);
-      }
-      return { ...result, response: { ...result.response, headers: resHeaders } };
-    };
-    const preflightInterceptor = async (interceptorOptions) => {
-      if (interceptorOptions.request.method === "OPTIONS") {
-        const resHeaders = {};
-        if (this.options.maxAge !== void 0) {
-          resHeaders["access-control-max-age"] = this.options.maxAge.toString();
-        }
-        if (this.options.allowMethods?.length) {
-          resHeaders["access-control-allow-methods"] = flattenStandardHeader(this.options.allowMethods);
-        }
-        const allowHeaders = this.options.allowHeaders ?? interceptorOptions.request.headers["access-control-request-headers"];
-        if (typeof allowHeaders === "string" || allowHeaders?.length) {
-          resHeaders["access-control-allow-headers"] = flattenStandardHeader(allowHeaders);
-        }
-        return {
-          matched: true,
-          response: {
-            status: 204,
-            headers: resHeaders,
-            body: void 0
-          }
-        };
-      }
-      return interceptorOptions.next();
-    };
-    return {
-      ...options,
-      routingInterceptors: [
-        corsHeadersInterceptor,
-        preflightInterceptor,
-        ...toArray(options.routingInterceptors)
-      ]
-    };
-  }
-  async resolveOrigin(option, origin, interceptorOptions) {
-    if (typeof option === "function") {
-      if (origin === void 0) {
-        return { value: void 0, varies: true };
-      }
-      const allowed2 = toArray(await option(origin, interceptorOptions));
-      if (allowed2.includes("*")) {
-        return { value: "*", varies: true };
-      }
-      return { value: allowed2.includes(origin) ? origin : void 0, varies: true };
-    }
-    const allowed = toArray(await option);
-    if (allowed.includes("*")) {
-      return { value: "*", varies: false };
-    }
-    if (origin !== void 0 && allowed.includes(origin)) {
-      return { value: origin, varies: true };
-    }
-    return { value: void 0, varies: allowed.length > 0 };
-  }
-}
-
-class GetMethodCsrfProtectionHandlerPlugin {
-  name = "~get-method-csrf-protection";
-  init(options) {
-    const interceptor = (interceptorOptions) => {
-      if (this.isAllowed(interceptorOptions)) {
-        return interceptorOptions.next();
-      }
-      throw new ORPCError("FORBIDDEN", { message: "Request blocked by CSRF protection." });
-    };
-    return {
-      ...options,
-      interceptors: [interceptor, ...toArray(options.interceptors)]
-    };
-  }
-  isAllowed({ request }) {
-    if (request.method !== "GET") {
-      return true;
-    }
-    const site = flattenStandardHeader(request.headers["sec-fetch-site"])?.toLowerCase();
-    if (site === void 0 || site === "same-origin" || site === "same-site") {
-      return true;
-    }
-    const mode = flattenStandardHeader(request.headers["sec-fetch-mode"])?.toLowerCase();
-    const dest = flattenStandardHeader(request.headers["sec-fetch-dest"])?.toLowerCase();
-    if (mode === void 0 || dest === void 0) {
-      return false;
-    }
-    return mode !== "navigate" || dest !== "document";
-  }
-}
-
-class MethodOverrideHandlerPlugin {
-  name = "~method-override";
-  /**
-   * Should override batch sub-request methods, not the original batch request.
-   */
-  before = ["~batch"];
-  param;
-  methods;
-  constructor(options = {}) {
-    this.param = options.param ?? "method";
-    this.methods = new Set((options.methods ?? ["PUT", "PATCH", "DELETE"]).map((method) => method.toUpperCase()));
-  }
-  init(options) {
-    const routingInterceptor = async ({ next, ...interceptorOptions }) => {
-      const { request } = interceptorOptions;
-      if (request.method !== "POST") {
-        return next();
-      }
-      const [pathname, search, hash] = parseStandardUrl(request.url);
-      const params = new URLSearchParams(search);
-      const raw = params.getAll(this.param).at(-1);
-      if (raw === void 0) {
-        return next();
-      }
-      const method = raw.toUpperCase();
-      if (!this.methods.has(method)) {
-        return next();
-      }
-      params.delete(this.param);
-      const url = `${pathname}${params.size ? `?${params}` : ""}${hash ?? ""}`;
-      return next({
-        ...interceptorOptions,
-        request: { ...request, method, url }
-      });
-    };
-    return {
-      ...options,
-      routingInterceptors: [routingInterceptor, ...toArray(options.routingInterceptors)]
-    };
-  }
-}
-
-const MAX_CONTENT_ENCODINGS = 5;
-class RequestCompressionHandlerPlugin {
-  name = "~request-compression";
-  /**
-   * Should decompress the original batch request body instead of sub-requests.
-   */
-  after = ["~batch"];
-  init(options) {
-    const routingInterceptor = async ({ next, ...interceptorOptions }) => {
-      const encodings = parseContentEncodings(
-        flattenStandardHeader(interceptorOptions.request.headers["content-encoding"])
-      );
-      if (encodings.length === 0 || !encodings.every(isSupportedEncoding)) {
-        return next();
-      }
-      const decompressedHeaders = {
-        ...interceptorOptions.request.headers,
-        "content-length": void 0,
-        "content-encoding": void 0
-      };
-      return next({
-        ...interceptorOptions,
-        request: {
-          ...interceptorOptions.request,
-          headers: decompressedHeaders,
-          async resolveBody(hint) {
-            const stream = await interceptorOptions.request.resolveBody("octet-stream");
-            if (!(stream instanceof ReadableStream)) {
-              return stream;
-            }
-            if (encodings.length > MAX_CONTENT_ENCODINGS) {
-              throw new ORPCError("UNSUPPORTED_MEDIA_TYPE", { message: "Too many content encodings." });
-            }
-            let decompressedStream = stream;
-            for (let i = encodings.length - 1; i >= 0; i--) {
-              decompressedStream = decompressedStream.pipeThrough(
-                new DecompressionStream(encodings[i])
-              );
-            }
-            const response = new Response(decompressedStream, {
-              headers: toFetchHeaders(decompressedHeaders)
-            });
-            return toStandardBody(response, { hint });
-          }
-        }
-      });
-    };
-    return {
-      ...options,
-      routingInterceptors: [
-        routingInterceptor,
-        ...toArray(options.routingInterceptors)
-      ]
-    };
-  }
-}
-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 RequestHeadersHandlerPlugin {
-  name = "~request-headers";
-  init(options) {
-    return {
-      ...options,
-      interceptors: [
-        (interceptorOptions) => {
-          const reqHeaders = interceptorOptions.context.reqHeaders ?? toFetchHeaders(interceptorOptions.request.headers);
-          return interceptorOptions.next({
-            ...interceptorOptions,
-            context: {
-              ...interceptorOptions.context,
-              reqHeaders
-            }
-          });
-        },
-        ...toArray(options.interceptors)
-      ]
-    };
-  }
-}
-
-const AVG_BYTES_PER_CHAR = 1.2;
-class ResponseCompressionHandlerPlugin {
-  name = "~response-compression";
-  /**
-   * Compression should be done after batching, to compress the final response.
-   * Compression should also be done after response headers are set, to access final headers like Content-Type and Cache-Control.
-   */
-  after = ["~batch", "~response-headers"];
-  encodings;
-  threshold;
-  isCompressibleContentType;
-  constructor(options = {}) {
-    this.encodings = options.encodings ?? ["gzip", "deflate"];
-    this.threshold = options.threshold ?? 1024;
-    this.isCompressibleContentType = options.isCompressibleContentType ?? isCompressibleContentType;
-  }
-  init(options) {
-    const routingInterceptor = async ({ next, ...interceptorOptions }) => {
-      const result = await next();
-      if (!result.matched) {
-        return result;
-      }
-      const response = result.response;
-      const encoding = negotiateResponseCompressionEncoding(response, interceptorOptions.request.headers, this.encodings);
-      if (encoding === void 0) {
-        return result;
-      }
-      const body = response.body;
-      const headers = response.headers;
-      if (body instanceof ReadableStream) {
-        const contentLength = Number(flattenStandardHeader(headers["content-length"]));
-        if ((!Number.isFinite(contentLength) || contentLength >= this.threshold) && this.isCompressibleContentType(flattenStandardHeader(headers["content-type"]), interceptorOptions)) {
-          return {
-            ...result,
-            response: {
-              ...response,
-              body: body.pipeThrough(new CompressionStream(encoding)),
-              headers: toCompressedHeaders(headers, encoding)
-            }
-          };
-        }
-      } else if (body instanceof Blob) {
-        const contentType = headers["content-type"] ?? body.type;
-        if ((!Number.isFinite(body.size) || body.size >= this.threshold) && this.isCompressibleContentType(flattenStandardHeader(contentType), interceptorOptions)) {
-          const contentDisposition = headers["content-disposition"] ?? generateContentDisposition(
-            body instanceof File ? body.name : "blob"
-          );
-          return {
-            ...result,
-            response: {
-              ...response,
-              body: body.stream().pipeThrough(new CompressionStream(encoding)),
-              headers: {
-                ...toCompressedHeaders(headers, encoding),
-                "standard-server": headers["standard-server"] ?? "file",
-                "content-type": contentType,
-                "content-disposition": contentDisposition
-              }
-            }
-          };
-        }
-      } else if (body instanceof FormData) {
-        const PART_OVERHEAD = 64;
-        let contentLength = 0;
-        for (const [key, value] of 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(body);
-          const compressedStream = res.body.pipeThrough(new CompressionStream(encoding));
-          return {
-            ...result,
-            response: {
-              ...response,
-              body: compressedStream,
-              headers: {
-                ...toCompressedHeaders(headers, encoding),
-                "standard-server": [],
-                "content-type": res.headers.get("content-type")
-              }
-            }
-          };
-        }
-      } else if (body instanceof URLSearchParams) {
-        const string = body.toString();
-        if (string.length * AVG_BYTES_PER_CHAR >= this.threshold) {
-          const [, bodyHeaders] = toFetchBody(body, headers);
-          return {
-            ...result,
-            response: {
-              ...response,
-              body: new Blob([string]).stream().pipeThrough(new CompressionStream(encoding)),
-              headers: {
-                ...toCompressedHeaders(bodyHeaders, encoding),
-                // An empty hint rather than none, so the adapter does not hint the compressed stream as `octet-stream`
-                "standard-server": bodyHeaders["standard-server"] ?? []
-              }
-            }
-          };
-        }
-      } else if (body !== void 0 && !isAsyncIteratorObject(body)) {
-        const [string, bodyHeaders] = toFetchBody(body, headers);
-        if (string.length * AVG_BYTES_PER_CHAR >= this.threshold) {
-          return {
-            ...result,
-            response: {
-              ...response,
-              body: new Blob([string]).stream().pipeThrough(new CompressionStream(encoding)),
-              headers: {
-                ...toCompressedHeaders(bodyHeaders, encoding),
-                "standard-server": bodyHeaders["standard-server"] ?? []
-              }
-            }
-          };
-        }
-      }
-      return result;
-    };
-    return {
-      ...options,
-      routingInterceptors: [
-        routingInterceptor,
-        ...toArray(options.routingInterceptors)
-      ]
-    };
-  }
-}
-function negotiateResponseCompressionEncoding(response, requestHeaders, encodings) {
-  if (flattenStandardHeader(response.headers["content-encoding"]) !== void 0) {
-    return void 0;
-  }
-  if (response.status === 206 || flattenStandardHeader(response.headers["content-range"]) !== void 0) {
-    return void 0;
-  }
-  if (isNoTransformCacheControl(flattenStandardHeader(response.headers["cache-control"]))) {
-    return void 0;
-  }
-  const acceptEncodings = parseAcceptEncodingQualities(flattenStandardHeader(requestHeaders["accept-encoding"]));
-  return encodings.find((encoding) => isAcceptableEncoding(acceptEncodings, encoding));
-}
-function toCompressedHeaders(headers, encoding) {
-  return {
-    ...headers,
-    "content-length": [],
-    "content-encoding": encoding,
-    "vary": varyByAcceptEncoding(flattenStandardHeader(headers.vary)),
-    /**
-     * A strong tag shared with the identity bytes would let `If-Range` splice them after compressed ones.
-     * A weak tag still revalidates through `If-None-Match`, and the compressed body serves no ranges.
-     *
-     * @see https://www.rfc-editor.org/rfc/rfc9110.html#name-etag
-     */
-    "etag": weakenEtag(flattenStandardHeader(headers.etag)),
-    "accept-ranges": []
-  };
-}
-function weakenEtag(etag) {
-  return etag === void 0 || etag.startsWith("W/") ? etag : `W/${etag}`;
-}
-
-class ResponseHeadersHandlerPlugin {
-  name = "~response-headers";
-  /**
-   * Interceptors should run after batch interceptors so headers are applied to each sub-response.
-   */
-  before = ["~batch"];
-  init(options) {
-    return {
-      ...options,
-      routingInterceptors: [
-        async (interceptorOptions) => {
-          const resHeaders = new Headers(interceptorOptions.context.resHeaders);
-          const result = await interceptorOptions.next({
-            ...interceptorOptions,
-            context: {
-              ...interceptorOptions.context,
-              resHeaders
-            }
-          });
-          if (!result.response) {
-            return result;
-          }
-          return {
-            ...result,
-            response: {
-              ...result.response,
-              headers: mergeStandardHeaders(result.response.headers, toStandardHeaders(resHeaders))
-            }
-          };
-        },
-        ...toArray(options.routingInterceptors)
-      ]
-    };
-  }
-}
-
-class RethrowHandlerPlugin {
-  name = "~rethrow";
-  filter;
-  CONTEXT_SYMBOL = Symbol("ORPC_RETHROW_HANDLER_PLUGIN_CONTEXT");
-  constructor(options) {
-    this.filter = options.filter;
-  }
-  init(options) {
-    const routingInterceptor = async (options2) => {
-      const pluginContext = {};
-      const result = await options2.next({
-        ...options2,
-        context: {
-          ...options2.context,
-          [this.CONTEXT_SYMBOL]: pluginContext
-        }
-      });
-      if (pluginContext.error) {
-        throw pluginContext.error.value;
-      }
-      return result;
-    };
-    const interceptor = async (options2) => {
-      const pluginContext = options2.context[this.CONTEXT_SYMBOL];
-      if (!pluginContext) {
-        throw new TypeError("[RethrowHandlerPlugin] Rethrow handler context has been corrupted or modified by another plugin or interceptor");
-      }
-      try {
-        return await options2.next();
-      } catch (error) {
-        if (this.filter(error, options2)) {
-          pluginContext.error = { value: error };
-        }
-        throw error;
-      }
-    };
-    return {
-      ...options,
-      routingInterceptors: [
-        ...toArray(options.routingInterceptors),
-        routingInterceptor
-        // rethrow as early as possible and keep it close to `interceptor` to avoid a corrupted or modified context
-      ],
-      interceptors: [
-        interceptor,
-        // catch as many errors as possible
-        ...toArray(options.interceptors)
-      ]
-    };
-  }
-}
-
-class SignalSyncHandlerPlugin {
-  name = "~signal-sync";
-  init(options) {
-    const clientInterceptor = async (interceptorOptions) => {
-      const controller = new AbortController();
-      const signal = anyAbortSignal([interceptorOptions.signal, controller.signal]);
-      const cancel = () => controller.abort(new AbortError("The response body was cancelled"));
-      const output = await interceptorOptions.next({ ...interceptorOptions, signal });
-      if (isAsyncIteratorObject(output)) {
-        return override(output, syncAsyncIterator(output, signal, cancel));
-      }
-      if (output instanceof ReadableStream) {
-        return override(output, syncReadableStream(output, signal, cancel));
-      }
-      return output;
-    };
-    return { ...options, clientInterceptors: [clientInterceptor, ...toArray(options.clientInterceptors)] };
-  }
-}
-function listenAbort(signal, onAbort) {
-  if (signal.aborted) {
-    onAbort();
-  } else {
-    signal.addEventListener("abort", onAbort, { once: true });
-  }
-  return () => signal.removeEventListener("abort", onAbort);
-}
-function syncAsyncIterator(iterator, signal, cancel) {
-  let cancelling;
-  const unlisten = listenAbort(signal, () => {
-    cancelling = (async () => iterator.return?.())();
-    cancelling.catch(() => {
-    });
-  });
-  return new AsyncIteratorClass(
-    () => runWithSignal(signal, () => iterator.next()),
-    async ({ kind }) => {
-      if (kind === "cancelled") {
-        cancel();
-        await cancelling;
-      }
-      unlisten();
-    }
-  );
-}
-function syncReadableStream(stream, signal, cancel) {
-  const reader = stream.getReader();
-  let cancelling;
-  let unlisten;
-  return new ReadableStream({
-    start(controller) {
-      unlisten = listenAbort(signal, () => {
-        controller.error(signal.reason);
-        cancelling = reader.cancel(signal.reason);
-        cancelling.catch(() => {
-        });
-      });
-    },
-    async pull(controller) {
-      try {
-        const { done, value } = await reader.read();
-        if (signal.aborted) {
-          return;
-        }
-        if (done) {
-          unlisten();
-          controller.close();
-        } else {
-          controller.enqueue(value);
-        }
-      } catch (error) {
-        unlisten();
-        throw error;
-      }
-    },
-    async cancel() {
-      cancel();
-      await cancelling;
-    }
-  }, { highWaterMark: 0 });
-}
-
-class TimeoutHandlerPlugin {
-  timeout;
-  streamingTimeout;
-  name = "~timeout";
-  constructor(options) {
-    this.timeout = options.timeout;
-    this.streamingTimeout = options.streamingTimeout;
-  }
-  init(options) {
-    const interceptor = async (interceptorOptions) => {
-      const timeoutMs = value(this.timeout, interceptorOptions);
-      const streamingTimeoutMs = value(this.streamingTimeout, interceptorOptions);
-      const hasTimeout = timeoutMs !== null && timeoutMs !== void 0;
-      const hasStreamingTimeout = streamingTimeoutMs !== null && streamingTimeoutMs !== void 0;
-      if (!hasTimeout && !hasStreamingTimeout) {
-        return interceptorOptions.next();
-      }
-      const controller = new AbortController();
-      const abortWithTimeout = (ms) => {
-        controller.abort(new AbortError(`Request timed out after ${ms}ms`));
-      };
-      const timeoutId = hasTimeout ? setTimeout(abortWithTimeout, timeoutMs, timeoutMs) : void 0;
-      const signal = anyAbortSignal([interceptorOptions.request.signal, controller.signal]);
-      try {
-        const response = await interceptorOptions.next({
-          ...interceptorOptions,
-          request: { ...interceptorOptions.request, signal }
-        });
-        if (hasStreamingTimeout) {
-          const body = response.body;
-          const isIterator = isAsyncIteratorObject(body);
-          if (isIterator || body instanceof ReadableStream) {
-            const streamingTimeoutId = setTimeout(abortWithTimeout, streamingTimeoutMs, streamingTimeoutMs);
-            const onFinish = () => clearTimeout(streamingTimeoutId);
-            return {
-              ...response,
-              body: isIterator ? override(body, wrapAsyncIterator(body, { onFinish })) : override(body, wrapReadableStream(body, { onFinish }))
-            };
-          }
-        }
-        return response;
-      } finally {
-        clearTimeout(timeoutId);
-      }
-    };
-    return { ...options, interceptors: [interceptor, ...toArray(options.interceptors)] };
-  }
-}
-
-export { BATCH_CONTENT_TYPE, BatchHandlerPlugin, CORSHandlerPlugin, CORSHandlerPlugin as CORSPlugin, GetMethodCsrfProtectionHandlerPlugin, MethodOverrideHandlerPlugin, RequestCompressionHandlerPlugin, RequestHeadersHandlerPlugin, RequestHeadersHandlerPlugin as RequestHeadersPlugin, ResponseCompressionHandlerPlugin, ResponseHeadersHandlerPlugin, ResponseHeadersHandlerPlugin as ResponseHeadersPlugin, RethrowHandlerPlugin, SignalSyncHandlerPlugin, TimeoutHandlerPlugin, negotiateResponseCompressionEncoding, toCompressedHeaders };