@noormdev/sdk 1.4.1 → 1.4.2

package/dist/chunk-A2OYZAVT.js

@@ -0,0 +1,1523 @@
+import { createRequire } from 'module';
+import { assert, definePrivateProps, clone, isFunction, noop, PriorityQueue, Deferred, isPlainObject, RateLimitTokenBucket, generateId, wait, attempt, TimeoutError, isTimeoutError } from './chunk-TXDGFA44.js';
+
+createRequire(import.meta.url);
+
+// 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, getEnvConfigName, isDebug, observer, shouldSkipConfirmations };
+//# sourceMappingURL=chunk-A2OYZAVT.js.map
+//# sourceMappingURL=chunk-A2OYZAVT.js.map