@noormdev/sdk 1.4.0 → 1.4.2

package/dist/{chunk-LY2F7ZFI.js → chunk-TXDGFA44.js}

@@ -1852,1521 +1852,6 @@ You can either \`unset ${key("APP_PROBLEMATIC")}\` or scope all vars to \`${key(
   };
 };
 
-// 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/environment.ts
-function isDebug() {
-  return isEnvTruthy(process.env["NOORM_DEBUG"]);
-}
-function isEnvTruthy(value) {
-  if (!value) return false;
-  const normalized = value.toLowerCase();
-  return normalized !== "0" && normalized !== "false";
-}
-function shouldSkipConfirmations() {
-  return isEnvTruthy(process.env["NOORM_YES"]);
-}
-function getEnvConfigName() {
-  return process.env["NOORM_CONFIG"];
-}
-
-// src/core/observer.ts
-var observer = new ObserverEngine({
-  name: "noorm",
-  spy: isDebug() ? (action) => console.error(`[noorm:${action.fn}] ${String(action.event)}`) : void 0
-});
-
-export { ObserverRelay, attempt, attemptSync, clone, equals, getEnvConfigName, gigabytes, isDebug, isTimeoutError, makeNestedConfig, merge, observer, retry, runWithTimeout, shouldSkipConfirmations, wait };
-//# sourceMappingURL=chunk-LY2F7ZFI.js.map
-//# sourceMappingURL=chunk-LY2F7ZFI.js.map
+export { Deferred, PriorityQueue, RateLimitTokenBucket, TimeoutError, assert, attempt, attemptSync, clone, definePrivateProps, equals, generateId, gigabytes, isFunction, isPlainObject, isTimeoutError, makeNestedConfig, merge, noop, retry, runWithTimeout, wait };
+//# sourceMappingURL=chunk-TXDGFA44.js.map
+//# sourceMappingURL=chunk-TXDGFA44.js.map