@xyo-network/hash 7.0.12 → 7.0.13

package/dist/browser/worker/wasmHash-bundle.mjs

@@ -1,16 +1,5 @@
 "use strict";
 (() => {
-  // ../../../../../../node_modules/.pnpm/@ariestools+sdk@7.0.4_@opentelemetry+api@1.9.1_@opentelemetry+sdk-trace-base@2.8.0_@ope_97da9f513cbe94e19a96d20f67b150bc/node_modules/@ariestools/sdk/dist/_pkg/typeof/neutral/index.mjs
-  function isUndefined(value) {
-    return value === void 0;
-  }
-  function isString(value) {
-    return typeof value === "string";
-  }
-  function isNumber(value) {
-    return typeof value === "number";
-  }
-
   // ../../../../../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/core/core.js
   var _a;
   // @__NO_SIDE_EFFECTS__
@@ -120,6 +109,25 @@
   }
   var captureStackTrace = "captureStackTrace" in Error ? Error.captureStackTrace : (..._args) => {
   };
+  function isObject(data) {
+    return typeof data === "object" && data !== null && !Array.isArray(data);
+  }
+  function isPlainObject(o) {
+    if (isObject(o) === false)
+      return false;
+    const ctor = o.constructor;
+    if (ctor === void 0)
+      return true;
+    if (typeof ctor !== "function")
+      return true;
+    const prot = ctor.prototype;
+    if (isObject(prot) === false)
+      return false;
+    if (Object.prototype.hasOwnProperty.call(prot, "isPrototypeOf") === false) {
+      return false;
+    }
+    return true;
+  }
   function clone(inst, def, params) {
     const cl = new inst._zod.constr(def ?? inst._zod.def);
     if (!def || params?.parent)
@@ -169,6 +177,14 @@
     }
     return false;
   }
+  function prefixIssues(path, issues) {
+    return issues.map((iss) => {
+      var _a3;
+      (_a3 = iss).path ?? (_a3.path = []);
+      iss.path.unshift(path);
+      return iss;
+    });
+  }
   function unwrapMessage(message) {
     return typeof message === "string" ? message : message?.message;
   }
@@ -276,6 +292,8 @@
   };
   var bigint = /^-?\d+n?$/;
   var number = /^-?\d+(?:\.\d+)?$/;
+  var boolean = /^(?:true|false)$/i;
+  var _null = /^null$/i;
 
   // ../../../../../../node_modules/.pnpm/zod@4.4.3/node_modules/zod/v4/core/checks.js
   var $ZodCheck = /* @__PURE__ */ $constructor("$ZodCheck", (inst, def) => {
@@ -528,6 +546,27 @@
       return payload;
     };
   });
+  var $ZodBoolean = /* @__PURE__ */ $constructor("$ZodBoolean", (inst, def) => {
+    $ZodType.init(inst, def);
+    inst._zod.pattern = boolean;
+    inst._zod.parse = (payload, _ctx) => {
+      if (def.coerce)
+        try {
+          payload.value = Boolean(payload.value);
+        } catch (_) {
+        }
+      const input = payload.value;
+      if (typeof input === "boolean")
+        return payload;
+      payload.issues.push({
+        expected: "boolean",
+        code: "invalid_type",
+        input,
+        inst
+      });
+      return payload;
+    };
+  });
   var $ZodBigInt = /* @__PURE__ */ $constructor("$ZodBigInt", (inst, def) => {
     $ZodType.init(inst, def);
     inst._zod.pattern = bigint;
@@ -548,6 +587,62 @@
       return payload;
     };
   });
+  var $ZodNull = /* @__PURE__ */ $constructor("$ZodNull", (inst, def) => {
+    $ZodType.init(inst, def);
+    inst._zod.pattern = _null;
+    inst._zod.values = /* @__PURE__ */ new Set([null]);
+    inst._zod.parse = (payload, _ctx) => {
+      const input = payload.value;
+      if (input === null)
+        return payload;
+      payload.issues.push({
+        expected: "null",
+        code: "invalid_type",
+        input,
+        inst
+      });
+      return payload;
+    };
+  });
+  function handleArrayResult(result, final, index) {
+    if (result.issues.length) {
+      final.issues.push(...prefixIssues(index, result.issues));
+    }
+    final.value[index] = result.value;
+  }
+  var $ZodArray = /* @__PURE__ */ $constructor("$ZodArray", (inst, def) => {
+    $ZodType.init(inst, def);
+    inst._zod.parse = (payload, ctx) => {
+      const input = payload.value;
+      if (!Array.isArray(input)) {
+        payload.issues.push({
+          expected: "array",
+          code: "invalid_type",
+          input,
+          inst
+        });
+        return payload;
+      }
+      payload.value = Array(input.length);
+      const proms = [];
+      for (let i = 0; i < input.length; i++) {
+        const item = input[i];
+        const result = def.element._zod.run({
+          value: item,
+          issues: []
+        }, ctx);
+        if (result instanceof Promise) {
+          proms.push(result.then((result2) => handleArrayResult(result2, payload, i)));
+        } else {
+          handleArrayResult(result, payload, i);
+        }
+      }
+      if (proms.length) {
+        return Promise.all(proms).then(() => payload);
+      }
+      return payload;
+    };
+  });
   function handleUnionResults(results, final, inst, ctx) {
     for (const result of results) {
       if (result.issues.length === 0) {
@@ -613,6 +708,132 @@
       });
     };
   });
+  var $ZodRecord = /* @__PURE__ */ $constructor("$ZodRecord", (inst, def) => {
+    $ZodType.init(inst, def);
+    inst._zod.parse = (payload, ctx) => {
+      const input = payload.value;
+      if (!isPlainObject(input)) {
+        payload.issues.push({
+          expected: "record",
+          code: "invalid_type",
+          input,
+          inst
+        });
+        return payload;
+      }
+      const proms = [];
+      const values = def.keyType._zod.values;
+      if (values) {
+        payload.value = {};
+        const recordKeys = /* @__PURE__ */ new Set();
+        for (const key of values) {
+          if (typeof key === "string" || typeof key === "number" || typeof key === "symbol") {
+            recordKeys.add(typeof key === "number" ? key.toString() : key);
+            const keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx);
+            if (keyResult instanceof Promise) {
+              throw new Error("Async schemas not supported in object keys currently");
+            }
+            if (keyResult.issues.length) {
+              payload.issues.push({
+                code: "invalid_key",
+                origin: "record",
+                issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config())),
+                input: key,
+                path: [key],
+                inst
+              });
+              continue;
+            }
+            const outKey = keyResult.value;
+            const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);
+            if (result instanceof Promise) {
+              proms.push(result.then((result2) => {
+                if (result2.issues.length) {
+                  payload.issues.push(...prefixIssues(key, result2.issues));
+                }
+                payload.value[outKey] = result2.value;
+              }));
+            } else {
+              if (result.issues.length) {
+                payload.issues.push(...prefixIssues(key, result.issues));
+              }
+              payload.value[outKey] = result.value;
+            }
+          }
+        }
+        let unrecognized;
+        for (const key in input) {
+          if (!recordKeys.has(key)) {
+            unrecognized = unrecognized ?? [];
+            unrecognized.push(key);
+          }
+        }
+        if (unrecognized && unrecognized.length > 0) {
+          payload.issues.push({
+            code: "unrecognized_keys",
+            input,
+            inst,
+            keys: unrecognized
+          });
+        }
+      } else {
+        payload.value = {};
+        for (const key of Reflect.ownKeys(input)) {
+          if (key === "__proto__")
+            continue;
+          if (!Object.prototype.propertyIsEnumerable.call(input, key))
+            continue;
+          let keyResult = def.keyType._zod.run({ value: key, issues: [] }, ctx);
+          if (keyResult instanceof Promise) {
+            throw new Error("Async schemas not supported in object keys currently");
+          }
+          const checkNumericKey = typeof key === "string" && number.test(key) && keyResult.issues.length;
+          if (checkNumericKey) {
+            const retryResult = def.keyType._zod.run({ value: Number(key), issues: [] }, ctx);
+            if (retryResult instanceof Promise) {
+              throw new Error("Async schemas not supported in object keys currently");
+            }
+            if (retryResult.issues.length === 0) {
+              keyResult = retryResult;
+            }
+          }
+          if (keyResult.issues.length) {
+            if (def.mode === "loose") {
+              payload.value[key] = input[key];
+            } else {
+              payload.issues.push({
+                code: "invalid_key",
+                origin: "record",
+                issues: keyResult.issues.map((iss) => finalizeIssue(iss, ctx, config())),
+                input: key,
+                path: [key],
+                inst
+              });
+            }
+            continue;
+          }
+          const result = def.valueType._zod.run({ value: input[key], issues: [] }, ctx);
+          if (result instanceof Promise) {
+            proms.push(result.then((result2) => {
+              if (result2.issues.length) {
+                payload.issues.push(...prefixIssues(key, result2.issues));
+              }
+              payload.value[keyResult.value] = result2.value;
+            }));
+          } else {
+            if (result.issues.length) {
+              payload.issues.push(...prefixIssues(key, result.issues));
+            }
+            payload.value[keyResult.value] = result.value;
+          }
+        }
+      }
+      if (proms.length) {
+        return Promise.all(proms).then(() => payload);
+      }
+      return payload;
+    };
+  });
   var $ZodTransform = /* @__PURE__ */ $constructor("$ZodTransform", (inst, def) => {
     $ZodType.init(inst, def);
     inst._zod.optin = "optional";
@@ -665,6 +886,23 @@
     }
     return next._zod.run({ value: left.value, issues: left.issues, fallback: left.fallback }, ctx);
   }
+  var $ZodLazy = /* @__PURE__ */ $constructor("$ZodLazy", (inst, def) => {
+    $ZodType.init(inst, def);
+    defineLazy(inst._zod, "innerType", () => {
+      const d = def;
+      if (!d._cachedInner)
+        d._cachedInner = def.getter();
+      return d._cachedInner;
+    });
+    defineLazy(inst._zod, "pattern", () => inst._zod.innerType?._zod?.pattern);
+    defineLazy(inst._zod, "propValues", () => inst._zod.innerType?._zod?.propValues);
+    defineLazy(inst._zod, "optin", () => inst._zod.innerType?._zod?.optin ?? void 0);
+    defineLazy(inst._zod, "optout", () => inst._zod.innerType?._zod?.optout ?? void 0);
+    inst._zod.parse = (payload, ctx) => {
+      const inner = inst._zod.innerType;
+      return inner._zod.run(payload, ctx);
+    };
+  });
   var $ZodCustom = /* @__PURE__ */ $constructor("$ZodCustom", (inst, def) => {
     $ZodCheck.init(inst, def);
     $ZodType.init(inst, def);
@@ -716,6 +954,13 @@
     });
   }
   // @__NO_SIDE_EFFECTS__
+  function _boolean(Class, params) {
+    return new Class({
+      type: "boolean",
+      ...normalizeParams(params)
+    });
+  }
+  // @__NO_SIDE_EFFECTS__
   function _bigint(Class, params) {
     return new Class({
       type: "bigint",
@@ -723,6 +968,13 @@
     });
   }
   // @__NO_SIDE_EFFECTS__
+  function _null2(Class, params) {
+    return new Class({
+      type: "null",
+      ...normalizeParams(params)
+    });
+  }
+  // @__NO_SIDE_EFFECTS__
   function _gte(value, params) {
     return new $ZodCheckGreaterThan({
       check: "greater_than",
@@ -802,6 +1054,14 @@
   function number2(params) {
     return _number(ZodMiniNumber, params);
   }
+  var ZodMiniBoolean = /* @__PURE__ */ $constructor("ZodMiniBoolean", (inst, def) => {
+    $ZodBoolean.init(inst, def);
+    ZodMiniType.init(inst, def);
+  });
+  // @__NO_SIDE_EFFECTS__
+  function boolean2(params) {
+    return _boolean(ZodMiniBoolean, params);
+  }
   var ZodMiniBigInt = /* @__PURE__ */ $constructor("ZodMiniBigInt", (inst, def) => {
     $ZodBigInt.init(inst, def);
     ZodMiniType.init(inst, def);
@@ -810,6 +1070,26 @@
   function bigint2(params) {
     return _bigint(ZodMiniBigInt, params);
   }
+  var ZodMiniNull = /* @__PURE__ */ $constructor("ZodMiniNull", (inst, def) => {
+    $ZodNull.init(inst, def);
+    ZodMiniType.init(inst, def);
+  });
+  // @__NO_SIDE_EFFECTS__
+  function _null3(params) {
+    return _null2(ZodMiniNull, params);
+  }
+  var ZodMiniArray = /* @__PURE__ */ $constructor("ZodMiniArray", (inst, def) => {
+    $ZodArray.init(inst, def);
+    ZodMiniType.init(inst, def);
+  });
+  // @__NO_SIDE_EFFECTS__
+  function array(element, params) {
+    return new ZodMiniArray({
+      type: "array",
+      element,
+      ...normalizeParams(params)
+    });
+  }
   var ZodMiniUnion = /* @__PURE__ */ $constructor("ZodMiniUnion", (inst, def) => {
     $ZodUnion.init(inst, def);
     ZodMiniType.init(inst, def);
@@ -822,6 +1102,27 @@
       ...normalizeParams(params)
     });
   }
+  var ZodMiniRecord = /* @__PURE__ */ $constructor("ZodMiniRecord", (inst, def) => {
+    $ZodRecord.init(inst, def);
+    ZodMiniType.init(inst, def);
+  });
+  // @__NO_SIDE_EFFECTS__
+  function record(keyType, valueType, params) {
+    if (!valueType || !valueType._zod) {
+      return new ZodMiniRecord({
+        type: "record",
+        keyType: /* @__PURE__ */ string2(),
+        valueType: keyType,
+        ...normalizeParams(valueType)
+      });
+    }
+    return new ZodMiniRecord({
+      type: "record",
+      keyType,
+      valueType,
+      ...normalizeParams(params)
+    });
+  }
   var ZodMiniTransform = /* @__PURE__ */ $constructor("ZodMiniTransform", (inst, def) => {
     $ZodTransform.init(inst, def);
     ZodMiniType.init(inst, def);
@@ -845,6 +1146,17 @@
       out
     });
   }
+  var ZodMiniLazy = /* @__PURE__ */ $constructor("ZodMiniLazy", (inst, def) => {
+    $ZodLazy.init(inst, def);
+    ZodMiniType.init(inst, def);
+  });
+  // @__NO_SIDE_EFFECTS__
+  function _lazy(getter) {
+    return new ZodMiniLazy({
+      type: "lazy",
+      getter
+    });
+  }
   var ZodMiniCustom = /* @__PURE__ */ $constructor("ZodMiniCustom", (inst, def) => {
     $ZodCustom.init(inst, def);
     ZodMiniType.init(inst, def);
@@ -854,177 +1166,3083 @@
     return _refine(ZodMiniCustom, fn, _params);
   }
 
-  // ../../../../../../node_modules/.pnpm/@ariestools+sdk@7.0.4_@opentelemetry+api@1.9.1_@opentelemetry+sdk-trace-base@2.8.0_@ope_97da9f513cbe94e19a96d20f67b150bc/node_modules/@ariestools/sdk/dist/_pkg/error/neutral/index.mjs
-  var assertError = (value, assert, defaultMessage) => {
-    if (!isUndefined(assert)) {
-      const assertString = typeof assert === "string" ? assert : typeof assert === "boolean" ? defaultMessage : assert(value, defaultMessage);
-      if (isString(assertString) || assertString) {
-        throw new Error(assertString === true ? defaultMessage : assertString);
-      }
-    }
-    return void 0;
-  };
-
-  // ../../../../../../node_modules/.pnpm/@ariestools+sdk@7.0.4_@opentelemetry+api@1.9.1_@opentelemetry+sdk-trace-base@2.8.0_@ope_97da9f513cbe94e19a96d20f67b150bc/node_modules/@ariestools/sdk/dist/_pkg/hex/neutral/index.mjs
-  var HexRegExMinMax = (minBytes = 0, maxBytes = Number.MAX_SAFE_INTEGER / 2) => {
-    return new RegExp(`^[a-f0-9]{${minBytes * 2},${maxBytes * 2}}$`);
-  };
-  var HexRegExMinMaxMixedCaseWithPrefix = (minBytes = 0, maxBytes = Number.MAX_SAFE_INTEGER / 2) => {
-    return new RegExp(`^0x[a-fA-F0-9]{${minBytes * 2},${maxBytes * 2}}$`);
-  };
-  var HexRegEx = /^[0-9a-f]+$/;
-  var HexRegExWithPrefix = /^0x[0-9a-f]+$/;
-  var ADDRESS_LENGTH = 40;
-  var AddressRegEx = HexRegExMinMax(ADDRESS_LENGTH / 2, ADDRESS_LENGTH / 2);
-  var AddressZod = pipe(
-    string2().check(_regex(AddressRegEx)),
-    transform((v) => v)
-  );
-  var bitsToNibbles = (value) => {
-    const nibbles = value >> 2;
-    if (value !== nibbles << 2) throw new Error("Bits for nibbles must multiple of 4");
-    return nibbles;
-  };
-  var isHex = (value, config2) => {
-    if (typeof value !== "string") return false;
-    const valueCharLength = value.length - (config2?.prefix === true ? 2 : 0);
-    if (config2?.bitLength !== void 0 && valueCharLength !== bitsToNibbles(config2?.bitLength)) return false;
-    const regex5 = config2?.prefix === true ? HexRegExWithPrefix : HexRegEx;
-    return regex5.test(value);
-  };
-  var hexFromHexString = (value, config2 = {}) => {
-    const {
-      prefix: isPrefix = false,
-      byteSize = 8,
-      bitLength
-    } = config2;
-    const nibbleBoundary = bitsToNibbles(byteSize);
-    const unEvened = (value.startsWith("0x") ? value.slice(2) : value).toLowerCase();
-    if (isHex(unEvened)) {
-      const evenCharacters = unEvened.padStart(Math.ceil(unEvened.length / nibbleBoundary) * nibbleBoundary, "0");
-      const padded = isNumber(bitLength) ? evenCharacters.padStart(bitLength / 4, "0") : evenCharacters;
-      return (isPrefix ? `0x${padded}` : padded).toLowerCase();
+  // ../../../../../../node_modules/.pnpm/async-mutex@0.5.0/node_modules/async-mutex/index.mjs
+  var E_TIMEOUT = new Error("timeout while waiting for mutex to become available");
+  var E_ALREADY_LOCKED = new Error("mutex already locked");
+  var E_CANCELED = new Error("request for lock canceled");
+  var __awaiter$2 = function(thisArg, _arguments, P, generator) {
+    function adopt(value) {
+      return value instanceof P ? value : new P(function(resolve) {
+        resolve(value);
+      });
     }
-    throw new Error("Received string is not a value hex");
-  };
-  var hexFromArrayBuffer = (buffer, config2) => {
-    const unPadded = [...new Uint8Array(buffer)].map((x) => x.toString(16).padStart(2, "0")).join("");
-    return hexFromHexString(unPadded, config2);
-  };
-  var hexFromBigInt = (value, config2 = {}) => {
-    const unPadded = value.toString(16);
-    return hexFromHexString(unPadded, config2);
-  };
-  var hexFromNumber = (value, config2) => {
-    return hexFromBigInt(BigInt(value), config2);
-  };
-  var hexFrom = (value, config2) => {
-    switch (typeof value) {
-      case "string": {
-        return hexFromHexString(value, config2);
+    return new (P || (P = Promise))(function(resolve, reject) {
+      function fulfilled(value) {
+        try {
+          step(generator.next(value));
+        } catch (e) {
+          reject(e);
+        }
       }
-      case "bigint": {
-        return hexFromBigInt(value, config2);
+      function rejected(value) {
+        try {
+          step(generator["throw"](value));
+        } catch (e) {
+          reject(e);
+        }
       }
-      case "number": {
-        return hexFromNumber(value, config2);
+      function step(result) {
+        result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
       }
-      case "object": {
-        return hexFromArrayBuffer(value, config2);
+      step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+  };
+  var Semaphore = class {
+    constructor(_value, _cancelError = E_CANCELED) {
+      this._value = _value;
+      this._cancelError = _cancelError;
+      this._queue = [];
+      this._weightedWaiters = [];
+    }
+    acquire(weight = 1, priority = 0) {
+      if (weight <= 0)
+        throw new Error(`invalid weight ${weight}: must be positive`);
+      return new Promise((resolve, reject) => {
+        const task = { resolve, reject, weight, priority };
+        const i = findIndexFromEnd(this._queue, (other) => priority <= other.priority);
+        if (i === -1 && weight <= this._value) {
+          this._dispatchItem(task);
+        } else {
+          this._queue.splice(i + 1, 0, task);
+        }
+      });
+    }
+    runExclusive(callback_1) {
+      return __awaiter$2(this, arguments, void 0, function* (callback, weight = 1, priority = 0) {
+        const [value, release] = yield this.acquire(weight, priority);
+        try {
+          return yield callback(value);
+        } finally {
+          release();
+        }
+      });
+    }
+    waitForUnlock(weight = 1, priority = 0) {
+      if (weight <= 0)
+        throw new Error(`invalid weight ${weight}: must be positive`);
+      if (this._couldLockImmediately(weight, priority)) {
+        return Promise.resolve();
+      } else {
+        return new Promise((resolve) => {
+          if (!this._weightedWaiters[weight - 1])
+            this._weightedWaiters[weight - 1] = [];
+          insertSorted(this._weightedWaiters[weight - 1], { resolve, priority });
+        });
       }
-      default: {
-        throw new Error(`Invalid type: ${typeof value}`);
+    }
+    isLocked() {
+      return this._value <= 0;
+    }
+    getValue() {
+      return this._value;
+    }
+    setValue(value) {
+      this._value = value;
+      this._dispatchQueue();
+    }
+    release(weight = 1) {
+      if (weight <= 0)
+        throw new Error(`invalid weight ${weight}: must be positive`);
+      this._value += weight;
+      this._dispatchQueue();
+    }
+    cancel() {
+      this._queue.forEach((entry) => entry.reject(this._cancelError));
+      this._queue = [];
+    }
+    _dispatchQueue() {
+      this._drainUnlockWaiters();
+      while (this._queue.length > 0 && this._queue[0].weight <= this._value) {
+        this._dispatchItem(this._queue.shift());
+        this._drainUnlockWaiters();
       }
     }
-  };
-  var HexZod = pipe(
-    string2().check(_regex(HexRegEx, { error: "Invalid hex format" })),
-    transform((val) => val)
+    _dispatchItem(item) {
+      const previousValue = this._value;
+      this._value -= item.weight;
+      item.resolve([previousValue, this._newReleaser(item.weight)]);
+    }
+    _newReleaser(weight) {
+      let called = false;
+      return () => {
+        if (called)
+          return;
+        called = true;
+        this.release(weight);
+      };
+    }
+    _drainUnlockWaiters() {
+      if (this._queue.length === 0) {
+        for (let weight = this._value; weight > 0; weight--) {
+          const waiters = this._weightedWaiters[weight - 1];
+          if (!waiters)
+            continue;
+          waiters.forEach((waiter) => waiter.resolve());
+          this._weightedWaiters[weight - 1] = [];
+        }
+      } else {
+        const queuedPriority = this._queue[0].priority;
+        for (let weight = this._value; weight > 0; weight--) {
+          const waiters = this._weightedWaiters[weight - 1];
+          if (!waiters)
+            continue;
+          const i = waiters.findIndex((waiter) => waiter.priority <= queuedPriority);
+          (i === -1 ? waiters : waiters.splice(0, i)).forEach(((waiter) => waiter.resolve()));
+        }
+      }
+    }
+    _couldLockImmediately(weight, priority) {
+      return (this._queue.length === 0 || this._queue[0].priority < priority) && weight <= this._value;
+    }
+  };
+  function insertSorted(a, v) {
+    const i = findIndexFromEnd(a, (other) => v.priority <= other.priority);
+    a.splice(i + 1, 0, v);
+  }
+  function findIndexFromEnd(a, predicate) {
+    for (let i = a.length - 1; i >= 0; i--) {
+      if (predicate(a[i])) {
+        return i;
+      }
+    }
+    return -1;
+  }
+  var __awaiter$1 = function(thisArg, _arguments, P, generator) {
+    function adopt(value) {
+      return value instanceof P ? value : new P(function(resolve) {
+        resolve(value);
+      });
+    }
+    return new (P || (P = Promise))(function(resolve, reject) {
+      function fulfilled(value) {
+        try {
+          step(generator.next(value));
+        } catch (e) {
+          reject(e);
+        }
+      }
+      function rejected(value) {
+        try {
+          step(generator["throw"](value));
+        } catch (e) {
+          reject(e);
+        }
+      }
+      function step(result) {
+        result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+      }
+      step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+  };
+  var Mutex = class {
+    constructor(cancelError) {
+      this._semaphore = new Semaphore(1, cancelError);
+    }
+    acquire() {
+      return __awaiter$1(this, arguments, void 0, function* (priority = 0) {
+        const [, releaser] = yield this._semaphore.acquire(1, priority);
+        return releaser;
+      });
+    }
+    runExclusive(callback, priority = 0) {
+      return this._semaphore.runExclusive(() => callback(), 1, priority);
+    }
+    isLocked() {
+      return this._semaphore.isLocked();
+    }
+    waitForUnlock(priority = 0) {
+      return this._semaphore.waitForUnlock(1, priority);
+    }
+    release() {
+      if (this._semaphore.isLocked())
+        this._semaphore.release();
+    }
+    cancel() {
+      return this._semaphore.cancel();
+    }
+  };
+
+  // ../../../../../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/version.js
+  var VERSION = "1.9.1";
+
+  // ../../../../../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/internal/semver.js
+  var re = /^(\d+)\.(\d+)\.(\d+)(-(.+))?$/;
+  function _makeCompatibilityCheck(ownVersion) {
+    const acceptedVersions = /* @__PURE__ */ new Set([ownVersion]);
+    const rejectedVersions = /* @__PURE__ */ new Set();
+    const myVersionMatch = ownVersion.match(re);
+    if (!myVersionMatch) {
+      return () => false;
+    }
+    const ownVersionParsed = {
+      major: +myVersionMatch[1],
+      minor: +myVersionMatch[2],
+      patch: +myVersionMatch[3],
+      prerelease: myVersionMatch[4]
+    };
+    if (ownVersionParsed.prerelease != null) {
+      return function isExactmatch(globalVersion) {
+        return globalVersion === ownVersion;
+      };
+    }
+    function _reject(v) {
+      rejectedVersions.add(v);
+      return false;
+    }
+    function _accept(v) {
+      acceptedVersions.add(v);
+      return true;
+    }
+    return function isCompatible2(globalVersion) {
+      if (acceptedVersions.has(globalVersion)) {
+        return true;
+      }
+      if (rejectedVersions.has(globalVersion)) {
+        return false;
+      }
+      const globalVersionMatch = globalVersion.match(re);
+      if (!globalVersionMatch) {
+        return _reject(globalVersion);
+      }
+      const globalVersionParsed = {
+        major: +globalVersionMatch[1],
+        minor: +globalVersionMatch[2],
+        patch: +globalVersionMatch[3],
+        prerelease: globalVersionMatch[4]
+      };
+      if (globalVersionParsed.prerelease != null) {
+        return _reject(globalVersion);
+      }
+      if (ownVersionParsed.major !== globalVersionParsed.major) {
+        return _reject(globalVersion);
+      }
+      if (ownVersionParsed.major === 0) {
+        if (ownVersionParsed.minor === globalVersionParsed.minor && ownVersionParsed.patch <= globalVersionParsed.patch) {
+          return _accept(globalVersion);
+        }
+        return _reject(globalVersion);
+      }
+      if (ownVersionParsed.minor <= globalVersionParsed.minor) {
+        return _accept(globalVersion);
+      }
+      return _reject(globalVersion);
+    };
+  }
+  var isCompatible = _makeCompatibilityCheck(VERSION);
+
+  // ../../../../../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/internal/global-utils.js
+  var major = VERSION.split(".")[0];
+  var GLOBAL_OPENTELEMETRY_API_KEY = /* @__PURE__ */ Symbol.for(`opentelemetry.js.api.${major}`);
+  var _global = typeof globalThis === "object" ? globalThis : typeof self === "object" ? self : typeof window === "object" ? window : typeof global === "object" ? global : {};
+  function registerGlobal(type, instance, diag2, allowOverride = false) {
+    var _a3;
+    const api = _global[GLOBAL_OPENTELEMETRY_API_KEY] = (_a3 = _global[GLOBAL_OPENTELEMETRY_API_KEY]) !== null && _a3 !== void 0 ? _a3 : {
+      version: VERSION
+    };
+    if (!allowOverride && api[type]) {
+      const err = new Error(`@opentelemetry/api: Attempted duplicate registration of API: ${type}`);
+      diag2.error(err.stack || err.message);
+      return false;
+    }
+    if (api.version !== VERSION) {
+      const err = new Error(`@opentelemetry/api: Registration of version v${api.version} for ${type} does not match previously registered API v${VERSION}`);
+      diag2.error(err.stack || err.message);
+      return false;
+    }
+    api[type] = instance;
+    diag2.debug(`@opentelemetry/api: Registered a global for ${type} v${VERSION}.`);
+    return true;
+  }
+  function getGlobal(type) {
+    var _a3, _b;
+    const globalVersion = (_a3 = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _a3 === void 0 ? void 0 : _a3.version;
+    if (!globalVersion || !isCompatible(globalVersion)) {
+      return;
+    }
+    return (_b = _global[GLOBAL_OPENTELEMETRY_API_KEY]) === null || _b === void 0 ? void 0 : _b[type];
+  }
+  function unregisterGlobal(type, diag2) {
+    diag2.debug(`@opentelemetry/api: Unregistering a global for ${type} v${VERSION}.`);
+    const api = _global[GLOBAL_OPENTELEMETRY_API_KEY];
+    if (api) {
+      delete api[type];
+    }
+  }
+
+  // ../../../../../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/diag/ComponentLogger.js
+  var DiagComponentLogger = class {
+    constructor(props) {
+      this._namespace = props.namespace || "DiagComponentLogger";
+    }
+    debug(...args) {
+      return logProxy("debug", this._namespace, args);
+    }
+    error(...args) {
+      return logProxy("error", this._namespace, args);
+    }
+    info(...args) {
+      return logProxy("info", this._namespace, args);
+    }
+    warn(...args) {
+      return logProxy("warn", this._namespace, args);
+    }
+    verbose(...args) {
+      return logProxy("verbose", this._namespace, args);
+    }
+  };
+  function logProxy(funcName, namespace, args) {
+    const logger = getGlobal("diag");
+    if (!logger) {
+      return;
+    }
+    return logger[funcName](namespace, ...args);
+  }
+
+  // ../../../../../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/diag/types.js
+  var DiagLogLevel;
+  (function(DiagLogLevel2) {
+    DiagLogLevel2[DiagLogLevel2["NONE"] = 0] = "NONE";
+    DiagLogLevel2[DiagLogLevel2["ERROR"] = 30] = "ERROR";
+    DiagLogLevel2[DiagLogLevel2["WARN"] = 50] = "WARN";
+    DiagLogLevel2[DiagLogLevel2["INFO"] = 60] = "INFO";
+    DiagLogLevel2[DiagLogLevel2["DEBUG"] = 70] = "DEBUG";
+    DiagLogLevel2[DiagLogLevel2["VERBOSE"] = 80] = "VERBOSE";
+    DiagLogLevel2[DiagLogLevel2["ALL"] = 9999] = "ALL";
+  })(DiagLogLevel || (DiagLogLevel = {}));
+
+  // ../../../../../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/diag/internal/logLevelLogger.js
+  function createLogLevelDiagLogger(maxLevel, logger) {
+    if (maxLevel < DiagLogLevel.NONE) {
+      maxLevel = DiagLogLevel.NONE;
+    } else if (maxLevel > DiagLogLevel.ALL) {
+      maxLevel = DiagLogLevel.ALL;
+    }
+    logger = logger || {};
+    function _filterFunc(funcName, theLevel) {
+      const theFunc = logger[funcName];
+      if (typeof theFunc === "function" && maxLevel >= theLevel) {
+        return theFunc.bind(logger);
+      }
+      return function() {
+      };
+    }
+    return {
+      error: _filterFunc("error", DiagLogLevel.ERROR),
+      warn: _filterFunc("warn", DiagLogLevel.WARN),
+      info: _filterFunc("info", DiagLogLevel.INFO),
+      debug: _filterFunc("debug", DiagLogLevel.DEBUG),
+      verbose: _filterFunc("verbose", DiagLogLevel.VERBOSE)
+    };
+  }
+
+  // ../../../../../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/api/diag.js
+  var API_NAME = "diag";
+  var DiagAPI = class _DiagAPI {
+    /** Get the singleton instance of the DiagAPI API */
+    static instance() {
+      if (!this._instance) {
+        this._instance = new _DiagAPI();
+      }
+      return this._instance;
+    }
+    /**
+     * Private internal constructor
+     * @private
+     */
+    constructor() {
+      function _logProxy(funcName) {
+        return function(...args) {
+          const logger = getGlobal("diag");
+          if (!logger)
+            return;
+          return logger[funcName](...args);
+        };
+      }
+      const self2 = this;
+      const setLogger = (logger, optionsOrLogLevel = { logLevel: DiagLogLevel.INFO }) => {
+        var _a3, _b, _c;
+        if (logger === self2) {
+          const err = new Error("Cannot use diag as the logger for itself. Please use a DiagLogger implementation like ConsoleDiagLogger or a custom implementation");
+          self2.error((_a3 = err.stack) !== null && _a3 !== void 0 ? _a3 : err.message);
+          return false;
+        }
+        if (typeof optionsOrLogLevel === "number") {
+          optionsOrLogLevel = {
+            logLevel: optionsOrLogLevel
+          };
+        }
+        const oldLogger = getGlobal("diag");
+        const newLogger = createLogLevelDiagLogger((_b = optionsOrLogLevel.logLevel) !== null && _b !== void 0 ? _b : DiagLogLevel.INFO, logger);
+        if (oldLogger && !optionsOrLogLevel.suppressOverrideMessage) {
+          const stack = (_c = new Error().stack) !== null && _c !== void 0 ? _c : "<failed to generate stacktrace>";
+          oldLogger.warn(`Current logger will be overwritten from ${stack}`);
+          newLogger.warn(`Current logger will overwrite one already registered from ${stack}`);
+        }
+        return registerGlobal("diag", newLogger, self2, true);
+      };
+      self2.setLogger = setLogger;
+      self2.disable = () => {
+        unregisterGlobal(API_NAME, self2);
+      };
+      self2.createComponentLogger = (options) => {
+        return new DiagComponentLogger(options);
+      };
+      self2.verbose = _logProxy("verbose");
+      self2.debug = _logProxy("debug");
+      self2.info = _logProxy("info");
+      self2.warn = _logProxy("warn");
+      self2.error = _logProxy("error");
+    }
+  };
+
+  // ../../../../../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/baggage/internal/baggage-impl.js
+  var BaggageImpl = class _BaggageImpl {
+    constructor(entries) {
+      this._entries = entries ? new Map(entries) : /* @__PURE__ */ new Map();
+    }
+    getEntry(key) {
+      const entry = this._entries.get(key);
+      if (!entry) {
+        return void 0;
+      }
+      return Object.assign({}, entry);
+    }
+    getAllEntries() {
+      return Array.from(this._entries.entries());
+    }
+    setEntry(key, entry) {
+      const newBaggage = new _BaggageImpl(this._entries);
+      newBaggage._entries.set(key, entry);
+      return newBaggage;
+    }
+    removeEntry(key) {
+      const newBaggage = new _BaggageImpl(this._entries);
+      newBaggage._entries.delete(key);
+      return newBaggage;
+    }
+    removeEntries(...keys) {
+      const newBaggage = new _BaggageImpl(this._entries);
+      for (const key of keys) {
+        newBaggage._entries.delete(key);
+      }
+      return newBaggage;
+    }
+    clear() {
+      return new _BaggageImpl();
+    }
+  };
+
+  // ../../../../../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/baggage/utils.js
+  var diag = DiagAPI.instance();
+  function createBaggage(entries = {}) {
+    return new BaggageImpl(new Map(Object.entries(entries)));
+  }
+
+  // ../../../../../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/context/context.js
+  function createContextKey(description) {
+    return Symbol.for(description);
+  }
+  var BaseContext = class _BaseContext {
+    /**
+     * Construct a new context which inherits values from an optional parent context.
+     *
+     * @param parentContext a context from which to inherit values
+     */
+    constructor(parentContext) {
+      const self2 = this;
+      self2._currentContext = parentContext ? new Map(parentContext) : /* @__PURE__ */ new Map();
+      self2.getValue = (key) => self2._currentContext.get(key);
+      self2.setValue = (key, value) => {
+        const context2 = new _BaseContext(self2._currentContext);
+        context2._currentContext.set(key, value);
+        return context2;
+      };
+      self2.deleteValue = (key) => {
+        const context2 = new _BaseContext(self2._currentContext);
+        context2._currentContext.delete(key);
+        return context2;
+      };
+    }
+  };
+  var ROOT_CONTEXT = new BaseContext();
+
+  // ../../../../../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/propagation/TextMapPropagator.js
+  var defaultTextMapGetter = {
+    get(carrier, key) {
+      if (carrier == null) {
+        return void 0;
+      }
+      return carrier[key];
+    },
+    keys(carrier) {
+      if (carrier == null) {
+        return [];
+      }
+      return Object.keys(carrier);
+    }
+  };
+  var defaultTextMapSetter = {
+    set(carrier, key, value) {
+      if (carrier == null) {
+        return;
+      }
+      carrier[key] = value;
+    }
+  };
+
+  // ../../../../../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/context/NoopContextManager.js
+  var NoopContextManager = class {
+    active() {
+      return ROOT_CONTEXT;
+    }
+    with(_context, fn, thisArg, ...args) {
+      return fn.call(thisArg, ...args);
+    }
+    bind(_context, target) {
+      return target;
+    }
+    enable() {
+      return this;
+    }
+    disable() {
+      return this;
+    }
+  };
+
+  // ../../../../../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/api/context.js
+  var API_NAME2 = "context";
+  var NOOP_CONTEXT_MANAGER = new NoopContextManager();
+  var ContextAPI = class _ContextAPI {
+    /** Empty private constructor prevents end users from constructing a new instance of the API */
+    constructor() {
+    }
+    /** Get the singleton instance of the Context API */
+    static getInstance() {
+      if (!this._instance) {
+        this._instance = new _ContextAPI();
+      }
+      return this._instance;
+    }
+    /**
+     * Set the current context manager.
+     *
+     * @returns true if the context manager was successfully registered, else false
+     */
+    setGlobalContextManager(contextManager) {
+      return registerGlobal(API_NAME2, contextManager, DiagAPI.instance());
+    }
+    /**
+     * Get the currently active context
+     */
+    active() {
+      return this._getContextManager().active();
+    }
+    /**
+     * Execute a function with an active context
+     *
+     * @param context context to be active during function execution
+     * @param fn function to execute in a context
+     * @param thisArg optional receiver to be used for calling fn
+     * @param args optional arguments forwarded to fn
+     */
+    with(context2, fn, thisArg, ...args) {
+      return this._getContextManager().with(context2, fn, thisArg, ...args);
+    }
+    /**
+     * Bind a context to a target function or event emitter
+     *
+     * @param context context to bind to the event emitter or function. Defaults to the currently active context
+     * @param target function or event emitter to bind
+     */
+    bind(context2, target) {
+      return this._getContextManager().bind(context2, target);
+    }
+    _getContextManager() {
+      return getGlobal(API_NAME2) || NOOP_CONTEXT_MANAGER;
+    }
+    /** Disable and remove the global context manager */
+    disable() {
+      this._getContextManager().disable();
+      unregisterGlobal(API_NAME2, DiagAPI.instance());
+    }
+  };
+
+  // ../../../../../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/trace/trace_flags.js
+  var TraceFlags;
+  (function(TraceFlags2) {
+    TraceFlags2[TraceFlags2["NONE"] = 0] = "NONE";
+    TraceFlags2[TraceFlags2["SAMPLED"] = 1] = "SAMPLED";
+  })(TraceFlags || (TraceFlags = {}));
+
+  // ../../../../../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/trace/invalid-span-constants.js
+  var INVALID_SPANID = "0000000000000000";
+  var INVALID_TRACEID = "00000000000000000000000000000000";
+  var INVALID_SPAN_CONTEXT = {
+    traceId: INVALID_TRACEID,
+    spanId: INVALID_SPANID,
+    traceFlags: TraceFlags.NONE
+  };
+
+  // ../../../../../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/trace/NonRecordingSpan.js
+  var NonRecordingSpan = class {
+    constructor(spanContext = INVALID_SPAN_CONTEXT) {
+      this._spanContext = spanContext;
+    }
+    // Returns a SpanContext.
+    spanContext() {
+      return this._spanContext;
+    }
+    // By default does nothing
+    setAttribute(_key, _value) {
+      return this;
+    }
+    // By default does nothing
+    setAttributes(_attributes) {
+      return this;
+    }
+    // By default does nothing
+    addEvent(_name, _attributes) {
+      return this;
+    }
+    addLink(_link) {
+      return this;
+    }
+    addLinks(_links) {
+      return this;
+    }
+    // By default does nothing
+    setStatus(_status) {
+      return this;
+    }
+    // By default does nothing
+    updateName(_name) {
+      return this;
+    }
+    // By default does nothing
+    end(_endTime) {
+    }
+    // isRecording always returns false for NonRecordingSpan.
+    isRecording() {
+      return false;
+    }
+    // By default does nothing
+    recordException(_exception, _time) {
+    }
+  };
+
+  // ../../../../../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/trace/context-utils.js
+  var SPAN_KEY = createContextKey("OpenTelemetry Context Key SPAN");
+  function getSpan(context2) {
+    return context2.getValue(SPAN_KEY) || void 0;
+  }
+  function getActiveSpan() {
+    return getSpan(ContextAPI.getInstance().active());
+  }
+  function setSpan(context2, span) {
+    return context2.setValue(SPAN_KEY, span);
+  }
+  function deleteSpan(context2) {
+    return context2.deleteValue(SPAN_KEY);
+  }
+  function setSpanContext(context2, spanContext) {
+    return setSpan(context2, new NonRecordingSpan(spanContext));
+  }
+  function getSpanContext(context2) {
+    var _a3;
+    return (_a3 = getSpan(context2)) === null || _a3 === void 0 ? void 0 : _a3.spanContext();
+  }
+
+  // ../../../../../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/trace/spancontext-utils.js
+  var isHex = new Uint8Array([
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    0,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1
+  ]);
+  function isValidHex(id, length) {
+    if (typeof id !== "string" || id.length !== length)
+      return false;
+    let r = 0;
+    for (let i = 0; i < id.length; i += 4) {
+      r += (isHex[id.charCodeAt(i)] | 0) + (isHex[id.charCodeAt(i + 1)] | 0) + (isHex[id.charCodeAt(i + 2)] | 0) + (isHex[id.charCodeAt(i + 3)] | 0);
+    }
+    return r === length;
+  }
+  function isValidTraceId(traceId) {
+    return isValidHex(traceId, 32) && traceId !== INVALID_TRACEID;
+  }
+  function isValidSpanId(spanId) {
+    return isValidHex(spanId, 16) && spanId !== INVALID_SPANID;
+  }
+  function isSpanContextValid(spanContext) {
+    return isValidTraceId(spanContext.traceId) && isValidSpanId(spanContext.spanId);
+  }
+  function wrapSpanContext(spanContext) {
+    return new NonRecordingSpan(spanContext);
+  }
+
+  // ../../../../../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/trace/NoopTracer.js
+  var contextApi = ContextAPI.getInstance();
+  var NoopTracer = class {
+    // startSpan starts a noop span.
+    startSpan(name, options, context2 = contextApi.active()) {
+      const root = Boolean(options === null || options === void 0 ? void 0 : options.root);
+      if (root) {
+        return new NonRecordingSpan();
+      }
+      const parentFromContext = context2 && getSpanContext(context2);
+      if (isSpanContext(parentFromContext) && isSpanContextValid(parentFromContext)) {
+        return new NonRecordingSpan(parentFromContext);
+      } else {
+        return new NonRecordingSpan();
+      }
+    }
+    startActiveSpan(name, arg2, arg3, arg4) {
+      let opts;
+      let ctx;
+      let fn;
+      if (arguments.length < 2) {
+        return;
+      } else if (arguments.length === 2) {
+        fn = arg2;
+      } else if (arguments.length === 3) {
+        opts = arg2;
+        fn = arg3;
+      } else {
+        opts = arg2;
+        ctx = arg3;
+        fn = arg4;
+      }
+      const parentContext = ctx !== null && ctx !== void 0 ? ctx : contextApi.active();
+      const span = this.startSpan(name, opts, parentContext);
+      const contextWithSpanSet = setSpan(parentContext, span);
+      return contextApi.with(contextWithSpanSet, fn, void 0, span);
+    }
+  };
+  function isSpanContext(spanContext) {
+    return spanContext !== null && typeof spanContext === "object" && "spanId" in spanContext && typeof spanContext["spanId"] === "string" && "traceId" in spanContext && typeof spanContext["traceId"] === "string" && "traceFlags" in spanContext && typeof spanContext["traceFlags"] === "number";
+  }
+
+  // ../../../../../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/trace/ProxyTracer.js
+  var NOOP_TRACER = new NoopTracer();
+  var ProxyTracer = class {
+    constructor(provider, name, version2, options) {
+      this._provider = provider;
+      this.name = name;
+      this.version = version2;
+      this.options = options;
+    }
+    startSpan(name, options, context2) {
+      return this._getTracer().startSpan(name, options, context2);
+    }
+    startActiveSpan(_name, _options, _context, _fn) {
+      const tracer = this._getTracer();
+      return Reflect.apply(tracer.startActiveSpan, tracer, arguments);
+    }
+    /**
+     * Try to get a tracer from the proxy tracer provider.
+     * If the proxy tracer provider has no delegate, return a noop tracer.
+     */
+    _getTracer() {
+      if (this._delegate) {
+        return this._delegate;
+      }
+      const tracer = this._provider.getDelegateTracer(this.name, this.version, this.options);
+      if (!tracer) {
+        return NOOP_TRACER;
+      }
+      this._delegate = tracer;
+      return this._delegate;
+    }
+  };
+
+  // ../../../../../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/trace/NoopTracerProvider.js
+  var NoopTracerProvider = class {
+    getTracer(_name, _version, _options) {
+      return new NoopTracer();
+    }
+  };
+
+  // ../../../../../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/trace/ProxyTracerProvider.js
+  var NOOP_TRACER_PROVIDER = new NoopTracerProvider();
+  var ProxyTracerProvider = class {
+    /**
+     * Get a {@link ProxyTracer}
+     */
+    getTracer(name, version2, options) {
+      var _a3;
+      return (_a3 = this.getDelegateTracer(name, version2, options)) !== null && _a3 !== void 0 ? _a3 : new ProxyTracer(this, name, version2, options);
+    }
+    getDelegate() {
+      var _a3;
+      return (_a3 = this._delegate) !== null && _a3 !== void 0 ? _a3 : NOOP_TRACER_PROVIDER;
+    }
+    /**
+     * Set the delegate tracer provider
+     */
+    setDelegate(delegate) {
+      this._delegate = delegate;
+    }
+    getDelegateTracer(name, version2, options) {
+      var _a3;
+      return (_a3 = this._delegate) === null || _a3 === void 0 ? void 0 : _a3.getTracer(name, version2, options);
+    }
+  };
+
+  // ../../../../../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/trace/status.js
+  var SpanStatusCode;
+  (function(SpanStatusCode2) {
+    SpanStatusCode2[SpanStatusCode2["UNSET"] = 0] = "UNSET";
+    SpanStatusCode2[SpanStatusCode2["OK"] = 1] = "OK";
+    SpanStatusCode2[SpanStatusCode2["ERROR"] = 2] = "ERROR";
+  })(SpanStatusCode || (SpanStatusCode = {}));
+
+  // ../../../../../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/context-api.js
+  var context = ContextAPI.getInstance();
+
+  // ../../../../../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/propagation/NoopTextMapPropagator.js
+  var NoopTextMapPropagator = class {
+    /** Noop inject function does nothing */
+    inject(_context, _carrier) {
+    }
+    /** Noop extract function does nothing and returns the input context */
+    extract(context2, _carrier) {
+      return context2;
+    }
+    fields() {
+      return [];
+    }
+  };
+
+  // ../../../../../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/baggage/context-helpers.js
+  var BAGGAGE_KEY = createContextKey("OpenTelemetry Baggage Key");
+  function getBaggage(context2) {
+    return context2.getValue(BAGGAGE_KEY) || void 0;
+  }
+  function getActiveBaggage() {
+    return getBaggage(ContextAPI.getInstance().active());
+  }
+  function setBaggage(context2, baggage) {
+    return context2.setValue(BAGGAGE_KEY, baggage);
+  }
+  function deleteBaggage(context2) {
+    return context2.deleteValue(BAGGAGE_KEY);
+  }
+
+  // ../../../../../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/api/propagation.js
+  var API_NAME3 = "propagation";
+  var NOOP_TEXT_MAP_PROPAGATOR = new NoopTextMapPropagator();
+  var PropagationAPI = class _PropagationAPI {
+    /** Empty private constructor prevents end users from constructing a new instance of the API */
+    constructor() {
+      this.createBaggage = createBaggage;
+      this.getBaggage = getBaggage;
+      this.getActiveBaggage = getActiveBaggage;
+      this.setBaggage = setBaggage;
+      this.deleteBaggage = deleteBaggage;
+    }
+    /** Get the singleton instance of the Propagator API */
+    static getInstance() {
+      if (!this._instance) {
+        this._instance = new _PropagationAPI();
+      }
+      return this._instance;
+    }
+    /**
+     * Set the current propagator.
+     *
+     * @returns true if the propagator was successfully registered, else false
+     */
+    setGlobalPropagator(propagator) {
+      return registerGlobal(API_NAME3, propagator, DiagAPI.instance());
+    }
+    /**
+     * Inject context into a carrier to be propagated inter-process
+     *
+     * @param context Context carrying tracing data to inject
+     * @param carrier carrier to inject context into
+     * @param setter Function used to set values on the carrier
+     */
+    inject(context2, carrier, setter = defaultTextMapSetter) {
+      return this._getGlobalPropagator().inject(context2, carrier, setter);
+    }
+    /**
+     * Extract context from a carrier
+     *
+     * @param context Context which the newly created context will inherit from
+     * @param carrier Carrier to extract context from
+     * @param getter Function used to extract keys from a carrier
+     */
+    extract(context2, carrier, getter = defaultTextMapGetter) {
+      return this._getGlobalPropagator().extract(context2, carrier, getter);
+    }
+    /**
+     * Return a list of all fields which may be used by the propagator.
+     */
+    fields() {
+      return this._getGlobalPropagator().fields();
+    }
+    /** Remove the global propagator */
+    disable() {
+      unregisterGlobal(API_NAME3, DiagAPI.instance());
+    }
+    _getGlobalPropagator() {
+      return getGlobal(API_NAME3) || NOOP_TEXT_MAP_PROPAGATOR;
+    }
+  };
+
+  // ../../../../../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/propagation-api.js
+  var propagation = PropagationAPI.getInstance();
+
+  // ../../../../../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/api/trace.js
+  var API_NAME4 = "trace";
+  var TraceAPI = class _TraceAPI {
+    /** Empty private constructor prevents end users from constructing a new instance of the API */
+    constructor() {
+      this._proxyTracerProvider = new ProxyTracerProvider();
+      this.wrapSpanContext = wrapSpanContext;
+      this.isSpanContextValid = isSpanContextValid;
+      this.deleteSpan = deleteSpan;
+      this.getSpan = getSpan;
+      this.getActiveSpan = getActiveSpan;
+      this.getSpanContext = getSpanContext;
+      this.setSpan = setSpan;
+      this.setSpanContext = setSpanContext;
+    }
+    /** Get the singleton instance of the Trace API */
+    static getInstance() {
+      if (!this._instance) {
+        this._instance = new _TraceAPI();
+      }
+      return this._instance;
+    }
+    /**
+     * Set the current global tracer.
+     *
+     * @returns true if the tracer provider was successfully registered, else false
+     */
+    setGlobalTracerProvider(provider) {
+      const success = registerGlobal(API_NAME4, this._proxyTracerProvider, DiagAPI.instance());
+      if (success) {
+        this._proxyTracerProvider.setDelegate(provider);
+      }
+      return success;
+    }
+    /**
+     * Returns the global tracer provider.
+     */
+    getTracerProvider() {
+      return getGlobal(API_NAME4) || this._proxyTracerProvider;
+    }
+    /**
+     * Returns a tracer from the global tracer provider.
+     */
+    getTracer(name, version2) {
+      return this.getTracerProvider().getTracer(name, version2);
+    }
+    /** Remove the global tracer provider */
+    disable() {
+      unregisterGlobal(API_NAME4, DiagAPI.instance());
+      this._proxyTracerProvider = new ProxyTracerProvider();
+    }
+  };
+
+  // ../../../../../../node_modules/.pnpm/@opentelemetry+api@1.9.1/node_modules/@opentelemetry/api/build/esm/trace-api.js
+  var trace = TraceAPI.getInstance();
+
+  // ../../../../../../node_modules/.pnpm/@opentelemetry+core@2.9.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/core/build/esm/common/time.js
+  var NANOSECOND_DIGITS = 9;
+  var NANOSECOND_DIGITS_IN_MILLIS = 6;
+  var MILLISECONDS_TO_NANOSECONDS = Math.pow(10, NANOSECOND_DIGITS_IN_MILLIS);
+  var SECOND_TO_NANOSECONDS = Math.pow(10, NANOSECOND_DIGITS);
+  function hrTimeToMicroseconds(time2) {
+    return time2[0] * 1e6 + time2[1] / 1e3;
+  }
+
+  // ../../../../../../node_modules/.pnpm/@opentelemetry+core@2.9.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/core/build/esm/ExportResult.js
+  var ExportResultCode;
+  (function(ExportResultCode2) {
+    ExportResultCode2[ExportResultCode2["SUCCESS"] = 0] = "SUCCESS";
+    ExportResultCode2[ExportResultCode2["FAILED"] = 1] = "FAILED";
+  })(ExportResultCode || (ExportResultCode = {}));
+
+  // ../../../../../../node_modules/.pnpm/@opentelemetry+sdk-trace@2.9.0_@opentelemetry+api@1.9.1/node_modules/@opentelemetry/sdk-trace/build/esm/export/ConsoleSpanExporter.js
+  var ConsoleSpanExporter = class {
+    /**
+     * Export spans.
+     * @param spans
+     * @param resultCallback
+     */
+    export(spans, resultCallback) {
+      return this._sendSpans(spans, resultCallback);
+    }
+    /**
+     * Shutdown the exporter.
+     */
+    shutdown() {
+      this._sendSpans([]);
+      return this.forceFlush();
+    }
+    /**
+     * Exports any pending spans in exporter
+     */
+    forceFlush() {
+      return Promise.resolve();
+    }
+    /**
+     * converts span info into more readable format
+     * @param span
+     */
+    _exportInfo(span) {
+      return {
+        resource: {
+          attributes: span.resource.attributes
+        },
+        instrumentationScope: span.instrumentationScope,
+        traceId: span.spanContext().traceId,
+        parentSpanContext: span.parentSpanContext,
+        traceState: span.spanContext().traceState?.serialize(),
+        name: span.name,
+        id: span.spanContext().spanId,
+        kind: span.kind,
+        timestamp: hrTimeToMicroseconds(span.startTime),
+        duration: hrTimeToMicroseconds(span.duration),
+        attributes: span.attributes,
+        status: span.status,
+        events: span.events,
+        links: span.links
+      };
+    }
+    /**
+     * Showing spans in console
+     * @param spans
+     * @param done
+     */
+    _sendSpans(spans, done) {
+      for (const span of spans) {
+        console.dir(this._exportInfo(span), { depth: 3 });
+      }
+      if (done) {
+        return done({ code: ExportResultCode.SUCCESS });
+      }
+    }
+  };
+
+  // ../../../../../../node_modules/.pnpm/@ariestools+sdk@7.0.8_@opentelemetry+api@1.9.1_@opentelemetry+sdk-trace-base@2.9.0_@ope_649172f6a3c2e5736d1bf5bb5ca2adbf/node_modules/@ariestools/sdk/dist/browser/index.mjs
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __decorateClass = (decorators, target, key, kind) => {
+    var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+    for (var i = decorators.length - 1, decorator; i >= 0; i--)
+      if (decorator = decorators[i])
+        result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+    if (kind && result) __defProp(target, key, result);
+    return result;
+  };
+  var Enum = (obj) => {
+    return obj;
+  };
+  var ApiStage = Enum({
+    Beta: "beta",
+    Local: "local",
+    Prod: "prod"
+  });
+  var fetchErrorMarker = "$$xylabs-fetch-error";
+  var codeTypes = {
+    ENOTFOUND: "dns",
+    EAI_AGAIN: "dns",
+    ECONNREFUSED: "connection-refused",
+    ECONNRESET: "connection-reset",
+    EPIPE: "connection-reset",
+    ETIMEDOUT: "connection-timeout",
+    UND_ERR_CONNECT_TIMEOUT: "connection-timeout",
+    UND_ERR_HEADERS_TIMEOUT: "timeout",
+    UND_ERR_BODY_TIMEOUT: "timeout",
+    EHOSTUNREACH: "unreachable",
+    ENETUNREACH: "unreachable",
+    CERT_HAS_EXPIRED: "tls",
+    DEPTH_ZERO_SELF_SIGNED_CERT: "tls",
+    UNABLE_TO_VERIFY_LEAF_SIGNATURE: "tls",
+    SELF_SIGNED_CERT_IN_CHAIN: "tls",
+    ERR_TLS_CERT_ALTNAME_INVALID: "tls"
+  };
+  function findErrorCode(error) {
+    let current = error;
+    for (let depth = 0; depth < 8 && current instanceof Error; depth++) {
+      const code = current.code;
+      if (typeof code === "string") return code;
+      current = current.cause;
+    }
+    return void 0;
+  }
+  function typeFromCode(code) {
+    if (Object.hasOwn(codeTypes, code)) return codeTypes[code];
+    if (code.startsWith("CERT_") || code.startsWith("ERR_TLS_")) return "tls";
+    return void 0;
+  }
+  function classifyFetchError(error) {
+    if (error instanceof Error) {
+      if (error.name === "TimeoutError") return { type: "timeout" };
+      if (error.name === "AbortError") return { type: "aborted" };
+    }
+    const code = findErrorCode(error);
+    if (code !== void 0) {
+      const type = typeFromCode(code);
+      if (type !== void 0) return { type, code };
+      return { type: "unknown", code };
+    }
+    if (error instanceof TypeError && /fetch failed|failed to fetch|network/i.test(error.message)) {
+      return { type: "network" };
+    }
+    return { type: "unknown" };
+  }
+  var FetchError = class extends Error {
+    __fetchErrorMarker = fetchErrorMarker;
+    body;
+    code;
+    method;
+    response;
+    status;
+    statusText;
+    type;
+    url;
+    constructor(message, context2 = {}) {
+      super(message, { cause: context2.cause });
+      this.name = "FetchError";
+      this.type = context2.type ?? "unknown";
+      this.code = context2.code;
+      this.url = context2.url;
+      this.method = context2.method;
+      this.status = context2.status;
+      this.statusText = context2.statusText;
+      this.response = context2.response;
+      this.body = context2.body;
+    }
+    toJSON() {
+      return {
+        name: this.name,
+        message: this.message,
+        type: this.type,
+        code: this.code,
+        url: this.url,
+        method: this.method,
+        status: this.status,
+        statusText: this.statusText
+      };
+    }
+  };
+  function isFetchError(value) {
+    return value instanceof FetchError || typeof value === "object" && value !== null && value.__fetchErrorMarker === fetchErrorMarker;
+  }
+  function toFetchError(error, context2 = {}) {
+    if (isFetchError(error)) return error;
+    const { type, code } = classifyFetchError(error);
+    const message = error instanceof Error ? error.message : String(error);
+    return new FetchError(message, {
+      ...context2,
+      type,
+      code,
+      cause: error
+    });
+  }
+  async function gzipString(body) {
+    const blob = new Blob([body]);
+    const stream = blob.stream().pipeThrough(new CompressionStream("gzip"));
+    const response = new Response(stream);
+    return response.arrayBuffer();
+  }
+  async function fetchCompress(url, options = {}) {
+    const { compressMinLength = 1024, ...init } = options;
+    try {
+      if (init.body !== void 0 && init.body !== null) {
+        const bodyStr = typeof init.body === "string" ? init.body : JSON.stringify(init.body);
+        if (bodyStr.length > compressMinLength) {
+          const headers = new Headers(init.headers);
+          headers.set("Content-Encoding", "gzip");
+          return await fetch(url, {
+            ...init,
+            body: await gzipString(bodyStr),
+            headers
+          });
+        }
+      }
+      return await fetch(url, init);
+    } catch (error) {
+      throw toFetchError(error, { url: url.toString(), method: init.method });
+    }
+  }
+  async function parseJsonResponse(response, context2 = {}) {
+    let text;
+    try {
+      text = await response.text();
+    } catch (error) {
+      throw toFetchError(error, context2);
+    }
+    if (text.trim() === "") return null;
+    try {
+      return JSON.parse(text);
+    } catch (error) {
+      throw new FetchError("Failed to parse response body as JSON", {
+        type: "parse",
+        url: context2.url,
+        method: context2.method,
+        status: response.status,
+        statusText: response.statusText,
+        body: text,
+        cause: error
+      });
+    }
+  }
+  async function tryParseJson(response) {
+    try {
+      const text = await response.text();
+      if (text.trim() === "") return null;
+      return JSON.parse(text);
+    } catch {
+      return null;
+    }
+  }
+  var FetchClientError = class extends FetchError {
+    config;
+    constructor(message, response, config2) {
+      super(message, {
+        type: "http-status",
+        url: config2.url,
+        method: config2.method,
+        status: response.status,
+        statusText: response.statusText,
+        response
+      });
+      this.name = "FetchClientError";
+      this.config = config2;
+    }
+  };
+  function buildHeaders(custom, includeContentType = false) {
+    const headers = new Headers();
+    headers.set("Accept", "application/json, text/plain, *.*");
+    if (includeContentType) {
+      headers.set("Content-Type", "application/json");
+    }
+    if (custom) {
+      const merged = new Headers(custom);
+      for (const [key, value] of merged.entries()) headers.set(key, value);
+    }
+    return headers;
+  }
+  function buildURL(config2) {
+    const base = config2.baseURL ?? "";
+    const path = config2.url ?? "";
+    const url = base === "" ? new URL(path) : new URL(path, base);
+    if (config2.params) {
+      for (const [key, value] of Object.entries(config2.params)) {
+        url.searchParams.set(key, value);
+      }
+    }
+    return url.href;
+  }
+  var FetchClient = class _FetchClient {
+    defaults;
+    constructor(defaults = {}) {
+      this.defaults = defaults;
+    }
+    static create(config2) {
+      return new _FetchClient(config2);
+    }
+    delete(url, config2) {
+      return this.request({
+        ...config2,
+        url,
+        method: "DELETE"
+      });
+    }
+    get(url, config2) {
+      return this.request({
+        ...config2,
+        url,
+        method: "GET"
+      });
+    }
+    patch(url, data, config2) {
+      return this.request({
+        ...config2,
+        url,
+        data,
+        method: "PATCH"
+      });
+    }
+    post(url, data, config2) {
+      return this.request({
+        ...config2,
+        url,
+        data,
+        method: "POST"
+      });
+    }
+    put(url, data, config2) {
+      return this.request({
+        ...config2,
+        url,
+        data,
+        method: "PUT"
+      });
+    }
+    async request(config2) {
+      const merged = { ...this.defaults, ...config2 };
+      const url = buildURL(merged);
+      const init = {
+        method: merged.method ?? "GET",
+        headers: buildHeaders(merged.headers, merged.data !== void 0),
+        compressMinLength: merged.compressMinLength,
+        signal: merged.timeout !== void 0 && merged.timeout !== 0 ? AbortSignal.timeout(merged.timeout) : merged.signal
+      };
+      if (merged.data !== void 0) {
+        init.body = JSON.stringify(merged.data);
+      }
+      const response = await fetchCompress(url, init);
+      const data = response.ok ? await parseJsonResponse(response, { url, method: merged.method }) : await tryParseJson(response);
+      const result = {
+        data,
+        headers: response.headers,
+        response,
+        status: response.status,
+        statusText: response.statusText
+      };
+      const validateStatus = merged.validateStatus === void 0 ? (s) => s >= 200 && s < 300 : merged.validateStatus;
+      if (validateStatus && !validateStatus(response.status)) {
+        throw new FetchClientError(
+          `Request failed with status ${response.status} ${response.statusText}`,
+          result,
+          { ...merged, url }
+        );
+      }
+      return result;
+    }
+  };
+  var FetchJsonClient = class _FetchJsonClient extends FetchClient {
+    constructor(config2) {
+      super(config2);
+    }
+    static create(config2) {
+      return new _FetchJsonClient(config2);
+    }
+  };
+  var fetchJsonClient = new FetchJsonClient();
+  function isUndefined(value) {
+    return value === void 0;
+  }
+  function isDefined(value) {
+    return !isUndefined(value);
+  }
+  function isString(value) {
+    return typeof value === "string";
+  }
+  function isNumber(value) {
+    return typeof value === "number";
+  }
+  function isObject2(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+  }
+  function isTruthy(value) {
+    return !!value;
+  }
+  function isError(value) {
+    return value instanceof Error;
+  }
+  function isPromise(value) {
+    return value instanceof Promise;
+  }
+  function assertDefinedEx(expr, func) {
+    if (expr !== void 0) return expr;
+    if (typeof func === "function") {
+      const errorOrMessage = func(expr);
+      throw typeof errorOrMessage === "string" ? new Error(errorOrMessage) : errorOrMessage;
+    }
+    if (func !== void 0) {
+      throw new Error("Invalid assertDefinedEx usage: second argument must be a function or undefined");
+    }
+    throw new Error("Assertion failed: value is undefined");
+  }
+  function assertEx(expr, func) {
+    if (expr !== void 0 && expr !== null && expr !== false && expr !== 0 && expr !== "" && expr !== 0n) return expr;
+    if (typeof func === "function") {
+      const errorOrMessage = func(expr);
+      throw typeof errorOrMessage === "string" ? new Error(errorOrMessage) : errorOrMessage;
+    }
+    if (func !== void 0) {
+      throw new Error("Invalid assertEx usage: second argument must be a function or undefined");
+    }
+    throw new Error("Assertion failed");
+  }
+  var HexRegExMinMax = (minBytes = 0, maxBytes = Number.MAX_SAFE_INTEGER / 2) => {
+    return new RegExp(`^[a-f0-9]{${minBytes * 2},${maxBytes * 2}}$`);
+  };
+  var HexRegExMinMaxMixedCaseWithPrefix = (minBytes = 0, maxBytes = Number.MAX_SAFE_INTEGER / 2) => {
+    return new RegExp(`^0x[a-fA-F0-9]{${minBytes * 2},${maxBytes * 2}}$`);
+  };
+  var HexRegEx = /^[0-9a-f]+$/;
+  var HexRegExWithPrefix = /^0x[0-9a-f]+$/;
+  var ADDRESS_LENGTH = 40;
+  var AddressRegEx = HexRegExMinMax(ADDRESS_LENGTH / 2, ADDRESS_LENGTH / 2);
+  var AddressZod = pipe(
+    string2().check(_regex(AddressRegEx)),
+    transform((v) => v)
+  );
+  var assertError = (value, assert, defaultMessage) => {
+    if (!isUndefined(assert)) {
+      const assertString = typeof assert === "string" ? assert : typeof assert === "boolean" ? defaultMessage : assert(value, defaultMessage);
+      if (isString(assertString) || assertString) {
+        throw new Error(assertString === true ? defaultMessage : assertString);
+      }
+    }
+    return void 0;
+  };
+  var handleError = (error, handler) => {
+    if (isError(error)) {
+      return handler(error);
+    }
+    throw error;
+  };
+  var bitsToNibbles = (value) => {
+    const nibbles = value >> 2;
+    if (value !== nibbles << 2) throw new Error("Bits for nibbles must multiple of 4");
+    return nibbles;
+  };
+  var isHex2 = (value, config2) => {
+    if (typeof value !== "string") return false;
+    const valueCharLength = value.length - (config2?.prefix === true ? 2 : 0);
+    if (config2?.bitLength !== void 0 && valueCharLength !== bitsToNibbles(config2?.bitLength)) return false;
+    const regex5 = config2?.prefix === true ? HexRegExWithPrefix : HexRegEx;
+    return regex5.test(value);
+  };
+  var hexFromHexString = (value, config2 = {}) => {
+    const {
+      prefix: isPrefix = false,
+      byteSize = 8,
+      bitLength
+    } = config2;
+    const nibbleBoundary = bitsToNibbles(byteSize);
+    const unEvened = (value.startsWith("0x") ? value.slice(2) : value).toLowerCase();
+    if (isHex2(unEvened)) {
+      const evenCharacters = unEvened.padStart(Math.ceil(unEvened.length / nibbleBoundary) * nibbleBoundary, "0");
+      const padded = isNumber(bitLength) ? evenCharacters.padStart(bitLength / 4, "0") : evenCharacters;
+      return (isPrefix ? `0x${padded}` : padded).toLowerCase();
+    }
+    throw new Error("Received string is not a value hex");
+  };
+  var hexFromArrayBuffer = (buffer, config2) => {
+    const unPadded = [...new Uint8Array(buffer)].map((x) => x.toString(16).padStart(2, "0")).join("");
+    return hexFromHexString(unPadded, config2);
+  };
+  var hexFromBigInt = (value, config2 = {}) => {
+    const unPadded = value.toString(16);
+    return hexFromHexString(unPadded, config2);
+  };
+  var hexFromNumber = (value, config2) => {
+    return hexFromBigInt(BigInt(value), config2);
+  };
+  var hexFrom = (value, config2) => {
+    switch (typeof value) {
+      case "string": {
+        return hexFromHexString(value, config2);
+      }
+      case "bigint": {
+        return hexFromBigInt(value, config2);
+      }
+      case "number": {
+        return hexFromNumber(value, config2);
+      }
+      case "object": {
+        return hexFromArrayBuffer(value, config2);
+      }
+      default: {
+        throw new Error(`Invalid type: ${typeof value}`);
+      }
+    }
+  };
+  var HexZod = pipe(
+    string2().check(_regex(HexRegEx, { error: "Invalid hex format" })),
+    transform((val) => val)
   );
   var toHex = (value, config2 = {}) => {
     const { prefix: isPrefix = false } = config2;
     return hexFrom(value, { prefix: isPrefix, ...config2 });
   };
-  var AddressValidationZod = pipe(
-    string2().check(
-      refine((x) => HexZod.safeParse(x).success),
-      refine((x) => x.length === ADDRESS_LENGTH, { error: (e) => new Error(`Address must have 40 characters [${String(e.input)}]`) })
-    ),
-    transform((v) => v)
-  );
-  var AddressTransformZod = pipe(
-    pipe(
-      union([string2(), bigint2(), number2()]),
-      transform((value) => {
-        if (typeof value === "bigint") {
-          return value.toString(16).padStart(ADDRESS_LENGTH, "0");
+  var AddressValidationZod = pipe(
+    string2().check(
+      refine((x) => HexZod.safeParse(x).success),
+      refine((x) => x.length === ADDRESS_LENGTH, { error: (e) => new Error(`Address must have 40 characters [${String(e.input)}]`) })
+    ),
+    transform((v) => v)
+  );
+  var AddressTransformZod = pipe(
+    pipe(
+      union([string2(), bigint2(), number2()]),
+      transform((value) => {
+        if (typeof value === "bigint") {
+          return value.toString(16).padStart(ADDRESS_LENGTH, "0");
+        }
+        if (typeof value === "string") {
+          return value.startsWith("0x") ? value.slice(2) : value;
+        }
+        return BigInt(value).toString(16).padStart(ADDRESS_LENGTH, "0");
+      })
+    ).check(refine((x) => AddressValidationZod.safeParse(x).success)),
+    transform((x) => x)
+  );
+  var EthAddressRegEx = HexRegExMinMaxMixedCaseWithPrefix(20, 20);
+  var EthAddressToStringZod = string2().check(_regex(EthAddressRegEx));
+  var EthAddressFromStringZod = pipe(
+    string2().check(_regex(EthAddressRegEx)),
+    transform((v) => toEthAddress(v))
+  );
+  var toEthAddress = (value, config2 = {}) => {
+    const { bitLength = 160, prefix: isPrefix = false } = config2;
+    return `0x${hexFrom(value, {
+      bitLength,
+      prefix: isPrefix,
+      ...config2
+    })}`;
+  };
+  var isEthAddress = (value, config2 = {}) => {
+    const { bitLength = 160, prefix: isPrefix = true } = config2;
+    const loweredValue = typeof value === "string" ? value.toLowerCase() : value;
+    return isHex2(loweredValue, { bitLength, prefix: isPrefix });
+  };
+  var EthAddressZod = string2().check(
+    _regex(EthAddressRegEx, { error: "Invalid address format" }),
+    refine(isEthAddress)
+  );
+  var isHash = (value, bitLength = 256) => {
+    return isHex2(value, { bitLength });
+  };
+  function asHash(value, assert) {
+    switch (typeof value) {
+      case "string": {
+        const stringValue = hexFromHexString(value);
+        return isHash(stringValue) ? stringValue : assertError(value, assert, `Value is not a Hash [${value}]`);
+      }
+      default: {
+        return isUndefined(assert) ? void 0 : assertError(value, assert, `Unsupported type [${typeof value}]`);
+      }
+    }
+  }
+  var HASH_LENGTH = 32;
+  var HashRegEx = HexRegExMinMax(HASH_LENGTH, HASH_LENGTH);
+  var HashZod = pipe(
+    string2().check(_regex(HashRegEx, { error: "Invalid hex format" })),
+    transform((val) => val)
+  );
+  var HashToJsonZod = pipe(HashZod, transform((v) => v));
+  var JsonToHashZod = pipe(string2(), transform((v) => asHash(v, true)));
+  function hexToBigInt(hex) {
+    return BigInt(hexFromHexString(hex, { prefix: true }));
+  }
+  var BigIntToJsonZod = pipe(
+    bigint2().check(_nonnegative()),
+    transform((x) => toHex(x))
+  );
+  var JsonToBigIntZod = pipe(
+    string2(),
+    transform((x) => hexToBigInt(toHex(x)))
+  );
+  var DEFAULT_HISTORY_INTERVAL = 1e3 * 5;
+  var DEFAULT_HISTORY_TIME = 60 * 60 * 1e3;
+  var MAX_GC_FREQUENCY = 1e3 * 60;
+  var MIN_GC_FREQUENCY = 1e3;
+  var MIN_HISTORY_INTERVAL = 1e3;
+  var Base = class _Base {
+    static defaultLogger;
+    static globalInstances = {};
+    static globalInstancesCountHistory = {};
+    static _historyInterval = DEFAULT_HISTORY_INTERVAL;
+    static _historyTime = DEFAULT_HISTORY_TIME;
+    static _historyTimeout;
+    static _lastGC = 0;
+    static _maxGcFrequency = MAX_GC_FREQUENCY;
+    _params;
+    constructor(params) {
+      this._params = params;
+      params?.logger?.debug(`Base constructed [${this.constructor.name}]`);
+      this.recordInstance();
+    }
+    static get historyInterval() {
+      return this._historyInterval;
+    }
+    static set historyInterval(value) {
+      assertEx(value <= this.historyTime, () => `historyInterval [${value}] must be less than or equal to historyTime [${this.historyTime}]`);
+      this._historyInterval = Math.max(value, MIN_HISTORY_INTERVAL);
+    }
+    static get historyTime() {
+      return this._historyTime;
+    }
+    static set historyTime(value) {
+      assertEx(value >= this.historyInterval, () => `historyTime [${value}] must be greater than or equal to historyInterval [${this.historyInterval}]`);
+      this._historyInterval = value;
+    }
+    static get maxGcFrequency() {
+      return this._maxGcFrequency;
+    }
+    static set maxGcFrequency(value) {
+      this._maxGcFrequency = Math.max(value, MIN_GC_FREQUENCY);
+    }
+    static get maxHistoryDepth() {
+      return Math.floor(this.historyTime / this.historyInterval);
+    }
+    get logger() {
+      return this.params?.logger ?? _Base.defaultLogger;
+    }
+    get meter() {
+      return this.params?.meterProvider?.getMeter(this.constructor.name);
+    }
+    get params() {
+      return this._params;
+    }
+    get tracer() {
+      return this.params?.traceProvider?.getTracer(this.constructor.name);
+    }
+    static gc(classNameOrForce = false) {
+      if (typeof classNameOrForce === "string") {
+        this.gcClass(classNameOrForce);
+      } else {
+        if (classNameOrForce || Date.now() - this._lastGC > this._maxGcFrequency) {
+          this.gcAll();
+        }
+      }
+    }
+    static instanceCount(className) {
+      return this.globalInstances[className]?.length ?? 0;
+    }
+    static instanceCounts() {
+      this.gc();
+      const result = {};
+      for (const [className, instances] of Object.entries(this.globalInstances)) result[className] = instances.length;
+      return result;
+    }
+    static startHistory() {
+      if (this._historyTimeout !== void 0) {
+        this.stopHistory();
+      }
+      const timeoutHandler = () => {
+        if (this._historyTimeout === void 0) {
+          return;
+        }
+        this.addToHistory();
+        this._historyTimeout = setTimeout(timeoutHandler, this.historyInterval);
+      };
+      this._historyTimeout = setTimeout(timeoutHandler, this.historyInterval);
+    }
+    static stopHistory() {
+      if (this._historyTimeout === void 0) {
+        return;
+      }
+      clearTimeout(this._historyTimeout);
+      this._historyTimeout = void 0;
+    }
+    static addToHistory() {
+      const counts = this.instanceCounts();
+      for (const className of Object.keys(this.globalInstances)) {
+        this.globalInstancesCountHistory[className] = this.globalInstancesCountHistory[className]?.slice(-this.maxHistoryDepth) ?? [];
+        this.globalInstancesCountHistory[className].push(counts[className]);
+      }
+    }
+    static gcAll() {
+      for (const className of Object.keys(this.globalInstances)) {
+        this.gcClass(className);
+      }
+    }
+    static gcClass(className) {
+      this.globalInstances[className] = this.globalInstances[className]?.filter((ref) => ref.deref() !== null) ?? [];
+    }
+    recordInstance() {
+      const baseClassName = this.constructor.name;
+      const instanceArray = _Base.globalInstances[baseClassName] ?? [];
+      instanceArray.push(new WeakRef(this));
+      _Base.globalInstances[baseClassName] = instanceArray;
+    }
+  };
+  var defaultForgetConfig = { timeout: 3e4 };
+  var defaultForgetNodeConfig = {
+    ...defaultForgetConfig,
+    terminateOnTimeout: false,
+    terminateOnException: false
+  };
+  var TimerScheduler = class {
+    currentTimeout;
+    interval = -1;
+    timeouts = [];
+    /**
+     * Cancels a timeout previously created with setTimeoutEx.
+     * @param id - The timeout ID returned by setTimeoutEx.
+     */
+    clearTimeoutEx(id) {
+      this.timeouts = this.timeouts.filter((timeout) => timeout.id !== id);
+      this.update(this.timeouts);
+    }
+    /** Clears all scheduled timeouts and resets internal state. */
+    reset() {
+      this.interval = -1;
+      clearTimeout(this.currentTimeout);
+      this.currentTimeout = void 0;
+      this.timeouts = [];
+    }
+    /**
+     * Sets a timeout using an optimized internal timer that coalesces multiple timeouts into a single native timer.
+     * @param func - The function to call after the delay.
+     * @param delay - The delay in milliseconds (must be >= 0).
+     * @returns A unique string ID that can be used with clearTimeoutEx to cancel the timeout.
+     */
+    setTimeoutEx(func, delay2) {
+      assertEx(delay2 >= 0, () => "delay must be >= 0");
+      const id = `${Date.now()}|${Math.random() * 9999999999}`;
+      this.timeouts.push({
+        delay: delay2,
+        func,
+        id
+      });
+      this.update();
+      return id;
+    }
+    timerFunc() {
+      const notFiring = this.timeouts.filter((timeout) => timeout.delay > this.interval);
+      const firing = this.timeouts.filter((timeout) => timeout.delay <= this.interval);
+      this.update(notFiring, this.interval);
+      for (const timeout of firing) {
+        timeout.func();
+      }
+    }
+    update(newTimeouts = this.timeouts, delayPassed = 0) {
+      if (newTimeouts.length === 0) {
+        this.reset();
+      } else {
+        const newInterval = Math.min(...newTimeouts.map((timeout) => timeout.delay));
+        if (newInterval === this.interval && this.currentTimeout !== void 0) {
+          return;
+        }
+        clearTimeout(this.currentTimeout);
+        this.timeouts = newTimeouts.map((timeout) => ({
+          delay: timeout.delay - delayPassed,
+          func: timeout.func,
+          id: timeout.id
+        }));
+        this.interval = newInterval;
+        this.currentTimeout = setTimeout(() => this.timerFunc(), this.interval);
+      }
+    }
+  };
+  var defaultTimerScheduler = new TimerScheduler();
+  var setTimeoutEx = (func, delay2) => defaultTimerScheduler.setTimeoutEx(func, delay2);
+  var delay = (ms) => {
+    return new Promise((resolve) => setTimeoutEx(() => resolve(), ms));
+  };
+  var ForgetPromise = class {
+    /**
+     * Number of forgotten promises still running (not yet settled).
+     * Decremented only when the underlying promise fulfills or rejects — not when a timeout fires.
+     */
+    static activeForgets = 0;
+    /** Number of forgotten promises that threw exceptions. */
+    static exceptedForgets = 0;
+    /** Logger instance used for error and warning output. */
+    static logger = console;
+    /** Whether any forgotten promises are still running, including any that have exceeded their timeout. */
+    static get active() {
+      return this.activeForgets > 0;
+    }
+    /**
+     * Waits until all forgotten promises have settled.
+     * @param interval - Polling interval in milliseconds.
+     * @param timeout - Optional maximum wait time in milliseconds.
+     * @returns `0` when every forgotten promise has settled; otherwise the number still running.
+     * A non-zero return after `timeout` elapses can include promises whose timeout callback already
+     * ran but whose work is still in flight.
+     */
+    static async awaitInactive(interval = 100, timeout) {
+      let timeoutRemaining = timeout;
+      while (this.active) {
+        await delay(interval);
+        if (timeoutRemaining !== void 0) {
+          timeoutRemaining -= interval;
+          if (timeoutRemaining <= 0) {
+            return this.activeForgets;
+          }
+        }
+      }
+      return 0;
+    }
+    /** Handles exceptions from forgotten promises by logging error details. */
+    static exceptionHandler(error, { name }, externalStackTrace) {
+      this.logger.error(`forget promise handler excepted [${name}]: ${error.message}`, error);
+      if (externalStackTrace !== void 0) {
+        this.logger.warn(`External Stack trace [${name}]:`, externalStackTrace);
+      }
+    }
+    /**
+     * Used to explicitly launch an async function (or Promise) with awaiting it
+     * @param promise The promise to forget
+     * @param config Configuration of forget settings
+     */
+    static forget(promise, config2) {
+      const stackError = new Error("Stack");
+      const externalStackTrace = stackError.stack;
+      const resolvedConfig = {
+        ...defaultForgetConfig,
+        ...globalThis.xy?.forget?.config,
+        ...config2
+      };
+      const resolvedPromise2 = typeof promise === "function" ? promise() : promise;
+      if (isPromise(resolvedPromise2)) {
+        try {
+          let isCompleted = false;
+          this.activeForgets++;
+          const promiseWrapper = async () => {
+            try {
+              const result = await resolvedPromise2;
+              this.activeForgets--;
+              isCompleted = true;
+              resolvedConfig?.onComplete?.([result, void 0]);
+            } catch (error) {
+              const caughtError = error instanceof Error ? error : new Error(String(error));
+              this.activeForgets--;
+              isCompleted = true;
+              this.logger.error(`forgotten promise excepted [${config2?.name ?? "unknown"}]: ${caughtError.message}`, caughtError);
+              resolvedConfig?.onComplete?.([void 0, caughtError]);
+            }
+          };
+          const promises = [promiseWrapper()];
+          const timeout = resolvedConfig.timeout ?? defaultForgetConfig.timeout;
+          if (isNumber(timeout)) {
+            const timeoutFunc = async () => {
+              await delay(timeout);
+              if (!isCompleted) {
+                resolvedConfig.onCancel?.();
+                this.timeoutHandler(timeout, resolvedConfig, externalStackTrace);
+              }
+            };
+            promises.push(timeoutFunc());
+          }
+          const race = Promise.race(promises);
+          void race.catch(() => {
+          });
+        } catch (ex) {
+          this.exceptedForgets += 1;
+          resolvedConfig?.onException?.(ex);
+          this.exceptionHandler(ex, resolvedConfig, externalStackTrace);
+        }
+      } else {
+        return;
+      }
+    }
+    /**
+     * Handles timeout events for forgotten promises by logging timeout details.
+     * Does not terminate the underlying promise; it may continue running after this is called.
+     */
+    static timeoutHandler(time2, { name = "unknown" }, externalStackTrace) {
+      this.logger.error(`forget promise timed out after ${time2}ms [still running] [${name}]`);
+      if (externalStackTrace !== void 0) {
+        this.logger.warn(`External Stack trace [${name}]:`, externalStackTrace);
+      }
+    }
+  };
+  var ForgetPromiseNode = class extends ForgetPromise {
+    /** Handles exceptions, optionally terminating the process based on config. */
+    static exceptionHandler(error, config2, externalStackTrace) {
+      super.exceptionHandler(error, config2, externalStackTrace);
+      if (config2?.terminateOnException === true) {
+        this.logger.error(`Attempting to terminate process [${config2?.name ?? "unknown"}]...`);
+        process.exit(1);
+      }
+    }
+    /** Forgets a promise using Node.js-specific configuration with process termination support. */
+    static forget(promise, config2) {
+      const resolvedConfig = {
+        ...defaultForgetNodeConfig,
+        ...globalThis.xy?.forget?.config,
+        ...config2
+      };
+      super.forget(promise, resolvedConfig);
+    }
+    /** Handles timeouts, optionally terminating the process based on config. */
+    static timeoutHandler(time2, config2, externalStackTrace) {
+      super.timeoutHandler(time2, config2, externalStackTrace);
+      if (config2?.terminateOnTimeout === true) {
+        this.logger.error(`Attempting to terminate process [${config2?.name ?? "unknown"}]...`);
+        process.exit(2);
+      }
+    }
+  };
+  var forgetNode = (promise, config2) => {
+    ForgetPromiseNode.forget(promise, config2);
+  };
+  var NO_META_EVENT_ERROR_MESSAGE = "`eventName` cannot be meta event `listenerAdded` or `listenerRemoved`";
+  var processGlobal = globalThis;
+  var resolvedPromise = Promise.resolve();
+  var isMetaEvent = (eventName) => eventName === "listenerAdded" || eventName === "listenerRemoved";
+  var Events = class _Events extends Base {
+    static anyMap = /* @__PURE__ */ new WeakMap();
+    static eventsMap = /* @__PURE__ */ new WeakMap();
+    static isGlobalDebugEnabled = false;
+    // this is here to be able to query the type, not use
+    eventData = {};
+    _canEmitMetaEvents = false;
+    constructor(params = {}) {
+      const mutatedParams = { ...params };
+      if (mutatedParams.debug) {
+        mutatedParams.debug.logger ??= (type, debugName, eventName, eventData) => {
+          let eventDataString;
+          try {
+            eventDataString = JSON.stringify(eventData);
+          } catch {
+            eventDataString = `Object with the following keys failed to stringify: ${Object.keys(eventData ?? {}).join(",")}`;
+          }
+          const eventNameString = typeof eventName === "symbol" || typeof eventName === "number" ? eventName.toString() : eventName;
+          const currentTime = /* @__PURE__ */ new Date();
+          const logTime = `${currentTime.getHours()}:${currentTime.getMinutes()}:${currentTime.getSeconds()}.${currentTime.getMilliseconds()}`;
+          this.logger?.log(`[${logTime}][events:${type}][${debugName}] Event Name: ${eventNameString}
+	data: ${eventDataString}`);
+        };
+      }
+      super(mutatedParams);
+      _Events.anyMap.set(this, /* @__PURE__ */ new Set());
+      _Events.eventsMap.set(this, /* @__PURE__ */ new Map());
+    }
+    /** Whether debug mode is enabled globally or via the DEBUG environment variable. */
+    static get isDebugEnabled() {
+      if (typeof processGlobal.process?.env !== "object") {
+        return this.isGlobalDebugEnabled;
+      }
+      const env = processGlobal.process?.env;
+      return env?.DEBUG === "events" || env?.DEBUG === "*" || this.isGlobalDebugEnabled;
+    }
+    static set isDebugEnabled(newValue) {
+      this.isGlobalDebugEnabled = newValue;
+    }
+    /** The debug configuration for this instance, if provided. */
+    get debug() {
+      return this.params.debug;
+    }
+    /**
+     * Removes all listeners for the specified event name(s).
+     * @param eventNames - One or more event names to clear listeners for.
+     */
+    clearListeners(eventNames) {
+      const eventNamesArray = Array.isArray(eventNames) ? eventNames : [eventNames];
+      for (const eventName of eventNamesArray) {
+        this.logIfDebugEnabled("clear", eventName);
+        if (typeof eventName === "string" || typeof eventName === "symbol" || typeof eventName === "number") {
+          const set = this.getListeners(eventName);
+          if (set) {
+            set.clear();
+          }
+        } else {
+          _Events.anyMap.get(this)?.clear();
+          const eventEntries = assertEx(_Events.eventsMap.get(this));
+          for (const [eventName2, listeners] of eventEntries) {
+            listeners.clear();
+            _Events.eventsMap.get(this)?.delete(eventName2);
+          }
+        }
+      }
+    }
+    /**
+     * Emits an event, invoking all registered listeners concurrently.
+     * @param eventName - The event to emit.
+     * @param eventArgs - The data to pass to listeners.
+     */
+    async emit(eventName, eventArgs) {
+      return await this.emitInternal(eventName, eventArgs);
+    }
+    /**
+     * Emits an internal meta event (listenerAdded or listenerRemoved).
+     * @param eventName - The meta event name.
+     * @param eventArgs - The meta event data containing listener and event information.
+     * @returns True if the meta event was emitted successfully.
+     */
+    async emitMetaEvent(eventName, eventArgs) {
+      if (isMetaEvent(eventName)) {
+        try {
+          this._canEmitMetaEvents = true;
+          await this.emitMetaEventInternal(eventName, eventArgs);
+          return true;
+        } finally {
+          this._canEmitMetaEvents = false;
+        }
+      }
+    }
+    /**
+     * Emits an event, invoking all registered listeners sequentially in order.
+     * @param eventName - The event to emit.
+     * @param eventArgs - The data to pass to listeners.
+     */
+    async emitSerial(eventName, eventArgs) {
+      if (isMetaEvent(eventName) && !this._canEmitMetaEvents) {
+        throw new TypeError(NO_META_EVENT_ERROR_MESSAGE);
+      }
+      const filterMatch = (args, filter) => {
+        switch (typeof filter) {
+          case "object": {
+            if (filter === null || args === null || typeof args !== "object") return args === filter;
+            return Object.entries(args).reduce((prev, [key, value]) => filter[key] === value ? true : prev, false);
+          }
+          default: {
+            return args === filter;
+          }
+        }
+      };
+      this.logIfDebugEnabled("emitSerial", eventName, eventArgs);
+      const listeners = this.getListeners(eventName) ?? /* @__PURE__ */ new Set();
+      const filteredListeners = [...listeners].filter((value) => isDefined(value.filter) ? filterMatch(eventArgs, value.filter) : true).map((info) => info.listener);
+      const anyListeners = assertEx(_Events.anyMap.get(this));
+      const staticListeners = [...filteredListeners];
+      const staticAnyListeners = [...anyListeners];
+      await resolvedPromise;
+      for (const listener of staticListeners) {
+        await this.safeCallListener(eventName, eventArgs, listener);
+      }
+      for (const listener of staticAnyListeners) {
+        await this.safeCallAnyListener(eventName, eventArgs, listener);
+      }
+    }
+    /**
+     * Returns the total number of listeners registered for the specified event name(s).
+     * @param eventNames - One or more event names to count listeners for.
+     * @returns The total listener count.
+     */
+    // TODO: Make test for this
+    listenerCount(eventNames) {
+      const eventNamesArray = Array.isArray(eventNames) ? eventNames : [eventNames];
+      let count = 0;
+      for (const eventName of eventNamesArray) {
+        if (typeof eventName === "string") {
+          count += assertEx(_Events.anyMap.get(this)).size + (this.getListeners(eventName)?.size ?? 0);
+          continue;
+        }
+        count += assertEx(_Events.anyMap.get(this)).size;
+        const eventListeners = assertEx(_Events.eventsMap.get(this)).values();
+        for (const value of eventListeners) {
+          count += value.size;
+        }
+      }
+      return count;
+    }
+    /**
+     * Logs debug information if debug mode is enabled.
+     * @param type - The type of operation being logged.
+     * @param eventName - The event name, if applicable.
+     * @param eventArgs - The event data, if applicable.
+     */
+    logIfDebugEnabled(type, eventName, eventArgs) {
+      if (_Events.isDebugEnabled || this.debug?.enabled === true) {
+        this.debug?.logger?.(type, this.debug.name, eventName, eventArgs);
+      }
+    }
+    /**
+     * Removes a specific listener from the specified event name(s).
+     * @param eventNames - One or more event names to unsubscribe from.
+     * @param listener - The listener to remove.
+     */
+    off(eventNames, listener) {
+      const eventNamesArray = Array.isArray(eventNames) ? eventNames : [eventNames];
+      for (const eventName of eventNamesArray) {
+        const set = this.getListeners(eventName);
+        if (set) {
+          set.delete(listener);
+          if (set.size === 0) {
+            const events = _Events.eventsMap.get(this);
+            events?.delete(eventName);
+          }
+        }
+        this.logIfDebugEnabled("unsubscribe", eventName);
+        if (!isMetaEvent(eventName)) {
+          forgetNode(this.emitMetaEvent("listenerRemoved", { eventName, listener }));
+        }
+      }
+    }
+    /**
+     * Removes a wildcard listener that was receiving all events.
+     * @param listener - The wildcard listener to remove.
+     */
+    offAny(listener) {
+      this.logIfDebugEnabled("unsubscribeAny");
+      const typedMap = _Events.anyMap.get(this);
+      typedMap?.delete(listener);
+      forgetNode(this.emitMetaEvent("listenerRemoved", { listener }));
+    }
+    /**
+     * Subscribes a listener to the specified event name(s).
+     * @param eventNames - One or more event names to listen for.
+     * @param listener - The callback to invoke when the event fires.
+     * @param filter - Optional filter to selectively invoke the listener based on event data.
+     * @returns An unsubscribe function.
+     */
+    on(eventNames, listener, filter) {
+      const eventNamesArray = Array.isArray(eventNames) ? eventNames : [eventNames];
+      for (const eventName of eventNamesArray) {
+        let set = this.getListeners(eventName);
+        if (!set) {
+          set = /* @__PURE__ */ new Set();
+          const events = _Events.eventsMap.get(this);
+          events?.set(eventName, set);
+        }
+        set.add({ filter, listener });
+        this.logIfDebugEnabled("subscribe", eventName);
+        if (!isMetaEvent(eventName)) {
+          forgetNode(this.emitMetaEvent("listenerAdded", { eventName, listener }));
+        }
+      }
+      return this.off.bind(this, eventNames, listener);
+    }
+    /**
+     * Subscribes a wildcard listener that receives all events.
+     * @param listener - The callback to invoke for any event.
+     * @returns An unsubscribe function.
+     */
+    onAny(listener) {
+      this.logIfDebugEnabled("subscribeAny");
+      _Events.anyMap.get(this)?.add(listener);
+      forgetNode(this.emitMetaEvent("listenerAdded", { listener }));
+      return this.offAny.bind(this, listener);
+    }
+    /**
+     * Subscribes a listener that will be invoked only once for the specified event, then automatically removed.
+     * @param eventName - The event to listen for.
+     * @param listener - The callback to invoke once.
+     * @returns An unsubscribe function.
+     */
+    once(eventName, listener) {
+      const subListener = async (args) => {
+        this.off(eventName, subListener);
+        await this.safeCallListener(eventName, args, listener);
+      };
+      this.on(eventName, subListener);
+      return this.off.bind(this, eventName, subListener);
+    }
+    async emitInternal(eventName, eventArgs, filter) {
+      if (isMetaEvent(eventName) && !this._canEmitMetaEvents) {
+        throw new TypeError(NO_META_EVENT_ERROR_MESSAGE);
+      }
+      this.logIfDebugEnabled("emit", eventName, eventArgs);
+      const listeners = this.getListeners(eventName) ?? /* @__PURE__ */ new Set();
+      const filteredListeners = [...listeners].filter((value) => isDefined(filter) ? isDefined(value.listener) : true).map((info) => info.listener);
+      const anyListeners = assertEx(_Events.anyMap.get(this));
+      const staticListeners = [...filteredListeners];
+      const staticAnyListeners = isMetaEvent(eventName) ? [] : [...anyListeners];
+      await resolvedPromise;
+      await Promise.all([
+        ...staticListeners.map(async (listener) => {
+          await this.safeCallListener(eventName, eventArgs, listener);
+        }),
+        ...staticAnyListeners.map(async (listener) => {
+          if (anyListeners.has(listener)) {
+            await this.safeCallAnyListener(eventName, eventArgs, listener);
+          }
+        })
+      ]);
+    }
+    async emitMetaEventInternal(eventName, eventArgs) {
+      if (isMetaEvent(eventName) && !this._canEmitMetaEvents) {
+        throw new TypeError("`eventName` cannot be meta event `listenerAdded` or `listenerRemoved`");
+      }
+      this.logIfDebugEnabled("emit", eventName, eventArgs);
+      const listeners = this.getListeners(eventName) ?? /* @__PURE__ */ new Set();
+      const filteredListeners = [...listeners].map((info) => info.listener);
+      const anyListeners = assertEx(_Events.anyMap.get(this));
+      const staticListeners = [...filteredListeners];
+      const staticAnyListeners = isMetaEvent(eventName) ? [] : [...anyListeners];
+      await resolvedPromise;
+      await Promise.all([
+        ...staticListeners.map(async (listener) => {
+          await this.safeCallListener(eventName, eventArgs, listener);
+        }),
+        /* v8 ignore start -- race condition guard */
+        ...staticAnyListeners.map(async (listener) => {
+          if (anyListeners.has(listener)) {
+            await this.safeCallAnyListener(eventName, eventArgs, listener);
+          }
+        })
+        /* v8 ignore stop */
+      ]);
+      return true;
+    }
+    getListeners(eventName) {
+      const events = assertEx(_Events.eventsMap.get(this));
+      if (!events.has(eventName)) {
+        return;
+      }
+      return events.get(eventName);
+    }
+    async safeCallAnyListener(eventName, eventArgs, listener) {
+      try {
+        return await listener(eventName, eventArgs);
+      } catch (ex) {
+        handleError(ex, (error) => {
+          this.logger?.error(`Listener[${String(eventName)}] Excepted: ${error.message}`);
+        });
+      }
+    }
+    async safeCallListener(eventName, eventArgs, listener) {
+      try {
+        return await listener(eventArgs);
+      } catch (ex) {
+        handleError(ex, (error) => {
+          this.logger?.error(`Listener[${String(eventName)}] Excepted: ${error.message}`);
+        });
+      }
+    }
+  };
+  var BaseEmitter = class extends Base {
+    // just here to query types
+    eventData = {};
+    events;
+    constructor(params) {
+      super(params);
+      this.events = new Events();
+    }
+    /**
+     * Removes all listeners for the specified event name(s).
+     * @param eventNames - One or more event names to clear listeners for.
+     * @returns This instance for chaining.
+     */
+    clearListeners(eventNames) {
+      this.events.clearListeners(eventNames);
+      return this;
+    }
+    /**
+     * Emits an event, invoking all registered listeners concurrently.
+     * @param eventName - The event to emit.
+     * @param eventArgs - The data to pass to listeners.
+     */
+    emit(eventName, eventArgs) {
+      return this.events.emit(eventName, eventArgs);
+    }
+    /**
+     * Emits an event, invoking all registered listeners sequentially in order.
+     * @param eventName - The event to emit.
+     * @param eventArgs - The data to pass to listeners.
+     */
+    emitSerial(eventName, eventArgs) {
+      return this.events.emitSerial(eventName, eventArgs);
+    }
+    /**
+     * Returns the total number of listeners registered for the specified event name(s).
+     * @param eventNames - One or more event names to count listeners for.
+     * @returns The total listener count.
+     */
+    listenerCount(eventNames) {
+      return this.events.listenerCount(eventNames);
+    }
+    /**
+     * Removes a specific listener from the specified event name(s).
+     * @param eventNames - One or more event names to unsubscribe from.
+     * @param listener - The listener to remove.
+     */
+    off(eventNames, listener) {
+      return this.events.off(eventNames, listener);
+    }
+    /**
+     * Removes a wildcard listener that was receiving all events.
+     * @param listener - The wildcard listener to remove.
+     */
+    offAny(listener) {
+      return this.events.offAny(listener);
+    }
+    /**
+     * Subscribes a listener to the specified event name(s).
+     * @param eventNames - One or more event names to listen for.
+     * @param listener - The callback to invoke when the event fires.
+     * @returns An unsubscribe function.
+     */
+    on(eventNames, listener) {
+      return this.events.on(eventNames, listener);
+    }
+    /**
+     * Subscribes a wildcard listener that receives all events.
+     * @param listener - The callback to invoke for any event.
+     * @returns An unsubscribe function.
+     */
+    onAny(listener) {
+      return this.events.onAny(listener);
+    }
+    /**
+     * Subscribes a listener that will be invoked only once for the specified event, then automatically removed.
+     * @param eventName - The event to listen for.
+     * @param listener - The callback to invoke once.
+     * @returns An unsubscribe function.
+     */
+    once(eventName, listener) {
+      return this.events.once(eventName, listener);
+    }
+  };
+  async function timeBudget(name, logger, func, budget, status = false) {
+    const start = Date.now();
+    const timer = status ? setInterval(() => {
+      const duration22 = Date.now() - start;
+      if (budget > 0 && duration22 > budget) {
+        logger?.warn(`Function [${name}] execution is exceeding budget: ${duration22}ms > ${budget}ms`);
+      }
+    }, Math.max(100, budget)) : void 0;
+    const result = await func();
+    const duration2 = Date.now() - start;
+    if (timer === void 0 && budget > 0 && duration2 > budget) {
+      logger?.warn(`Function [${name}] execution exceeded budget: ${duration2}ms > ${budget}ms`);
+    }
+    if (timer !== void 0) {
+      clearInterval(timer);
+    }
+    return result;
+  }
+  function cloneContextWithoutSpan(activeCtx, configKeys = []) {
+    let newCtx = ROOT_CONTEXT;
+    const baggage = propagation.getBaggage(activeCtx);
+    if (baggage) {
+      newCtx = propagation.setBaggage(newCtx, baggage);
+    }
+    for (const key of configKeys) {
+      const value = activeCtx.getValue(key);
+      if (value !== void 0) {
+        newCtx = newCtx.setValue(key, value);
+      }
+    }
+    return newCtx;
+  }
+  function spanRoot(name, fn, tracer) {
+    const activeTracer = tracer ?? trace.getTracer(name);
+    if (isDefined(activeTracer)) {
+      const activeContext = context.active();
+      const noSpanContext = cloneContextWithoutSpan(activeContext);
+      const span2 = activeTracer.startSpan(name, {}, noSpanContext);
+      return context.with(trace.setSpan(noSpanContext, span2), () => {
+        try {
+          const result = fn();
+          span2.setStatus({ code: SpanStatusCode.OK });
+          return result;
+        } catch (ex) {
+          const error = ex;
+          span2.recordException(error);
+          span2.setStatus({ code: SpanStatusCode.ERROR, message: error.message });
+          throw ex;
+        } finally {
+          span2.end();
         }
-        if (typeof value === "string") {
-          return value.startsWith("0x") ? value.slice(2) : value;
+      });
+    }
+    return fn();
+  }
+  async function spanRootAsync(name, fn, {
+    timeBudgetLimit,
+    logger,
+    tracer
+  } = {}) {
+    const funcToRun = isDefined(timeBudgetLimit) ? () => timeBudget(name, logger ?? console, fn, timeBudgetLimit) : fn;
+    const activeTracer = tracer ?? trace.getTracer(name);
+    if (isDefined(activeTracer)) {
+      const activeContext = context.active();
+      const noSpanContext = cloneContextWithoutSpan(activeContext);
+      const span2 = activeTracer.startSpan(name, {}, noSpanContext);
+      return await context.with(trace.setSpan(noSpanContext, span2), async () => {
+        try {
+          const result = await funcToRun();
+          span2.setStatus({ code: SpanStatusCode.OK });
+          return result;
+        } catch (ex) {
+          const error = ex;
+          span2.recordException(error);
+          span2.setStatus({ code: SpanStatusCode.ERROR, message: error.message });
+          throw ex;
+        } finally {
+          span2.end();
         }
-        return BigInt(value).toString(16).padStart(ADDRESS_LENGTH, "0");
-      })
-    ).check(refine((x) => AddressValidationZod.safeParse(x).success)),
-    transform((x) => x)
-  );
-  var EthAddressRegEx = HexRegExMinMaxMixedCaseWithPrefix(20, 20);
-  var EthAddressToStringZod = string2().check(_regex(EthAddressRegEx));
-  var EthAddressFromStringZod = pipe(
-    string2().check(_regex(EthAddressRegEx)),
-    transform((v) => toEthAddress(v))
-  );
-  var toEthAddress = (value, config2 = {}) => {
-    const { bitLength = 160, prefix: isPrefix = false } = config2;
-    return `0x${hexFrom(value, {
-      bitLength,
-      prefix: isPrefix,
-      ...config2
-    })}`;
+      });
+    }
+    return await funcToRun();
+  }
+  function creatable() {
+    return (constructor) => {
+      constructor;
+    };
+  }
+  var Factory = class _Factory {
+    /** The Creatable class this factory delegates creation to. */
+    creatable;
+    /** Default parameters merged into every `create` call. */
+    defaultParams;
+    /** Labels identifying resources created by this factory. */
+    labels;
+    constructor(creatable2, params, labels = {}) {
+      this.creatable = creatable2;
+      this.defaultParams = params;
+      this.labels = Object.assign({}, creatable2.labels ?? {}, labels ?? {});
+    }
+    /**
+     * Creates a new Factory instance with the given default params and labels.
+     * @param creatableModule - The Creatable class to wrap
+     * @param params - Default parameters for new instances
+     * @param labels - Labels to assign to created instances
+     */
+    static withParams(creatableModule, params, labels = {}) {
+      return new _Factory(creatableModule, params, labels);
+    }
+    /**
+     * Creates a new instance, merging the provided params over the factory defaults.
+     * @param params - Optional parameters to override the factory defaults
+     */
+    create(params) {
+      const mergedParams = {
+        ...this.defaultParams,
+        ...params
+      };
+      return this.creatable.create(mergedParams);
+    }
   };
-  var isEthAddress = (value, config2 = {}) => {
-    const { bitLength = 160, prefix: isPrefix = true } = config2;
-    const loweredValue = typeof value === "string" ? value.toLowerCase() : value;
-    return isHex(loweredValue, { bitLength, prefix: isPrefix });
+  function getFunctionName(depth = 2) {
+    const error = new Error("Stack");
+    let newIndex;
+    const stackParts = error.stack?.split("\n")[depth]?.split(" ");
+    const funcName = stackParts?.find((item, index) => {
+      if (!(item.length > 0 && item !== "at")) {
+        return;
+      }
+      if (item === "new") {
+        newIndex = index;
+      }
+      return true;
+    }) ?? "<unknown>";
+    return isNumber(newIndex) ? `${funcName} ${stackParts?.[newIndex + 1]}` : funcName;
+  }
+  var getPrototype = (value) => {
+    const prototype = Object.getPrototypeOf(value);
+    return typeof prototype === "object" ? prototype : null;
   };
-  var EthAddressZod = string2().check(
-    _regex(EthAddressRegEx, { error: "Invalid address format" }),
-    refine(isEthAddress)
-  );
-  var isHash = (value, bitLength = 256) => {
-    return isHex(value, { bitLength });
+  function getRootFunction(obj, funcName) {
+    if (obj === null || typeof obj !== "object") return void 0;
+    let current = obj;
+    let prototype = getPrototype(current);
+    while (prototype !== null && prototype[funcName] !== void 0) {
+      current = prototype;
+      prototype = getPrototype(current);
+    }
+    return current[funcName];
+  }
+  var AbstractCreatableConstructorKey = /* @__PURE__ */ Symbol.for("AbstractCreatableConstructor");
+  var CREATABLE_NOT_STARTED = "Creatable not Started";
+  var AbstractCreatable = class extends BaseEmitter {
+    /** Optional default logger for this instance. */
+    defaultLogger;
+    _startPromise;
+    _status = null;
+    _statusMutex = new Mutex();
+    _validatedParams;
+    constructor(key, params) {
+      assertEx(key === AbstractCreatableConstructorKey, () => "AbstractCreatable should not be instantiated directly, use the static create method instead");
+      super(params);
+    }
+    /** The name identifier for this creatable instance. */
+    get name() {
+      return this.params.name;
+    }
+    /** The validated and merged parameters for this instance. */
+    get params() {
+      this._validatedParams ??= this.paramsValidator(super.params);
+      return this._validatedParams;
+    }
+    /** Whether this instance can be started (must be in 'created' or 'stopped' status). */
+    get startable() {
+      return this.status === "created" || this.status === "stopped";
+    }
+    /** The current lifecycle status of this instance, or null if not yet initialized. */
+    get status() {
+      return this._status;
+    }
+    /** The status reporter used to broadcast lifecycle changes. */
+    get statusReporter() {
+      return this.params.statusReporter;
+    }
+    /**
+     * Asynchronously creates a new instance by processing params, constructing,
+     * and running both static and instance createHandlers.
+     * @param inParams - Optional partial parameters to configure the instance
+     * @returns The fully initialized instance
+     */
+    static async create(inParams = {}) {
+      const params = await this.paramsHandler(inParams);
+      const name = params.name ?? this.name;
+      try {
+        const [Constructor] = [this];
+        const instance = new Constructor(AbstractCreatableConstructorKey, params);
+        instance.setStatus("creating");
+        const initializedInstance = await this.createHandler(instance);
+        await instance.createHandler();
+        instance.setStatus("created");
+        return initializedInstance;
+      } catch (ex) {
+        params.statusReporter?.report(name, "error", isError(ex) ? ex : new Error(`Error creating: ${name}`));
+        params.logger?.error(`Error creating creatable [${name}]: ${isError(ex) ? `${ex.message} ${ex.stack}` : String(ex)}`);
+        throw isError(ex) ? ex : new Error(`Error creating: ${name}`);
+      }
+    }
+    /**
+     * Static hook called during creation to perform additional initialization.
+     * Override in subclasses to customize post-construction setup.
+     * @param instance - The newly constructed instance
+     * @returns The instance, potentially modified
+     */
+    static createHandler(instance) {
+      return instance;
+    }
+    /**
+     * Static hook called during creation to validate and transform params.
+     * Override in subclasses to add default values or validation.
+     * @param params - The raw partial params provided to `create`
+     * @returns The processed params ready for construction
+     */
+    static paramsHandler(params = {}) {
+      return { ...params };
+    }
+    /** Instance-level creation hook. Override in subclasses to perform setup after construction. */
+    createHandler() {
+      assertEx(this._status === "creating", () => `createHandler can not be called [status = ${this.status}]`);
+    }
+    /**
+     * Validates and returns the merged params, ensuring required fields are present.
+     * Override in subclasses to add custom validation logic.
+     * @param params - The raw partial params to validate
+     * @returns The validated params
+     */
+    paramsValidator(params) {
+      return { ...params, name: params.name };
+    }
+    /**
+     * Executes a function within a telemetry span.
+     * @param name - The span name
+     * @param fn - The function to execute within the span
+     */
+    span(name, fn) {
+      return spanRoot(name, fn, this.tracer);
+    }
+    /**
+     * Executes an async function within a telemetry span.
+     * @param name - The span name
+     * @param fn - The async function to execute within the span
+     * @param config - Optional span configuration
+     */
+    async spanAsync(name, fn, config2 = {}) {
+      return await spanRootAsync(name, fn, {
+        ...config2,
+        tracer: config2.tracer ?? this.tracer,
+        logger: config2.logger ?? this.defaultLogger
+      });
+    }
+    /**
+     * Starts the instance, transitioning through 'starting' to 'started' status.
+     * Thread-safe via mutex. Returns true if already started or started successfully.
+     */
+    async start() {
+      this._noOverride("start");
+      if (this.status === "started") {
+        return true;
+      }
+      return await this._statusMutex.runExclusive(async () => {
+        try {
+          if (this.status === "started") {
+            return true;
+          }
+          assertEx(this.startable, () => `Creatable [${this.name}] is not startable in status [${this.status}]`);
+          this.setStatus("starting");
+          await this.startHandler();
+          this.setStatus("started");
+          return true;
+        } catch (ex) {
+          this.setStatus("error", isError(ex) ? ex : new Error(`Error starting: ${String(ex)}`));
+          this.logger?.error(`Error starting creatable [${this.name}]: ${isError(ex) ? `${ex.message} ${ex.stack}` : String(ex)}`);
+          return false;
+        }
+      });
+    }
+    /**
+     * Checks whether this instance is currently started.
+     * Takes an action if not started, based on the notStartedAction parameter.
+     * @param notStartedAction - What to do if not started: 'error'/'throw' throws, 'warn'/'log' logs, 'none' is silent
+     * @returns True if started, false otherwise
+     */
+    started(notStartedAction = "log") {
+      if (isString(this.status) && this.status === "started") {
+        return true;
+      }
+      const message = () => `${CREATABLE_NOT_STARTED} [${this.name}] current state: ${this.status}`;
+      switch (notStartedAction) {
+        case "error": {
+          throw new Error(message());
+        }
+        case "throw": {
+          throw new Error(message());
+        }
+        case "warn": {
+          this.logger?.warn(message());
+          break;
+        }
+        case "log": {
+          this.logger?.log(message());
+          break;
+        }
+        case "none": {
+          break;
+        }
+        default: {
+          throw new Error(`Unknown notStartedAction: ${notStartedAction}`);
+        }
+      }
+      return false;
+    }
+    /**
+     * Async version of `started` that can optionally auto-start the instance.
+     * @param notStartedAction - What to do if not started and auto-start is disabled
+     * @param tryStart - If true, attempts to start the instance automatically
+     * @returns True if the instance is or becomes started
+     */
+    async startedAsync(notStartedAction = "log", tryStart = true) {
+      if (isString(this.status) && this.status === "started") {
+        return true;
+      }
+      if (this.status !== null && ["created", "stopped", "starting"].includes(this.status)) {
+        this._startPromise ??= (async () => {
+          if (tryStart) {
+            try {
+              return await this.start();
+            } finally {
+              this._startPromise = void 0;
+            }
+          }
+          return this.started(notStartedAction);
+        })();
+      } else {
+        const message = `${CREATABLE_NOT_STARTED} [${this.name}] current state: ${this.status}`;
+        throw new Error(message);
+      }
+      if (isUndefined(this._startPromise)) {
+        throw new Error(`Failed to create start promise: ${this.status}`);
+      }
+      return await this._startPromise;
+    }
+    /**
+     * Stops the instance, transitioning through 'stopping' to 'stopped' status.
+     * Thread-safe via mutex. Returns true if already stopped or stopped successfully.
+     */
+    async stop() {
+      this._noOverride("stop");
+      if (this.status === "stopped") {
+        return true;
+      }
+      return await this._statusMutex.runExclusive(async () => {
+        try {
+          if (this.status === "stopped") {
+            return true;
+          }
+          assertEx(this.status === "started", () => `Creatable [${this.name}] is not stoppable in status [${this.status}]`);
+          this.setStatus("stopping");
+          await this.stopHandler();
+          this.setStatus("stopped");
+          return true;
+        } catch (ex) {
+          this.setStatus("error", isError(ex) ? ex : new Error(`Error stopping: ${String(ex)}`));
+          return false;
+        }
+      });
+    }
+    /**
+     * Asserts that the given function has not been overridden in a subclass.
+     * Used to enforce the handler pattern (override `startHandler` not `start`).
+     */
+    _noOverride(functionName2 = getFunctionName(3)) {
+      const thisFunc = this[functionName2];
+      const rootFunc = getRootFunction(this, functionName2);
+      assertEx(thisFunc === rootFunc, () => `Override not allowed for [${functionName2}] - override ${functionName2}Handler instead`);
+    }
+    setStatus(value, progressOrError) {
+      this._status = value;
+      if (value !== null) {
+        if (value === "error") {
+          if (isError(progressOrError)) {
+            this.statusReporter?.report(this.name, value, progressOrError);
+            return;
+          }
+        } else {
+          if (isNumber(progressOrError)) {
+            this.statusReporter?.report(this.name, value, progressOrError);
+            return;
+          }
+        }
+        this.statusReporter?.report(this.name, value);
+      }
+    }
+    /** Override in subclasses to define start behavior. Throw an error on failure. */
+    startHandler() {
+    }
+    /** Override in subclasses to define stop behavior. Throw an error on failure. */
+    stopHandler() {
+    }
   };
-  function asHash(value, assert) {
-    switch (typeof value) {
-      case "string": {
-        const stringValue = hexFromHexString(value);
-        return isHash(stringValue) ? stringValue : assertError(value, assert, `Value is not a Hash [${value}]`);
+  AbstractCreatable = __decorateClass([
+    creatable()
+  ], AbstractCreatable);
+  var AbstractCreatableWithFactory = class extends AbstractCreatable {
+    /**
+     * Creates a factory that produces instances of this class with pre-configured params and labels.
+     * @param params - Default parameters for instances created by the factory
+     * @param labels - Labels to assign to created instances
+     */
+    static factory(params, labels) {
+      return Factory.withParams(this, params, labels);
+    }
+  };
+  AbstractCreatableWithFactory = __decorateClass([
+    creatable()
+  ], AbstractCreatableWithFactory);
+  var LogLevel = Enum({
+    error: 1,
+    warn: 2,
+    info: 3,
+    log: 4,
+    debug: 5,
+    trace: 6
+  });
+  var AsTypeFactory = {
+    create: (typeCheck) => {
+      const func = (value, assertOrConfig, config2) => {
+        const isPredicate = typeof assertOrConfig === "number";
+        const resolvedAssert = isPredicate || typeof assertOrConfig === "object" ? void 0 : assertOrConfig;
+        const resolvedConfig = isPredicate ? void 0 : typeof assertOrConfig === "object" ? assertOrConfig : config2;
+        const isRequired = isTruthy(resolvedConfig?.required);
+        if (!isRequired && (value === void 0 || value === null)) {
+          return void 0;
+        }
+        if (isPromise(value)) {
+          throw new TypeError('un-awaited promises may not be sent to "as" functions');
+        }
+        const result = typeCheck(value, resolvedConfig) ? value : void 0;
+        if (resolvedAssert !== void 0) {
+          const message = typeof resolvedAssert === "function" ? resolvedAssert : () => resolvedAssert;
+          return assertDefinedEx(result, message);
+        }
+        return result;
+      };
+      return func;
+    },
+    createOptional: (typeCheck) => {
+      const func = (value) => {
+        if (value === void 0 || value === null) return void 0;
+        if (isPromise(value)) {
+          throw new TypeError('un-awaited promises may not be sent to "as" functions');
+        }
+        return typeCheck(value) ? value : void 0;
+      };
+      return func;
+    }
+  };
+  var AsObjectFactory = {
+    create: (typeCheck) => {
+      return AsTypeFactory.create(typeCheck);
+    },
+    createOptional: (typeCheck) => {
+      return AsTypeFactory.createOptional(typeCheck);
+    }
+  };
+  var asAnyObject = (() => AsObjectFactory.create((obj) => isObject2(obj)))();
+  var isUnsafeKey = (key) => typeof key === "string" && ["__proto__", "constructor", "prototype"].includes(key);
+  var isPlainObject2 = (value) => {
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+  };
+  function merge(target, source, options) {
+    if (!source || typeof source !== "object") return target;
+    for (const key of Reflect.ownKeys(source)) {
+      if (isUnsafeKey(key)) {
+        continue;
       }
-      default: {
-        return isUndefined(assert) ? void 0 : assertError(value, assert, `Unsupported type [${typeof value}]`);
+      const value = source[key];
+      if (Array.isArray(value)) {
+        const targetValue = target[key];
+        target[key] = options?.arrayStrategy === "concat" && Array.isArray(targetValue) ? [...targetValue, ...value] : value;
+      } else if (value !== null && typeof value === "object" && isPlainObject2(value)) {
+        const targetValue = target[key];
+        if (targetValue === void 0 || targetValue === null || typeof targetValue !== "object" || !isPlainObject2(targetValue)) {
+          target[key] = {};
+        }
+        merge(target[key], value, options);
+      } else {
+        target[key] = value;
       }
     }
+    return target;
   }
-  var HASH_LENGTH = 32;
-  var HashRegEx = HexRegExMinMax(HASH_LENGTH, HASH_LENGTH);
-  var HashZod = pipe(
-    string2().check(_regex(HashRegEx, { error: "Invalid hex format" })),
-    transform((val) => val)
-  );
-  var HashToJsonZod = pipe(HashZod, transform((v) => v));
-  var JsonToHashZod = pipe(string2(), transform((v) => asHash(v, true)));
-  function hexToBigInt(hex) {
-    return BigInt(hexFromHexString(hex, { prefix: true }));
+  function createDeepMerge(options) {
+    return function deepMerge2(...objects) {
+      const result = options.mutate === true ? objects[0] ?? {} : {};
+      for (const obj of objects) {
+        merge(result, obj, options);
+      }
+      return result;
+    };
   }
-  var BigIntToJsonZod = pipe(
-    bigint2().check(_nonnegative()),
-    transform((x) => toHex(x))
-  );
-  var JsonToBigIntZod = pipe(
+  var deepMerge = createDeepMerge({ arrayStrategy: "overwrite", mutate: false });
+  var formatZodValue = (value) => {
+    const json = JSON.stringify(value);
+    return json ?? String(value);
+  };
+  function zodAsFactory(zod, name) {
+    function asFunc(value, assert) {
+      const result = safeParse(zod, value);
+      if (result.success) {
+        return value;
+      }
+      if (assert !== void 0) {
+        let assertConfig;
+        switch (typeof assert) {
+          case "string": {
+            assertConfig = `[${name}][${formatZodValue(value)}] ${assert}`;
+            break;
+          }
+          case "object": {
+            assertConfig = `[${name}][${assert.name}][${formatZodValue(value)}] ${result.error.message}`;
+            break;
+          }
+          case "boolean": {
+            assertConfig = `[${name}][${formatZodValue(value)}] ${result.error.message}`;
+            break;
+          }
+          case "function": {
+            assertConfig = assert(value, result.error.message);
+            break;
+          }
+        }
+        return assertError(value, assertConfig, result.error.message);
+      }
+    }
+    return asFunc;
+  }
+  function zodIsFactory(zod) {
+    return (value) => safeParse(zod, value).success;
+  }
+  function zodToFactory(zod, name) {
+    const as = zodAsFactory(zod, name);
+    function toFunc(value, assert) {
+      if (isDefined(assert)) {
+        return as(value, assert);
+      }
+      return as(value);
+    }
+    return toFunc;
+  }
+  var JsonArrayZod = array(_lazy(() => JsonValueZod));
+  var JsonValueZod = _lazy(() => union([
     string2(),
-    transform((x) => hexToBigInt(toHex(x)))
-  );
+    number2(),
+    boolean2(),
+    _null3(),
+    array(JsonValueZod),
+    record(string2(), JsonValueZod)
+    // object with string keys and JSON values
+  ]));
+  var JsonObjectZod = record(string2(), JsonValueZod);
+  var isJsonValue = zodIsFactory(JsonValueZod);
+  var asJsonValue = zodAsFactory(JsonValueZod, "asJsonValue");
+  var toJsonValue = zodToFactory(JsonValueZod, "toJsonValue");
+  var isJsonArray = zodIsFactory(JsonArrayZod);
+  var asJsonArray = zodAsFactory(JsonArrayZod, "asJsonArray");
+  var toJsonArray = zodToFactory(JsonArrayZod, "toJsonArray");
+  var isJsonObject = zodIsFactory(JsonObjectZod);
+  var asJsonObject = zodAsFactory(JsonObjectZod, "asJsonObject");
+  var toJsonObject = zodToFactory(JsonObjectZod, "toJsonObject");
+  var color = (open, close = 39) => {
+    return (value) => `\x1B[${open}m${value}\x1B[${close}m`;
+  };
+  var logColors = {
+    green: color(32),
+    grey: color(90),
+    magenta: color(35),
+    red: color(31),
+    white: color(37),
+    yellow: color(33)
+  };
+  function spanDurationInMillis(span2) {
+    return span2.duration[0] * 1e3 + span2.duration[1] / 1e6;
+  }
+  var XyConsoleSpanExporter = class _XyConsoleSpanExporter extends ConsoleSpanExporter {
+    /** Duration thresholds (in ms) that map to increasing log levels. */
+    static durationToLogLevel = [
+      0,
+      1,
+      10,
+      100,
+      1e3
+    ];
+    /** Chalk color functions corresponding to each log level. */
+    static logLevelToChalkColor = [
+      logColors.grey,
+      logColors.white,
+      logColors.green,
+      logColors.yellow,
+      logColors.red
+    ];
+    logger;
+    _logLevel;
+    constructor(logLevel = 0, logger = console) {
+      super();
+      this._logLevel = logLevel;
+      this.logger = logger;
+    }
+    /** The minimum log level required for a span to be exported. */
+    get logLevel() {
+      return this._logLevel;
+    }
+    export(spans) {
+      for (const span2 of spans) {
+        const spanLevel = this.spanLevel(span2);
+        if (spanLevel < this.logLevel) {
+          continue;
+        }
+        const duration2 = spanDurationInMillis(span2);
+        this.logger.log(logColors.grey([
+          `Span [${span2.name}]`,
+          this.logColor(spanLevel)(`${duration2}ms`),
+          `TraceId: ${span2.spanContext().traceId}`
+        ].join(", ")));
+      }
+    }
+    /**
+     * Returns the chalk color function for the given log level.
+     * @param level - The log level index.
+     * @returns A chalk color function.
+     */
+    logColor(level) {
+      return _XyConsoleSpanExporter.logLevelToChalkColor[level] ?? logColors.magenta;
+    }
+    /**
+     * Determines the log level of a span based on its duration.
+     * @param span - The span to evaluate.
+     * @returns The numeric log level (index into durationToLogLevel).
+     */
+    spanLevel(span2) {
+      let logLevel = 0;
+      const duration2 = spanDurationInMillis(span2);
+      for (let x = _XyConsoleSpanExporter.durationToLogLevel.length - 1; x >= 0; x--) {
+        if (duration2 > _XyConsoleSpanExporter.durationToLogLevel[x]) {
+          logLevel = x;
+          break;
+        }
+      }
+      return logLevel;
+    }
+  };
 
-  // ../../../../../../node_modules/.pnpm/@xylabs+threads@7.0.4_@opentelemetry+api@1.9.1_@opentelemetry+sdk-trace-base@2.8.0_@ope_2d1c7879bd64186a17682f1cb6bc1690/node_modules/@xylabs/threads/dist/browser/worker/worker.browser.mjs
+  // ../../../../../../node_modules/.pnpm/@xylabs+threads@7.0.8_@opentelemetry+api@1.9.1_@opentelemetry+sdk-trace-base@2.9.0_@ope_a1685075a98125ef0b6f31620ba50469/node_modules/@xylabs/threads/dist/browser/worker/worker.browser.mjs
   var DefaultErrorSerializer = {
     deserialize: (message) => {
       const error = Object.create(Error.prototype);
@@ -1304,7 +4522,7 @@
       step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
   }
-  var Mutex = class {
+  var Mutex2 = class {
     constructor() {
       this.mutex = Promise.resolve();
     }
@@ -1328,7 +4546,7 @@
     }
   };
   var _a2;
-  function getGlobal() {
+  function getGlobal2() {
     if (typeof globalThis !== "undefined")
       return globalThis;
     if (typeof self !== "undefined")
@@ -1337,7 +4555,7 @@
       return window;
     return global;
   }
-  var globalObject = getGlobal();
+  var globalObject = getGlobal2();
   var nodeBuffer = (_a2 = globalObject.Buffer) !== null && _a2 !== void 0 ? _a2 : null;
   var textEncoder = globalObject.TextEncoder ? new globalObject.TextEncoder() : null;
   function hexCharCodesToInt(a, b) {
@@ -1432,7 +4650,7 @@
   }
   var MAX_HEAP = 16 * 1024;
   var WASM_FUNC_HASH_LENGTH = 4;
-  var wasmMutex = new Mutex();
+  var wasmMutex = new Mutex2();
   var wasmModuleCache = /* @__PURE__ */ new Map();
   function WASMInterface(binary, hashLength) {
     return __awaiter(this, void 0, void 0, function* () {
@@ -1613,19 +4831,19 @@
       return wasm;
     });
   }
-  var mutex$l = new Mutex();
-  var mutex$k = new Mutex();
+  var mutex$l = new Mutex2();
+  var mutex$k = new Mutex2();
   var uint32View = new DataView(new ArrayBuffer(4));
-  var mutex$j = new Mutex();
-  var mutex$i = new Mutex();
-  var mutex$h = new Mutex();
-  var mutex$g = new Mutex();
+  var mutex$j = new Mutex2();
+  var mutex$i = new Mutex2();
+  var mutex$h = new Mutex2();
+  var mutex$g = new Mutex2();
   var polyBuffer = new Uint8Array(8);
-  var mutex$f = new Mutex();
-  var mutex$e = new Mutex();
-  var mutex$d = new Mutex();
-  var mutex$c = new Mutex();
-  var mutex$b = new Mutex();
+  var mutex$f = new Mutex2();
+  var mutex$e = new Mutex2();
+  var mutex$d = new Mutex2();
+  var mutex$c = new Mutex2();
+  var mutex$b = new Mutex2();
   var name$a = "sha256";
   var data$a = "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";
   var hash$a = "8c18dd94";
@@ -1634,8 +4852,8 @@
     data: data$a,
     hash: hash$a
   };
-  var mutex$a = new Mutex();
-  var mutex$9 = new Mutex();
+  var mutex$a = new Mutex2();
+  var mutex$9 = new Mutex2();
   var wasmCache$9 = null;
   function sha256(data) {
     if (wasmCache$9 === null) {
@@ -1651,18 +4869,18 @@
       return Promise.reject(err);
     }
   }
-  var mutex$8 = new Mutex();
-  var mutex$7 = new Mutex();
-  var mutex$6 = new Mutex();
-  var mutex$5 = new Mutex();
+  var mutex$8 = new Mutex2();
+  var mutex$7 = new Mutex2();
+  var mutex$6 = new Mutex2();
+  var mutex$5 = new Mutex2();
   var seedBuffer$2 = new Uint8Array(8);
-  var mutex$4 = new Mutex();
+  var mutex$4 = new Mutex2();
   var seedBuffer$1 = new Uint8Array(8);
-  var mutex$3 = new Mutex();
+  var mutex$3 = new Mutex2();
   var seedBuffer = new Uint8Array(8);
-  var mutex$2 = new Mutex();
-  var mutex$1 = new Mutex();
-  var mutex = new Mutex();
+  var mutex$2 = new Mutex2();
+  var mutex$1 = new Mutex2();
+  var mutex = new Mutex2();
 
   // src/worker/wasmHash.ts
   expose({ hash: async (data) => asHash(await sha256(data), true) });