sia-reactor 0.0.0

package/dist/index.d.cts

@@ -0,0 +1 @@
+export { N as Payload, R as REvent, a4 as Reactive, a5 as ReactivePrefs, a6 as Reactor, a7 as ReactorEvent, O as ReactorOptions, a8 as getSnapshotVersion, a9 as getVersion, aa as inert, ab as intent, ac as isInert, ad as isIntent, ae as isVolatile, af as live, ag as methods, ah as reactive, ai as stable, aj as state, ak as volatile } from './index-DBfVdpnb.cjs';

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { N as Payload, R as REvent, a4 as Reactive, a5 as ReactivePrefs, a6 as Reactor, a7 as ReactorEvent, O as ReactorOptions, a8 as getSnapshotVersion, a9 as getVersion, aa as inert, ab as intent, ac as isInert, ad as isIntent, ae as isVolatile, af as live, ag as methods, ah as reactive, ai as stable, aj as state, ak as volatile } from './index-DBfVdpnb.js';

package/dist/index.js

@@ -0,0 +1,662 @@
+import {
+  deleteAny,
+  getAny,
+  getTrailPaths,
+  getTrailRecords,
+  inAny,
+  isStrictObj,
+  mergeObjs,
+  nuke,
+  parseEvOpts,
+  setAny
+} from "./chunk-JTRN6O5Y.js";
+
+// src/core/reactor.ts
+var RAW = /* @__PURE__ */ Symbol.for("S.I.A_RAW");
+var INERTIA = /* @__PURE__ */ Symbol.for("S.I.A_INERTIA");
+var REJECTABLE = /* @__PURE__ */ Symbol.for("S.I.A_REJECTABLE");
+var INDIFFABLE = /* @__PURE__ */ Symbol.for("S.I.A_INDIFFABLE");
+var TERMINATOR = /* @__PURE__ */ Symbol.for("S.I.A_TERMINATOR");
+var VERSION = /* @__PURE__ */ Symbol.for("S.I.A_VERSION");
+var SSVERSION = /* @__PURE__ */ Symbol.for("S.I.A_SNAPSHOT_VERSION");
+var NOOP = () => {
+};
+var R_BATCH = ("undefined" !== typeof queueMicrotask ? queueMicrotask : setTimeout).bind(window);
+var R_LOG = console.log.bind(console, "[S.I.A Reactor]");
+var EV_WARN = console.warn.bind(console, "[S.I.A Event]");
+var EV_OPTS = {
+  LISTENER: ["capture", "depth", "once", "signal", "immediate"],
+  MEDIATOR: ["lazy", "signal", "immediate"]
+};
+var _ReactorEvent = class _ReactorEvent {
+  constructor(payload, bubbles = false, canWarn = true) {
+    this.eventPhase = _ReactorEvent.NONE;
+    this._propagationStopped = false;
+    this._immediatePropagationStopped = false;
+    this._resolved = "";
+    this._rejected = "";
+    this._warn = NOOP;
+    this.type = this.staticType = payload.type;
+    this.target = payload.target;
+    this.currentTarget = payload.currentTarget;
+    this.root = payload.root;
+    this.value = payload.target.value;
+    this.oldValue = payload.target.oldValue;
+    this.path = payload.target.path;
+    this.rejectable = payload.rejectable;
+    this.bubbles = bubbles;
+    if (canWarn) this._warn = EV_WARN;
+  }
+  get propagationStopped() {
+    return this._propagationStopped;
+  }
+  stopPropagation() {
+    this._propagationStopped = true;
+  }
+  get immediatePropagationStopped() {
+    return this._immediatePropagationStopped;
+  }
+  stopImmediatePropagation() {
+    this._propagationStopped = true;
+    this._immediatePropagationStopped = true;
+  }
+  get resolved() {
+    return this._resolved;
+  }
+  resolve(message) {
+    if (!this.rejectable) return this._warn(`Ignored resolve() call on a non-rejectable ${this.staticType} at "${this.path}"`);
+    if (this.eventPhase !== _ReactorEvent.CAPTURING_PHASE) this._warn(`Resolving an intent on ${this.staticType} at "${this.path}" outside of the capture phase is unadvised.`);
+    if (this.rejectable) this._resolved = message || `Could ${this.staticType} intended value at "${this.path}"`;
+  }
+  get rejected() {
+    return this._rejected;
+  }
+  reject(reason) {
+    if (!this.rejectable) return this._warn(`Ignored reject() call on a non-rejectable ${this.staticType} at "${this.path}"`);
+    if (this.eventPhase !== _ReactorEvent.CAPTURING_PHASE) this._warn(`Rejecting an intent on ${this.staticType} at "${this.path}" outside of the capture phase is unadvised.`);
+    if (this.rejectable) this._rejected = reason || `Couldn't ${this.staticType} intended value at "${this.path}"`;
+  }
+  composedPath() {
+    return getTrailPaths(this.path);
+  }
+  get canWarn() {
+    return this._warn === EV_WARN;
+  }
+};
+_ReactorEvent.NONE = 0;
+_ReactorEvent.CAPTURING_PHASE = 1;
+_ReactorEvent.AT_TARGET = 2;
+_ReactorEvent.BUBBLING_PHASE = 3;
+var ReactorEvent = _ReactorEvent;
+var Reactor = class {
+  constructor(obj = {}, options) {
+    this.proxyCache = /* @__PURE__ */ new WeakMap();
+    this.log = NOOP;
+    // `?:`s | pay the ~800 byte price upfront for what u might never use
+    this.isLogging = false;
+    // keeping track so API getter doesn't slow down internal iterations in any way
+    this.isTracing = false;
+    this.isTracking = false;
+    this.isSCloning = false;
+    // Smart Cloning
+    this.isBatching = false;
+    this[INERTIA] = true;
+    this.config = {
+      crossRealms: false,
+      eventBubbling: true,
+      batchingFunction: R_BATCH,
+      ...options
+    };
+    this.core = this.proxied(obj);
+    if (!options) return;
+    this.canLog = !!options.debug;
+    if (this.isTracking = !!options.referenceTracking) this.lineage = /* @__PURE__ */ new WeakMap();
+    if (this.isSCloning = this.isTracking && !!options.smartCloning) this.snapshotCache = /* @__PURE__ */ new WeakMap();
+    this.isTracing = this.isTracking && !!options.lineageTracing;
+  }
+  proxied(obj, rejectable = false, indiffable = false, parent, key, path) {
+    if (!obj || typeof obj !== "object") return obj;
+    if (!(isStrictObj(obj, this.config.crossRealms, false) || Array.isArray(obj)) || obj[INERTIA]) return obj;
+    obj = obj[RAW] || obj;
+    if (this.isTracking && parent && key) this.link(obj, parent, key, false);
+    if (this.proxyCache.has(obj)) return this.proxyCache.get(obj);
+    rejectable || (rejectable = obj[REJECTABLE]);
+    indiffable || (indiffable = obj[INDIFFABLE]);
+    const proxy = new Proxy(obj, {
+      // Robust Proxy handler
+      get: (object, key2, receiver) => {
+        if (key2 === RAW) return object;
+        let value = object[key2];
+        const safeKey = String(key2), fullPath = this.isTracing ? void 0 : path ? path + "." + safeKey : safeKey, paths = this.isTracing ? this.trace(object, safeKey) : fullPath;
+        this.log(`\u{1F440} [GET Trap] Initiated for "${safeKey}" on "${paths}"`);
+        if (this.config.get) value = this.config.get(object, key2, value, receiver, paths);
+        if (this.getters) {
+          const wildcords = this.getters.get("*");
+          for (let i = 0, len = this.isTracing ? paths.length : 1; i < len; i++) {
+            const currPath = this.isTracing ? paths[i] : fullPath, cords = this.getters.get(currPath);
+            if (!cords && !wildcords) continue;
+            const target = {
+              path: currPath,
+              value,
+              key: safeKey,
+              object: receiver
+            }, payload = {
+              type: "get",
+              target,
+              currentTarget: target,
+              root: this.core,
+              rejectable
+            };
+            if (cords) value = this.mediate(currPath, payload, "get", cords);
+            if (!wildcords) continue;
+            target.value = value;
+            value = this.mediate("*", payload, "get", wildcords);
+          }
+        }
+        return this.proxied(value, rejectable, indiffable, object, safeKey, fullPath);
+      },
+      set: (object, key2, value, receiver) => {
+        let unchanged, safeValue, safeOldValue, terminated = false;
+        const safeKey = String(key2), fullPath = this.isTracing ? void 0 : path ? path + "." + safeKey : safeKey, paths = this.isTracing ? this.trace(object, safeKey) : fullPath, loopLen = this.isTracing ? paths.length : 1, oldValue = object[key2];
+        if (this.isTracking || !indiffable) {
+          safeOldValue = oldValue?.[RAW] || oldValue;
+          safeValue = value?.[RAW] || value;
+          unchanged = Object.is(safeValue, safeOldValue);
+        }
+        if (!indiffable && unchanged) return true;
+        this.log(`\u270F\uFE0F [SET Trap] Initiated for "${safeKey}" on "${paths}"`);
+        if (this.config.set) terminated = (value = this.config.set(object, key2, value, oldValue, receiver, paths)) === TERMINATOR;
+        if (this.setters) {
+          const wildcords = this.setters.get("*");
+          for (let i = 0; i < loopLen; i++) {
+            const currPath = this.isTracking ? paths[i] : fullPath, cords = this.setters.get(currPath);
+            if (!cords && !wildcords) continue;
+            const target = {
+              path: currPath,
+              value,
+              oldValue,
+              key: safeKey,
+              object: receiver
+            }, payload = {
+              type: "set",
+              target,
+              currentTarget: target,
+              root: this.core,
+              terminated,
+              rejectable
+            };
+            if (cords) {
+              const result2 = this.mediate(currPath, payload, "set", cords);
+              if (!(terminated || (terminated = payload.terminated))) value = result2;
+            }
+            if (!wildcords) continue;
+            target.value = value;
+            const result = this.mediate("*", payload, "set", wildcords);
+            if (!(terminated || (terminated = payload.terminated))) value = result;
+          }
+        }
+        if (terminated) return this.log(`\u{1F6E1}\uFE0F [SET Mediator] Terminated on "${paths}"`), true;
+        object[key2] = value;
+        if (this.isTracking && !unchanged) this.isSCloning && this.stamp(object), this.unlink(safeOldValue, object, safeKey), this.link(safeValue, object, safeKey);
+        if (this.watchers || this.listeners)
+          for (let i = 0; i < loopLen; i++) {
+            const currPath = this.isTracking ? paths[i] : fullPath, target = {
+              path: currPath,
+              value,
+              oldValue,
+              key: safeKey,
+              object: receiver
+            };
+            this.notify(currPath, {
+              type: "set",
+              target,
+              currentTarget: target,
+              root: this.core,
+              terminated,
+              rejectable
+            });
+          }
+        return true;
+      },
+      deleteProperty: (object, key2) => {
+        let value, receiver = this.proxyCache.get(object), terminated = false;
+        const safeKey = String(key2), fullPath = this.isTracing ? void 0 : path ? path + "." + safeKey : safeKey, paths = this.isTracing ? this.trace(object, safeKey) : fullPath, loopLen = this.isTracing ? paths.length : 1, oldValue = object[key2];
+        this.log(`\u{1F5D1}\uFE0F [DELETE Trap] Initiated for "${safeKey}" on "${paths}"`);
+        if (this.config.delete) terminated = (value = this.config.delete(object, key2, oldValue, receiver, paths)) === TERMINATOR;
+        if (this.deleters) {
+          const wildcords = this.deleters.get("*");
+          for (let i = 0; i < loopLen; i++) {
+            const currPath = this.isTracking ? paths[i] : fullPath, cords = this.deleters.get(currPath);
+            if (!cords && !wildcords) continue;
+            const target = {
+              path: currPath,
+              value,
+              oldValue,
+              key: safeKey,
+              object: receiver
+            }, payload = {
+              type: "delete",
+              target,
+              currentTarget: target,
+              root: this.core,
+              rejectable
+            };
+            if (cords) {
+              const result2 = this.mediate(currPath, payload, "delete", cords);
+              if (!(terminated || (terminated = payload.terminated))) value = result2;
+            }
+            if (!wildcords) continue;
+            const result = this.mediate("*", payload, "delete", wildcords);
+            if (!(terminated || (terminated = payload.terminated))) value = result;
+          }
+        }
+        if (terminated) return this.log(`\u{1F6E1}\uFE0F [DELETE Mediator] Terminated on "${paths}"`), true;
+        delete object[key2];
+        if (this.isTracking) this.isSCloning && this.stamp(object), this.unlink(oldValue?.[RAW] || oldValue, object, safeKey);
+        if (this.watchers || this.listeners)
+          for (let i = 0; i < loopLen; i++) {
+            const currPath = this.isTracking ? paths[i] : fullPath, target = {
+              path: currPath,
+              value,
+              oldValue,
+              key: safeKey,
+              object: receiver
+            };
+            this.notify(currPath, {
+              type: "delete",
+              target,
+              currentTarget: target,
+              root: this.core,
+              rejectable
+            });
+          }
+        return true;
+      }
+    });
+    return this.proxyCache.set(obj, proxy), proxy;
+  }
+  trace(target, path, paths = [], visited = /* @__PURE__ */ new WeakSet()) {
+    if (Object.is(target, this.core[RAW] || this.core)) return paths.push(path), paths;
+    if (visited.has(target)) return paths;
+    visited.add(target);
+    const es = this.lineage.get(target);
+    if (!es) return paths;
+    for (let i = 0, len = es.length; i < len; i += 2) this.trace(es[i], es[i + 1] ? es[i + 1] + "." + path : path, paths, visited);
+    return paths;
+  }
+  // won't be called without `.isTracking` so internal guard avoided
+  link(target, parent, key, typecheck = true, es) {
+    if (typecheck && !(isStrictObj(target, this.config.crossRealms) || Array.isArray(target))) return;
+    es = this.lineage.get(target) ?? (this.lineage.set(target, es = []), es);
+    for (let i = 0, len = es.length; i < len; i += 2) if (Object.is(es[i], parent) && es[i + 1] === key) return;
+    es.push(parent, key);
+  }
+  unlink(target, parent, key) {
+    if (!(isStrictObj(target, this.config.crossRealms) || Array.isArray(target))) return;
+    const es = this.lineage.get(target);
+    if (es) {
+      for (let i = 0, len = es.length; i < len; i += 2) if (Object.is(es[i], parent) && es[i + 1] === key) return void es.splice(i, 2);
+    }
+  }
+  stamp(target, typecheck = true) {
+    if (typecheck && "object" !== typeof target) return;
+    target[VERSION] = (target[VERSION] || 0) + 1;
+    const es = this.lineage?.get(target);
+    if (es) for (let i = 0, len = es.length; i < len; i += 2) this.stamp(es[i]);
+  }
+  mediate(path, payload, type, cords) {
+    let terminated = false, value = payload.target.value;
+    const isGet = type === "get", isSet = type === "set", mediators = isGet ? this.getters : isSet ? this.setters : this.deleters;
+    for (let i = !isGet ? 0 : cords.length - 1, len = !isGet ? cords.length : -1; i !== len; i += !isGet ? 1 : -1) {
+      const response = isGet ? cords[i].cb(value, payload) : isSet ? cords[i].cb(value, terminated, payload) : cords[i].cb(terminated, payload);
+      if (isGet || !(terminated || (terminated = payload.terminated = response === TERMINATOR))) value = response;
+      if (cords[i].once) cords.splice(i--, 1), !cords.length && mediators.delete(path);
+    }
+    return value;
+  }
+  notify(path, payload) {
+    if (this.watchers) {
+      const wildcords = this.watchers.get("*"), cords = this.watchers.get(path);
+      if (cords)
+        for (let i = 0, len = cords.length; i < len; i++) {
+          cords[i].cb(payload.target.value, payload);
+          if (cords[i].once) cords.splice(i--, 1), !cords.length && this.watchers.delete(path);
+        }
+      if (wildcords)
+        for (let i = 0, len = wildcords.length; i < len; i++) {
+          wildcords[i].cb(payload.target.value, payload);
+          if (wildcords[i].once) wildcords.splice(i--, 1), !wildcords.length && this.watchers.delete("*");
+        }
+    }
+    this.listeners && this.schedule(path, payload);
+  }
+  schedule(path, payload) {
+    this.batch ?? (this.batch = /* @__PURE__ */ new Map());
+    this.batch.set(path, payload), !this.isBatching && this.initBatching();
+  }
+  initBatching() {
+    this.isBatching = true, this.config.batchingFunction(() => this.flush());
+  }
+  flush() {
+    this.isBatching = false, this.batch && this.tick(this.batch.keys());
+    if (this.queue?.size) for (const task of this.queue) task(), this.queue.delete(task);
+  }
+  wave(path, payload) {
+    const e = new ReactorEvent(payload, this.config.eventBubbling, this.isLogging), chain = getTrailRecords(this.core, path);
+    e.eventPhase = ReactorEvent.CAPTURING_PHASE;
+    for (let i = 0; i <= chain.length - 2; i++) {
+      if (e.propagationStopped) break;
+      this.fire(chain[i], e, true);
+    }
+    if (e.propagationStopped) return;
+    e.eventPhase = ReactorEvent.AT_TARGET;
+    this.fire(chain[chain.length - 1], e, true);
+    !e.immediatePropagationStopped && this.fire(chain[chain.length - 1], e, false);
+    if (!e.bubbles) return;
+    e.eventPhase = ReactorEvent.BUBBLING_PHASE;
+    for (let i = chain.length - 2; i >= 0; i--) {
+      if (e.propagationStopped) break;
+      this.fire(chain[i], e, false);
+    }
+  }
+  fire([path, object, value], e, isCapture, cords = this.listeners.get(path)) {
+    if (!cords) return;
+    e.type = path !== e.target.path ? "update" : e.staticType;
+    e.currentTarget = {
+      path,
+      value,
+      oldValue: e.type !== "update" ? e.target.oldValue : void 0,
+      key: e.type !== "update" ? path : path.slice(path.lastIndexOf(".") + 1) || "",
+      object
+    };
+    let tDepth, lDepth;
+    for (let i = 0, len = cords.length; i < len; i++) {
+      if (e.immediatePropagationStopped) break;
+      if (cords[i].capture !== isCapture) continue;
+      if (cords[i].depth !== void 0) {
+        tDepth ?? (tDepth = this.getDepth(e.target.path)), lDepth ?? (lDepth = this.getDepth(path));
+        if (tDepth > lDepth + cords[i].depth) continue;
+      }
+      cords[i].cb(e);
+      if (cords[i].once) cords.splice(i--, 1), !cords.length && this.listeners.delete(path);
+    }
+  }
+  tick(paths) {
+    if (!paths) return this.flush();
+    if ("string" === typeof paths) {
+      const task = this.batch?.get(paths);
+      task && (this.wave(paths, task), this.batch.delete(paths));
+    } else
+      for (const path of paths) {
+        const task = this.batch.get(path);
+        task && (this.wave(path, task), this.batch.delete(path));
+      }
+  }
+  stall(task) {
+    this.queue ?? (this.queue = /* @__PURE__ */ new Set());
+    this.queue.add(task), !this.isBatching && this.initBatching();
+  }
+  nostall(task) {
+    return this.queue?.delete(task);
+  }
+  bind(cord, signal) {
+    signal?.aborted ? cord.clup() : signal?.addEventListener("abort", cord.clup, { once: true });
+    if (signal && !signal.aborted) cord.sclup = () => signal.removeEventListener("abort", cord.clup);
+    return cord.clup;
+  }
+  clone(obj, raw, visited = /* @__PURE__ */ new WeakMap()) {
+    if (!(isStrictObj(obj, this.config.crossRealms) || Array.isArray(obj)) || visited.has(obj)) return obj;
+    const version = obj[VERSION] || 0, cached = !raw && this.isSCloning && this.snapshotCache.get(obj);
+    if (cached && obj[SSVERSION] === version) return cached;
+    const clone = !raw ? Array.isArray(obj) ? [] : {} : obj[RAW] || obj;
+    visited.set(obj, clone);
+    const keys = Object.keys(obj);
+    for (let i = 0, len = keys.length; i < len; i++) clone[keys[i]] = this.clone(obj[keys[i]], raw, visited);
+    if (!raw && this.isSCloning) {
+      this.snapshotCache.set(obj, clone);
+      obj[SSVERSION] = version;
+    }
+    return clone;
+  }
+  getDepth(p, d = !p ? 0 : 1) {
+    for (let i = 0, len = p.length; i < len; i++) if (p.charCodeAt(i) === 46) d++;
+    return d;
+  }
+  getContext(path) {
+    const lastDot = path.lastIndexOf("."), value = path === "*" ? this.core : getAny(this.core, path), object = lastDot === -1 ? this.core : getAny(this.core, path.slice(0, lastDot));
+    return {
+      path,
+      value,
+      key: path.slice(lastDot + 1) || "",
+      object
+    };
+  }
+  syncAdd(key, path, cb, opts, onImmediate) {
+    var _a;
+    const { lazy = false, once = false, signal, immediate = false } = parseEvOpts(opts, EV_OPTS.MEDIATOR), store = this[_a = `${key}${key.endsWith("t") ? "t" : ""}ers`] ?? (this[_a] = /* @__PURE__ */ new Map());
+    let cords = store.get(path), cord;
+    if (cords) {
+      for (let i = 0, len = cords.length; i < len; i++)
+        if (Object.is(cords[i].cb, cb)) {
+          cord = cords[i];
+          break;
+        }
+    }
+    if (cord) return cord.clup;
+    let task;
+    cord = {
+      cb,
+      once,
+      clup: () => (lazy && this.nostall(task), this[`no${key}`](path, cb))
+    };
+    immediate && onImmediate?.(immediate);
+    task = () => (cords ?? (store.set(path, cords = []), cords)).push(cord);
+    lazy ? this.stall(task) : task();
+    return this.bind(cord, signal);
+  }
+  syncDrop(store, path, cb) {
+    const cords = store?.get(path);
+    if (!cords) return void 0;
+    for (let i = 0, len = cords.length; i < len; i++) if (Object.is(cords[i].cb, cb)) return cords[i].sclup?.(), cords.splice(i--, 1), !cords.length && store.delete(path), true;
+    return false;
+  }
+  get(path, cb, opts) {
+    return this.syncAdd("get", path, cb, opts, (imm) => (imm !== "auto" || inAny(this.core, path)) && getAny(this.core, path));
+  }
+  gonce(path, cb, opts) {
+    return this.get(path, cb, {
+      ...parseEvOpts(opts, EV_OPTS.MEDIATOR),
+      once: true
+    });
+  }
+  noget(path, cb) {
+    return this.syncDrop(this.getters, path, cb);
+  }
+  set(path, cb, opts) {
+    return this.syncAdd("set", path, cb, opts, (imm) => (imm !== "auto" || inAny(this.core, path)) && setAny(this.core, path, getAny(this.core, path)));
+  }
+  sonce(path, cb, opts) {
+    return this.set(path, cb, Object.assign(parseEvOpts(opts, EV_OPTS.MEDIATOR), { once: true }));
+  }
+  noset(path, cb) {
+    return this.syncDrop(this.setters, path, cb);
+  }
+  delete(path, cb, opts) {
+    return this.syncAdd("delete", path, cb, opts, (imm) => (imm !== "auto" || inAny(this.core, path)) && deleteAny(this.core, path, void 0));
+  }
+  donce(path, cb, opts) {
+    return this.delete(path, cb, Object.assign(parseEvOpts(opts, EV_OPTS.MEDIATOR), { once: true }));
+  }
+  nodelete(path, cb) {
+    return this.syncDrop(this.deleters, path, cb);
+  }
+  watch(path, cb, opts) {
+    return this.syncAdd(
+      "watch",
+      path,
+      cb,
+      opts,
+      (imm) => imm !== "auto" && inAny(this.core, path) && ((target) => cb(target.value, {
+        type: "init",
+        target,
+        currentTarget: target,
+        root: this.core,
+        rejectable: false
+      }))(this.getContext(path))
+    );
+  }
+  wonce(path, cb, opts) {
+    return this.watch(path, cb, Object.assign(parseEvOpts(opts, EV_OPTS.MEDIATOR), { once: true }));
+  }
+  nowatch(path, cb) {
+    return this.syncDrop(this.watchers, path, cb);
+  }
+  on(path, cb, options) {
+    this.listeners ?? (this.listeners = /* @__PURE__ */ new Map());
+    const { capture = false, once = false, signal, immediate = false, depth } = parseEvOpts(options, EV_OPTS.LISTENER);
+    let cords = this.listeners.get(path), cord;
+    if (cords) {
+      for (let i = 0, len = cords.length; i < len; i++)
+        if (Object.is(cords[i].cb, cb) && capture === cords[i].capture) {
+          cord = cords[i];
+          break;
+        }
+    }
+    if (cord) return cord.clup;
+    cord = {
+      cb,
+      capture,
+      depth,
+      once,
+      clup: () => this.off(path, cb, options)
+    };
+    if (immediate && (immediate !== "auto" || inAny(this.core, path))) {
+      const target = this.getContext(path);
+      cb(
+        new ReactorEvent(
+          {
+            type: "init",
+            target,
+            currentTarget: target,
+            root: this.core,
+            rejectable: false
+          },
+          this.config.eventBubbling,
+          this.isLogging
+        )
+      );
+    }
+    (cords ?? (this.listeners.set(path, cords = []), cords)).push(cord);
+    return this.bind(cord, signal);
+  }
+  once(path, cb, options) {
+    return this.on(path, cb, Object.assign(parseEvOpts(options, EV_OPTS.LISTENER), { once: true }));
+  }
+  off(path, cb, options) {
+    const cords = this.listeners?.get(path);
+    if (!cords) return void 0;
+    const { capture } = parseEvOpts(options, EV_OPTS.LISTENER);
+    for (let i = 0, len = cords.length; i < len; i++) if (Object.is(cords[i].cb, cb) && cords[i].capture === capture) return cords[i].sclup?.(), cords.splice(i--, 1), !cords.length && this.listeners.delete(path), true;
+    return false;
+  }
+  snapshot(raw = !this.isSCloning, branch = this.core) {
+    return this.clone(branch, raw);
+  }
+  cascade({ type, currentTarget: { path, value: news, oldValue: olds } }, objSafe = true) {
+    if (type !== "set" && type !== "delete" || !(isStrictObj(news, this.config.crossRealms) || Array.isArray(news)) || (objSafe ? !(isStrictObj(olds, this.config.crossRealms) || Array.isArray(olds)) : false)) return;
+    const obj = objSafe ? mergeObjs(olds, news) : news, keys = Object.keys(obj);
+    for (let i = 0, len = keys.length; i < len; i++) setAny(this.core, path + "." + keys[i], obj[keys[i]]);
+  }
+  reset() {
+    this.getters?.clear(), this.setters?.clear(), this.deleters?.clear(), this.watchers?.clear(), this.listeners?.clear();
+    this.queue?.clear(), this.batch?.clear(), this.isBatching = false;
+    this.proxyCache = /* @__PURE__ */ new WeakMap();
+  }
+  destroy() {
+    this.reset(), nuke(this);
+  }
+  get canLog() {
+    return this.log === R_LOG;
+  }
+  set canLog(value) {
+    this.log = (this.isLogging = value) ? R_LOG : NOOP;
+  }
+  get canTrackReferences() {
+    return this.isTracking;
+  }
+  get canTraceLineage() {
+    return this.isTracing;
+  }
+  get canSmartClone() {
+    return this.isSCloning;
+  }
+};
+
+// src/tools/mixins.ts
+var methods = ["tick", "stall", "nostall", "get", "gonce", "noget", "set", "sonce", "noset", "delete", "donce", "nodelete", "watch", "wonce", "nowatch", "on", "once", "off", "cascade", "snapshot", "reset", "destroy"];
+function reactive(target, options, prefs) {
+  const descriptors = {}, rtr = target instanceof Reactor ? target : new Reactor(target, options), locks = { enumerable: false, configurable: true, writable: false }, hasAffix = !!(prefs?.prefix || prefs?.suffix);
+  for (let key of methods) {
+    if (hasAffix) (prefs?.whitelist?.includes(key) ?? true) && (key = `${prefs?.prefix || ""}${key}${prefs?.suffix || ""}`);
+    else if (prefs?.whitelist?.includes(key)) continue;
+    descriptors[key] = { value: rtr[key].bind(rtr), ...locks };
+  }
+  descriptors["__Reactor__"] = { value: rtr, ...locks };
+  return Object.defineProperties(rtr.core, descriptors), rtr.core;
+}
+function inert(target) {
+  target[INERTIA] = true;
+  return target;
+}
+function live(target) {
+  delete target[INERTIA];
+  return target;
+}
+function isInert(target) {
+  return !!target[INERTIA];
+}
+function intent(target) {
+  target[REJECTABLE] = true;
+  return target;
+}
+function state(target) {
+  delete target[REJECTABLE];
+  return target;
+}
+function isIntent(target) {
+  return !!target[REJECTABLE];
+}
+function volatile(target) {
+  target[INDIFFABLE] = true;
+  return target;
+}
+function stable(target) {
+  delete target[INDIFFABLE];
+  return target;
+}
+function isVolatile(target) {
+  return !!target[INDIFFABLE];
+}
+function getVersion(target) {
+  return target[VERSION] || 0;
+}
+function getSnapshotVersion(target) {
+  return target[SSVERSION] || 0;
+}
+export {
+  Reactor,
+  ReactorEvent,
+  getSnapshotVersion,
+  getVersion,
+  inert,
+  intent,
+  isInert,
+  isIntent,
+  isVolatile,
+  live,
+  methods,
+  reactive,
+  stable,
+  state,
+  volatile
+};

package/dist/types.cjs

@@ -0,0 +1,18 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/types.ts
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);