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

package/dist/index.mjs

@@ -1,5 +1,5 @@
-import { AbortError, AsyncIteratorClass, isTypescriptObject, getOrBind } from '@standardserver/shared';
-export { AbortError, AsyncIteratorClass, SequentialIdGenerator, getOrBind, isAsyncIteratorObject, isTypescriptObject, parseEmptyableJSON, sleep, stringifyJSON, toArray } from '@standardserver/shared';
+import { safeDecodeURIComponent, safeEncodeURIComponent, AbortError, AsyncIteratorClass, getOrBind, isTypescriptObject, isAsyncIteratorObject, throwIfAborted } from '@standard-server/shared';
+export { AbortError, AsyncIteratorClass, SequentialIdGenerator, getOrBind, isAsyncIteratorObject, isTypescriptObject, parseEmptyableJSON, safeDecodeURIComponent, safeEncodeURIComponent, sequential, sleep, stringifyJSON, throwIfAborted, toArray } from '@standard-server/shared';
 
 function resolveMaybeOptionalOptions(rest) {
   return rest[0] ?? {};
@@ -16,24 +16,44 @@ async function loadBytes(source) {
   }
   return new Uint8Array(await source.arrayBuffer());
 }
-async function toStringOrBytes(source) {
+function toStringOrBytes(source) {
   if (typeof source === "string") {
     return source;
   }
   if (source instanceof ArrayBuffer) {
     return new Uint8Array(source);
   }
-  if (source instanceof Blob) {
-    return loadBytes(source);
-  }
   if (Array.isArray(source)) {
-    return loadBytes(new Blob(source));
+    return concatBytes(source);
   }
   if (source instanceof Uint8Array) {
     return source;
   }
   return new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
 }
+function toBytes(item) {
+  if (typeof item === "string") {
+    return new TextEncoder().encode(item);
+  }
+  if (item instanceof ArrayBuffer) {
+    return new Uint8Array(item);
+  }
+  if (item instanceof Uint8Array) {
+    return item;
+  }
+  return new Uint8Array(item.buffer, item.byteOffset, item.byteLength);
+}
+function concatBytes(items) {
+  const chunks = items.map(toBytes);
+  const totalLength = chunks.reduce((sum, chunk) => sum + chunk.byteLength, 0);
+  const result = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const chunk of chunks) {
+    result.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return result;
+}
 
 function isDeepEqual(a, b) {
   return isDeepEqualInternal(a, b, /* @__PURE__ */ new WeakMap());
@@ -91,6 +111,11 @@ function isAbortError(error) {
   return error instanceof Error && error.name.includes("Abort");
 }
 
+const AsyncGeneratorFunction = Object.getPrototypeOf(async function* () {
+}).constructor;
+function isAsyncGeneratorFunction(value) {
+  return value instanceof AsyncGeneratorFunction;
+}
 function once(fn) {
   let cached;
   return () => {
@@ -102,9 +127,9 @@ function once(fn) {
     return result;
   };
 }
-function defer(callback) {
+function defer(callback, delay = 0) {
   if (typeof setTimeout === "function") {
-    setTimeout(callback, 0);
+    setTimeout(callback, delay);
   } else {
     Promise.resolve().then(() => Promise.resolve().then(() => Promise.resolve().then(callback)));
   }
@@ -117,23 +142,15 @@ function tryOrUndefined(fn) {
   }
 }
 
-function tryDecodeURIComponent(value) {
-  try {
-    return decodeURIComponent(value);
-  } catch {
-    return value;
-  }
-}
-
 function pathToHttpPath(path) {
-  return `/${path.map(encodeURIComponent).join("/")}`;
+  return `/${path.map(safeEncodeURIComponent).join("/")}`;
 }
 function normalizeHttpPath(path) {
   const paths = path.split("/");
   if (paths.at(0) === "") {
     paths.shift();
   }
-  return pathToHttpPath(paths.map(tryDecodeURIComponent));
+  return pathToHttpPath(paths.map(safeDecodeURIComponent));
 }
 function mergeHttpPath(a, b) {
   return `${a.endsWith("/") ? a.slice(0, -1) : a}${b}`;
@@ -156,167 +173,54 @@ function matchesHttpPath(url, path) {
   }
   return charAfterPrefix === void 0 || charAfterPrefix === "?" || charAfterPrefix === "#";
 }
-
-function compareSequentialIds(a, b) {
-  if (a.length !== b.length) {
-    return a.length - b.length;
-  }
-  return a < b ? -1 : a > b ? 1 : 0;
-}
-
-function onStart(callback) {
-  return async (options, ...rest) => {
-    await callback(options, ...rest);
-    return await options.next();
-  };
-}
-function onSuccess(callback) {
-  return async (options, ...rest) => {
-    const result = await options.next();
-    await callback(result, options, ...rest);
-    return result;
-  };
-}
-function onError(callback) {
-  return async (options, ...rest) => {
-    try {
-      return await options.next();
-    } catch (error) {
-      await callback(error, options, ...rest);
-      throw error;
-    }
-  };
-}
-function onFinish(callback) {
-  let state;
-  return async (options, ...rest) => {
-    try {
-      const result = await options.next();
-      state = [null, result, true];
-      return result;
-    } catch (error) {
-      state = [error, void 0, false];
-      throw error;
-    } finally {
-      await callback(state, options, ...rest);
-    }
-  };
-}
-function intercept(interceptors, options, main) {
-  if (!interceptors?.length) {
-    return main(options);
-  }
-  const next = (options2, index) => {
-    const interceptor = interceptors[index];
-    if (!interceptor) {
-      return main(options2);
+const ACCEPT_ENCODING_QUALITY_REGEX = /^\s*q=([\d.]+)\s*$/i;
+function parseAcceptEncodingQualities(header) {
+  const qualities = /* @__PURE__ */ new Map();
+  for (const part of header?.split(",") ?? []) {
+    const [rawCoding, ...params] = part.split(";");
+    const coding = rawCoding.trim().toLowerCase();
+    if (coding === "") {
+      continue;
     }
-    return interceptor({
-      ...options2,
-      next: (newOptions = options2) => next(newOptions, index + 1)
-    });
-  };
-  return next(options, 0);
-}
-
-const SPAN_ERROR_STATUS = 2;
-const OPENTELEMETRY_CONFIG_SYMBOL = Symbol.for("ORPC_OPENTELEMETRY_CONFIG");
-function setOpenTelemetryConfig(config) {
-  globalThis[OPENTELEMETRY_CONFIG_SYMBOL] = config;
-}
-function getOpenTelemetryConfig() {
-  return globalThis[OPENTELEMETRY_CONFIG_SYMBOL];
-}
-function startSpan(options) {
-  const tracer = getOpenTelemetryConfig()?.tracer;
-  if (!tracer) {
-    return void 0;
-  }
-  const { name, context, ...spanOptions } = typeof options === "string" ? { name: options } : options;
-  return tracer.startSpan(name, spanOptions, context);
-}
-function recordSpanError(span, error) {
-  if (!span) {
-    return;
-  }
-  const exception = toOtelException(error);
-  span.recordException(exception);
-  if (!isAbortError(error)) {
-    span.setStatus({
-      code: SPAN_ERROR_STATUS,
-      message: exception.message
-    });
+    const quality = params.map((param) => ACCEPT_ENCODING_QUALITY_REGEX.exec(param)?.[1]).find((value) => value !== void 0);
+    qualities.set(coding, quality === void 0 ? 1 : Number(quality));
   }
+  return qualities;
 }
-function setSpanAttributeIfDefined(span, key, value) {
-  if (!span || value === void 0) {
-    return;
-  }
-  span.setAttribute(key, value);
+function isAcceptableEncoding(qualities, coding) {
+  return (qualities.get(coding) ?? qualities.get("*") ?? 0) > 0;
 }
-function toOtelException(error) {
-  if (error instanceof Error) {
-    const exception = {
-      message: error.message,
-      name: error.name,
-      stack: error.stack
-    };
-    if ("code" in error && (typeof error.code === "string" || typeof error.code === "number")) {
-      exception.code = error.code;
-    }
-    return exception;
+function varyByAcceptEncoding(vary) {
+  if (vary === void 0) {
+    return "accept-encoding";
   }
-  return { message: String(error) };
+  const fields = vary.split(",").map((field) => field.trim().toLowerCase());
+  return fields.includes("accept-encoding") || fields.includes("*") ? vary : `${vary}, accept-encoding`;
 }
-function toSpanAttributeValue(data) {
-  if (data === void 0) {
-    return "undefined";
-  }
-  try {
-    return JSON.stringify(data, (_, value) => {
-      if (typeof value === "bigint") {
-        return value.toString();
-      }
-      if (value instanceof Map || value instanceof Set) {
-        return Array.from(value);
-      }
-      return value;
-    });
-  } catch {
-    return String(data);
+const CACHE_CONTROL_NO_TRANSFORM_REGEX = /(?:^|,)\s*no-transform\s*(?:,|$)/i;
+function isNoTransformCacheControl(cacheControl) {
+  if (cacheControl === void 0) {
+    return false;
   }
+  return CACHE_CONTROL_NO_TRANSFORM_REGEX.test(cacheControl);
 }
-async function runWithSpan(options, fn) {
-  const tracer = getOpenTelemetryConfig()?.tracer;
-  if (!tracer) {
-    return fn();
-  }
-  if (typeof options === "string") {
-    options = { name: options };
+const COMPRESSIBLE_CONTENT_TYPE_REGEX = /^\s*(?:text\/(?!event-stream(?:[;\s]|$))[^;\s]+|application\/(?:javascript|json|xml|xml-dtd|ecmascript|dart|postscript|rtf|tar|toml|vnd\.dart|vnd\.ms-fontobject|vnd\.ms-opentype|wasm|x-httpd-php|x-javascript|x-ns-proxy-autoconfig|x-sh|x-tar|x-virtualbox-hdd|x-virtualbox-ova|x-virtualbox-ovf|x-virtualbox-vbox|x-virtualbox-vdi|x-virtualbox-vhd|x-virtualbox-vmdk|x-www-form-urlencoded)|font\/(?:otf|ttf)|image\/(?:bmp|vnd\.adobe\.photoshop|vnd\.microsoft\.icon|vnd\.ms-dds|x-icon|x-ms-bmp)|message\/rfc822|model\/gltf-binary|x-shader\/x-fragment|x-shader\/x-vertex|[^;\s]+?\+(?:json|text|xml|yaml))(?:[;\s]|$)/i;
+const MAX_COMPRESSIBLE_CONTENT_TYPE_LENGTH = 1024;
+function isCompressibleContentType(contentType) {
+  if (contentType === null || contentType === void 0) {
+    return false;
   }
-  const callback = async (span) => {
-    try {
-      return await fn(span);
-    } catch (e) {
-      recordSpanError(span, e);
-      throw e;
-    } finally {
-      span.end();
-    }
-  };
-  if (options.context) {
-    return tracer.startActiveSpan(options.name, options, options.context, callback);
-  } else {
-    return tracer.startActiveSpan(options.name, options, callback);
+  if (contentType.length > MAX_COMPRESSIBLE_CONTENT_TYPE_LENGTH) {
+    return false;
   }
+  return COMPRESSIBLE_CONTENT_TYPE_REGEX.test(contentType);
 }
-async function runInSpanContext(span, fn) {
-  const otelConfig = getOpenTelemetryConfig();
-  if (!span || !otelConfig) {
-    return fn();
+
+function compareSequentialIds(a, b) {
+  if (a.length !== b.length) {
+    return a.length - b.length;
   }
-  const ctx = otelConfig.trace.setSpan(otelConfig.context.active(), span);
-  return otelConfig.context.with(ctx, fn);
+  return a < b ? -1 : a > b ? 1 : 0;
 }
 
 class AsyncIdQueue {
@@ -393,6 +297,93 @@ class AsyncIdQueue {
   }
 }
 
+const TRACER_SYMBOL = Symbol.for("ORPC_TRACER");
+function setTracer(tracer) {
+  globalThis[TRACER_SYMBOL] = tracer;
+}
+function getTracer() {
+  return globalThis[TRACER_SYMBOL];
+}
+function startSpan(options) {
+  const tracer = getTracer();
+  if (!tracer) {
+    return void 0;
+  }
+  if (typeof options === "string") {
+    return tracer.startSpan(options);
+  }
+  return tracer.startSpan(options.name, options.parent);
+}
+function recordSpanError(span, error) {
+  if (!span) {
+    return;
+  }
+  span.recordException(isAbortError(error) ? "info" : "error", toTracingException(error));
+}
+function setSpanAttributeIfDefined(span, key, value) {
+  if (!span || value === void 0) {
+    return;
+  }
+  span.setAttribute(key, value);
+}
+function toTracingException(error) {
+  if (error instanceof Error) {
+    const exception = {
+      message: error.message,
+      name: error.name,
+      stack: error.stack
+    };
+    if ("code" in error && (typeof error.code === "string" || typeof error.code === "number")) {
+      exception.code = error.code;
+    }
+    return exception;
+  }
+  return { message: String(error) };
+}
+function toSpanAttributeValue(data) {
+  if (data === void 0) {
+    return "undefined";
+  }
+  try {
+    return JSON.stringify(data, (_, value) => {
+      if (typeof value === "bigint") {
+        return value.toString();
+      }
+      if (value instanceof Map || value instanceof Set) {
+        return Array.from(value);
+      }
+      return value;
+    });
+  } catch {
+    return String(data);
+  }
+}
+async function runWithSpan(options, fn) {
+  const tracer = getTracer();
+  if (!tracer) {
+    return fn();
+  }
+  const name = typeof options === "string" ? options : options.name;
+  const parent = typeof options === "string" ? void 0 : options.parent;
+  return tracer.startActiveSpan(name, parent, async (span) => {
+    try {
+      return await fn(span);
+    } catch (e) {
+      recordSpanError(span, e);
+      throw e;
+    } finally {
+      span.end();
+    }
+  });
+}
+function runInSpanContext(span, fn) {
+  const tracer = getTracer();
+  if (!span || !tracer) {
+    return fn();
+  }
+  return tracer.withActiveSpan(span, fn);
+}
+
 function wrapAsyncIterator(iterator, { runWith, mapResult, mapError, onError, onFinish }) {
   runWith ??= (run) => run();
   let isDone;
@@ -491,6 +482,57 @@ function replicateAsyncIterator(source, count) {
   });
   return replicated;
 }
+function consumeAsyncIterator(iterator, options) {
+  void (async () => {
+    let onFinishState;
+    try {
+      const resolvedIterator = await iterator;
+      while (true) {
+        const { done, value } = await resolvedIterator.next();
+        if (done) {
+          const realValue = value;
+          onFinishState = [null, realValue, true];
+          options.onSuccess?.(realValue);
+          break;
+        }
+        try {
+          options.onEvent(value);
+        } catch (error) {
+          await resolvedIterator.return?.();
+          throw error;
+        }
+      }
+    } catch (error) {
+      onFinishState = [error, void 0, false];
+      options.onError?.(error);
+    } finally {
+      options.onFinish?.(onFinishState);
+    }
+  })();
+  return async () => {
+    await (await iterator)?.return?.();
+  };
+}
+
+function value(value2, ...args) {
+  if (typeof value2 === "function") {
+    return value2(...args);
+  }
+  return value2;
+}
+
+function override(target, partial) {
+  const proxy = new Proxy(typeof target === "function" ? partial : target, {
+    get(_, prop) {
+      const targetValue = prop in partial ? partial : value(target);
+      return getOrBind(targetValue, prop);
+    },
+    has(_, prop) {
+      return Reflect.has(partial, prop) || Reflect.has(value(target), prop);
+    }
+  });
+  return proxy;
+}
 
 function findDeepMatches(check, payload, segments = [], maps = [], values = []) {
   if (check(payload)) {
@@ -501,7 +543,7 @@ function findDeepMatches(check, payload, segments = [], maps = [], values = [])
       findDeepMatches(check, v, [...segments, i], maps, values);
     });
   } else if (isPlainObject(payload)) {
-    for (const key in payload) {
+    for (const key of Object.keys(payload)) {
       findDeepMatches(check, payload[key], [...segments, key], maps, values);
     }
   }
@@ -513,6 +555,18 @@ function getConstructor(value) {
   }
   return Object.getPrototypeOf(value)?.constructor;
 }
+function* getConstructors(value) {
+  if (!isTypescriptObject(value)) {
+    return;
+  }
+  let proto = Object.getPrototypeOf(value);
+  while (proto != null) {
+    if (proto.constructor) {
+      yield proto.constructor;
+    }
+    proto = Object.getPrototypeOf(proto);
+  }
+}
 function isPlainObject(value) {
   if (!value || typeof value !== "object") {
     return false;
@@ -520,13 +574,16 @@ function isPlainObject(value) {
   const proto = Object.getPrototypeOf(value);
   return proto === Object.prototype || !proto || !proto.constructor;
 }
+function getOwn(object, key) {
+  return Object.hasOwn(object, key) ? object[key] : void 0;
+}
 function get(object, path) {
   let current = object;
   for (const key of path) {
     if (!isTypescriptObject(current)) {
       return void 0;
     }
-    current = current[key];
+    current = getOwn(current, key);
   }
   return current;
 }
@@ -534,37 +591,111 @@ function set(root, path, value) {
   let current = root;
   for (let i = 0; i < path.length - 1; i++) {
     const key = path[i];
-    const next = current[key];
+    const next = getOwn(current, key);
     if (!isTypescriptObject(next)) {
-      current[key] = {};
+      const child = {};
+      setOwn(current, key, child);
+      current = child;
+    } else {
+      current = next;
     }
-    current = current[key];
   }
-  current[path.at(-1)] = value;
+  setOwn(current, path.at(-1), value);
 }
-function omit(obj, keys) {
+function setOwn(object, key, value) {
+  if (key === "__proto__") {
+    Object.defineProperty(object, key, {
+      value,
+      writable: true,
+      enumerable: true,
+      configurable: true
+    });
+  } else {
+    object[key] = value;
+  }
+}
+function mergeTwoLevels(first, second) {
+  if (!isPlainObject(first) || !isPlainObject(second)) {
+    return second;
+  }
+  const result = { ...first, ...second };
+  for (const key of Object.keys(second)) {
+    if (!Object.hasOwn(first, key)) {
+      continue;
+    }
+    const firstValue = first[key];
+    const secondValue = second[key];
+    if (isPlainObject(firstValue) && isPlainObject(secondValue)) {
+      result[key] = { ...firstValue, ...secondValue };
+    }
+  }
+  return result;
+}
+function omit(obj, keys) {
   const result = { ...obj };
   for (const key of keys) {
     delete result[key];
   }
   return result;
 }
+function pick(obj, keys) {
+  const result = {};
+  for (const key of keys) {
+    if (Object.hasOwn(obj, key)) {
+      result[key] = obj[key];
+    }
+  }
+  return result;
+}
 function clone(value) {
+  return cloneWithVisited(value, /* @__PURE__ */ new WeakMap());
+}
+function cloneWithVisited(value, visited) {
   if (Array.isArray(value)) {
-    return value.map(clone);
+    const existing = visited.get(value);
+    if (existing) {
+      return existing;
+    }
+    const result = [];
+    visited.set(value, result);
+    for (const item of value) {
+      result.push(cloneWithVisited(item, visited));
+    }
+    return result;
   }
   if (isPlainObject(value)) {
+    const existing = visited.get(value);
+    if (existing) {
+      return existing;
+    }
     const result = {};
-    for (const key in value) {
-      result[key] = clone(value[key]);
+    visited.set(value, result);
+    for (const key of Object.keys(value)) {
+      setOwn(result, key, cloneWithVisited(value[key], visited));
     }
     for (const sym of Object.getOwnPropertySymbols(value)) {
-      result[sym] = clone(value[sym]);
+      setOwn(result, sym, cloneWithVisited(value[sym], visited));
     }
     return result;
   }
   return value;
 }
+function copyOnWrite(parent, key, original) {
+  const value = parent[key];
+  if (value !== original) {
+    return value;
+  }
+  let copy;
+  if (Array.isArray(value)) {
+    copy = value.slice();
+  } else if (isPlainObject(value)) {
+    copy = { ...value };
+  } else {
+    return value;
+  }
+  setOwn(parent, key, copy);
+  return copy;
+}
 function isPropertyKey(value) {
   const type = typeof value;
   return type === "string" || type === "number" || type === "symbol";
@@ -576,7 +707,8 @@ const NullProtoObj = /* @__PURE__ */ (() => {
   Object.freeze(e.prototype);
   return e;
 })();
-function bindMethods(obj) {
+function bindMethods(obj, options = {}) {
+  const unbound = new Set(options.unbound);
   const methods = new NullProtoObj();
   let current = obj;
   while (current && current !== Object.prototype) {
@@ -584,18 +716,18 @@ function bindMethods(obj) {
       if (key === "constructor" || key in methods) {
         continue;
       }
-      const val = obj[key];
+      const val = getOrBind(obj, key, { bind: !unbound.has(key) });
       if (typeof val === "function") {
-        methods[key] = val.bind(obj);
+        methods[key] = val;
       }
     }
     for (const sym of Object.getOwnPropertySymbols(current)) {
       if (sym in methods) {
         continue;
       }
-      const val = obj[sym];
+      const val = getOrBind(obj, sym, { bind: !unbound.has(sym) });
       if (typeof val === "function") {
-        methods[sym] = val.bind(obj);
+        methods[sym] = val;
       }
     }
     current = Object.getPrototypeOf(current);
@@ -603,84 +735,6 @@ function bindMethods(obj) {
   return methods;
 }
 
-function sortPlugins(plugins) {
-  const pluginCount = plugins.length;
-  const pluginIdToIndices = /* @__PURE__ */ new Map();
-  for (let i = 0; i < pluginCount; i++) {
-    const plugin = plugins[i];
-    const indices = pluginIdToIndices.get(plugin.name);
-    if (indices === void 0) {
-      pluginIdToIndices.set(plugin.name, [i]);
-    } else {
-      indices.push(i);
-    }
-  }
-  const graph = Array.from(
-    { length: pluginCount },
-    () => /* @__PURE__ */ new Set()
-  );
-  for (let i = 0; i < pluginCount; i++) {
-    const plugin = plugins[i];
-    const beforeList = plugin.before;
-    if (beforeList !== void 0) {
-      for (const beforeId of beforeList) {
-        const beforeIndices = pluginIdToIndices.get(beforeId);
-        if (beforeIndices === void 0)
-          continue;
-        for (const beforeIndex of beforeIndices) {
-          const beforeGraph = graph[beforeIndex];
-          if (beforeGraph !== void 0) {
-            beforeGraph.add(i);
-          }
-        }
-      }
-    }
-    const afterList = plugin.after;
-    if (afterList !== void 0) {
-      const currentGraph = graph[i];
-      if (currentGraph !== void 0) {
-        for (const afterId of afterList) {
-          const afterIndices = pluginIdToIndices.get(afterId);
-          if (afterIndices === void 0)
-            continue;
-          for (const afterIndex of afterIndices) {
-            currentGraph.add(afterIndex);
-          }
-        }
-      }
-    }
-  }
-  const sorted = [];
-  const visiting = /* @__PURE__ */ new Set();
-  const visited = /* @__PURE__ */ new Set();
-  function visit(index) {
-    if (visited.has(index))
-      return;
-    if (visiting.has(index)) {
-      const plugin2 = plugins[index];
-      const pluginId = plugin2 !== void 0 ? plugin2.name : "unknown";
-      throw new Error(`Circular dependency detected involving plugin "${pluginId}"`);
-    }
-    visiting.add(index);
-    const deps = graph[index];
-    if (deps !== void 0) {
-      for (const depIndex of deps) {
-        visit(depIndex);
-      }
-    }
-    visiting.delete(index);
-    visited.add(index);
-    const plugin = plugins[index];
-    if (plugin !== void 0) {
-      sorted.push(plugin);
-    }
-  }
-  for (let i = 0; i < pluginCount; i++) {
-    visit(i);
-  }
-  return sorted;
-}
-
 function promiseWithResolvers() {
   const result = {};
   result.promise = new Promise((resolve, reject) => {
@@ -689,68 +743,18 @@ function promiseWithResolvers() {
   });
   return result;
 }
-
-function value(value2, ...args) {
-  if (typeof value2 === "function") {
-    return value2(...args);
-  }
-  return value2;
-}
-
-function override(target, partial) {
-  const proxy = new Proxy(typeof target === "function" ? partial : target, {
-    get(_, prop) {
-      const targetValue = prop in partial ? partial : value(target);
-      return getOrBind(targetValue, prop);
-    },
-    has(_, prop) {
-      return Reflect.has(partial, prop) || Reflect.has(value(target), prop);
-    }
-  });
-  return proxy;
-}
-
-function allAbortSignal(signals) {
-  const realSignals = signals.filter((signal) => signal !== void 0);
-  if (realSignals.length === 0 || realSignals.length !== signals.length) {
-    return void 0;
-  }
-  const controller = new AbortController();
-  const abortIfAllAborted = () => {
-    if (realSignals.every((signal) => signal.aborted)) {
-      controller.abort();
+function captureAsyncContext() {
+  const { promise, resolve } = promiseWithResolvers();
+  const result = promise.then((callback) => callback());
+  let called = false;
+  return (callback) => {
+    if (called) {
+      return Promise.reject(new Error("A captured async context can be run only once."));
     }
+    called = true;
+    resolve(callback);
+    return result;
   };
-  abortIfAllAborted();
-  for (const signal of realSignals) {
-    signal.addEventListener("abort", () => {
-      abortIfAllAborted();
-    }, {
-      once: true,
-      signal: controller.signal
-    });
-  }
-  return controller.signal;
-}
-async function runWithSignal(signal, fn) {
-  if (!signal) {
-    return fn();
-  }
-  signal.throwIfAborted();
-  const { promise, reject, resolve } = promiseWithResolvers();
-  let abortListener;
-  signal.addEventListener("abort", abortListener = () => {
-    reject(signal.reason);
-    abortListener = void 0;
-  });
-  try {
-    fn().then(resolve, reject);
-    return await promise;
-  } finally {
-    if (abortListener) {
-      signal.removeEventListener("abort", abortListener);
-    }
-  }
 }
 
 function replicateReadableStream(stream, count) {
@@ -823,7 +827,7 @@ function traceReadableStream(options, stream) {
     }
   });
 }
-function streamToAsyncIteratorClass(stream, { signal } = {}) {
+function streamToAsyncIteratorObject(stream, { signal } = {}) {
   const reader = stream.getReader();
   let cancelledBySignal = false;
   return new AsyncIteratorClass(
@@ -889,4 +893,208 @@ function asyncIteratorToUnproxiedDataStream(iterator) {
   });
 }
 
-export { AsyncIdQueue, NullProtoObj, ORPC_NAME, allAbortSignal, asyncIteratorToStream, asyncIteratorToUnproxiedDataStream, bindMethods, clone, compareSequentialIds, defer, findDeepMatches, get, getConstructor, getOpenTelemetryConfig, intercept, isAbortError, isDeepEqual, isPlainObject, isPropertyKey, loadBytes, matchesHttpPath, matchesHttpPathPrefix, mergeHttpPath, normalizeHttpPath, omit, onError, onFinish, onStart, onSuccess, once, override, pathToHttpPath, promiseWithResolvers, recordSpanError, replicateAsyncIterator, replicateReadableStream, resolveMaybeOptionalOptions, runInSpanContext, runWithSignal, runWithSpan, set, setOpenTelemetryConfig, setSpanAttributeIfDefined, sortPlugins, splitInHalf, startSpan, streamToAsyncIteratorClass, toOtelException, toSpanAttributeValue, toStringOrBytes, traceAsyncIterator, traceReadableStream, tryDecodeURIComponent, tryOrUndefined, value, wrapAsyncIterator, wrapReadableStream };
+function onStart(callback) {
+  return async (options, ...rest) => {
+    await callback(options, ...rest);
+    return await options.next();
+  };
+}
+function onSuccess(callback) {
+  return async (options, ...rest) => {
+    const result = await options.next();
+    await callback(result, options, ...rest);
+    return result;
+  };
+}
+function onError(callback) {
+  return async (options, ...rest) => {
+    try {
+      return await options.next();
+    } catch (error) {
+      await callback(error, options, ...rest);
+      throw error;
+    }
+  };
+}
+function onFinish(callback) {
+  return async (options, ...rest) => {
+    let state;
+    try {
+      const result = await options.next();
+      state = [null, result, true];
+      return result;
+    } catch (error) {
+      state = [error, void 0, false];
+      throw error;
+    } finally {
+      await callback(state, options, ...rest);
+    }
+  };
+}
+function onAsyncIteratorObjectError(callback) {
+  return async (options, ...rest) => {
+    const output = await options.next();
+    if (!isAsyncIteratorObject(output)) {
+      return output;
+    }
+    return override(output, wrapAsyncIterator(output, {
+      onError: (error) => callback(error, options, ...rest)
+    }));
+  };
+}
+function onReadableStreamError(callback) {
+  return async (options, ...rest) => {
+    const output = await options.next();
+    if (!(output instanceof ReadableStream)) {
+      return output;
+    }
+    return override(output, wrapReadableStream(output, {
+      onError: (error) => callback(error, options, ...rest)
+    }));
+  };
+}
+function intercept(interceptors, options, main) {
+  if (!interceptors?.length) {
+    return main(options);
+  }
+  const next = (options2, index) => {
+    const interceptor = interceptors[index];
+    if (!interceptor) {
+      return main(options2);
+    }
+    return interceptor({
+      ...options2,
+      next: (newOptions = options2) => next(newOptions, index + 1)
+    });
+  };
+  return next(options, 0);
+}
+
+function sortPlugins(plugins) {
+  const pluginCount = plugins.length;
+  const pluginIdToIndices = /* @__PURE__ */ new Map();
+  for (let i = 0; i < pluginCount; i++) {
+    const plugin = plugins[i];
+    const indices = pluginIdToIndices.get(plugin.name);
+    if (indices === void 0) {
+      pluginIdToIndices.set(plugin.name, [i]);
+    } else {
+      indices.push(i);
+    }
+  }
+  const dependencies = Array.from({ length: pluginCount }, () => []);
+  for (let i = 0; i < pluginCount; i++) {
+    const plugin = plugins[i];
+    if (plugin.before !== void 0) {
+      for (const beforeId of plugin.before) {
+        const beforeIndices = pluginIdToIndices.get(beforeId);
+        if (beforeIndices !== void 0) {
+          for (const beforeIndex of beforeIndices) {
+            dependencies[beforeIndex].push(i);
+          }
+        }
+      }
+    }
+    if (plugin.after !== void 0) {
+      for (const afterId of plugin.after) {
+        const afterIndices = pluginIdToIndices.get(afterId);
+        if (afterIndices !== void 0) {
+          for (const afterIndex of afterIndices) {
+            dependencies[i].push(afterIndex);
+          }
+        }
+      }
+    }
+  }
+  const sorted = [];
+  const placed = /* @__PURE__ */ new Set();
+  while (sorted.length < pluginCount) {
+    const next = plugins.findIndex((_, i) => !placed.has(i) && dependencies[i].every((dependency) => placed.has(dependency)));
+    if (next === -1) {
+      throw new Error(`Circular dependency detected involving plugin "${findCyclicPlugin(plugins, dependencies, placed).name}"`);
+    }
+    placed.add(next);
+    sorted.push(plugins[next]);
+  }
+  return sorted;
+}
+function findCyclicPlugin(plugins, dependencies, placed) {
+  const seen = /* @__PURE__ */ new Set();
+  let current = plugins.findIndex((_, i) => !placed.has(i));
+  while (!seen.has(current)) {
+    seen.add(current);
+    current = dependencies[current].find((dependency) => !placed.has(dependency));
+  }
+  return plugins[current];
+}
+
+function allAbortSignal(signals) {
+  const realSignals = signals.filter((signal) => signal !== void 0);
+  if (realSignals.length === 0 || realSignals.length !== signals.length) {
+    return void 0;
+  }
+  const controller = new AbortController();
+  const abortIfAllAborted = () => {
+    if (realSignals.every((signal) => signal.aborted)) {
+      controller.abort();
+    }
+  };
+  abortIfAllAborted();
+  for (const signal of realSignals) {
+    signal.addEventListener("abort", () => {
+      abortIfAllAborted();
+    }, {
+      once: true,
+      signal: controller.signal
+    });
+  }
+  return controller.signal;
+}
+function anyAbortSignal(signals) {
+  const realSignals = signals.filter((signal) => signal !== void 0);
+  if (realSignals.length === 0) {
+    return void 0;
+  }
+  if (realSignals.length === 1) {
+    return realSignals[0];
+  }
+  if (typeof AbortSignal !== "undefined" && typeof AbortSignal.any === "function") {
+    return AbortSignal.any(realSignals);
+  }
+  const controller = new AbortController();
+  for (const signal of realSignals) {
+    if (signal.aborted) {
+      controller.abort(signal.reason);
+      break;
+    }
+    signal.addEventListener("abort", () => {
+      controller.abort(signal.reason);
+    }, {
+      once: true,
+      signal: controller.signal
+    });
+  }
+  return controller.signal;
+}
+async function runWithSignal(signal, fn) {
+  if (!signal) {
+    return fn();
+  }
+  throwIfAborted(signal);
+  const { promise, reject, resolve } = promiseWithResolvers();
+  let abortListener;
+  signal.addEventListener("abort", abortListener = () => {
+    reject(signal.reason);
+    abortListener = void 0;
+  });
+  try {
+    fn().then(resolve, reject);
+    return await promise;
+  } finally {
+    if (abortListener) {
+      signal.removeEventListener("abort", abortListener);
+    }
+  }
+}
+
+export { AsyncIdQueue, NullProtoObj, ORPC_NAME, allAbortSignal, anyAbortSignal, asyncIteratorToStream, asyncIteratorToUnproxiedDataStream, bindMethods, captureAsyncContext, clone, compareSequentialIds, consumeAsyncIterator, copyOnWrite, defer, findDeepMatches, get, getConstructor, getConstructors, getOwn, getTracer, intercept, isAbortError, isAcceptableEncoding, isAsyncGeneratorFunction, isCompressibleContentType, isDeepEqual, isNoTransformCacheControl, isPlainObject, isPropertyKey, loadBytes, matchesHttpPath, matchesHttpPathPrefix, mergeHttpPath, mergeTwoLevels, normalizeHttpPath, omit, onAsyncIteratorObjectError, onError, onFinish, onReadableStreamError, onStart, onSuccess, once, override, parseAcceptEncodingQualities, pathToHttpPath, pick, promiseWithResolvers, recordSpanError, replicateAsyncIterator, replicateReadableStream, resolveMaybeOptionalOptions, runInSpanContext, runWithSignal, runWithSpan, set, setOwn, setSpanAttributeIfDefined, setTracer, sortPlugins, splitInHalf, startSpan, streamToAsyncIteratorObject, toSpanAttributeValue, toStringOrBytes, toTracingException, traceAsyncIterator, traceReadableStream, tryOrUndefined, value, varyByAcceptEncoding, wrapAsyncIterator, wrapReadableStream };