@orpc/shared 1.14.11 → 1.14.12

package/dist/index.mjs

@@ -1,114 +1,33 @@
-import { AbortError, AsyncIteratorClass, getOrBind, isTypescriptObject, isAsyncIteratorObject } from '@standardserver/shared';
-export { AbortError, AsyncIteratorClass, SequentialIdGenerator, getOrBind, isAsyncIteratorObject, isTypescriptObject, parseEmptyableJSON, sequential, sleep, stringifyJSON, toArray } from '@standardserver/shared';
+export { group, guard, mapEntries, mapValues, omit, retry, sleep } from 'radash';
 
 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)];
 }
 
-async function loadBytes(source) {
+function readAsBuffer(source) {
   if (typeof source.bytes === "function") {
     return source.bytes();
   }
-  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;
+  return source.arrayBuffer();
 }
 
 const ORPC_NAME = "orpc";
+const ORPC_SHARED_PACKAGE_NAME = "@orpc/shared";
+const ORPC_SHARED_PACKAGE_VERSION = "1.14.12";
 
-function isAbortError(error) {
-  return error instanceof Error && error.name.includes("Abort");
+class AbortError extends Error {
+  constructor(...rest) {
+    super(...rest);
+    this.name = "AbortError";
+  }
 }
 
 function once(fn) {
@@ -122,6 +41,15 @@ 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);
@@ -129,102 +57,33 @@ 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 OPENTELEMETRY_CONFIG_SYMBOL = Symbol.for("ORPC_OPENTELEMETRY_CONFIG");
-function setOpenTelemetryConfig(config) {
-  globalThis[OPENTELEMETRY_CONFIG_SYMBOL] = config;
+const GLOBAL_OTEL_CONFIG_KEY = `__${ORPC_SHARED_PACKAGE_NAME}@${ORPC_SHARED_PACKAGE_VERSION}/otel/config__`;
+function setGlobalOtelConfig(config) {
+  globalThis[GLOBAL_OTEL_CONFIG_KEY] = config;
 }
-function getOpenTelemetryConfig() {
-  return globalThis[OPENTELEMETRY_CONFIG_SYMBOL];
+function getGlobalOtelConfig() {
+  return globalThis[GLOBAL_OTEL_CONFIG_KEY];
 }
-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 startSpan(name, options = {}, context) {
+  const tracer = getGlobalOtelConfig()?.tracer;
+  return tracer?.startSpan(name, options, context);
 }
-function recordSpanError(span, error) {
+function setSpanError(span, error, options = {}) {
   if (!span) {
     return;
   }
   const exception = toOtelException(error);
   span.recordException(exception);
-  if (!isAbortError(error)) {
+  if (!options.signal?.aborted || options.signal.reason !== error) {
     span.setStatus({
       code: SPAN_ERROR_STATUS,
       message: exception.message
     });
   }
 }
-function setSpanAttributeIfDefined(span, key, value) {
+function setSpanAttribute(span, key, value) {
   if (!span || value === void 0) {
     return;
   }
@@ -262,32 +121,29 @@ function toSpanAttributeValue(data) {
     return String(data);
   }
 }
-async function runWithSpan(options, fn) {
-  const tracer = getOpenTelemetryConfig()?.tracer;
+async function runWithSpan({ name, context, ...options }, fn) {
+  const tracer = getGlobalOtelConfig()?.tracer;
   if (!tracer) {
     return fn();
   }
-  if (typeof options === "string") {
-    options = { name: options };
-  }
   const callback = async (span) => {
     try {
       return await fn(span);
     } catch (e) {
-      recordSpanError(span, e);
+      setSpanError(span, e, options);
       throw e;
     } finally {
       span.end();
     }
   };
-  if (options.context) {
-    return tracer.startActiveSpan(options.name, options, options.context, callback);
+  if (context) {
+    return tracer.startActiveSpan(name, options, context, callback);
   } else {
-    return tracer.startActiveSpan(options.name, options, callback);
+    return tracer.startActiveSpan(name, options, callback);
   }
 }
 async function runInSpanContext(span, fn) {
-  const otelConfig = getOpenTelemetryConfig();
+  const otelConfig = getGlobalOtelConfig();
   if (!span || !otelConfig) {
     return fn();
   }
@@ -299,9 +155,15 @@ class AsyncIdQueue {
   openIds = /* @__PURE__ */ new Set();
   queues = /* @__PURE__ */ new Map();
   waiters = /* @__PURE__ */ new Map();
-  get size() {
+  get length() {
     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);
   }
@@ -369,54 +231,74 @@ class AsyncIdQueue {
   }
 }
 
-function wrapAsyncIterator(iterator, { runWith, mapResult, mapError, onError, onFinish }) {
-  runWith ??= (run) => run();
-  let isDone;
-  return new AsyncIteratorClass(async () => {
-    try {
-      let result;
-      try {
-        result = await runWith(() => iterator.next());
-        isDone = result.done;
-      } catch (error) {
-        isDone = true;
-        throw error;
+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 };
       }
-      return mapResult ? await mapResult(result) : result;
-    } catch (error) {
-      await onError?.(error);
-      throw mapError ? await mapError(error) : error;
-    }
-  }, async (_state) => {
-    try {
-      if (!isDone) {
-        try {
-          await runWith(async () => iterator.return?.());
-        } catch (error) {
-          await onError?.(error);
-          throw error;
+      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");
         }
       }
-    } finally {
-      await onFinish?.();
+    });
+  }
+  next() {
+    return this.#next();
+  }
+  async return(value) {
+    this.#isDone = true;
+    if (!this.#isExecuteComplete) {
+      this.#isExecuteComplete = true;
+      await this.#cleanup("return");
     }
-  });
-}
-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();
+    return { done: true, value };
+  }
+  async throw(err) {
+    this.#isDone = true;
+    if (!this.#isExecuteComplete) {
+      this.#isExecuteComplete = true;
+      await this.#cleanup("throw");
     }
-  });
+    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");
+    }
+  }
+  [Symbol.asyncIterator]() {
+    return this;
+  }
 }
 function replicateAsyncIterator(source, count) {
   const queue = new AsyncIdQueue();
@@ -456,9 +338,9 @@ function replicateAsyncIterator(source, count) {
         }
         throw item.error;
       },
-      async ({ kind, error }) => {
-        queue.close({ id, reason: error });
-        if (kind === "cancelled" && !queue.size && !isSourceFinished) {
+      async (reason) => {
+        queue.close({ id });
+        if (reason !== "next" && !queue.length && !isSourceFinished) {
           isSourceFinished = true;
           await source?.return?.();
         }
@@ -467,51 +349,194 @@ 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;
+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?.());
         }
-        options.onEvent(value);
+      } 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();
+        }
+      }
+    });
+    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) {
-      onFinishState = [error, void 0, false];
-      options.onError?.(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 {
-      options.onFinish?.(onFinishState);
+      await callback(state, options, ...rest);
     }
-  })();
-  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 value(value2, ...args) {
-  if (typeof value2 === "function") {
-    return value2(...args);
+function parseEmptyableJSON(text) {
+  if (!text) {
+    return void 0;
   }
-  return value2;
+  return JSON.parse(text);
+}
+function stringifyJSON(value) {
+  return JSON.stringify(value);
 }
 
-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 logError(error) {
+  if (typeof console === "object" && typeof console.error === "function") {
+    console.error(error);
+  }
 }
 
 function findDeepMatches(check, payload, segments = [], maps = [], values = []) {
@@ -522,7 +547,7 @@ function findDeepMatches(check, payload, segments = [], maps = [], values = [])
     payload.forEach((v, i) => {
       findDeepMatches(check, v, [...segments, i], maps, values);
     });
-  } else if (isPlainObject(payload)) {
+  } else if (isObject(payload)) {
     for (const key in payload) {
       findDeepMatches(check, payload[key], [...segments, key], maps, values);
     }
@@ -535,47 +560,21 @@ function getConstructor(value) {
   }
   return Object.getPrototypeOf(value)?.constructor;
 }
-function isPlainObject(value) {
+function isObject(value) {
   if (!value || typeof value !== "object") {
     return false;
   }
   const proto = Object.getPrototypeOf(value);
   return proto === Object.prototype || !proto || !proto.constructor;
 }
-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 isTypescriptObject(value) {
+  return !!value && (typeof value === "object" || typeof value === "function");
 }
 function clone(value) {
   if (Array.isArray(value)) {
     return value.map(clone);
   }
-  if (isPlainObject(value)) {
+  if (isObject(value)) {
     const result = {};
     for (const key in value) {
       result[key] = clone(value[key]);
@@ -587,6 +586,16 @@ 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";
@@ -598,143 +607,70 @@ const NullProtoObj = /* @__PURE__ */ (() => {
   Object.freeze(e.prototype);
   return e;
 })();
-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);
+
+function value(value2, ...args) {
+  if (typeof value2 === "function") {
+    return value2(...args);
   }
-  return methods;
+  return value2;
 }
-
-function promiseWithResolvers() {
-  const result = {};
-  result.promise = new Promise((resolve, reject) => {
-    result.resolve = resolve;
-    result.reject = reject;
-  });
-  return result;
+function fallback(value2, fallback2) {
+  return value2 === void 0 ? fallback2 : 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;
+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;
       }
-      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;
+      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);
+            }
+          })));
         }
-      } finally {
-        await finish();
-      }
+      });
     }
   });
 }
-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;
-    },
-    onError(error) {
-      recordSpanError(getSpan(), error);
+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;
     },
-    onFinish() {
-      getSpan()?.end();
+    has(_, prop) {
+      return Reflect.has(partial, prop) || Reflect.has(value(target), prop);
     }
   });
+  return proxy;
 }
-function streamToAsyncIteratorObject(stream, { signal } = {}) {
+
+function streamToAsyncIteratorClass(stream) {
   const reader = stream.getReader();
-  let cancelledBySignal = false;
   return new AsyncIteratorClass(
     async () => {
-      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);
-      }
+      return reader.read();
     },
-    async ({ kind, error }) => {
-      if (kind === "cancelled" || kind === "error" && cancelledBySignal) {
-        await reader.cancel(error);
-      }
+    async () => {
+      await reader.cancel();
     }
   );
 }
@@ -760,7 +696,7 @@ function asyncIteratorToUnproxiedDataStream(iterator) {
       if (done) {
         controller.close();
       } else {
-        const unproxied = isPlainObject(value) ? { ...value } : Array.isArray(value) ? value.map((i) => i) : value;
+        const unproxied = isObject(value) ? { ...value } : Array.isArray(value) ? value.map((i) => i) : value;
         controller.enqueue(unproxied);
       }
     },
@@ -770,228 +706,12 @@ function asyncIteratorToUnproxiedDataStream(iterator) {
   });
 }
 
-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;
-  });
+function tryDecodeURIComponent(value) {
   try {
-    fn().then(resolve, reject);
-    return await promise;
-  } finally {
-    if (abortListener) {
-      signal.removeEventListener("abort", abortListener);
-    }
+    return decodeURIComponent(value);
+  } catch {
+    return 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 };
+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 };