@noormdev/sdk 1.0.0-alpha.2 → 1.0.0-alpha.20

package/dist/chunk-UDUDHOIB.js

@@ -0,0 +1,3136 @@
+import { createRequire } from 'module';
+
+createRequire(import.meta.url);
+
+// node_modules/@logosdx/utils/dist/esm/object-utils/index.mjs
+var definePrivateProps = (target, props, configurable = false) => {
+  Object.entries(props).map(([prop, value]) => {
+    Object.defineProperty(target, prop, {
+      value,
+      writable: false,
+      enumerable: false,
+      configurable
+    });
+  });
+};
+var reach = (obj, val) => {
+  const path = val.split(".");
+  return path.reduce((acc, key) => {
+    if (acc === void 0 || acc === null) {
+      return null;
+    }
+    if (acc instanceof Map) {
+      return acc.get(key);
+    }
+    if (acc instanceof Set) {
+      const has = acc.has(key);
+      const values = Array.from(acc);
+      if (has) {
+        return values[values.indexOf(key)];
+      }
+      return values[key];
+    }
+    return acc[key];
+  }, obj);
+};
+var setDeep = (obj, path, value) => {
+  assert(typeof obj === "object" && obj !== null, "obj must be a non-null object");
+  assert(typeof path === "string" && path.length > 0, "path must be a non-empty string");
+  const keys = path.split(".");
+  const lastKey = keys[keys.length - 1];
+  let current = obj;
+  for (let i = 0; i < keys.length - 1; i++) {
+    const key = keys[i];
+    if (current === null || current === void 0) {
+      throw new Error(`Cannot set property '${key}' on ${current} at path: ${keys.slice(0, i).join(".")}`);
+    }
+    if (typeof current !== "object") {
+      throw new Error(`Cannot set property '${key}' on primitive value at path: ${keys.slice(0, i).join(".")}`);
+    }
+    if (!(key in current)) {
+      current[key] = {};
+    }
+    current = current[key];
+  }
+  if (current === null || current === void 0) {
+    throw new Error(`Cannot set property '${lastKey}' on ${current}`);
+  }
+  if (typeof current !== "object") {
+    throw new Error(`Cannot set property '${lastKey}' on primitive value`);
+  }
+  current[lastKey] = value;
+};
+var setDeepMany = (obj, entries) => {
+  assert(typeof obj === "object" && obj !== null, "obj must be a non-null object");
+  assert(Array.isArray(entries), "entries must be an array");
+  for (let i = 0; i < entries.length; i++) {
+    const entry = entries[i];
+    assert(Array.isArray(entry) && entry.length === 2, `entry ${i} must be a [path, value] tuple`);
+    const [path, value] = entry;
+    assert(typeof path === "string" && path.length > 0, `entry ${i} must have a non-empty string path (received: ${typeof path})`);
+    setDeep(obj, path, value);
+  }
+};
+
+// node_modules/@logosdx/utils/dist/esm/validation/assert.mjs
+var AssertError = class extends Error {
+};
+var isOptional = (val, check) => val === void 0 || val === null || (check instanceof Function ? !!check(val) : !!check);
+var assert = (test, message, ErrorClass) => {
+  const check = test instanceof Function ? !!test() : !!test;
+  if (check === false) {
+    throw new (ErrorClass || AssertError)(message || "assertion failed");
+  }
+};
+var assertOptional = (val, ...rest) => {
+  if (val !== void 0) {
+    assert(...rest);
+  }
+};
+
+// node_modules/@logosdx/utils/dist/esm/validation/type-guards.mjs
+var isPrimitive = (val) => val === null || val === void 0 || typeof val === "string" || typeof val === "number" || typeof val === "boolean" || typeof val === "symbol" || typeof val === "bigint";
+var hasNoConstructor = (val) => val === null || val === void 0;
+var hasSameConstructor = (value, compare) => hasNoConstructor(value) === false && hasNoConstructor(compare) === false && value.constructor === compare.constructor;
+var isFunction = (a) => a instanceof Function;
+var isObject = (a) => a instanceof Object;
+var commonObjects = /* @__PURE__ */ new Set([
+  Date,
+  RegExp,
+  Function,
+  Error,
+  EvalError,
+  RangeError,
+  ReferenceError,
+  SyntaxError,
+  TypeError,
+  URIError,
+  AggregateError,
+  DOMException,
+  Array,
+  Set,
+  Map,
+  WeakMap,
+  WeakSet,
+  Promise,
+  Proxy,
+  Symbol,
+  BigInt,
+  WeakRef,
+  FinalizationRegistry,
+  DataView,
+  ArrayBuffer,
+  Int8Array,
+  Uint8Array,
+  Uint8ClampedArray,
+  Int16Array,
+  Uint16Array,
+  Int32Array,
+  Uint32Array,
+  Float32Array,
+  Float64Array,
+  BigInt64Array,
+  BigUint64Array,
+  FormData,
+  URLSearchParams
+]);
+var isPlainObject = (a) => !isPrimitive(a) && isObject(a) && !commonObjects.has(a.constructor);
+
+// node_modules/@logosdx/utils/dist/esm/validation/values.mjs
+var ENABLED_VALUES = /* @__PURE__ */ new Set([
+  "true",
+  "yes",
+  true
+]);
+var DISABLED_VALUES = /* @__PURE__ */ new Set([
+  "false",
+  "no",
+  false
+]);
+var isEnabledValue = (val) => {
+  return ENABLED_VALUES.has(val);
+};
+var isDisabledValue = (val) => {
+  return DISABLED_VALUES.has(val);
+};
+
+// node_modules/@logosdx/utils/dist/esm/async/attempt.mjs
+var attempt = async (fn) => {
+  assert(isFunction(fn), "fn must be a function");
+  try {
+    return [
+      await fn(),
+      null
+    ];
+  } catch (e) {
+    return [
+      null,
+      e
+    ];
+  }
+};
+var attemptSync = (fn) => {
+  assert(isFunction(fn), "fn must be a function");
+  try {
+    return [
+      fn(),
+      null
+    ];
+  } catch (e) {
+    return [
+      null,
+      e
+    ];
+  }
+};
+
+// node_modules/@logosdx/utils/dist/esm/data-structures/helpers.mjs
+var cloneHandlers = /* @__PURE__ */ new Map();
+var mergeHandlers = /* @__PURE__ */ new Map();
+var DANGEROUS_PROPS = /* @__PURE__ */ new Set([
+  "__proto__",
+  "constructor",
+  "prototype"
+]);
+var isDangerousKey = (key) => {
+  return typeof key === "string" && DANGEROUS_PROPS.has(key);
+};
+var getSafeKeys = (obj) => {
+  return Object.keys(obj).filter((key) => !isDangerousKey(key));
+};
+
+// node_modules/@logosdx/utils/dist/esm/data-structures/clone.mjs
+var prepareCloneHandlers = () => {
+  cloneHandlers.set(Array, (arr, seen) => arr.map((v) => clone(v, seen)));
+  cloneHandlers.set(Object, (obj, seen) => {
+    const copy = {};
+    const keys = Object.keys(obj);
+    for (const key of keys) {
+      if (isDangerousKey(key)) {
+        continue;
+      }
+      copy[key] = clone(obj[key], seen);
+    }
+    return copy;
+  });
+  cloneHandlers.set(Map, (_map, seen) => {
+    const copy = /* @__PURE__ */ new Map();
+    for (const entry of _map.entries()) {
+      const [key, val] = entry;
+      copy.set(key, clone(val, seen));
+    }
+    return copy;
+  });
+  cloneHandlers.set(Set, (_set, seen) => {
+    const copy = /* @__PURE__ */ new Set();
+    for (const original of _set) {
+      copy.add(clone(original, seen));
+    }
+    return copy;
+  });
+  const TYPED_ARRAYS = [
+    Int8Array,
+    Uint8Array,
+    Uint8ClampedArray,
+    Int16Array,
+    Uint16Array,
+    Int32Array,
+    Uint32Array,
+    Float32Array,
+    Float64Array,
+    BigInt64Array,
+    BigUint64Array
+  ];
+  TYPED_ARRAYS.forEach((TypedArrayConstructor) => {
+    cloneHandlers.set(TypedArrayConstructor, (arr) => {
+      return new TypedArrayConstructor(arr);
+    });
+  });
+  cloneHandlers.set(ArrayBuffer, (buffer) => {
+    return buffer.slice(0);
+  });
+  cloneHandlers.set(DataView, (view) => {
+    const clonedBuffer = view.buffer.slice(0);
+    return new DataView(clonedBuffer, view.byteOffset, view.byteLength);
+  });
+  cloneHandlers.set(Error, (error, seen) => {
+    const cloned = typeof structuredClone === "function" ? structuredClone(error) : new error.constructor(error.message);
+    if (error.name) {
+      cloned.name = error.name;
+    }
+    if (error.stack) {
+      cloned.stack = error.stack;
+    }
+    const keys = Object.keys(error);
+    for (const key of keys) {
+      if (key !== "name" && key !== "message" && key !== "stack" && !isDangerousKey(key)) {
+        cloned[key] = clone(error[key], seen);
+      }
+    }
+    return cloned;
+  });
+  cloneHandlers.set(Date, (date) => {
+    return new Date(date.getTime());
+  });
+  cloneHandlers.set(RegExp, (regex) => {
+    return new RegExp(regex.source, regex.flags);
+  });
+};
+var cloneHandlersInitialized = false;
+var useRawHandler = /* @__PURE__ */ new Set([
+  ArrayBuffer,
+  DataView,
+  Int8Array,
+  Uint8Array,
+  Uint8ClampedArray,
+  Int16Array,
+  Uint16Array,
+  Int32Array,
+  Uint32Array,
+  Float32Array,
+  Float64Array,
+  BigInt64Array,
+  BigUint64Array,
+  Error,
+  Date,
+  RegExp
+]);
+var clone = (original, seen = /* @__PURE__ */ new WeakMap()) => {
+  if (!cloneHandlersInitialized) {
+    prepareCloneHandlers();
+    cloneHandlersInitialized = true;
+  }
+  if (isPrimitive(original)) {
+    return original;
+  }
+  if (seen.has(original)) {
+    return seen.get(original);
+  }
+  if (original instanceof Error) {
+    const cloneType2 = cloneHandlers.get(Error);
+    return cloneType2(original, seen);
+  }
+  const actualConstructor = Object.getPrototypeOf(original)?.constructor || original.constructor;
+  const cloneType = cloneHandlers.get(actualConstructor);
+  if (!cloneType) {
+    return original;
+  }
+  if (useRawHandler.has(actualConstructor)) {
+    return cloneType(original, seen);
+  }
+  let placeholder;
+  if (Array.isArray(original)) {
+    placeholder = [];
+    seen.set(original, placeholder);
+    const cloned2 = cloneType(original, seen);
+    placeholder.push(...cloned2);
+    return placeholder;
+  }
+  if (original instanceof Map) {
+    placeholder = /* @__PURE__ */ new Map();
+    seen.set(original, placeholder);
+    const cloned2 = cloneType(original, seen);
+    for (const [key, value] of cloned2) {
+      placeholder.set(key, value);
+    }
+    return placeholder;
+  }
+  if (original instanceof Set) {
+    placeholder = /* @__PURE__ */ new Set();
+    seen.set(original, placeholder);
+    const cloned2 = cloneType(original, seen);
+    for (const value of cloned2) {
+      placeholder.add(value);
+    }
+    return placeholder;
+  }
+  placeholder = {};
+  seen.set(original, placeholder);
+  const cloned = cloneType(original, seen);
+  Object.assign(placeholder, cloned);
+  return placeholder;
+};
+
+// node_modules/@logosdx/utils/dist/esm/data-structures/merge.mjs
+var mergeArrays = (target, source) => {
+  for (const value of source) {
+    target.push(value);
+  }
+  return target;
+};
+var mergeSets = (target, source) => {
+  for (const value of source) {
+    if (!target.has(value)) {
+      target.add(value);
+    }
+  }
+  return target;
+};
+var overwriteArrays = (target, source) => {
+  target.length = 0;
+  for (const value of source) {
+    target.push(value);
+  }
+  return target;
+};
+var overwriteSets = (target, source) => {
+  target.clear();
+  for (const value of source) {
+    target.add(value);
+  }
+  return target;
+};
+var prepareMergeHandlers = () => {
+  mergeHandlers.set(Array, (target, source, options) => {
+    if (options?.mergeArrays) {
+      return mergeArrays(target, source);
+    }
+    return overwriteArrays(target, source);
+  });
+  mergeHandlers.set(Set, (target, source, options) => {
+    if (options?.mergeSets) {
+      return mergeSets(target, source);
+    }
+    return overwriteSets(target, source);
+  });
+  mergeHandlers.set(Object, (_target, _source, options) => {
+    const target = _target;
+    const source = _source;
+    const sourceKeys = Object.keys(source);
+    for (const key of sourceKeys) {
+      if (isDangerousKey(key)) {
+        continue;
+      }
+      if (target[key] === void 0 || hasNoConstructor(target[key]) || hasNoConstructor(source[key])) {
+        target[key] = source[key];
+        continue;
+      }
+      if (hasSameConstructor(target[key], source[key])) {
+        target[key] = merge(target[key], source[key], options);
+        continue;
+      }
+      target[key] = source[key];
+    }
+    return target;
+  });
+  mergeHandlers.set(Map, (_target, _source, options) => {
+    const target = _target;
+    const source = _source;
+    for (const [key, bValue] of source.entries()) {
+      if (!target.has(key)) {
+        target.set(key, bValue);
+        continue;
+      }
+      const aValue = target.get(key);
+      if (hasNoConstructor(aValue) || hasNoConstructor(bValue)) {
+        target.set(key, bValue);
+        continue;
+      }
+      if (hasSameConstructor(bValue, aValue)) {
+        target.set(key, merge(aValue, bValue, options));
+        continue;
+      }
+      target.set(key, bValue);
+    }
+    return target;
+  });
+  mergeHandlers.set(Error, (_target, _source, options) => {
+    const target = _target;
+    const source = _source;
+    const sourceKeys = getSafeKeys(source);
+    for (const key of sourceKeys) {
+      if (target[key] === void 0) {
+        target[key] = source[key];
+        continue;
+      }
+      if (hasSameConstructor(target[key], source[key])) {
+        target[key] = merge(target[key], source[key], options);
+        continue;
+      }
+      target[key] = source[key];
+    }
+    return target;
+  });
+  const TYPED_ARRAYS = [
+    Int8Array,
+    Uint8Array,
+    Uint8ClampedArray,
+    Int16Array,
+    Uint16Array,
+    Int32Array,
+    Uint32Array,
+    Float32Array,
+    Float64Array,
+    BigInt64Array,
+    BigUint64Array
+  ];
+  TYPED_ARRAYS.forEach((TypedArrayConstructor) => {
+    mergeHandlers.set(TypedArrayConstructor, (_target, source) => {
+      return new TypedArrayConstructor(source);
+    });
+  });
+  mergeHandlers.set(ArrayBuffer, (_target, source) => {
+    return source.slice(0);
+  });
+  mergeHandlers.set(DataView, (_target, source) => {
+    const sourceView = source;
+    const clonedBuffer = sourceView.buffer.slice(0);
+    return new DataView(clonedBuffer, sourceView.byteOffset, sourceView.byteLength);
+  });
+  const ERROR_TYPES = [
+    Error,
+    TypeError,
+    ReferenceError,
+    SyntaxError,
+    RangeError,
+    EvalError,
+    URIError
+  ];
+  ERROR_TYPES.forEach((ErrorConstructor) => {
+    mergeHandlers.set(ErrorConstructor, (_target, source) => {
+      const sourceError = source;
+      const cloned = new sourceError.constructor(sourceError.message);
+      if (sourceError.name) {
+        cloned.name = sourceError.name;
+      }
+      if (sourceError.stack) {
+        cloned.stack = sourceError.stack;
+      }
+      const keys = Object.keys(sourceError);
+      for (const key of keys) {
+        if (key !== "name" && key !== "message" && key !== "stack" && !isDangerousKey(key)) {
+          cloned[key] = sourceError[key];
+        }
+      }
+      return cloned;
+    });
+  });
+};
+var mergeHandlersInitialized = false;
+var mergeDefaults = {
+  mergeArrays: true,
+  mergeSets: true
+};
+var merge = (target, source, options = {}) => {
+  if (!mergeHandlersInitialized) {
+    prepareMergeHandlers();
+    mergeHandlersInitialized = true;
+  }
+  options = {
+    ...mergeDefaults,
+    ...options
+  };
+  if (isPrimitive(source) || source instanceof Date) {
+    return source;
+  }
+  if (hasSameConstructor(source, target)) {
+    const actualConstructor = Object.getPrototypeOf(target)?.constructor || target.constructor;
+    const mergeType = mergeHandlers.get(actualConstructor);
+    if (!mergeType) {
+      return target;
+    }
+    return mergeType(target, source, options);
+  }
+  return source;
+};
+
+// node_modules/@logosdx/utils/dist/esm/data-structures/priority-queue.mjs
+var fifoCompare = (a, b) => {
+  if (a.priority === b.priority) {
+    return a.order - b.order;
+  }
+  return a.priority - b.priority;
+};
+var lifoCompare = (a, b) => {
+  if (a.priority === b.priority) {
+    return b.order - a.order;
+  }
+  return a.priority - b.priority;
+};
+var PriorityQueue = class _PriorityQueue {
+  #heap = [];
+  #insertionCounter = 0;
+  #compare;
+  #options;
+  constructor(options = {}) {
+    this.#compare = options.lifo ? lifoCompare : fifoCompare;
+    if (options.compare) {
+      this.#compare = options.compare;
+    }
+    if (options.maxHeap) {
+      const originalCompare = this.#compare;
+      this.#compare = (a, b) => -originalCompare(a, b);
+    }
+    this.#options = options;
+  }
+  /**
+   * Adds a new item into the queue.
+   * @param value The payload associated with the item
+   * @param priority Numeric priority (lower = higher priority)
+   *
+   * Time Complexity: O(log n)
+   * Space Complexity: O(1)
+   */
+  push(value, priority = 0) {
+    const node = {
+      value,
+      priority,
+      order: this.#insertionCounter++
+    };
+    this.#heap.push(node);
+    this.#bubbleUp(this.#heap.length - 1);
+  }
+  /**
+   * Removes and returns the highest-priority item.
+   * Returns null if the queue is empty.
+   *
+   * Time Complexity: O(log n)
+   * Space Complexity: O(1)
+   */
+  pop() {
+    if (this.#heap.length === 0) return null;
+    const top = this.#heap[0];
+    const last = this.#heap.pop();
+    if (this.#heap.length > 0) {
+      this.#heap[0] = last;
+      this.#bubbleDown(0);
+    }
+    return top.value;
+  }
+  /**
+   * Removes and returns many items from the queue.
+   * Returns an empty array if the queue is empty.
+   */
+  popMany(count = 1) {
+    const items = [];
+    if (count === 0) {
+      return items;
+    }
+    if (count > this.#heap.length) {
+      count = this.#heap.length;
+    }
+    for (let i = count; i > 0; i--) {
+      items.push(this.pop());
+    }
+    return items;
+  }
+  /**
+   * Returns the next item to be dequeued without removing it.
+   */
+  peek() {
+    return this.isEmpty() ? null : this.#heap[0].value;
+  }
+  /**
+   * Returns the next item to be dequeued without removing it.
+   */
+  peekMany(count = 1) {
+    return this.#heap.slice(0, count).map((node) => node.value);
+  }
+  /**
+   * Find an item in the queue by predicate.
+   */
+  find(predicate) {
+    return this.#heap.find((node) => predicate(node.value))?.value ?? null;
+  }
+  /**
+   * Heapify the queue.
+   *
+   * Time Complexity: O(n)
+   * Space Complexity: O(n)
+   */
+  heapify(items) {
+    this.#heap = items.slice(0);
+    this.#insertionCounter = items.length;
+    for (let i = Math.floor(this.#heap.length / 2); i >= 0; i--) {
+      this.#bubbleDown(i);
+    }
+  }
+  clone() {
+    const clone2 = new _PriorityQueue(this.#options);
+    clone2.heapify(this.#heap);
+    return clone2;
+  }
+  /**
+   * Returns a sorted array of the queue.
+   */
+  toSortedArray() {
+    const clone2 = this.clone();
+    const sorted = [];
+    while (clone2.#heap.length > 0) {
+      sorted.push(clone2.pop());
+    }
+    return sorted;
+  }
+  /**
+   * Returns an iterator over the queue.
+   */
+  *[Symbol.iterator]() {
+    const clone2 = this.clone();
+    while (clone2.#heap.length > 0) {
+      yield clone2.pop();
+    }
+  }
+  /**
+   * Returns the number of items in the queue.
+   */
+  size() {
+    return this.#heap.length;
+  }
+  /**
+   * Returns true if the queue is empty.
+   */
+  isEmpty() {
+    return this.#heap.length === 0;
+  }
+  /**
+   * Clears all items and resets the insertion counter.
+   */
+  clear() {
+    this.#heap = [];
+    this.#insertionCounter = 0;
+  }
+  /**
+   * Moves the node at index up to restore heap invariant.
+   *
+   * Time Complexity: O(log n)
+   * Space Complexity: O(1)
+   */
+  #bubbleUp(index) {
+    let idx = index;
+    while (idx > 0) {
+      const parentIdx = idx - 1 >> 1;
+      if (this.#compare(this.#heap[idx], this.#heap[parentIdx]) < 0) {
+        this.#swap(idx, parentIdx);
+        idx = parentIdx;
+      } else {
+        break;
+      }
+    }
+  }
+  /**
+   * Moves the node at index down to restore heap invariant.
+   *
+   * Time Complexity: O(log n)
+   * Space Complexity: O(1)
+   */
+  #bubbleDown(index) {
+    const length = this.#heap.length;
+    let idx = index;
+    while (true) {
+      const left = (idx << 1) + 1;
+      const right = left + 1;
+      let smallest = idx;
+      if (left < length && this.#compare(this.#heap[left], this.#heap[smallest]) < 0) {
+        smallest = left;
+      }
+      if (right < length && this.#compare(this.#heap[right], this.#heap[smallest]) < 0) {
+        smallest = right;
+      }
+      if (smallest === idx) {
+        break;
+      }
+      this.#swap(idx, smallest);
+      idx = smallest;
+    }
+  }
+  /**
+   * Swaps two nodes in the heap.
+   */
+  #swap(i, j) {
+    [this.#heap[i], this.#heap[j]] = [
+      this.#heap[j],
+      this.#heap[i]
+    ];
+  }
+};
+
+// node_modules/@logosdx/utils/dist/esm/flow-control/misc.mjs
+var Deferred = class {
+  promise;
+  resolve;
+  reject;
+  constructor() {
+    this.promise = new Promise((resolve, reject) => {
+      this.resolve = resolve;
+      this.reject = reject;
+    });
+  }
+};
+if (typeof Promise.withResolvers !== "function") {
+  Promise.withResolvers = () => {
+    return new Deferred();
+  };
+}
+var TimeoutPromise = class extends Promise {
+  clear;
+};
+var wait = (ms, value = true) => {
+  let timeout;
+  const promise = new TimeoutPromise((resolve) => {
+    timeout = setTimeout(() => {
+      timeout = null;
+      resolve(value);
+    }, ms);
+  });
+  promise.clear = () => {
+    if (!timeout) return;
+    clearTimeout(timeout);
+    timeout = null;
+  };
+  return promise;
+};
+if (typeof setImmediate !== "function") {
+  let nextHandle = 0;
+  const tasks = /* @__PURE__ */ new Map();
+  const channel = new MessageChannel();
+  channel.port1.onmessage = async (event) => {
+    const handle = event.data;
+    const fn = tasks.get(handle);
+    if (!fn) return;
+    const [, error] = await attempt(fn);
+    if (error) console.error("Error in setImmediate", error);
+  };
+  globalThis.setImmediate = (fn, ...args) => {
+    const handle = nextHandle++;
+    tasks.set(handle, () => fn(...args));
+    channel.port2.postMessage(handle);
+    return handle;
+  };
+  globalThis.clearImmediate = (handle) => {
+    tasks.delete(handle);
+  };
+}
+
+// node_modules/@logosdx/utils/dist/esm/_helpers.mjs
+var maps = {
+  retry: /* @__PURE__ */ new WeakMap(),
+  circuitBreaker: /* @__PURE__ */ new WeakMap(),
+  rateLimit: /* @__PURE__ */ new WeakMap(),
+  throttle: /* @__PURE__ */ new WeakMap(),
+  debounce: /* @__PURE__ */ new WeakMap(),
+  memoize: /* @__PURE__ */ new WeakMap(),
+  withTimeout: /* @__PURE__ */ new WeakMap(),
+  inflight: /* @__PURE__ */ new WeakMap()
+};
+var assertNotWrapped = (fn, name) => {
+  if (maps[name].has(fn)) {
+    throw new Error(`Function is already wrapped with ${name}`);
+  }
+};
+
+// node_modules/@logosdx/utils/dist/esm/async/retry.mjs
+var RetryError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "RetryError";
+  }
+};
+var validateOpts = (opts) => {
+  assert(isPlainObject(opts), "opts must be an object");
+  assertOptional(opts.retries, typeof opts.retries === "number" && opts.retries > 0, "retries must be a positive number");
+  assertOptional(opts.delay, typeof opts.delay === "number" && opts.delay >= 0, "delay must be a positive number");
+  assertOptional(opts.backoff, typeof opts.backoff === "number" && opts.backoff > 0, "backoff must be a positive number");
+  assertOptional(opts.shouldRetry, isFunction(opts.shouldRetry), "shouldRetry must be a function");
+  assertOptional(opts.signal, opts.signal instanceof AbortSignal, "signal must be an AbortSignal");
+};
+var retry = async (fn, opts) => {
+  assert(isFunction(fn), "fn must be a function");
+  assertNotWrapped(fn, "retry");
+  validateOpts(opts);
+  const { delay = 0, retries = 3, backoff = 1, jitterFactor = 0, shouldRetry = () => true, signal, throwLastError = false, onRetryExhausted, onRetry } = opts;
+  let attempts = 0;
+  let lastError = null;
+  while (attempts < retries) {
+    signal?.throwIfAborted();
+    if (attempts > 0 && onRetry && lastError) {
+      await onRetry(lastError, attempts);
+    }
+    const [result, error] = await attempt(fn);
+    signal?.throwIfAborted();
+    if (error === null) {
+      return result;
+    }
+    lastError = error;
+    if (error && shouldRetry(error)) {
+      await wait(delay * backoff * (1 + jitterFactor * Math.random()));
+      attempts++;
+      signal?.throwIfAborted();
+      continue;
+    }
+    throw error;
+  }
+  if (onRetryExhausted) {
+    return onRetryExhausted(lastError);
+  }
+  if (throwLastError) {
+    throw lastError;
+  }
+  throw new RetryError("Max retries reached");
+};
+
+// node_modules/@logosdx/utils/dist/esm/misc/index.mjs
+var noop = () => {
+};
+var generateId = () => "_" + Math.random().toString(36).slice(2, 9);
+var unserializableIds = /* @__PURE__ */ new WeakMap();
+var getUnserializableId = (value) => {
+  if (!unserializableIds.has(value)) {
+    unserializableIds.set(value, generateId());
+  }
+  return unserializableIds.get(value);
+};
+var serializer = (args) => {
+  const seen = /* @__PURE__ */ new WeakSet();
+  const stringify = (value) => {
+    if (value === null) return "null";
+    if (value === void 0) return "undefined";
+    if (typeof value === "string") return `${value}`;
+    if (typeof value === "number") {
+      if (Object.is(value, -0)) return "-0";
+      return String(value);
+    }
+    if (typeof value === "boolean") return String(value);
+    if (typeof value === "bigint") return `bi:${value}`;
+    if (typeof value === "symbol") return `sym:${getUnserializableId(value)}`;
+    if (typeof value === "function") return `fn:${getUnserializableId(value)}`;
+    if (value instanceof Date) return `d:${value.getTime()}`;
+    if (value instanceof RegExp) return `r:${value.toString()}`;
+    if (value instanceof Error) return `e:${getUnserializableId(value)}`;
+    if (value instanceof WeakMap) return `wm:${getUnserializableId(value)}`;
+    if (value instanceof WeakSet) return `ws:${getUnserializableId(value)}`;
+    if (typeof value === "object") {
+      if (seen.has(value)) return `circ:${getUnserializableId(value)}`;
+      seen.add(value);
+      if (value instanceof Map) {
+        const pairs2 = Array.from(value.entries()).map(([k, v]) => `${stringify(k)}:${stringify(v)}`).sort();
+        const result2 = `map:${pairs2.join(",")}`;
+        seen.delete(value);
+        return result2;
+      }
+      if (value instanceof Set) {
+        const values = Array.from(value).map(stringify).sort();
+        const result2 = `set:${values.join(",")}`;
+        seen.delete(value);
+        return result2;
+      }
+      if (Array.isArray(value)) {
+        const result2 = `[${value.map(stringify).join(",")}]`;
+        seen.delete(value);
+        return result2;
+      }
+      const keys = Object.keys(value).sort();
+      const pairs = keys.map((key2) => `"${key2}":${stringify(value[key2])}`);
+      const result = `{${pairs.join(",")}}`;
+      seen.delete(value);
+      return result;
+    }
+    return `u:${String(value)}`;
+  };
+  const key = args.map(stringify).join("|");
+  return key || "0";
+};
+
+// node_modules/@logosdx/utils/dist/esm/flow-control/memo/helpers.mjs
+var unwrapValue = (value) => {
+  if (value instanceof WeakRef) {
+    const deref = value.deref();
+    return [
+      deref,
+      deref === void 0
+    ];
+  }
+  return [
+    value,
+    false
+  ];
+};
+var createCacheItem = (value, createdAt, expiresAt, useWeakRef, accessSequence) => {
+  const storedValue = useWeakRef && isObject(value) && value !== null ? new WeakRef(value) : value;
+  return {
+    value: storedValue,
+    createdAt,
+    expiresAt,
+    accessCount: 1,
+    lastAccessed: createdAt,
+    accessSequence
+  };
+};
+var isExpired = (item) => {
+  return Date.now() >= item.expiresAt;
+};
+var updateAccessMetadata = (item, sequence) => {
+  const now = Date.now();
+  item.lastAccessed = now;
+  item.accessCount = (item.accessCount ?? 0) + 1;
+  item.accessSequence = sequence;
+};
+var evictLRU = (cache) => {
+  let lruKey = null;
+  let lruTime = Infinity;
+  let lruSequence = Infinity;
+  for (const [key, item] of cache.entries()) {
+    const itemLastAccessed = item.lastAccessed ?? 0;
+    const itemAccessSequence = item.accessSequence ?? 0;
+    const isLessRecent = itemLastAccessed < lruTime || itemLastAccessed === lruTime && itemAccessSequence < lruSequence;
+    if (isLessRecent) {
+      lruTime = itemLastAccessed;
+      lruSequence = itemAccessSequence;
+      lruKey = key;
+    }
+  }
+  if (lruKey) {
+    cache.delete(lruKey);
+  }
+  return lruKey;
+};
+
+// node_modules/@logosdx/utils/dist/esm/flow-control/memo/memoizeSync.mjs
+var memoizedFunctions = /* @__PURE__ */ new WeakSet();
+var memoizeSync = (fn, opts = {}) => {
+  assert(isFunction(fn), "fn must be a function");
+  assert(!memoizedFunctions.has(fn), "Function is already wrapped by memoize");
+  const { ttl = 6e4, maxSize = 1e3, generateKey, onError, cleanupInterval = 6e4, useWeakRef = false, shouldCache } = opts;
+  const { staleIn, staleTimeout, adapter } = opts;
+  assert(ttl > 0, "ttl must be greater than 0");
+  assert(maxSize > 0, "maxSize must be greater than 0");
+  assert(isOptional(cleanupInterval, (val) => typeof val === "number" && val >= 0), "cleanupInterval must be >= 0");
+  assertOptional(generateKey, isFunction(generateKey), "generateKey must be a function");
+  assertOptional(onError, isFunction(onError), "onError must be a function");
+  assert(adapter === void 0, "memoizeSync does not support custom cache adapters (use memoize for async adapters like Redis)");
+  assert(staleTimeout === void 0, "memoizeSync does not support staleTimeout (sync functions execute instantly)");
+  assert(staleIn === void 0, "memoizeSync does not support staleIn (sync functions execute instantly, use ttl instead)");
+  const cache = /* @__PURE__ */ new Map();
+  let accessSequence = 0;
+  let hits = 0;
+  let misses = 0;
+  let evictions = 0;
+  let cleanupTimer;
+  const getNextSequence = () => {
+    if (accessSequence >= Number.MAX_SAFE_INTEGER - 1) {
+      accessSequence = 0;
+    }
+    return ++accessSequence;
+  };
+  const recordHit = () => hits++;
+  const recordMiss = () => misses++;
+  const cleanupExpired = () => {
+    const now = Date.now();
+    for (const [key, item] of cache.entries()) {
+      if (now >= item.expiresAt) {
+        cache.delete(key);
+      }
+    }
+  };
+  if (cleanupInterval > 0) {
+    cleanupTimer = setInterval(() => cleanupExpired(), cleanupInterval);
+    if (typeof cleanupTimer.unref === "function") {
+      cleanupTimer.unref();
+    }
+  }
+  const memoized = function(...args) {
+    if (shouldCache) {
+      const [shouldCacheResult, shouldCacheError] = attemptSync(() => shouldCache(...args));
+      if (!shouldCacheError && !shouldCacheResult) {
+        return fn(...args);
+      }
+    }
+    const [key, keyError] = attemptSync(() => generateKey ? generateKey(...args) : serializer(args));
+    if (keyError) {
+      onError?.(keyError, args);
+      recordMiss();
+      return fn(...args);
+    }
+    const cached = cache.get(key);
+    if (cached && !isExpired(cached)) {
+      updateAccessMetadata(cached, getNextSequence());
+      const [unwrapped, wasGC] = unwrapValue(cached.value);
+      if (wasGC) {
+        cache.delete(key);
+        recordMiss();
+        const [value2, error2] = attemptSync(() => fn(...args));
+        if (error2) {
+          onError?.(error2, args);
+          throw error2;
+        }
+        const now2 = Date.now();
+        const item2 = createCacheItem(value2, now2, now2 + ttl, useWeakRef, getNextSequence());
+        if (cache.size >= maxSize) {
+          evictLRU(cache);
+          evictions++;
+        }
+        cache.set(key, item2);
+        return value2;
+      }
+      recordHit();
+      return unwrapped;
+    }
+    recordMiss();
+    const [value, error] = attemptSync(() => fn(...args));
+    if (error) {
+      onError?.(error, args);
+      throw error;
+    }
+    const now = Date.now();
+    const item = createCacheItem(value, now, now + ttl, useWeakRef, getNextSequence());
+    if (cache.size >= maxSize) {
+      evictLRU(cache);
+      evictions++;
+    }
+    cache.set(key, item);
+    return value;
+  };
+  memoized.cache = {
+    clear: () => {
+      cache.clear();
+      hits = 0;
+      misses = 0;
+      evictions = 0;
+      accessSequence = 0;
+      if (cleanupTimer !== void 0) {
+        clearInterval(cleanupTimer);
+        cleanupTimer = void 0;
+      }
+    },
+    delete: (key) => {
+      return cache.delete(key);
+    },
+    has: (key) => {
+      const item = cache.get(key);
+      if (!item) {
+        return false;
+      }
+      if (isExpired(item)) {
+        cache.delete(key);
+        return false;
+      }
+      return true;
+    },
+    get size() {
+      return cache.size;
+    },
+    stats: () => {
+      return {
+        hits,
+        misses,
+        evictions,
+        hitRate: hits + misses > 0 ? hits / (hits + misses) : 0,
+        size: cache.size
+      };
+    },
+    keys: () => {
+      return cache.keys();
+    },
+    entries: () => {
+      const results = [];
+      for (const [key, item] of cache.entries()) {
+        if (!isExpired(item)) {
+          const [unwrapped] = unwrapValue(item.value);
+          results.push([
+            key,
+            unwrapped
+          ]);
+        }
+      }
+      return results;
+    }
+  };
+  memoizedFunctions.add(memoized);
+  return memoized;
+};
+
+// node_modules/@logosdx/utils/dist/esm/flow-control/rate-limit.mjs
+var RateLimitTokenBucket = class {
+  #tokens;
+  #lastRefill;
+  #stats;
+  #save;
+  #load;
+  capacity;
+  refillIntervalMs;
+  constructor(config) {
+    assert(isPlainObject(config), "config must be an object");
+    assert(typeof config.capacity === "number" && config.capacity > 0, "capacity must be a positive number");
+    assert(typeof config.refillIntervalMs === "number" && config.refillIntervalMs > 0, "refillIntervalMs must be a positive number");
+    assertOptional(config.save, isFunction(config.save), "save must be a function");
+    assertOptional(config.load, isFunction(config.load), "load must be a function");
+    assertOptional(config.initialState, isPlainObject(config.initialState), "initialState must be an object");
+    this.capacity = config.capacity;
+    this.refillIntervalMs = config.refillIntervalMs;
+    this.#save = config.save;
+    this.#load = config.load;
+    if (config.initialState) {
+      this.#tokens = config.initialState.tokens ?? config.capacity;
+      this.#lastRefill = config.initialState.lastRefill ?? Date.now();
+      this.#stats = {
+        totalRequests: config.initialState.stats?.totalRequests ?? 0,
+        rejectedRequests: config.initialState.stats?.rejectedRequests ?? 0,
+        totalWaitTime: config.initialState.stats?.totalWaitTime ?? 0,
+        waitCount: config.initialState.stats?.waitCount ?? 0,
+        createdAt: config.initialState.stats?.createdAt ?? Date.now()
+      };
+    } else {
+      this.#tokens = config.capacity;
+      this.#lastRefill = Date.now();
+      this.#stats = {
+        totalRequests: 0,
+        rejectedRequests: 0,
+        totalWaitTime: 0,
+        waitCount: 0,
+        createdAt: Date.now()
+      };
+    }
+  }
+  /**
+   * Whether save and load functions are configured for persistence.
+   */
+  get isSaveable() {
+    return isFunction(this.#save) && isFunction(this.#load);
+  }
+  /**
+   * Get the current state for persistence.
+   * This is the minimal data structure needed to restore the bucket.
+   */
+  get state() {
+    this.#refill();
+    return {
+      tokens: this.#tokens,
+      lastRefill: this.#lastRefill,
+      stats: {
+        ...this.#stats
+      }
+    };
+  }
+  /**
+   * Save the current state using the configured save function.
+   * @throws If no save function is configured
+   */
+  async save() {
+    const saveFn = this.#save;
+    if (!isFunction(saveFn)) {
+      throw new Error("No save function configured");
+    }
+    await saveFn(this.state);
+  }
+  /**
+   * Load state from the configured load function.
+   * If the load function returns undefined/null, the bucket state is not modified.
+   * @throws If no load function is configured
+   */
+  async load() {
+    const loadFn = this.#load;
+    if (!isFunction(loadFn)) {
+      throw new Error("No load function configured");
+    }
+    const loadedState = await loadFn();
+    if (loadedState) {
+      this.#tokens = loadedState.tokens ?? this.capacity;
+      this.#lastRefill = loadedState.lastRefill ?? Date.now();
+      if (loadedState.stats) {
+        this.#stats = {
+          totalRequests: loadedState.stats.totalRequests ?? 0,
+          rejectedRequests: loadedState.stats.rejectedRequests ?? 0,
+          totalWaitTime: loadedState.stats.totalWaitTime ?? 0,
+          waitCount: loadedState.stats.waitCount ?? 0,
+          createdAt: loadedState.stats.createdAt ?? Date.now()
+        };
+      }
+    }
+  }
+  /**
+   * Check if there are enough tokens available without consuming them.
+   *
+   * @param count - Number of tokens to check for (default: 1)
+   * @returns true if tokens are available, false otherwise
+   *
+   * @example
+   * if (bucket.hasTokens()) {
+   *     // We're within rate limit, proceed
+   *     bucket.consume();
+   * }
+   */
+  hasTokens(count = 1) {
+    this.#refill();
+    return this.#tokens >= count;
+  }
+  #refill() {
+    const now = Date.now();
+    const elapsed = now - this.#lastRefill;
+    const refillRate = 1 / this.refillIntervalMs;
+    if (elapsed < 0 || elapsed > this.refillIntervalMs * this.capacity * 2) {
+      this.#lastRefill = now;
+      this.#tokens = this.capacity;
+      return;
+    }
+    if (elapsed > 0) {
+      const tokensToAdd = elapsed * refillRate;
+      this.#tokens = Math.min(this.capacity, this.#tokens + tokensToAdd);
+      this.#lastRefill = now;
+    }
+  }
+  reset() {
+    this.#tokens = this.capacity;
+    this.#lastRefill = Date.now();
+  }
+  get tokens() {
+    return Math.floor(this.#tokens);
+  }
+  consume(count = 1) {
+    this.#refill();
+    this.#stats.totalRequests++;
+    if (this.#tokens >= count) {
+      this.#tokens -= count;
+      return true;
+    }
+    this.#stats.rejectedRequests++;
+    return false;
+  }
+  getWaitTimeMs(count = 1) {
+    this.#refill();
+    const deficit = count - this.#tokens;
+    if (deficit <= 0) return 0;
+    const refillRate = 1 / this.refillIntervalMs;
+    const waitTime = Math.ceil(deficit / refillRate) + 1;
+    return waitTime;
+  }
+  getNextAvailable(count = 1) {
+    return new Date(Date.now() + this.getWaitTimeMs(count));
+  }
+  /**
+   * Get a snapshot of current statistics and state.
+   *
+   * @returns Object containing usage statistics and current state
+   */
+  get snapshot() {
+    this.#refill();
+    const now = Date.now();
+    const uptime = now - this.#stats.createdAt;
+    return {
+      currentTokens: this.tokens,
+      capacity: this.capacity,
+      refillIntervalMs: this.refillIntervalMs,
+      totalRequests: this.#stats.totalRequests,
+      rejectedRequests: this.#stats.rejectedRequests,
+      successfulRequests: this.#stats.totalRequests - this.#stats.rejectedRequests,
+      rejectionRate: this.#stats.totalRequests > 0 ? this.#stats.rejectedRequests / this.#stats.totalRequests : 0,
+      totalWaitTime: this.#stats.totalWaitTime,
+      waitCount: this.#stats.waitCount,
+      averageWaitTime: this.#stats.waitCount > 0 ? this.#stats.totalWaitTime / this.#stats.waitCount : 0,
+      uptime,
+      createdAt: this.#stats.createdAt
+    };
+  }
+  /**
+   * Waits for the next token to be available before
+   * allowing the caller to proceed.
+   *
+   * @param onRateLimit - Callback to invoke when the rate limit is exceeded
+   *
+   * @example
+   * const bucket = new RateLimitTokenBucket({
+   *     capacity: 10,
+   *     refillIntervalMs: 1000
+   * });
+   *
+   * await bucket.waitForToken(() => {
+   *     console.log('Rate limit exceeded');
+   * });
+   * console.log('Token available');
+   *
+   * bucket.consume();
+   * console.log('Token consumed');
+   */
+  async waitForToken(count = 1, opts = {}) {
+    const { onRateLimit, abortController, jitterFactor = 0 } = opts;
+    this.#refill();
+    if (this.#tokens >= count) return;
+    const waitStart = Date.now();
+    this.#stats.waitCount++;
+    while (this.#tokens < count) {
+      if (abortController?.signal?.aborted) return;
+      await onRateLimit?.(new RateLimitError("Rate limit exceeded", this.capacity), this.getNextAvailable(count));
+      await wait(this.getWaitTimeMs(count) + Math.random() * jitterFactor);
+      this.#refill();
+    }
+    const waitEnd = Date.now();
+    this.#stats.totalWaitTime += waitEnd - waitStart;
+  }
+  /**
+   * Waits for tokens to be available and consumes them atomically.
+   *
+   * @param onRateLimit - Callback to invoke when the rate limit is exceeded
+   *
+   * @example
+   * const bucket = new RateLimitTokenBucket({
+   *     capacity: 10,
+   *     refillIntervalMs: 1000
+   * });
+   *
+   * await bucket.waitAndConsume(() => {
+   *     console.log('Rate limit exceeded');
+   * });
+   * console.log('Token acquired and consumed');
+   */
+  async waitAndConsume(count = 1, opts = {}) {
+    const { onRateLimit, abortController, jitterFactor = 0 } = opts;
+    this.#refill();
+    this.#stats.totalRequests++;
+    if (this.#tokens >= count) {
+      this.#tokens -= count;
+      return true;
+    }
+    const waitStart = Date.now();
+    this.#stats.waitCount++;
+    while (this.#tokens < count) {
+      if (abortController?.signal?.aborted) {
+        this.#stats.rejectedRequests++;
+        return false;
+      }
+      await onRateLimit?.(new RateLimitError("Rate limit exceeded", this.capacity), this.getNextAvailable(count));
+      await wait(this.getWaitTimeMs(count) + Math.random() * jitterFactor);
+      this.#refill();
+    }
+    this.#tokens -= count;
+    const waitEnd = Date.now();
+    this.#stats.totalWaitTime += waitEnd - waitStart;
+    return true;
+  }
+};
+var RateLimitError = class extends Error {
+  maxCalls;
+  constructor(message, maxCalls) {
+    super(message);
+    this.name = "RateLimitError";
+    this.maxCalls = maxCalls;
+  }
+};
+
+// node_modules/@logosdx/utils/dist/esm/flow-control/with-timeout.mjs
+var TimeoutError = class extends Error {
+  constructor(message) {
+    super(message);
+  }
+};
+var isTimeoutError = (error) => {
+  return error?.constructor?.name === TimeoutError.name;
+};
+
+// node_modules/@logosdx/utils/dist/esm/units/time.mjs
+var timeUnits = {
+  sec: 1e3,
+  min: 60 * 1e3,
+  min15: 15 * 60 * 1e3,
+  min30: 30 * 60 * 1e3,
+  hour: 60 * 60 * 1e3,
+  hour2: 2 * 60 * 60 * 1e3,
+  hour4: 4 * 60 * 60 * 1e3,
+  hour8: 8 * 60 * 60 * 1e3,
+  hour12: 12 * 60 * 60 * 1e3,
+  day: 24 * 60 * 60 * 1e3,
+  week: 7 * 24 * 60 * 60 * 1e3,
+  secs(n) {
+    return n * this.sec;
+  },
+  mins(n) {
+    return n * this.min;
+  },
+  hours(n) {
+    return n * this.hour;
+  },
+  days(n) {
+    return n * this.day;
+  },
+  weeks(n) {
+    return n * this.week;
+  },
+  months(n) {
+    return Math.round(n * 30.4 * this.day);
+  },
+  years(n) {
+    return n * 365 * this.day;
+  }
+};
+var seconds = (n) => timeUnits.secs(n);
+var minutes = (n) => timeUnits.mins(n);
+var hours = (n) => timeUnits.hours(n);
+var days = (n) => timeUnits.days(n);
+var weeks = (n) => timeUnits.weeks(n);
+var months = (n) => timeUnits.months(n);
+var years = (n) => timeUnits.years(n);
+var parseTimeDuration = (str) => {
+  const match = str.match(/^(\d+(?:\.\d+)?)\s*(s|sec|secs?|seconds?|m|min|mins?|minutes?|h|hr|hrs?|hour|hours?|d|day|days?|w|wk|wks?|week|weeks?|mo|mon|mons?|month|months?|y|yr|yrs?|year|years?)$/i);
+  if (!match) {
+    throw new Error(`Invalid time duration: ${str}`);
+  }
+  const [, num, unit] = match;
+  const n = parseFloat(num);
+  const unitLower = unit.toLowerCase();
+  if (unitLower.startsWith("s")) return seconds(n);
+  if (unitLower.startsWith("m") && !unitLower.startsWith("mo")) return minutes(n);
+  if (unitLower.startsWith("h")) return hours(n);
+  if (unitLower.startsWith("d")) return days(n);
+  if (unitLower.startsWith("w")) return weeks(n);
+  if (unitLower.startsWith("mo")) return months(n);
+  if (unitLower.startsWith("y")) return years(n);
+  throw new Error(`Unknown unit: ${unit}`);
+};
+
+// node_modules/@logosdx/utils/dist/esm/units/bytes.mjs
+var byteUnits = {
+  kb: 1024,
+  mb: 1024 ** 2,
+  gb: 1024 ** 3,
+  tb: 1024 ** 4,
+  kbs(n) {
+    return n * this.kb;
+  },
+  mbs(n) {
+    return n * this.mb;
+  },
+  gbs(n) {
+    return n * this.gb;
+  },
+  tbs(n) {
+    return n * this.tb;
+  }
+};
+var kilobytes = (n) => byteUnits.kbs(n);
+var megabytes = (n) => byteUnits.mbs(n);
+var gigabytes = (n) => byteUnits.gbs(n);
+var terabytes = (n) => byteUnits.tbs(n);
+var parseByteSize = (str) => {
+  const match = str.match(/^(\d+(?:\.\d+)?)\s*(kb|kbs?|kilobytes?|mb|mbs?|megabytes?|gb|gbs?|gigabytes?|tb|tbs?|terabytes?)$/i);
+  if (!match) {
+    throw new Error(`Invalid byte size: ${str}`);
+  }
+  const [, num, unit] = match;
+  const n = parseFloat(num);
+  const unitLower = unit.toLowerCase();
+  if (unitLower.startsWith("k")) return kilobytes(n);
+  if (unitLower.startsWith("m")) return megabytes(n);
+  if (unitLower.startsWith("g")) return gigabytes(n);
+  if (unitLower.startsWith("t")) return terabytes(n);
+  throw new Error(`Unknown unit: ${unit}`);
+};
+
+// node_modules/@logosdx/utils/dist/esm/config/index.mjs
+var onlyNumRegex = /^\d+$/;
+var castValuesToTypes = (obj, opts = {}) => {
+  const { parseUnits = false, skipConversion } = opts;
+  for (const key in obj) {
+    const k = key;
+    const val = obj[k];
+    if (skipConversion?.(key, val)) {
+      continue;
+    }
+    const isObject2 = typeof val === "object" && val !== null;
+    if (isObject2) {
+      castValuesToTypes(val, opts);
+      continue;
+    }
+    if (parseUnits && typeof val === "string") {
+      const [timeDuration, timeErr] = attemptSync(() => parseTimeDuration(val));
+      if (!timeErr && typeof timeDuration === "number") {
+        obj[k] = timeDuration;
+        continue;
+      }
+      const [byteSize, bytesErr] = attemptSync(() => parseByteSize(val));
+      if (!bytesErr && typeof byteSize === "number") {
+        obj[k] = byteSize;
+        continue;
+      }
+    }
+    const truthy = isEnabledValue(obj[k]);
+    const falsy = isDisabledValue(obj[k]);
+    if (truthy || falsy) {
+      obj[k] = truthy;
+      continue;
+    }
+    if (typeof val === "string" && onlyNumRegex.test(val)) {
+      obj[k] = Number(val);
+      continue;
+    }
+  }
+};
+var makeNestedConfig = (_flatConfig, opts = {}) => {
+  assert(typeof _flatConfig === "object" && _flatConfig !== null, "flatConfig must be a non-null object");
+  assert(typeof opts === "object" && opts !== null, "opts must be a non-null object");
+  assert(opts.filter === void 0 || typeof opts.filter === "function", "filter must be a function");
+  assert(opts.forceAllCapToLower === void 0 || typeof opts.forceAllCapToLower === "boolean", "forceAllCapToLower must be a boolean");
+  assert(opts.separator === void 0 || typeof opts.separator === "string", "separator must be a string");
+  assert(opts.stripPrefix === void 0 || typeof opts.stripPrefix === "string" || typeof opts.stripPrefix === "number", "stripPrefix must be a string or number");
+  assert(opts.parseUnits === void 0 || typeof opts.parseUnits === "boolean", "parseUnits must be a boolean");
+  assert(opts.skipConversion === void 0 || typeof opts.skipConversion === "function", "skipConversion must be a function");
+  assert(opts.memoizeOpts === void 0 || typeof opts.memoizeOpts === "object" || opts.memoizeOpts === false, "memoizeOpts must be an object or false");
+  const { filter, forceAllCapToLower = true, separator = "_", stripPrefix, parseUnits = false, skipConversion, memoizeOpts = false } = opts;
+  const isAllCaps = (str) => /^[A-Z0-9_]+$/.test(str);
+  const handleCasing = (str) => {
+    let processedStr = str;
+    if (stripPrefix !== void 0) {
+      if (typeof stripPrefix === "number") {
+        processedStr = str.slice(stripPrefix);
+      } else {
+        processedStr = str.startsWith(stripPrefix) ? str.slice(stripPrefix.length) : str;
+      }
+    }
+    const split = processedStr.split(separator);
+    return split.map((s) => {
+      if (isAllCaps(s) && forceAllCapToLower) return s.toLowerCase();
+      return s;
+    }).join(".");
+  };
+  function allConfigs() {
+    const flatConfig = clone(_flatConfig);
+    const config = {};
+    const keys = Object.entries(flatConfig).filter(([key, val]) => filter?.(key, val) ?? true).map(([key]) => key).sort();
+    const [, err] = attemptSync(() => {
+      setDeepMany(config, keys.map((k) => [
+        handleCasing(k),
+        flatConfig[k]
+      ]));
+      castValuesToTypes(config, {
+        parseUnits,
+        skipConversion
+      });
+    });
+    if (err instanceof Error && err.message.includes("on primitive value")) {
+      const key = (k) => k.split("_").join(separator);
+      const eq = (k, v) => `${key(k)}=${v}`;
+      const message = [
+        "Failed to load flatmap variables.",
+        "You're likely trying to set a nested property on a non-object value.",
+        `For example, if you have ${eq("APP_DB_NAME", "foo")}, and then you try to set`,
+        `${eq("APP_DB_NAME_TEST", "bar")}, you'll get this error because ${key("APP_DB_NAME")} is a string.`,
+        "The correct way is to designate each namespace (separated by underscores) as ",
+        `an object. For example, ${eq("APP_DB_NAME", "foo")} becomes { db: { name: "foo" } }, and,`,
+        `${eq("APP_DB_NAME_TEST", "bar")} becomes { db: { name: { test: "bar" } } }, but both cannot coexist.`,
+        `
+
+You can either \`unset ${key("APP_PROBLEMATIC")}\` or scope all vars to \`${key("APP_NAMESPACE_NAME")}\` to`,
+        "make it a nested object.",
+        "\n\n"
+      ];
+      console.error(message.join(" "));
+    }
+    if (err) throw err;
+    return config;
+  }
+  function getConfig(path, defaultValue) {
+    const config = allConfigs();
+    const value = reach(config, path);
+    if (value === void 0 || value === null) {
+      return defaultValue;
+    }
+    return value;
+  }
+  if (!memoizeOpts) return {
+    allConfigs,
+    getConfig
+  };
+  return {
+    allConfigs: memoizeSync(allConfigs, memoizeOpts),
+    getConfig: memoizeSync(getConfig, memoizeOpts)
+  };
+};
+
+// node_modules/@logosdx/observer/dist/esm/helpers.mjs
+var EventTrace = class extends Error {
+  listener;
+  data;
+  func;
+  event;
+  stack;
+};
+var traceStackFilterRgx = new RegExp(`(${[
+  "node_modules",
+  "node:internal",
+  "$spy",
+  "makeEventTracer",
+  "sendToSpy",
+  "Function.spy",
+  "Observable.Engine"
+].join("|")})`);
+var EventError = class extends Error {
+  event;
+  listener;
+  data;
+  constructor(message, opts) {
+    super(message);
+    this.event = opts?.event;
+    this.listener = opts?.listener;
+    this.data = opts?.data;
+  }
+};
+var makeEventTracer = (event, caller, listenerOrData) => {
+  const err = new Error();
+  const split = err.stack.split("\n");
+  split.shift();
+  const filtered = split.filter((line) => !traceStackFilterRgx.test(line));
+  const message = `EventStack (${event} ${caller.toString()}):`;
+  filtered.unshift(message);
+  const stack = filtered.join("\n");
+  const tracer = new EventTrace(message);
+  tracer.name = message;
+  tracer.func = caller;
+  tracer.event = event;
+  tracer.stack = stack;
+  tracer.listener = null;
+  tracer.data = null;
+  if (typeof listenerOrData === "function") {
+    tracer.listener = listenerOrData;
+  } else {
+    tracer.data = listenerOrData;
+  }
+  return tracer;
+};
+var rgxStrToRgx = (rgxStr) => {
+  const split = rgxStr?.replace(/^\//, "").split("/");
+  const flags = split.pop();
+  const expr = split.join("/");
+  return RegExp(expr, flags);
+};
+var arrOfMatchingValues = (vals, map) => {
+  const listeners = [];
+  for (const key of vals) {
+    for (const fn of map.get(key) || /* @__PURE__ */ new Set()) {
+      listeners.push({
+        event: key,
+        func: fn
+      });
+    }
+  }
+  return listeners;
+};
+var InternalEvs = /* @__PURE__ */ (function(InternalEvs2) {
+  InternalEvs2["on"] = "on";
+  InternalEvs2["off"] = "off";
+  InternalEvs2["emit"] = "emit";
+  InternalEvs2["clear"] = "clear";
+  return InternalEvs2;
+})({});
+var InternalEvent = class extends Event {
+  type;
+  data;
+  constructor(ev, data) {
+    super(ev);
+    this.data = data;
+    this.type = ev;
+  }
+};
+var validateEvent = (fn, opts) => {
+  if (opts.event === void 0 || typeof opts.event !== "string" && opts.event instanceof RegExp === false) {
+    throw new EventError(`observer.${fn}: Event must be a string or RegExp`, opts);
+  }
+};
+var validateListener = (fn, opts) => {
+  if (opts.listener !== void 0 && typeof opts.listener !== "function") {
+    throw new EventError(`observer.${fn}: Listener must be a function`, opts);
+  }
+};
+
+// node_modules/@logosdx/observer/dist/esm/generator.mjs
+var DeferredEvent = class extends Deferred {
+  cleanup;
+};
+var EventGenerator = class {
+  #observer;
+  #event;
+  #buffer;
+  #waiting = null;
+  #done = false;
+  #listener = null;
+  #lastValue = null;
+  #assertNotDestroyed = () => {
+    if (this.#done === true) {
+      throw new EventError(`Event generator for ${this.#event.toString()} has been destroyed`, {
+        event: this.#event,
+        listener: this.#listener,
+        data: null
+      });
+    }
+  };
+  cleanup;
+  next;
+  constructor(observer2, event, options) {
+    this.#observer = observer2;
+    this.#event = event;
+    this.#buffer = new PriorityQueue();
+    this.#listener = (data) => {
+      this.#lastValue = data;
+      if (this.#waiting) {
+        const defer = this.#waiting;
+        this.#waiting = null;
+        defer.resolve(data);
+      } else {
+        this.#buffer.push(data);
+      }
+    };
+    const off = observer2.on(event, this.#listener);
+    let generatorAbortCtrl;
+    this.next = () => {
+      this.#assertNotDestroyed();
+      const buffered = this.#buffer.pop();
+      if (buffered !== null) {
+        return Promise.resolve(buffered);
+      }
+      if (!this.#waiting) {
+        this.#waiting = new DeferredEvent();
+        this.#waiting.promise.cleanup = this.cleanup;
+        this.#waiting.promise.resolve = this.#waiting.resolve;
+        this.#waiting.promise.reject = this.#waiting.reject;
+      }
+      return this.#waiting.promise;
+    };
+    this.cleanup = () => {
+      if (this.#done) return;
+      off();
+      this.#done = true;
+      const abortError = new EventError("Aborted", {
+        event: this.#event,
+        listener: this.#listener,
+        data: null
+      });
+      if (this.#waiting) {
+        this.#waiting.reject(abortError);
+        this.#waiting = null;
+      }
+      this.#_iterPromise.forEach((promise) => {
+        promise.reject?.(abortError);
+      });
+      this.#_iterPromise.clear();
+      this.#buffer.clear();
+      this.#lastValue = null;
+      generatorAbortCtrl?.abort();
+    };
+    const userSignal = options?.signal;
+    if (userSignal) {
+      if (userSignal.aborted) {
+        this.#done = true;
+        return;
+      }
+      generatorAbortCtrl = new AbortController();
+      userSignal.addEventListener("abort", this.cleanup, {
+        signal: generatorAbortCtrl.signal
+      });
+    }
+  }
+  /**
+   * Store iterator's last promise. Handles multiple promises
+   * for when the generator is used in multiple places.
+   */
+  #_iterPromise = /* @__PURE__ */ new Set();
+  async *[Symbol.asyncIterator]() {
+    while (!this.#done) {
+      const promise = this.next();
+      this.#_iterPromise.add(promise);
+      yield await promise;
+      this.#_iterPromise.delete(promise);
+    }
+    return Promise.resolve(void 0);
+  }
+  get lastValue() {
+    return this.#lastValue;
+  }
+  get done() {
+    return this.#done;
+  }
+  emit(data) {
+    this.#assertNotDestroyed();
+    this.#observer.emit(this.#event, data);
+  }
+};
+
+// node_modules/@logosdx/observer/dist/esm/queue/state.mjs
+var QueueStateManager = class {
+  status = "stopped";
+  #allowedTransitions = {
+    ["running"]: [
+      "paused",
+      "draining",
+      "stopped"
+    ],
+    ["draining"]: [
+      "stopped",
+      "paused"
+    ],
+    ["paused"]: [
+      "running",
+      "draining",
+      "stopped"
+    ],
+    ["stopped"]: [
+      "running",
+      "draining"
+    ]
+  };
+  transition(to) {
+    assert(this.#allowedTransitions[this.status].includes(to), `Invalid transition from ${this.status} to ${to}`);
+    this.status = to;
+  }
+  is(...states) {
+    return states.includes(this.status);
+  }
+  get state() {
+    return this.status;
+  }
+};
+
+// node_modules/@logosdx/observer/dist/esm/queue/statistics.mjs
+var QueueStats = class {
+  observer;
+  queueName;
+  #processing;
+  #processed;
+  #avgProcessingTime;
+  #success;
+  #error;
+  #rejected;
+  constructor(observer2, queueName) {
+    this.observer = observer2;
+    this.queueName = queueName;
+    this.#processing = 0;
+    this.#processed = 0;
+    this.#avgProcessingTime = 0;
+    this.#success = 0;
+    this.#error = 0;
+    this.#rejected = 0;
+    this.observer.on(`queue:${this.queueName}:processing`, () => {
+      this.#processing++;
+    });
+    this.observer.on(`queue:${this.queueName}:success`, (wrapped) => {
+      this.#processed++;
+      this.#success++;
+      this.#processing--;
+      this.#calculateAvg(wrapped.data.elapsed);
+    });
+    this.observer.on(`queue:${this.queueName}:error`, () => {
+      this.#processed++;
+      this.#error++;
+      this.#processing--;
+    });
+    this.observer.on(`queue:${this.queueName}:rejected`, () => this.#rejected++);
+  }
+  #calculateAvg(elapsed) {
+    this.#avgProcessingTime = (this.#avgProcessingTime * (this.#success - 1) + elapsed) / this.#success;
+  }
+  get stats() {
+    return {
+      processed: this.#processed,
+      processing: this.#processing,
+      avgProcessingTime: this.#avgProcessingTime,
+      success: this.#success,
+      error: this.#error,
+      rejected: this.#rejected
+    };
+  }
+};
+
+// node_modules/@logosdx/observer/dist/esm/queue/helpers.mjs
+var InternalQueueEvent = class {
+  data;
+  constructor(data) {
+    this.data = data;
+  }
+};
+var QueueRejectionReason = /* @__PURE__ */ (function(QueueRejectionReason2) {
+  QueueRejectionReason2["full"] = "Queue is full";
+  QueueRejectionReason2["notRunning"] = "Queue is not running";
+  return QueueRejectionReason2;
+})({});
+
+// node_modules/@logosdx/observer/dist/esm/queue/queue.mjs
+var EventQueue = class {
+  opts;
+  #queue;
+  #priorites;
+  #off;
+  #state;
+  #stats;
+  #rateLimiter;
+  #idle;
+  #waiting;
+  #listening;
+  #debugging;
+  #generation;
+  #activeRunners;
+  #runningNodes;
+  constructor(opts) {
+    this.opts = opts;
+    this.#priorites = /* @__PURE__ */ new Map();
+    this.#off = noop;
+    this.#state = new QueueStateManager();
+    this.#idle = true;
+    this.#waiting = false;
+    this.#listening = false;
+    this.#debugging = false;
+    this.#generation = 0;
+    this.#activeRunners = 0;
+    this.#runningNodes = /* @__PURE__ */ new Set();
+    const { observer: observer2 = new ObserverEngine(), event, process: process2, name, type = "fifo", concurrency = 1, pollIntervalMs = 100, jitterFactor = 0, rateLimitIntervalMs = 1e3, processIntervalMs = 0, taskTimeoutMs = 0, autoStart = true, debug = false } = this.opts;
+    let { maxQueueSize = 999999999, rateLimitCapacity = 999999999 } = this.opts;
+    assert(isPlainObject(this.opts), "Options is required to be an object");
+    assert(isFunction(observer2?.on), "ObserverEngine is required");
+    assert(typeof event === "string" && event.length > 0 || event instanceof RegExp, "Event is required to be a string or RegExp");
+    assert(isFunction(process2), "Process is required to be a function");
+    assert(name && typeof name === "string" && name.length > 0, "Name is required");
+    assert(concurrency > 0, "Concurrency must be greater than 0");
+    assert(pollIntervalMs > 0, "pollIntervalMs must be a number greater than 0");
+    assert(jitterFactor >= 0 && jitterFactor <= 1, "Jitter must be a number greater than or equal to 0 and less than or equal to 1");
+    assert(maxQueueSize > 0, "MaxQueueSize must be a number greater than 0");
+    assert(rateLimitIntervalMs > 0, "rateLimitIntervalMs must be a number greater than 0");
+    assert(rateLimitCapacity > 0, "rateLimitCapacity must be a number greater than 0");
+    assert(processIntervalMs >= 0, "processIntervalMs must be a number greater than or equal to 0");
+    assert(taskTimeoutMs >= 0, "taskTimeoutMs must be a number greater than or equal to 0");
+    assert(type === "fifo" || type === "lifo", 'Type must be either "fifo" or "lifo"');
+    assert(typeof autoStart === "boolean", "AutoStart must be a boolean");
+    if (maxQueueSize === Infinity) {
+      maxQueueSize = 999999999;
+    }
+    if (rateLimitCapacity === Infinity) {
+      rateLimitCapacity = 999999999;
+    }
+    Object.assign(this.opts, {
+      observer: observer2,
+      type,
+      concurrency,
+      maxQueueSize,
+      pollIntervalMs,
+      jitterFactor,
+      processIntervalMs,
+      taskTimeoutMs
+    });
+    this.#debugging = debug;
+    this.#stats = new QueueStats(observer2, name);
+    this.#rateLimiter = new RateLimitTokenBucket({
+      capacity: rateLimitCapacity,
+      refillIntervalMs: rateLimitIntervalMs
+    });
+    this.#queue = new PriorityQueue({
+      lifo: type === "lifo"
+    });
+    if (autoStart) {
+      this.start();
+    }
+  }
+  #listen() {
+    if (this.#listening) return;
+    this.#listening = true;
+    const off = this.opts.observer.on(this.opts.event, (payload) => {
+      const maybeInternal = payload?.data ?? payload;
+      if (maybeInternal instanceof InternalQueueEvent) {
+        return;
+      }
+      const data = payload;
+      const item = {
+        data,
+        _taskId: generateId(),
+        priority: this.#priorites.get(data) ?? 0
+      };
+      this.#priorites.delete(data);
+      if (this.#queue.size() >= this.opts.maxQueueSize) {
+        this.#emit("rejected", {
+          ...item,
+          reason: QueueRejectionReason.full
+        });
+        return;
+      }
+      this.#emit("added", item);
+      this.#idle = false;
+      this.#queue.push(item, item.priority);
+    });
+    this.#off = () => {
+      off();
+      this.#listening = false;
+    };
+  }
+  #emit(event, payload) {
+    if (this.#debugging) {
+      const args = [
+        `[${this.name}] ${event}`,
+        payload?._taskId ?? "",
+        payload?.data ?? ""
+      ];
+      if (this.#debugging === "verbose") {
+        args[1] = payload;
+      }
+      console.log(...args);
+    }
+    this.opts.observer.emit(`queue:${this.name}:${event}`, new InternalQueueEvent(payload));
+  }
+  /**
+   * Setups concurrency and begins processing items
+   */
+  #launchRunners() {
+    const generation = ++this.#generation;
+    for (let i = 0; i < this.opts.concurrency; i++) {
+      this.#workerLoop(generation, i);
+    }
+  }
+  /**
+   * Loops and processes items in the queue until the queue is stopped
+   */
+  async #workerLoop(generation, instance) {
+    const { pollIntervalMs, jitterFactor } = this.opts;
+    this.#activeRunners++;
+    while (this.#state.is("running") && this.#generation === generation) {
+      if (!this.pending) {
+        if (!this.#idle && !this.pending && this.#runningNodes.size === 0) {
+          this.#idle = true;
+          this.#emit("idle");
+        }
+        this.#waiting = true;
+        await wait(pollIntervalMs * (1 + Math.random() * jitterFactor));
+        this.#waiting = false;
+        continue;
+      }
+      const data = this.#queue.pop();
+      if (!data) continue;
+      this.#runningNodes.add(`${generation}-${instance}`);
+      await this.#processNext(data);
+      if (this.opts.processIntervalMs > 0) {
+        await wait(this.opts.processIntervalMs);
+      }
+      this.#runningNodes.delete(`${generation}-${instance}`);
+    }
+    this.#activeRunners--;
+  }
+  /**
+   * Processes the next item in the queue, if the queue is not
+   * in a state that prevents it from processing the item.
+   */
+  async #processNext(item) {
+    if (!this.#state.is("running", "draining")) {
+      this.#queue.push(item);
+      return;
+    }
+    let rateLimited = false;
+    if (!this.#state.is("draining")) {
+      await this.#rateLimiter.waitAndConsume(1, {
+        onRateLimit: () => {
+          this.#emit("rate-limited", item);
+          rateLimited = true;
+        }
+      });
+    }
+    const startedAt = Date.now();
+    this.#emit("processing", {
+      ...item,
+      startedAt,
+      rateLimited
+    });
+    const [, err] = await attempt(async () => {
+      if (this.opts.taskTimeoutMs === 0) {
+        return this.opts.process(item.data);
+      }
+      const result = await Promise.race([
+        this.opts.process(item.data),
+        wait(this.opts.taskTimeoutMs, new TimeoutError("Task timed out"))
+      ]);
+      if (isTimeoutError(result)) {
+        this.#emit("timeout", {
+          ...item,
+          error: result
+        });
+        throw result;
+      }
+      return result;
+    });
+    const elapsed = Date.now() - startedAt;
+    if (err) {
+      this.#emit("error", {
+        ...item,
+        error: err,
+        rateLimited
+      });
+    } else {
+      this.#emit("success", {
+        ...item,
+        startedAt,
+        elapsed,
+        rateLimited
+      });
+    }
+    if (this.#queue.size() === 0 && this.#state.is("running")) {
+      this.#emit("empty");
+    }
+  }
+  /**
+   * Start the queue if it is not already started
+   */
+  start() {
+    if (this.#state.is("running")) return;
+    this.#listen();
+    this.#state.transition("running");
+    this.#emit("start");
+    this.#launchRunners();
+    this.#emit("started");
+    return Promise.resolve();
+  }
+  /**
+   * Stop the queue
+   */
+  stop() {
+    if (this.#state.is("stopped")) return;
+    this.#off();
+    this.#state.transition("stopped");
+    this.#emit("stopped");
+  }
+  /**
+   * Pause the queue
+   */
+  pause() {
+    if (this.#state.is("paused")) return;
+    this.#state.transition("paused");
+    this.#emit("paused");
+    return Promise.resolve();
+  }
+  /**
+   * Resume the queue
+   */
+  resume() {
+    if (this.#state.is("running")) return;
+    this.#listen();
+    this.#state.transition("running");
+    this.#launchRunners();
+    this.#emit("resumed");
+    return Promise.resolve();
+  }
+  /**
+   * Processes a batch of items from the queue, and then
+   * calls the before and after functions. Returns the
+   * number of items processed.
+   */
+  async #processBatch(limit = Infinity, beforeFn, afterFn) {
+    let count = limit === Infinity ? this.#queue.size() : limit;
+    const items = this.#queue.popMany(count);
+    if (count < items.length) {
+      count = items.length;
+    }
+    beforeFn?.(count);
+    if (count !== 0) {
+      for (const item of items) {
+        await this.#processNext(item);
+      }
+    }
+    afterFn?.(count);
+    return count;
+  }
+  /**
+   * Empty and process all items in the queue and
+   * then stop the queue. Returns the number of items
+   * processed.
+   */
+  shutdown(force = false) {
+    if (this.#state.is("draining", "stopped")) return Promise.resolve(0);
+    if (force) {
+      const count = this.purge();
+      this.stop();
+      this.#emit("shutdown", {
+        force,
+        pending: count
+      });
+      return Promise.resolve(count);
+    }
+    return this.#processBatch(Infinity, (pending) => {
+      this.pause();
+      this.#state.transition("draining");
+      this.#off();
+      this.#emit("drain", {
+        pending
+      });
+    }, (drained) => {
+      this.#emit("drained", force ? {
+        pending: drained
+      } : {
+        drained
+      });
+      this.stop();
+      this.#emit("shutdown", force ? {
+        force,
+        pending: drained
+      } : {
+        force
+      });
+    });
+  }
+  /**
+   * Executes `limit` items in the queue
+   * and then emits a `flush` event. Returns the number
+   * of items processed.
+   */
+  async flush(limit = Infinity) {
+    return this.#processBatch(limit, (pending) => this.#emit("flush", {
+      pending
+    }), (flushed) => this.#emit("flushed", {
+      flushed
+    }));
+  }
+  /**
+   * Clears the queue and emits a `purge` event. Returns
+   * the number of items purged.
+   */
+  purge() {
+    const count = this.#queue.size();
+    this.#queue.clear();
+    this.#emit("purged", {
+      count
+    });
+    return count;
+  }
+  /**
+   * Emit an event to the observer, which then gets
+   * picked up by the queue and processed.
+   *
+   * @param data The data to add to the queue
+   * @param priority The priority of the data
+   *
+   * @note If priority is provided, it will be used to determine the order of the data in the queue.
+   *       The higher the priority, the sooner the data will be processed.
+   *
+   * @note If priority is not provided, the data will be added to the queue with a priority of 0.
+   */
+  add(data, priority) {
+    if (!this.#state.is("running", "paused")) {
+      this.#emit("rejected", {
+        data,
+        reason: QueueRejectionReason.notRunning
+      });
+      return false;
+    }
+    if (this.#queue.size() >= this.opts.maxQueueSize) {
+      this.#emit("rejected", {
+        data,
+        reason: QueueRejectionReason.full
+      });
+      return false;
+    }
+    if (priority) {
+      this.#priorites.set(data, priority);
+    }
+    this.opts.observer.emit(this.opts.event, data);
+    return true;
+  }
+  debug(on = false) {
+    this.#debugging = on;
+  }
+  #observerForQueue() {
+    return this.opts.observer;
+  }
+  on(event, listener) {
+    return this.#observerForQueue().on(`queue:${this.name}:${event}`, listener);
+  }
+  once(event, listener) {
+    return this.#observerForQueue().once(`queue:${this.name}:${event}`, listener);
+  }
+  off(event, listener) {
+    return this.#observerForQueue().off(`queue:${this.name}:${event}`, listener);
+  }
+  /**
+   * The name of the queue
+   */
+  get name() {
+    return this.opts.name;
+  }
+  /**
+   * Whether the queue is waiting for the
+   * the
+   */
+  get isWaiting() {
+    return this.#waiting;
+  }
+  /**
+   * Whether the queue is idle
+   */
+  get isIdle() {
+    return this.#idle && this.#state.is("running");
+  }
+  /**
+   * Whether the queue is running
+   */
+  get isRunning() {
+    return this.#state.is("running");
+  }
+  /**
+   * Whether the queue is paused
+   */
+  get isPaused() {
+    return this.#state.is("paused");
+  }
+  /**
+   * Whether the queue is stopped
+   */
+  get isStopped() {
+    return this.#state.is("stopped");
+  }
+  /**
+   * Whether the queue is draining
+   */
+  get isDraining() {
+    return this.#state.is("draining");
+  }
+  /**
+   * The current state of the queue
+   */
+  get state() {
+    return this.#state.state;
+  }
+  /**
+   * The number of items in the queue
+   */
+  get pending() {
+    return this.#queue.size();
+  }
+  /**
+   * The stats of the queue
+   */
+  get stats() {
+    return clone(this.#stats.stats);
+  }
+  get snapshot() {
+    return {
+      name: this.name,
+      state: this.state,
+      pending: this.pending,
+      stats: this.stats,
+      rateLimiter: this.#rateLimiter.snapshot,
+      activeRunners: this.#activeRunners,
+      runningNodes: this.#runningNodes,
+      isIdle: this.isIdle,
+      isWaiting: this.isWaiting,
+      isRunning: this.isRunning,
+      isPaused: this.isPaused,
+      isStopped: this.isStopped,
+      isDraining: this.isDraining,
+      isEmpty: this.pending === 0
+    };
+  }
+};
+
+// node_modules/@logosdx/observer/dist/esm/engine.mjs
+var ObserverEngine = class _ObserverEngine {
+  #listenerMap = /* @__PURE__ */ new Map();
+  #rgxListenerMap = /* @__PURE__ */ new Map();
+  #internalListener = new EventTarget();
+  #emitValidator;
+  #spy;
+  // Hidden property for holding the spy function
+  // when debugging is enabled. Used to restore the
+  // original spy function when debugging is disabled.
+  #__spy;
+  // Instance-level AbortController for cleanup
+  #instanceController = new AbortController();
+  #instanceSignal;
+  constructor(options) {
+    if (options) {
+      assert(!options.name || typeof options.name === "string", "Observable options.name must be a string", TypeError);
+      assert(!options.spy || typeof options.spy === "function", "Observable options.spy must be a function", TypeError);
+      assert(!options.emitValidator || typeof options.emitValidator === "function", "Observable options.emitValidator must be a function", TypeError);
+      this.#spy = options.spy;
+    }
+    this.#instanceSignal = this.#instanceController.signal;
+    const userSignal = options?.signal;
+    const clearOnAbort = () => this.clear();
+    this.#instanceSignal.addEventListener("abort", clearOnAbort, {
+      once: true
+    });
+    if (userSignal) {
+      userSignal.addEventListener("abort", clearOnAbort, {
+        once: true
+      });
+    }
+    definePrivateProps(this, {
+      on: this.on,
+      once: this.once,
+      emit: this.emit,
+      off: this.off,
+      observe: this.observe,
+      debug: this.debug,
+      $has: this.$has,
+      $facts: this.$facts,
+      $internals: this.$internals,
+      name: options?.name || Math.random().toString(36).substring(7)
+    });
+    this.#emitValidator = options?.emitValidator;
+  }
+  name;
+  /**
+   * Returns facts about the the internal state of the observable instance.
+   */
+  $facts() {
+    const listenKeys = [
+      ...this.#listenerMap.keys()
+    ];
+    const rgxKeys = [
+      ...this.#rgxListenerMap.keys()
+    ];
+    const listenerCounts = Object.fromEntries([
+      listenKeys.map((k) => [
+        k,
+        this.#listenerMap.get(k)?.size
+      ]),
+      rgxKeys.map((k) => [
+        k,
+        this.#rgxListenerMap.get(k)?.size
+      ])
+    ].flat());
+    return {
+      listeners: listenKeys,
+      rgxListeners: rgxKeys,
+      listenerCounts,
+      hasSpy: !!this.#spy
+    };
+  }
+  /**
+  * The internals of the observable instance.
+     *
+     * NOTE: Do not use this to try to meddle with the
+     * internals of the observable instance. This is for
+     * debugging purposes only.
+  */
+  $internals() {
+    return {
+      listenerMap: clone(this.#listenerMap),
+      rgxListenerMap: clone(this.#rgxListenerMap),
+      internalListener: clone(this.#internalListener),
+      name: this.name,
+      spy: this.#spy
+    };
+  }
+  $has(event) {
+    if (event instanceof RegExp) {
+      return this.#rgxListenerMap.has(event.toString());
+    }
+    return this.#listenerMap.has(event) || this.#rgxListenerMap.has(event);
+  }
+  #currentSpy(...args) {
+    if (this.#spy) {
+      this.#spy.apply(this, args);
+    }
+  }
+  /**
+   * Enables or disables debugging for the observable instance.
+   * Works in conjunction with your spy function. Provides a
+   * stack trace of events that are triggered, listened to, and
+   * cleaned up.
+   *
+   * @param on Whether to enable or disable debugging
+   */
+  debug(on = true) {
+    const original = this.#spy;
+    const spy = (ev) => {
+      const { event, fn, data, listener } = ev;
+      console.info(makeEventTracer(event, fn, data || listener));
+      original && original(ev);
+    };
+    if (on) {
+      this.#spy = spy;
+      this.#__spy = original;
+      return;
+    }
+    this.#spy = this.#__spy;
+  }
+  /**
+   * Sets the spy function for the observable instance.
+   * @param spy The spy function to set
+   * @param force Whether to force the spy function to be set even if one is already set
+   */
+  spy(spy, force = false) {
+    assert(isFunction(spy), "spy must be a function", TypeError);
+    assert(force || this.#spy === void 0, "you already have a spy function set", TypeError);
+    this.#spy = spy;
+  }
+  /**
+   * Observes given component as an extension of this observable instance.
+   * @param component Component to wrap events around
+   * @param options Optional configuration including signal for cleanup
+   *
+   * @example
+   *
+   * const obs = new ObserverEngine();
+   *
+   * const modal = {};
+   *
+   * obs.observe(modal);
+   *
+   * modal.on('modal-open', () => {});
+   *
+   * obs.trigger('modal-open'); // opens modal
+   * modal.trigger('modal-open'); // opens modal
+   *
+   * modal.cleanup(); // clears all event listeners
+   */
+  observe(component, options) {
+    const self = this;
+    const userSignal = options?.signal;
+    if (userSignal?.aborted) {
+      definePrivateProps(component, {
+        on: noop,
+        once: noop,
+        off: noop,
+        emit: noop,
+        clear: noop,
+        cleanup: noop
+      });
+      return component;
+    }
+    const track = /* @__PURE__ */ new Map();
+    const trackListener = (event, fn) => {
+      const _set = track.get(event) || /* @__PURE__ */ new Set();
+      _set.add(fn);
+      track.set(event, _set);
+      return fn;
+    };
+    const rmAll = () => {
+      for (const entry of track.entries()) {
+        const [ev, _set] = entry;
+        [
+          ..._set
+        ].forEach((fn) => self.off(ev, fn));
+        track.set(ev, /* @__PURE__ */ new Set());
+      }
+    };
+    const afterOff = (_event) => {
+      const [event, callback] = _event.data;
+      const _set = track.get(event);
+      _set?.delete(callback);
+    };
+    this.#internalListener.addEventListener(InternalEvs.off, afterOff);
+    this.#internalListener.addEventListener(InternalEvs.clear, rmAll);
+    const on = (ev, fn) => {
+      return self.on(ev, trackListener(ev, fn));
+    };
+    const once = (ev, fn) => {
+      return self.once(ev, trackListener(ev, fn));
+    };
+    const off = (ev, fn) => {
+      self.off(ev, fn);
+    };
+    const emit = (ev, data) => {
+      return self.emit(ev, data);
+    };
+    const clear = () => rmAll();
+    let observeAbortCtrl;
+    const cleanup = () => {
+      rmAll();
+      self.#internalListener.removeEventListener(InternalEvs.off, afterOff);
+      self.#internalListener.removeEventListener(InternalEvs.clear, rmAll);
+      observeAbortCtrl?.abort();
+    };
+    if (userSignal) {
+      observeAbortCtrl = new AbortController();
+      const composedSignal = AbortSignal.any([
+        this.#instanceSignal,
+        userSignal
+      ]);
+      composedSignal.addEventListener("abort", cleanup, {
+        signal: observeAbortCtrl.signal
+      });
+    }
+    definePrivateProps(component, {
+      on,
+      once,
+      off,
+      emit,
+      clear,
+      cleanup
+    });
+    return component;
+  }
+  /**
+   * Gets information about the event, whether it's a regex or not,
+   * the event name, and the regex itself.
+   */
+  #eventInfo(event) {
+    const isRgx = event.constructor === RegExp;
+    const eventName = event.toString();
+    return {
+      isRgx,
+      eventName,
+      rgx: event
+    };
+  }
+  /**
+   * Returns all event names that match the regex
+   */
+  #withRgxMatchKeys(rgx) {
+    return [
+      ...this.#listenerMap.keys()
+    ].filter((k) => rgx.test(k));
+  }
+  /**
+   * Returns all regexes that match the key
+   */
+  #withKeyMatchRgx(key) {
+    return [
+      ...this.#rgxListenerMap.keys()
+    ].filter((s) => rgxStrToRgx(s).test(key)).flat();
+  }
+  /**
+   * Returns all event names that match the regex
+   */
+  #matchStr(rgx) {
+    const events = this.#withRgxMatchKeys(rgx);
+    return arrOfMatchingValues(events, this.#listenerMap);
+  }
+  /**
+   * Returns all regexes that match the key
+   */
+  #matchRgx(str) {
+    const events = this.#withKeyMatchRgx(str);
+    return arrOfMatchingValues(events, this.#rgxListenerMap);
+  }
+  /**
+   * Listen for an event
+   * @param event
+   * @param listenerOrOptions - Either a callback function or options object
+   * @param options
+   */
+  on(event, listenerOrOptions, options) {
+    const isListenerFn = typeof listenerOrOptions === "function";
+    const listener = isListenerFn ? listenerOrOptions : void 0;
+    const resolvedOptions = isListenerFn ? options : listenerOrOptions;
+    if (!resolvedOptions?.once) {
+      validateEvent("on", {
+        event,
+        listener
+      });
+      validateListener("on", {
+        event,
+        listener
+      });
+    }
+    if (listener === void 0) {
+      return new EventGenerator(this, event, resolvedOptions);
+    }
+    const userSignal = resolvedOptions?.signal;
+    if (userSignal?.aborted) {
+      return () => {
+      };
+    }
+    const { eventName, isRgx } = this.#eventInfo(event);
+    const listenerMap = isRgx ? this.#rgxListenerMap : this.#listenerMap;
+    this.#currentSpy({
+      event,
+      fn: resolvedOptions?.once ? "once" : "on",
+      data: null,
+      listener,
+      context: this
+    });
+    const cbSet = listenerMap.get(eventName) || /* @__PURE__ */ new Set([
+      listener
+    ]);
+    if (cbSet && !cbSet.has(listener)) {
+      cbSet.add(listener);
+    }
+    if (!listenerMap.has(eventName)) {
+      listenerMap.set(eventName, cbSet);
+    }
+    this.#internalListener.dispatchEvent(new InternalEvent(InternalEvs.on, [
+      event,
+      listener
+    ]));
+    let cleanedUp = false;
+    const cleanup = () => {
+      if (cleanedUp) return;
+      cleanedUp = true;
+      this.#currentSpy({
+        event,
+        fn: "cleanup",
+        data: null,
+        listener,
+        context: this
+      });
+      cbSet.delete(listener);
+      if (cbSet.size === 0) {
+        listenerMap.delete(eventName);
+      }
+      this.#internalListener.dispatchEvent(new InternalEvent(InternalEvs.off, [
+        event,
+        listener
+      ]));
+    };
+    if (userSignal) {
+      const abortHandler = () => {
+        cleanup();
+        this.#instanceSignal.removeEventListener("abort", abortHandler);
+      };
+      userSignal.addEventListener("abort", abortHandler, {
+        once: true
+      });
+      this.#instanceSignal.addEventListener("abort", abortHandler, {
+        once: true
+      });
+      const originalCleanup = cleanup;
+      const wrappedCleanup = () => {
+        originalCleanup();
+        userSignal.removeEventListener("abort", abortHandler);
+        this.#instanceSignal.removeEventListener("abort", abortHandler);
+      };
+      return wrappedCleanup;
+    }
+    return cleanup;
+  }
+  /**
+   * Executes a callback once when the specified
+   * event is emitted, or returns a promise that
+   * resolves when the event is emitted
+   */
+  once(event, listenerOrOptions, options) {
+    const isListenerFn = typeof listenerOrOptions === "function";
+    const listener = isListenerFn ? listenerOrOptions : void 0;
+    const resolvedOptions = isListenerFn ? options : listenerOrOptions;
+    validateEvent("once", {
+      event,
+      listener
+    });
+    validateListener("once", {
+      event,
+      listener
+    });
+    if (!listener) {
+      const defer = new DeferredEvent();
+      const userSignal = resolvedOptions?.signal;
+      if (userSignal?.aborted) {
+        defer.reject(userSignal.reason ?? new DOMException("Aborted", "AbortError"));
+        defer.promise.cleanup = () => {
+        };
+        return defer.promise;
+      }
+      let promiseAbortCtrl;
+      const cleanup = this.once(event, (data) => {
+        defer.resolve(data);
+        promiseAbortCtrl?.abort();
+      }, resolvedOptions);
+      if (userSignal) {
+        promiseAbortCtrl = new AbortController();
+        userSignal.addEventListener("abort", () => {
+          cleanup();
+          defer.reject(userSignal.reason ?? new DOMException("Aborted", "AbortError"));
+        }, {
+          signal: promiseAbortCtrl.signal
+        });
+      }
+      defer.promise.cleanup = () => {
+        cleanup();
+        promiseAbortCtrl?.abort();
+      };
+      return defer.promise;
+    }
+    const self = this;
+    const runOnce = function(...args) {
+      const { eventName, isRgx } = self.#eventInfo(event);
+      const listenerMap = isRgx ? self.#rgxListenerMap : self.#listenerMap;
+      const fns = listenerMap.get(eventName);
+      if (fns) {
+        fns.delete(runOnce);
+        if (fns.size === 0) listenerMap.delete(eventName);
+      }
+      listener.apply(self, args);
+    };
+    return this.on(event, runOnce, {
+      once: true,
+      ...resolvedOptions
+    });
+  }
+  /**
+   * Stop listening for an event
+   * @param event
+   * @param listener
+   */
+  off(event, listener) {
+    validateEvent("off", {
+      event,
+      listener
+    });
+    this.#currentSpy({
+      event,
+      fn: "off",
+      data: null,
+      listener,
+      context: this
+    });
+    const { eventName, isRgx, rgx } = this.#eventInfo(event);
+    const matches = isRgx ? this.#withRgxMatchKeys(rgx) : [
+      eventName
+    ];
+    matches.forEach((_ev) => {
+      const ev = _ev;
+      this.#internalListener.dispatchEvent(new InternalEvent(InternalEvs.off, [
+        ev,
+        listener
+      ]));
+      if (listener) {
+        const fns = this.#listenerMap.get(ev);
+        if (fns) {
+          fns.delete(listener);
+          if (fns.size === 0) this.#listenerMap.delete(ev);
+        }
+        return;
+      }
+      this.#listenerMap.delete(ev);
+    });
+  }
+  /** Emits an event */
+  emit(event, data) {
+    validateEvent("emit", {
+      event,
+      data
+    });
+    if (this.#emitValidator) {
+      this.#emitValidator(event, data, this);
+    }
+    this.#currentSpy({
+      event,
+      fn: "emit",
+      data,
+      listener: null,
+      context: this
+    });
+    const { eventName, isRgx, rgx } = this.#eventInfo(event);
+    if (!isRgx) {
+      const cbs2 = this.#listenerMap.get(eventName);
+      const rgxCbs = this.#matchRgx(eventName);
+      if (cbs2) cbs2.forEach((fn) => fn.apply(this, [
+        data,
+        {
+          event,
+          listener: fn
+        }
+      ]));
+      if (rgxCbs) rgxCbs.forEach(({ func }) => func.apply(this, [
+        {
+          data,
+          event,
+          listener: func
+        }
+      ]));
+      this.#internalListener.dispatchEvent(new InternalEvent(InternalEvs.emit, [
+        eventName,
+        data
+      ]));
+      return;
+    }
+    const cbs = this.#matchStr(rgx);
+    if (cbs) cbs.forEach(({ event: event2, func }) => func.apply(this, [
+      data,
+      {
+        event: event2,
+        listener: func
+      }
+    ]));
+    this.#withRgxMatchKeys(rgx).forEach((ev) => {
+      this.#internalListener.dispatchEvent(new InternalEvent(InternalEvs.emit, [
+        ev,
+        data
+      ]));
+    });
+  }
+  clear() {
+    this.#listenerMap.clear();
+    this.#rgxListenerMap.clear();
+    this.#internalListener.dispatchEvent(new InternalEvent(InternalEvs.clear, [
+      "clear",
+      null
+    ]));
+  }
+  queue(event, process2, options) {
+    return new EventQueue({
+      ...options,
+      event,
+      process: process2,
+      observer: this
+    });
+  }
+  /**
+   * Checks if an event key passes through the filter/exclude pipeline.
+   * Filter narrows first, then exclude removes from that set.
+   */
+  static #passesFilter(event, options) {
+    if (!options) return true;
+    const { filter, exclude } = options;
+    if (filter) {
+      const passes = filter.some((f) => f instanceof RegExp ? f.test(event) : f === event);
+      if (!passes) return false;
+    }
+    if (exclude) {
+      const blocked = exclude.some((e) => e instanceof RegExp ? e.test(event) : e === event);
+      if (blocked) return false;
+    }
+    return true;
+  }
+  /**
+   * Moves or copies listeners between two ObserverEngine instances.
+   * Static methods on the same class can access # private fields directly.
+   */
+  static #moveListeners(source, target, remove, options) {
+    for (const [event, callbacks] of source.#listenerMap) {
+      if (!_ObserverEngine.#passesFilter(event, options)) continue;
+      const targetSet = target.#listenerMap.get(event) || /* @__PURE__ */ new Set();
+      for (const cb of callbacks) {
+        targetSet.add(cb);
+      }
+      target.#listenerMap.set(event, targetSet);
+      if (remove) {
+        source.#listenerMap.delete(event);
+      }
+    }
+    for (const [event, callbacks] of source.#rgxListenerMap) {
+      if (!_ObserverEngine.#passesFilter(event, options)) continue;
+      const targetSet = target.#rgxListenerMap.get(event) || /* @__PURE__ */ new Set();
+      for (const cb of callbacks) {
+        targetSet.add(cb);
+      }
+      target.#rgxListenerMap.set(event, targetSet);
+      if (remove) {
+        source.#rgxListenerMap.delete(event);
+      }
+    }
+  }
+  /**
+   * Transfers all matching listeners from source to target, removing
+   * them from the source. Target's existing listeners are preserved.
+   *
+   * Useful when cloning an engine (e.g. FetchEngine) and carrying
+   * over observability listeners to the new instance.
+   *
+   * @example
+   *
+   *     const old = new ObserverEngine();
+   *     const next = new ObserverEngine();
+   *
+   *     old.on('ready', handler);
+   *
+   *     ObserverEngine.transfer(old, next);
+   *     // `next` now owns the 'ready' listener; `old` has none
+   *
+   * @example
+   *
+   *     // Transfer only specific events
+   *     ObserverEngine.transfer(old, next, {
+   *         filter: ['ready', /^user\./]
+   *     });
+   */
+  static transfer(source, target, options) {
+    _ObserverEngine.#moveListeners(source, target, true, options);
+  }
+  /**
+   * Copies all matching listeners from source to target without
+   * removing them from the source. Target's existing listeners
+   * are preserved.
+   *
+   * Useful when forking an engine so both instances react to the
+   * same events independently.
+   *
+   * @example
+   *
+   *     const primary = new ObserverEngine();
+   *     const mirror = new ObserverEngine();
+   *
+   *     primary.on('update', handler);
+   *
+   *     ObserverEngine.copy(primary, mirror);
+   *     // Both engines now have the 'update' listener
+   *
+   * @example
+   *
+   *     // Copy everything except internal events
+   *     ObserverEngine.copy(primary, mirror, {
+   *         exclude: [/^__/]
+   *     });
+   */
+  static copy(source, target, options) {
+    _ObserverEngine.#moveListeners(source, target, false, options);
+  }
+};
+
+// node_modules/@logosdx/observer/dist/esm/relay.mjs
+var ObserverRelay = class {
+  #pub;
+  #sub;
+  #subEmit;
+  #isShutdown = false;
+  emit;
+  on;
+  once;
+  off;
+  queue;
+  constructor(options) {
+    const name = options?.name;
+    this.#pub = new ObserverEngine({
+      name: name ? `${name}:pub` : void 0,
+      spy: options?.spy,
+      signal: options?.signal,
+      emitValidator: options?.emitValidator?.pub
+    });
+    this.#sub = new ObserverEngine({
+      name: name ? `${name}:sub` : void 0,
+      spy: options?.spy,
+      signal: options?.signal,
+      emitValidator: options?.emitValidator?.sub
+    });
+    this.on = this.#sub.on.bind(this.#sub);
+    this.once = this.#sub.once.bind(this.#sub);
+    this.off = this.#sub.off.bind(this.#sub);
+    this.queue = this.#sub.queue.bind(this.#sub);
+    this.#subEmit = this.#sub.emit.bind(this.#sub);
+    const pubEmit = this.#pub.emit.bind(this.#pub);
+    this.emit = (event, data) => {
+      if (this.#isShutdown) return;
+      pubEmit(event, data);
+    };
+    this.#pub.on(/.+/, ({ event, data }) => this.send(event, data));
+    if (options?.signal) {
+      options.signal.addEventListener("abort", () => {
+        this.#isShutdown = true;
+      });
+    }
+  }
+  receive(event, data, ctx) {
+    if (this.#isShutdown) return;
+    this.#subEmit(event, {
+      data,
+      ctx
+    });
+  }
+  spy(spy) {
+    if (this.#isShutdown) return;
+    this.#pub.spy(spy, true);
+    this.#sub.spy(spy, true);
+  }
+  $has(event) {
+    return {
+      pub: this.#pub.$has(event),
+      sub: this.#sub.$has(event)
+    };
+  }
+  $facts() {
+    return {
+      pub: this.#pub.$facts(),
+      sub: this.#sub.$facts()
+    };
+  }
+  $internals() {
+    return {
+      pub: this.#pub.$internals(),
+      sub: this.#sub.$internals()
+    };
+  }
+  get isShutdown() {
+    return this.#isShutdown;
+  }
+  shutdown() {
+    if (this.#isShutdown) return;
+    this.#isShutdown = true;
+    this.#pub.clear();
+    this.#sub.clear();
+  }
+};
+
+// src/core/observer.ts
+var observer = new ObserverEngine({
+  name: "noorm",
+  spy: process.env["NOORM_DEBUG"] ? (action) => console.error(`[noorm:${action.fn}] ${String(action.event)}`) : void 0
+});
+
+export { ObserverRelay, attempt, attemptSync, clone, gigabytes, makeNestedConfig, merge, observer, retry };
+//# sourceMappingURL=chunk-UDUDHOIB.js.map
+//# sourceMappingURL=chunk-UDUDHOIB.js.map