@orpc/shared 1.14.9 → 1.14.11

package/dist/index.mjs

@@ -1,33 +1,114 @@
-export { group, guard, mapEntries, mapValues, omit, retry, sleep } from 'radash';
+import { AbortError, AsyncIteratorClass, getOrBind, isTypescriptObject, isAsyncIteratorObject } from '@standardserver/shared';
+export { AbortError, AsyncIteratorClass, SequentialIdGenerator, getOrBind, isAsyncIteratorObject, isTypescriptObject, parseEmptyableJSON, sequential, sleep, stringifyJSON, toArray } from '@standardserver/shared';
 
 function resolveMaybeOptionalOptions(rest) {
   return rest[0] ?? {};
 }
 
-function toArray(value) {
-  return Array.isArray(value) ? value : value === void 0 || value === null ? [] : [value];
-}
 function splitInHalf(arr) {
   const half = Math.ceil(arr.length / 2);
   return [arr.slice(0, half), arr.slice(half)];
 }
 
-function readAsBuffer(source) {
+async function loadBytes(source) {
   if (typeof source.bytes === "function") {
     return source.bytes();
   }
-  return source.arrayBuffer();
+  return new Uint8Array(await source.arrayBuffer());
+}
+function toStringOrBytes(source) {
+  if (typeof source === "string") {
+    return source;
+  }
+  if (source instanceof ArrayBuffer) {
+    return new Uint8Array(source);
+  }
+  if (Array.isArray(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());
+}
+function isDeepEqualInternal(a, b, visited) {
+  if (Object.is(a, b)) {
+    return true;
+  }
+  if (typeof a !== typeof b) {
+    return false;
+  }
+  if (a === null || typeof a !== "object") {
+    return false;
+  }
+  if (b === null || typeof b !== "object") {
+    return false;
+  }
+  const isArray = Array.isArray(a);
+  if (isArray !== Array.isArray(b)) {
+    return false;
+  }
+  if (isArray && a.length !== b.length) {
+    return false;
+  }
+  const aRecord = a;
+  const bRecord = b;
+  const visitedMatches = visited.get(a);
+  if (visitedMatches?.has(b)) {
+    return true;
+  }
+  if (visitedMatches) {
+    visitedMatches.add(b);
+  } else {
+    visited.set(a, new WeakSet([b]));
+  }
+  const aKeys = Object.keys(aRecord).filter((k) => aRecord[k] !== void 0);
+  const bKeys = Object.keys(bRecord).filter((k) => bRecord[k] !== void 0);
+  if (aKeys.length !== bKeys.length) {
+    return false;
+  }
+  for (const key of aKeys) {
+    if (!Object.hasOwn(bRecord, key)) {
+      return false;
+    }
+    if (!isDeepEqualInternal(aRecord[key], bRecord[key], visited)) {
+      return false;
+    }
+  }
+  return true;
 }
 
 const ORPC_NAME = "orpc";
-const ORPC_SHARED_PACKAGE_NAME = "@orpc/shared";
-const ORPC_SHARED_PACKAGE_VERSION = "1.14.9";
 
-class AbortError extends Error {
-  constructor(...rest) {
-    super(...rest);
-    this.name = "AbortError";
-  }
+function isAbortError(error) {
+  return error instanceof Error && error.name.includes("Abort");
 }
 
 function once(fn) {
@@ -41,15 +122,6 @@ function once(fn) {
     return result;
   };
 }
-function sequential(fn) {
-  let lastOperationPromise = Promise.resolve();
-  return (...args) => {
-    return lastOperationPromise = lastOperationPromise.catch(() => {
-    }).then(() => {
-      return fn(...args);
-    });
-  };
-}
 function defer(callback) {
   if (typeof setTimeout === "function") {
     setTimeout(callback, 0);
@@ -57,33 +129,102 @@ function defer(callback) {
     Promise.resolve().then(() => Promise.resolve().then(() => Promise.resolve().then(callback)));
   }
 }
+function tryOrUndefined(fn) {
+  try {
+    return fn();
+  } catch {
+    return void 0;
+  }
+}
+
+function tryDecodeURIComponent(value) {
+  try {
+    return decodeURIComponent(value);
+  } catch {
+    return value;
+  }
+}
+
+function pathToHttpPath(path) {
+  return `/${path.map(encodeURIComponent).join("/")}`;
+}
+function normalizeHttpPath(path) {
+  const paths = path.split("/");
+  if (paths.at(0) === "") {
+    paths.shift();
+  }
+  return pathToHttpPath(paths.map(tryDecodeURIComponent));
+}
+function mergeHttpPath(a, b) {
+  return `${a.endsWith("/") ? a.slice(0, -1) : a}${b}`;
+}
+function matchesHttpPathPrefix(url, prefix) {
+  if (!url.startsWith(prefix)) {
+    return false;
+  }
+  const charAfterPrefix = url[prefix.length];
+  return charAfterPrefix === "/" || charAfterPrefix === "?" || charAfterPrefix === "#" || charAfterPrefix === void 0 || prefix[prefix.length - 1] === "/";
+}
+function matchesHttpPath(url, path) {
+  const pathWithoutEndSlash = path.endsWith("/") ? path.slice(0, path.length - 1) : path;
+  if (!url.startsWith(pathWithoutEndSlash)) {
+    return false;
+  }
+  let charAfterPrefix = url[pathWithoutEndSlash.length];
+  if (charAfterPrefix === "/") {
+    charAfterPrefix = url[pathWithoutEndSlash.length + 1];
+  }
+  return charAfterPrefix === void 0 || charAfterPrefix === "?" || charAfterPrefix === "#";
+}
+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;
+  }
+  if (contentType.length > MAX_COMPRESSIBLE_CONTENT_TYPE_LENGTH) {
+    return false;
+  }
+  return COMPRESSIBLE_CONTENT_TYPE_REGEX.test(contentType);
+}
+
+function compareSequentialIds(a, b) {
+  if (a.length !== b.length) {
+    return a.length - b.length;
+  }
+  return a < b ? -1 : a > b ? 1 : 0;
+}
 
 const SPAN_ERROR_STATUS = 2;
-const GLOBAL_OTEL_CONFIG_KEY = `__${ORPC_SHARED_PACKAGE_NAME}@${ORPC_SHARED_PACKAGE_VERSION}/otel/config__`;
-function setGlobalOtelConfig(config) {
-  globalThis[GLOBAL_OTEL_CONFIG_KEY] = config;
+const OPENTELEMETRY_CONFIG_SYMBOL = Symbol.for("ORPC_OPENTELEMETRY_CONFIG");
+function setOpenTelemetryConfig(config) {
+  globalThis[OPENTELEMETRY_CONFIG_SYMBOL] = config;
 }
-function getGlobalOtelConfig() {
-  return globalThis[GLOBAL_OTEL_CONFIG_KEY];
+function getOpenTelemetryConfig() {
+  return globalThis[OPENTELEMETRY_CONFIG_SYMBOL];
 }
-function startSpan(name, options = {}, context) {
-  const tracer = getGlobalOtelConfig()?.tracer;
-  return tracer?.startSpan(name, options, context);
+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 setSpanError(span, error, options = {}) {
+function recordSpanError(span, error) {
   if (!span) {
     return;
   }
   const exception = toOtelException(error);
   span.recordException(exception);
-  if (!options.signal?.aborted || options.signal.reason !== error) {
+  if (!isAbortError(error)) {
     span.setStatus({
       code: SPAN_ERROR_STATUS,
       message: exception.message
     });
   }
 }
-function setSpanAttribute(span, key, value) {
+function setSpanAttributeIfDefined(span, key, value) {
   if (!span || value === void 0) {
     return;
   }
@@ -121,29 +262,32 @@ function toSpanAttributeValue(data) {
     return String(data);
   }
 }
-async function runWithSpan({ name, context, ...options }, fn) {
-  const tracer = getGlobalOtelConfig()?.tracer;
+async function runWithSpan(options, fn) {
+  const tracer = getOpenTelemetryConfig()?.tracer;
   if (!tracer) {
     return fn();
   }
+  if (typeof options === "string") {
+    options = { name: options };
+  }
   const callback = async (span) => {
     try {
       return await fn(span);
     } catch (e) {
-      setSpanError(span, e, options);
+      recordSpanError(span, e);
       throw e;
     } finally {
       span.end();
     }
   };
-  if (context) {
-    return tracer.startActiveSpan(name, options, context, callback);
+  if (options.context) {
+    return tracer.startActiveSpan(options.name, options, options.context, callback);
   } else {
-    return tracer.startActiveSpan(name, options, callback);
+    return tracer.startActiveSpan(options.name, options, callback);
   }
 }
 async function runInSpanContext(span, fn) {
-  const otelConfig = getGlobalOtelConfig();
+  const otelConfig = getOpenTelemetryConfig();
   if (!span || !otelConfig) {
     return fn();
   }
@@ -155,15 +299,9 @@ class AsyncIdQueue {
   openIds = /* @__PURE__ */ new Set();
   queues = /* @__PURE__ */ new Map();
   waiters = /* @__PURE__ */ new Map();
-  get length() {
+  get size() {
     return this.openIds.size;
   }
-  get waiterIds() {
-    return Array.from(this.waiters.keys());
-  }
-  hasBufferedItems(id) {
-    return Boolean(this.queues.get(id)?.length);
-  }
   open(id) {
     this.openIds.add(id);
   }
@@ -231,74 +369,54 @@ class AsyncIdQueue {
   }
 }
 
-function isAsyncIteratorObject(maybe) {
-  if (!maybe || typeof maybe !== "object") {
-    return false;
-  }
-  return "next" in maybe && typeof maybe.next === "function" && Symbol.asyncIterator in maybe && typeof maybe[Symbol.asyncIterator] === "function";
-}
-const fallbackAsyncDisposeSymbol = Symbol.for("asyncDispose");
-const asyncDisposeSymbol = Symbol.asyncDispose ?? fallbackAsyncDisposeSymbol;
-class AsyncIteratorClass {
-  #isDone = false;
-  #isExecuteComplete = false;
-  #cleanup;
-  #next;
-  constructor(next, cleanup) {
-    this.#cleanup = cleanup;
-    this.#next = sequential(async () => {
-      if (this.#isDone) {
-        return { done: true, value: void 0 };
-      }
+function wrapAsyncIterator(iterator, { runWith, mapResult, mapError, onError, onFinish }) {
+  runWith ??= (run) => run();
+  let isDone;
+  return new AsyncIteratorClass(async () => {
+    try {
+      let result;
       try {
-        const result = await next();
-        if (result.done) {
-          this.#isDone = true;
-        }
-        return result;
-      } catch (err) {
-        this.#isDone = true;
-        throw err;
-      } finally {
-        if (this.#isDone && !this.#isExecuteComplete) {
-          this.#isExecuteComplete = true;
-          await this.#cleanup("next");
-        }
+        result = await runWith(() => iterator.next());
+        isDone = result.done;
+      } catch (error) {
+        isDone = true;
+        throw error;
       }
-    });
-  }
-  next() {
-    return this.#next();
-  }
-  async return(value) {
-    this.#isDone = true;
-    if (!this.#isExecuteComplete) {
-      this.#isExecuteComplete = true;
-      await this.#cleanup("return");
+      return mapResult ? await mapResult(result) : result;
+    } catch (error) {
+      await onError?.(error);
+      throw mapError ? await mapError(error) : error;
     }
-    return { done: true, value };
-  }
-  async throw(err) {
-    this.#isDone = true;
-    if (!this.#isExecuteComplete) {
-      this.#isExecuteComplete = true;
-      await this.#cleanup("throw");
+  }, async (_state) => {
+    try {
+      if (!isDone) {
+        try {
+          await runWith(async () => iterator.return?.());
+        } catch (error) {
+          await onError?.(error);
+          throw error;
+        }
+      }
+    } finally {
+      await onFinish?.();
     }
-    throw err;
-  }
-  /**
-   * asyncDispose symbol only available in esnext, we should fallback to Symbol.for('asyncDispose')
-   */
-  async [asyncDisposeSymbol]() {
-    this.#isDone = true;
-    if (!this.#isExecuteComplete) {
-      this.#isExecuteComplete = true;
-      await this.#cleanup("dispose");
+  });
+}
+function traceAsyncIterator(options, iterator) {
+  const getSpan = once(() => startSpan(options));
+  return wrapAsyncIterator(iterator, {
+    runWith: (run) => runInSpanContext(getSpan(), run),
+    mapResult(result) {
+      getSpan()?.addEvent(result.done ? "completed" : "yielded");
+      return result;
+    },
+    onError(error) {
+      recordSpanError(getSpan(), error);
+    },
+    onFinish() {
+      getSpan()?.end();
     }
-  }
-  [Symbol.asyncIterator]() {
-    return this;
-  }
+  });
 }
 function replicateAsyncIterator(source, count) {
   const queue = new AsyncIdQueue();
@@ -338,9 +456,9 @@ function replicateAsyncIterator(source, count) {
         }
         throw item.error;
       },
-      async (reason) => {
-        queue.close({ id });
-        if (reason !== "next" && !queue.length && !isSourceFinished) {
+      async ({ kind, error }) => {
+        queue.close({ id, reason: error });
+        if (kind === "cancelled" && !queue.size && !isSourceFinished) {
           isSourceFinished = true;
           await source?.return?.();
         }
@@ -349,194 +467,51 @@ function replicateAsyncIterator(source, count) {
   });
   return replicated;
 }
-function asyncIteratorWithSpan({ name, ...options }, iterator) {
-  let span;
-  return new AsyncIteratorClass(
-    async () => {
-      span ??= startSpan(name);
-      try {
-        const result = await runInSpanContext(span, () => iterator.next());
-        span?.addEvent(result.done ? "completed" : "yielded");
-        return result;
-      } catch (err) {
-        setSpanError(span, err, options);
-        throw err;
-      }
-    },
-    async (reason) => {
-      try {
-        if (reason !== "next") {
-          await runInSpanContext(span, () => iterator.return?.());
-        }
-      } catch (err) {
-        setSpanError(span, err, options);
-        throw err;
-      } finally {
-        span?.end();
-      }
-    }
-  );
-}
-
-class EventPublisher {
-  #listenersMap = /* @__PURE__ */ new Map();
-  #maxBufferedEvents;
-  constructor(options = {}) {
-    this.#maxBufferedEvents = options.maxBufferedEvents ?? 100;
-  }
-  get size() {
-    return this.#listenersMap.size;
-  }
-  /**
-   * Emits an event and delivers the payload to all subscribed listeners.
-   */
-  publish(event, payload) {
-    const listeners = this.#listenersMap.get(event);
-    if (!listeners) {
-      return;
-    }
-    for (const listener of listeners) {
-      listener(payload);
-    }
-  }
-  subscribe(event, listenerOrOptions) {
-    if (typeof listenerOrOptions === "function") {
-      let listeners = this.#listenersMap.get(event);
-      if (!listeners) {
-        this.#listenersMap.set(event, listeners = []);
-      }
-      listeners.push(listenerOrOptions);
-      return once(() => {
-        listeners.splice(listeners.indexOf(listenerOrOptions), 1);
-        if (listeners.length === 0) {
-          this.#listenersMap.delete(event);
-        }
-      });
-    }
-    const signal = listenerOrOptions?.signal;
-    const maxBufferedEvents = listenerOrOptions?.maxBufferedEvents ?? this.#maxBufferedEvents;
-    signal?.throwIfAborted();
-    const bufferedEvents = [];
-    const pullResolvers = [];
-    const unsubscribe = this.subscribe(event, (payload) => {
-      const resolver = pullResolvers.shift();
-      if (resolver) {
-        resolver[0]({ done: false, value: payload });
-      } else {
-        bufferedEvents.push(payload);
-        if (bufferedEvents.length > maxBufferedEvents) {
-          bufferedEvents.shift();
+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;
         }
+        options.onEvent(value);
       }
-    });
-    const abortListener = (event2) => {
-      unsubscribe();
-      pullResolvers.forEach((resolver) => resolver[1](event2.target.reason));
-      pullResolvers.length = 0;
-      bufferedEvents.length = 0;
-    };
-    signal?.addEventListener("abort", abortListener, { once: true });
-    return new AsyncIteratorClass(async () => {
-      if (signal?.aborted) {
-        throw signal.reason;
-      }
-      if (bufferedEvents.length > 0) {
-        return { done: false, value: bufferedEvents.shift() };
-      }
-      return new Promise((resolve, reject) => {
-        pullResolvers.push([resolve, reject]);
-      });
-    }, async () => {
-      unsubscribe();
-      signal?.removeEventListener("abort", abortListener);
-      pullResolvers.forEach((resolver) => resolver[0]({ done: true, value: void 0 }));
-      pullResolvers.length = 0;
-      bufferedEvents.length = 0;
-    });
-  }
-}
-
-class SequentialIdGenerator {
-  index = BigInt(1);
-  generate() {
-    const id = this.index.toString(36);
-    this.index++;
-    return id;
-  }
-}
-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;
+      onFinishState = [error, void 0, false];
+      options.onError?.(error);
     } finally {
-      await callback(state, options, ...rest);
+      options.onFinish?.(onFinishState);
     }
+  })();
+  return async () => {
+    await (await iterator)?.return?.();
   };
 }
-function intercept(interceptors, options, main) {
-  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 parseEmptyableJSON(text) {
-  if (!text) {
-    return void 0;
+function value(value2, ...args) {
+  if (typeof value2 === "function") {
+    return value2(...args);
   }
-  return JSON.parse(text);
-}
-function stringifyJSON(value) {
-  return JSON.stringify(value);
+  return value2;
 }
 
-function logError(error) {
-  if (typeof console === "object" && typeof console.error === "function") {
-    console.error(error);
-  }
+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 = []) {
@@ -547,7 +522,7 @@ function findDeepMatches(check, payload, segments = [], maps = [], values = [])
     payload.forEach((v, i) => {
       findDeepMatches(check, v, [...segments, i], maps, values);
     });
-  } else if (isObject(payload)) {
+  } else if (isPlainObject(payload)) {
     for (const key in payload) {
       findDeepMatches(check, payload[key], [...segments, key], maps, values);
     }
@@ -560,21 +535,47 @@ function getConstructor(value) {
   }
   return Object.getPrototypeOf(value)?.constructor;
 }
-function isObject(value) {
+function isPlainObject(value) {
   if (!value || typeof value !== "object") {
     return false;
   }
   const proto = Object.getPrototypeOf(value);
   return proto === Object.prototype || !proto || !proto.constructor;
 }
-function isTypescriptObject(value) {
-  return !!value && (typeof value === "object" || typeof value === "function");
+function get(object, path) {
+  let current = object;
+  for (const key of path) {
+    if (!isTypescriptObject(current) || !Object.hasOwn(current, key)) {
+      return void 0;
+    }
+    current = current[key];
+  }
+  return current;
+}
+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];
+    if (!isTypescriptObject(next)) {
+      current[key] = {};
+    }
+    current = current[key];
+  }
+  current[path.at(-1)] = value;
+}
+function omit(obj, keys) {
+  const result = { ...obj };
+  for (const key of keys) {
+    delete result[key];
+  }
+  return result;
 }
 function clone(value) {
   if (Array.isArray(value)) {
     return value.map(clone);
   }
-  if (isObject(value)) {
+  if (isPlainObject(value)) {
     const result = {};
     for (const key in value) {
       result[key] = clone(value[key]);
@@ -586,16 +587,6 @@ function clone(value) {
   }
   return value;
 }
-function get(object, path) {
-  let current = object;
-  for (const key of path) {
-    if (!isTypescriptObject(current)) {
-      return void 0;
-    }
-    current = current[key];
-  }
-  return current;
-}
 function isPropertyKey(value) {
   const type = typeof value;
   return type === "string" || type === "number" || type === "symbol";
@@ -607,70 +598,143 @@ const NullProtoObj = /* @__PURE__ */ (() => {
   Object.freeze(e.prototype);
   return e;
 })();
-
-function value(value2, ...args) {
-  if (typeof value2 === "function") {
-    return value2(...args);
+function bindMethods(obj) {
+  const methods = new NullProtoObj();
+  let current = obj;
+  while (current && current !== Object.prototype) {
+    for (const key of Object.getOwnPropertyNames(current)) {
+      if (key === "constructor" || key in methods) {
+        continue;
+      }
+      const val = obj[key];
+      if (typeof val === "function") {
+        methods[key] = val.bind(obj);
+      }
+    }
+    for (const sym of Object.getOwnPropertySymbols(current)) {
+      if (sym in methods) {
+        continue;
+      }
+      const val = obj[sym];
+      if (typeof val === "function") {
+        methods[sym] = val.bind(obj);
+      }
+    }
+    current = Object.getPrototypeOf(current);
   }
-  return value2;
+  return methods;
 }
-function fallback(value2, fallback2) {
-  return value2 === void 0 ? fallback2 : value2;
+
+function promiseWithResolvers() {
+  const result = {};
+  result.promise = new Promise((resolve, reject) => {
+    result.resolve = resolve;
+    result.reject = reject;
+  });
+  return result;
 }
 
-function preventNativeAwait(target) {
-  return new Proxy(target, {
-    get(target2, prop, receiver) {
-      const value2 = Reflect.get(target2, prop, receiver);
-      if (prop !== "then" || typeof value2 !== "function") {
-        return value2;
+function replicateReadableStream(stream, count) {
+  if (count <= 0) {
+    return [];
+  }
+  const replicated = [];
+  let pending = stream;
+  for (let index = 0; index < count - 1; index++) {
+    const [replica, remainder] = pending.tee();
+    replicated.push(replica);
+    pending = remainder;
+  }
+  replicated.push(pending);
+  return replicated;
+}
+function wrapReadableStream(stream, { runWith, mapResult, mapError, onError, onFinish }) {
+  runWith ??= (run) => run();
+  const reader = once(() => stream.getReader());
+  const finish = once(async () => onFinish?.());
+  return new ReadableStream({
+    async pull(controller) {
+      let result;
+      try {
+        const readResult = await runWith(() => reader().read());
+        result = mapResult ? await mapResult(readResult) : readResult;
+      } catch (error) {
+        try {
+          await onError?.(error);
+          controller.error(mapError ? await mapError(error) : error);
+        } finally {
+          await finish();
+        }
+        return;
       }
-      return new Proxy(value2, {
-        apply(targetFn, thisArg, args) {
-          if (args.length !== 2 || args.some((arg) => !isNativeFunction(arg))) {
-            return Reflect.apply(targetFn, thisArg, args);
-          }
-          let shouldOmit = true;
-          args[0].call(thisArg, preventNativeAwait(new Proxy(target2, {
-            get: (target3, prop2, receiver2) => {
-              if (shouldOmit && prop2 === "then") {
-                shouldOmit = false;
-                return void 0;
-              }
-              return Reflect.get(target3, prop2, receiver2);
-            }
-          })));
+      if (result.done) {
+        controller.close();
+        await finish();
+      } else {
+        controller.enqueue(result.value);
+      }
+    },
+    async cancel(reason) {
+      try {
+        try {
+          await runWith(() => reader().cancel(reason));
+        } catch (error) {
+          await onError?.(error);
+          throw error;
         }
-      });
+      } finally {
+        await finish();
+      }
     }
   });
 }
-const NATIVE_FUNCTION_REGEX = /^\s*function\s*\(\)\s*\{\s*\[native code\]\s*\}\s*$/;
-function isNativeFunction(fn) {
-  return typeof fn === "function" && NATIVE_FUNCTION_REGEX.test(fn.toString());
-}
-function overlayProxy(target, partial) {
-  const proxy = new Proxy(typeof target === "function" ? partial : target, {
-    get(_, prop) {
-      const targetValue = prop in partial ? partial : value(target);
-      const v = Reflect.get(targetValue, prop);
-      return typeof v === "function" ? v.bind(targetValue) : v;
+function traceReadableStream(options, stream) {
+  const getSpan = once(() => startSpan(options));
+  return wrapReadableStream(stream, {
+    runWith: (run) => runInSpanContext(getSpan(), run),
+    mapResult(result) {
+      getSpan()?.addEvent(result.done ? "closed" : "enqueued");
+      return result;
     },
-    has(_, prop) {
-      return Reflect.has(partial, prop) || Reflect.has(value(target), prop);
+    onError(error) {
+      recordSpanError(getSpan(), error);
+    },
+    onFinish() {
+      getSpan()?.end();
     }
   });
-  return proxy;
 }
-
-function streamToAsyncIteratorClass(stream) {
+function streamToAsyncIteratorObject(stream, { signal } = {}) {
   const reader = stream.getReader();
+  let cancelledBySignal = false;
   return new AsyncIteratorClass(
     async () => {
-      return reader.read();
+      if (signal?.aborted) {
+        cancelledBySignal = true;
+        throw signal.reason;
+      }
+      if (!signal) {
+        return reader.read();
+      }
+      const { promise, reject } = promiseWithResolvers();
+      const onAbort = () => reject(signal.reason);
+      signal.addEventListener("abort", onAbort, { once: true });
+      try {
+        return await Promise.race([
+          reader.read(),
+          promise.catch(async (reason) => {
+            cancelledBySignal = true;
+            throw reason;
+          })
+        ]);
+      } finally {
+        signal.removeEventListener("abort", onAbort);
+      }
     },
-    async () => {
-      await reader.cancel();
+    async ({ kind, error }) => {
+      if (kind === "cancelled" || kind === "error" && cancelledBySignal) {
+        await reader.cancel(error);
+      }
     }
   );
 }
@@ -696,7 +760,7 @@ function asyncIteratorToUnproxiedDataStream(iterator) {
       if (done) {
         controller.close();
       } else {
-        const unproxied = isObject(value) ? { ...value } : Array.isArray(value) ? value.map((i) => i) : value;
+        const unproxied = isPlainObject(value) ? { ...value } : Array.isArray(value) ? value.map((i) => i) : value;
         controller.enqueue(unproxied);
       }
     },
@@ -706,12 +770,228 @@ function asyncIteratorToUnproxiedDataStream(iterator) {
   });
 }
 
-function tryDecodeURIComponent(value) {
+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 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 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 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.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();
+  }
+  signal.throwIfAborted();
+  const { promise, reject, resolve } = promiseWithResolvers();
+  let abortListener;
+  signal.addEventListener("abort", abortListener = () => {
+    reject(signal.reason);
+    abortListener = void 0;
+  });
   try {
-    return decodeURIComponent(value);
-  } catch {
-    return value;
+    fn().then(resolve, reject);
+    return await promise;
+  } finally {
+    if (abortListener) {
+      signal.removeEventListener("abort", abortListener);
+    }
   }
 }
 
-export { AbortError, AsyncIdQueue, AsyncIteratorClass, EventPublisher, NullProtoObj, ORPC_NAME, ORPC_SHARED_PACKAGE_NAME, ORPC_SHARED_PACKAGE_VERSION, SequentialIdGenerator, asyncIteratorToStream, asyncIteratorToUnproxiedDataStream, asyncIteratorWithSpan, clone, compareSequentialIds, defer, fallback, findDeepMatches, get, getConstructor, getGlobalOtelConfig, intercept, isAsyncIteratorObject, isObject, isPropertyKey, isTypescriptObject, logError, onError, onFinish, onStart, onSuccess, once, overlayProxy, parseEmptyableJSON, preventNativeAwait, readAsBuffer, replicateAsyncIterator, resolveMaybeOptionalOptions, runInSpanContext, runWithSpan, sequential, setGlobalOtelConfig, setSpanAttribute, setSpanError, splitInHalf, startSpan, streamToAsyncIteratorClass, stringifyJSON, toArray, toOtelException, toSpanAttributeValue, tryDecodeURIComponent, value };
+export { AsyncIdQueue, NullProtoObj, ORPC_NAME, allAbortSignal, anyAbortSignal, asyncIteratorToStream, asyncIteratorToUnproxiedDataStream, bindMethods, clone, compareSequentialIds, consumeAsyncIterator, defer, findDeepMatches, get, getConstructor, getOpenTelemetryConfig, intercept, isAbortError, isCompressibleContentType, isDeepEqual, isPlainObject, isPropertyKey, loadBytes, matchesHttpPath, matchesHttpPathPrefix, mergeHttpPath, normalizeHttpPath, omit, onAsyncIteratorObjectError, onError, onFinish, onReadableStreamError, onStart, onSuccess, once, override, pathToHttpPath, promiseWithResolvers, recordSpanError, replicateAsyncIterator, replicateReadableStream, resolveMaybeOptionalOptions, runInSpanContext, runWithSignal, runWithSpan, set, setOpenTelemetryConfig, setSpanAttributeIfDefined, sortPlugins, splitInHalf, startSpan, streamToAsyncIteratorObject, toOtelException, toSpanAttributeValue, toStringOrBytes, traceAsyncIterator, traceReadableStream, tryDecodeURIComponent, tryOrUndefined, value, wrapAsyncIterator, wrapReadableStream };