sia-reactor 0.0.21 → 0.0.22

package/dist/{plugins.cjs → modules.cjs}

@@ -17,28 +17,34 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/ts/plugins.ts
-var plugins_exports = {};
-__export(plugins_exports, {
-  BaseReactorPlugin: () => BaseReactorPlugin,
+// src/ts/modules.ts
+var modules_exports = {};
+__export(modules_exports, {
+  AsyncStorageAdapter: () => AsyncStorageAdapter,
+  BaseReactorModule: () => BaseReactorModule,
   BaseStorageAdapter: () => BaseStorageAdapter,
+  COOKIE_ADAPTER_BUILD: () => COOKIE_ADAPTER_BUILD,
+  CookieAdapter: () => CookieAdapter,
   INDEXED_DB_ADAPTER_BUILD: () => INDEXED_DB_ADAPTER_BUILD,
   IndexedDBAdapter: () => IndexedDBAdapter,
   LocalStorageAdapter: () => LocalStorageAdapter,
-  MemoryStorageAdapter: () => MemoryStorageAdapter,
-  PERSIST_PLUGIN_BUILD: () => PERSIST_PLUGIN_BUILD,
-  PersistPlugin: () => PersistPlugin,
+  MemoryAdapter: () => MemoryAdapter,
+  PERSIST_MODULE_BUILD: () => PERSIST_MODULE_BUILD,
+  PersistModule: () => PersistModule,
+  SessionStorageAdapter: () => SessionStorageAdapter,
   StorageAdapter: () => StorageAdapter,
-  TIME_TRAVEL_PLUGIN_BUILD: () => TIME_TRAVEL_PLUGIN_BUILD,
-  TimeTravelPlugin: () => TimeTravelPlugin
+  TIME_TRAVEL_MODULE_BUILD: () => TIME_TRAVEL_MODULE_BUILD,
+  TimeTravelModule: () => TimeTravelModule
 });
-module.exports = __toCommonJS(plugins_exports);
+module.exports = __toCommonJS(modules_exports);
 
 // src/ts/core/consts.ts
 var CTX = {
   /** Flag indicating whether the application is running in development mode. */
   isDevEnv: "undefined" !== typeof process ? process.env.NODE_ENV !== "production" : true,
-  /** active `Autotracker` instance, override for automatic dependency collection on `Reactor` traps. */
+  /** Flag indicating whether a cascade is currently ongoing so reactors can allow all writes. */
+  isCascading: false,
+  /** Active `Autotracker` instance, override for automatic dependency collection on `Reactor` traps. */
   autotracker: null
 };
 var RAW = /* @__PURE__ */ Symbol.for("S.I.A_RAW");
@@ -50,7 +56,6 @@ var VERSION = /* @__PURE__ */ Symbol.for("S.I.A_VERSION");
 var SSVERSION = /* @__PURE__ */ Symbol.for("S.I.A_SNAPSHOT_VERSION");
 var RTR_BATCH = "undefined" !== typeof window ? ("undefined" !== typeof queueMicrotask ? queueMicrotask : setTimeout).bind(window) : "undefined" !== typeof process && process.nextTick ? process.nextTick : setTimeout;
 var RTR_LOG = console.log.bind(console, "[S.I.A Reactor]");
-var EVT_WARN = console.warn.bind(console, "[S.I.A Event]");
 var EVT_OPTS = { LISTENER: ["capture", "depth", "once", "signal", "immediate"], MEDIATOR: ["lazy", "signal", "immediate"] };
 var NIL = Object.freeze({});
 var NOOP = () => {
@@ -149,9 +154,33 @@ function inAny(source, key, separator = ".", keyFunc) {
 function parseEvtOpts(options, opts, boolOpt = opts[0], result = {}) {
   return Object.assign(result, "boolean" === typeof options ? { [boolOpt]: options } : options), result;
 }
+function fanout(a, b, c, d) {
+  const isEvtPld = !!a?.target, [state, path, news, olds, opts, type] = isEvtPld ? [a.root, a.currentTarget.path, a.currentTarget.value, a.currentTarget.oldValue, b || NIL, a.type] : [a, b, c, (d || NIL).merge ? getAny(a, b) : NIL, d || NIL], target = path === "*" ? state : getAny(state, path);
+  if (isEvtPld && type !== "set" && type !== "delete" || !target || !canHandle(news, opts)) return;
+  const prev = CTX.isCascading;
+  CTX.isCascading = isEvtPld;
+  try {
+    const walk = (target2, obj, depth = 1, keys = Object.keys(obj)) => {
+      for (let i = 0, len = keys.length; i < len; i++) {
+        const val = obj[keys[i]];
+        try {
+          depth > 1 && canHandle(val, opts) ? walk(target2[keys[i]] ||= {}, val, depth - 1) : target2[keys[i]] = val;
+        } catch {
+        }
+      }
+    };
+    walk(target, opts.merge && canHandle(olds, opts) ? mergeObjs(olds, news) : news, opts.depth === true ? Infinity : +opts.depth);
+  } finally {
+    CTX.isCascading = prev;
+  }
+}
 function mergeObjs(o1 = {}, o2 = {}) {
-  const merged = { ...o1 || {}, ...o2 || {} };
-  return Object.keys(merged).forEach((k) => isObj(o1?.[k]) && isObj(o2?.[k]) && (merged[k] = mergeObjs(o1[k], o2[k]))), merged;
+  const merged = { ...o1 ||= {}, ...o2 ||= {} }, keys = Object.keys(merged);
+  for (let i = 0, len = keys.length; i < len; i++) {
+    const k = keys[i];
+    if (isObj(o1[k]) && isObj(o2[k])) merged[k] = mergeObjs(o1[k], o2[k]);
+  }
+  return merged;
 }
 function getTrailRecords(obj, path, reverse = false) {
   const parts = path.split("."), chain = [["*", obj, obj]];
@@ -166,7 +195,11 @@ function deepClone(obj, config = NIL, seen = /* @__PURE__ */ new WeakMap()) {
   const clone = config.preserveContext ? Object.create(Object.getPrototypeOf(obj)) : Array.isArray(obj) ? [] : {};
   seen.set(obj, clone);
   const keys = config.preserveContext ? Reflect.ownKeys(obj) : Object.keys(obj);
-  for (let i = 0, len = keys.length; i < len; i++) clone[keys[i]] = deepClone(obj[keys[i]], config, seen);
+  for (let i = 0, len = keys.length; i < len; i++)
+    try {
+      clone[keys[i]] = deepClone(obj[keys[i]], config, seen);
+    } catch {
+    }
   return clone;
 }
 function nuke(target) {
@@ -206,35 +239,34 @@ var ReactorEvent = class _ReactorEvent {
   staticType;
   /** Original event target context. */
   target;
-  /** Root reactive object for this event wave. */
+  /** Root reactive object for this event instance wave. */
   root;
-  /** Original target path for this event wave. */
+  /** Original target path for this event instance wave. */
   path;
   /** Current value at the event target path. */
   value;
   /** Previous value at the event target path. */
   oldValue;
-  /** Whether resolve/reject intent semantics are allowed for this event. */
+  /** Whether resolve/reject intent semantics are allowed for this event instance. */
   rejectable;
-  /** Whether this event wave can bubble back up to ancestors or just capture down. */
+  /** Whether this event instance wave can bubble back up to ancestors or just capture down. */
   bubbles;
   /**
-   * `DOMHighResTimeStamp` for this event payload for native event parity and accuracy.
+   * `DOMHighResTimeStamp` for this event instance payload for native event parity and accuracy.
    * Enable `eventTimeStamps` option, then use this over custom timestamps in listeners for accuracy.
    * */
   timestamp;
-  _warn = NOOP;
+  /** The `Reactor` instance that dispatched this event instance. */
+  reactor;
   _resolved = "";
   _rejected = "";
   _propagationStopped = false;
   _immediatePropagationStopped = false;
   /**
    * @param payload Source payload for this event instance.
-   * @param bubbles Whether bubbling is enabled for this wave.
-   * @param canWarn Whether warning output is enabled.
-   * @param canStamp Whether timestamping is enabled.
+   * @param reactor The `Reactor` instance creating this event instance.
    */
-  constructor(payload, bubbles = false, canStamp = false, canWarn = true) {
+  constructor(payload, reactor) {
     this.staticType = this.type = payload.type;
     this.target = payload.target;
     this.currentTarget = payload.currentTarget;
@@ -243,9 +275,9 @@ var ReactorEvent = class _ReactorEvent {
     this.value = payload.target.value;
     this.oldValue = payload.target.oldValue;
     this.rejectable = payload.rejectable;
-    this.bubbles = bubbles;
-    if (canStamp) this.timestamp = performance.now();
-    if (canWarn) this._warn = EVT_WARN;
+    this.bubbles = !!reactor.config.eventBubbling;
+    if (reactor.config.eventTimeStamps) this.timestamp = performance.now();
+    this.reactor = reactor;
   }
   /** Whether propagation has been stopped. */
   get propagationStopped() {
@@ -275,9 +307,9 @@ var ReactorEvent = class _ReactorEvent {
    * @example e.resolve("API Load successful"); // message
    */
   resolve(message) {
-    if (!this.rejectable) return this._warn(`[ReactorEvent] Ignored resolve() call on a non-rejectable ${this.staticType} at "${this.path}"`);
-    if (this.eventPhase !== _ReactorEvent.CAPTURING_PHASE) this._warn(`[ReactorEvent] 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}"`;
+    if (!this.rejectable) return this.reactor.log(`[ReactorEvent] Ignored \`resolve()\` call on a non-rejectable ${this.staticType} at "${this.path}"`);
+    if (this.eventPhase !== _ReactorEvent.CAPTURING_PHASE) this.reactor.log(`[ReactorEvent] Resolving an intent on ${this.staticType} at "${this.path}" outside of the capture phase is unadvised.`);
+    if (this.rejectable) this.reactor.log(`[ReactorEvent] ${this._resolved = message || `Could ${this.staticType} intended value at "${this.path}"`}`);
   }
   /** Rejection reason for rejectable events. */
   get rejected() {
@@ -290,9 +322,9 @@ var ReactorEvent = class _ReactorEvent {
    * @example e.resolve("User is not logged in"); // reason
    */
   reject(reason) {
-    if (!this.rejectable) return this._warn(`[ReactorEvent] Ignored reject() call on a non-rejectable ${this.staticType} at "${this.path}"`);
-    if (this.eventPhase !== _ReactorEvent.CAPTURING_PHASE) this._warn(`[ReactorEvent] 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}"`;
+    if (!this.rejectable) return this.reactor.log(`[ReactorEvent] Ignored \`reject()\` call on a non-rejectable ${this.staticType} at "${this.path}"`);
+    if (this.eventPhase !== _ReactorEvent.CAPTURING_PHASE) this.reactor.log(`[ReactorEvent] Rejecting an intent on ${this.staticType} at "${this.path}" outside of the capture phase is unadvised.`);
+    if (this.rejectable) this.reactor.log(`[ReactorEvent] ${this._rejected = reason || `Couldn't ${this.staticType} intended value at "${this.path}"`}`);
   }
   /**
    * Returns event path values from target to root.
@@ -301,24 +333,22 @@ var ReactorEvent = class _ReactorEvent {
   composedPath() {
     return getTrailRecords(this.root, this.path, true).map((r) => r[2]);
   }
-  get canWarn() {
-    return this._warn !== NOOP;
-  }
 };
 
 // src/ts/core/reactor.ts
 var Reactor = class {
+  /** Logger function for this reactor instance, override if desired, `this.canLog = false` resets. */
   log = NOOP;
+  /** The core state object for this reactor instance. */
   core;
   // `?:`s | pay the ~800 byte price upfront for what u might never use
-  plugins;
+  /** The modules being used by this reactor. */
+  modules;
+  /** Configuration options for this reactor instance. */
   config;
+  /** Whether this reactor instance is currently batching updates, a window view into the engine timing */
   isBatching = false;
   // Async Batching
-  isCascading = false;
-  // Setter Cascading
-  isLogging = false;
-  // keeping track so API getter doesn't slow down internal iterations in any way
   queue;
   // Tasks to run after flush
   batch;
@@ -385,7 +415,7 @@ var Reactor = class {
           safeValue = value?.[RAW] || value;
           unchanged = this.config.equalityFunction(safeValue, safeOldValue);
         }
-        if (!indiffable && unchanged && !this.isCascading) return this.log(`\u{1F504} [Reactor \`set\` Trap] Unchanged for "${keyStr}" on "${paths}"`), true;
+        if (!indiffable && unchanged && !CTX.isCascading) return this.log(`\u{1F504} [Reactor \`set\` Trap] Unchanged for "${keyStr}" on "${paths}"`), true;
         if (this.config.set) terminated = (value = this.config.set(object, key2, value, oldValue, receiver, paths)) === TERMINATOR;
         if (this.setters) {
           const wildcords = this.setters.get("*");
@@ -539,7 +569,7 @@ var Reactor = class {
     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.config.eventTimeStamps, this.isLogging), chain = getTrailRecords(this.core, path);
+    const e = new ReactorEvent(payload, this), chain = getTrailRecords(this.core, path);
     e.eventPhase = ReactorEvent.CAPTURING_PHASE;
     for (let i = 0; i <= chain.length - 2; i++) {
       if (e.propagationStopped) break;
@@ -613,8 +643,8 @@ var Reactor = class {
     return depth;
   }
   getContext(path) {
-    const lastDot = path.lastIndexOf("."), value = getAny(this.core, path), object = lastDot === -1 ? this.core : getAny(this.core, path.slice(0, lastDot));
-    return { path, value, key: path.slice(lastDot + 1) || "", hadKey: true, object };
+    const last = path.lastIndexOf("."), value = getAny(this.core, path), object = last === -1 ? this.core : getAny(this.core, path.slice(0, last));
+    return { path, value, key: path.slice(last + 1) || "", hadKey: true, object };
   }
   bindSignal(cord, sig) {
     if (sig) sig.aborted ? cord.clup() : sig.addEventListener("abort", cord.clup, { once: true });
@@ -630,7 +660,11 @@ var Reactor = class {
     const clone = !raw ? this.config.preserveContext ? Object.create(Object.getPrototypeOf(obj)) : Array.isArray(obj) ? [] : {} : obj;
     seen.set(obj, clone);
     const keys = this.config.preserveContext ? Reflect.ownKeys(obj) : Object.keys(obj);
-    for (let i = 0, len = keys.length; i < len; i++) clone[keys[i]] = this.cloned(obj[keys[i]], raw, seen);
+    for (let i = 0, len = keys.length; i < len; i++)
+      try {
+        clone[keys[i]] = this.cloned(obj[keys[i]], raw, seen);
+      } catch {
+      }
     if (!raw && this.config.smartCloning) this.snapCache.set(obj, clone), obj[SSVERSION] = version;
     return clone;
   }
@@ -718,7 +752,7 @@ var Reactor = class {
    * rtr.delete("cache.temp", () => TERMINATOR);
    */
   delete(path, callback, options) {
-    return this.syncAdd("delete", path, callback, options, (imm) => (imm !== "auto" || inAny(this.core, path)) && deleteAny(this.core, path, void 0));
+    return this.syncAdd("delete", path, callback, options, (imm) => (imm !== "auto" || inAny(this.core, path)) && deleteAny(this.core, path));
   }
   /** Registers a delete mediator for a path that only triggers once. */
   donce(path, callback, options) {
@@ -735,7 +769,7 @@ var Reactor = class {
   }
   /**
    * Registers a watcher for a path.
-   * Watch callbacks run synchronously with the operation.
+   * Watch callbacks run synchronously with the operation, use leaf paths for reliability as it sees exact sets; no bubbling here.
    * @param path Path or wildcard path.
    * @param callback Watch callback.
    * @param options Sync options.
@@ -784,7 +818,7 @@ var Reactor = class {
     cord = { cb: callback, capture, depth, once, clup: () => this.off(path, callback, options), lDepth: depth !== void 0 ? this.getDepth(path) : depth };
     if (immediate && (immediate !== "auto" || inAny(this.core, path))) {
       const target = this.getContext(path);
-      callback(new ReactorEvent({ type: "init", target, currentTarget: target, root: this.core, rejectable: false }, this.config.eventBubbling, this.isLogging));
+      callback(new ReactorEvent({ type: "init", target, currentTarget: target, root: this.core, rejectable: false }, this));
     }
     (cords ?? (this.listeners.set(path, cords = []), cords)).push(cord);
     return this.bindSignal(cord, signal);
@@ -815,56 +849,39 @@ var Reactor = class {
     return this.cloned(arguments.length < 2 ? this.core : branch, raw);
   }
   /**
-   * Cascades object updates into direct child paths.
-   * @param payload Event or payload source.
-   * @param objectSafe Merge old/new object values before cascading, don't set for arrays; merger doesn't play nice
-   * @example
-   * rtr.on("user", (event) => rtr.cascade(event));
-   * @example
-   * rtr.watch("user", (_value, payload) => rtr.cascade(payload));
-   */
-  cascade({ type, currentTarget: { path, value: news, oldValue: olds } }, objectSafe = true) {
-    if (type !== "set" && type !== "delete" || !canHandle(news, this.config) || (objectSafe ? !canHandle(olds, this.config) : false)) return;
-    const obj = objectSafe ? mergeObjs(olds, news) : news, keys = Object.keys(obj);
-    this.isCascading = true;
-    for (let i = 0, len = keys.length; i < len; i++) setAny(this.core, path === "*" ? keys[i] : path + "." + keys[i], obj[keys[i]]);
-    this.isCascading = false;
-  }
-  /**
-   * Installs a plugin instance.
-   * @param plugin Plugin instance.
-   * @returns Current reactor for fluent chaining.
+   * Installs a module instance.
+   * @param target Module instance.
+   * @param id Optional identification tag for this instance in the module.
+   * @returns Current `Reactor` instance for fluent chaining.
    */
-  plugIn(plugin) {
-    const name = plugin.constructor.plugName;
-    this.plugins?.get(name)?.destroy();
-    return (this.plugins ??= /* @__PURE__ */ new Map()).set(name, (plugin.setup(this), plugin)), this;
+  use(target, id) {
+    return (this.modules ??= /* @__PURE__ */ new Set()).add(target.setup(this, id)), this;
   }
-  /** Resets the reactor to its initial state. */
+  /** Resets this reactor instance to its initial state. */
   reset() {
     this.getters?.clear(), this.setters?.clear(), this.deleters?.clear(), this.watchers?.clear(), this.listeners?.clear();
     this.batch?.clear(), this.queue?.clear(), this.isBatching = false;
   }
   destroy() {
-    if (this.plugins) for (const plug of this.plugins.values()) plug.destroy();
+    if (this.modules) for (const mdle of this.modules) mdle.destroy();
     this.reset(), nuke(this);
   }
   get canLog() {
-    return this.isLogging = this.log !== NOOP;
+    return this.log !== NOOP;
   }
   set canLog(value) {
-    this.log = (this.isLogging = value) ? RTR_LOG : NOOP;
+    this.log = value ? RTR_LOG : NOOP;
   }
-  get canTraceLineage() {
-    return this.config.referenceTracking && !!this.config.lineageTracing;
+  get canLineageTrace() {
+    return this.config.lineageTracing && this.config.referenceTracking;
   }
   get canSmartClone() {
-    return this.config.referenceTracking && !!this.config.smartCloning;
+    return this.config.smartCloning && this.config.referenceTracking;
   }
 };
 
 // src/ts/core/mixins.ts
-var methods = ["tick", "stall", "nostall", "get", "gonce", "noget", "set", "sonce", "noset", "delete", "donce", "nodelete", "watch", "wonce", "nowatch", "on", "once", "off", "snapshot", "cascade", "plugIn", "reset", "destroy"];
+var methods = ["tick", "stall", "nostall", "get", "gonce", "noget", "set", "sonce", "noset", "delete", "donce", "nodelete", "watch", "wonce", "nowatch", "on", "once", "off", "snapshot", "use", "reset", "destroy"];
 function reactive(target, build, preferences = NIL) {
   if ("__Reactor__" in target) return target;
   const descriptors = {}, rtr = getReactor(target, true, build), locks = { enumerable: false, configurable: true, writable: false }, hasAffix = !!(preferences.prefix || preferences.suffix);
@@ -872,7 +889,7 @@ function reactive(target, build, preferences = NIL) {
     let key = methods[i];
     if (hasAffix) (preferences.whitelist?.includes(key) ?? true) && (key = `${preferences.prefix || ""}${key}${preferences.suffix || ""}`);
     else if (preferences.whitelist?.includes(key)) continue;
-    descriptors[key] = { value: rtr[key].bind(rtr), ...locks };
+    descriptors[key] = { value: rtr[methods[i]].bind(rtr), ...locks };
   }
   descriptors["__Reactor__"] = { value: rtr, ...locks };
   return Object.defineProperties(rtr.core, descriptors), rtr.core;
@@ -909,47 +926,75 @@ function guardMethod(fn, onError = (e) => console.error(e)) {
   });
 }
 
-// src/ts/plugins/base.ts
-var BaseReactorPlugin = class {
-  static plugName;
+// src/ts/modules/base.ts
+var wpArr = ["*"];
+var BaseReactorModule = class {
+  static moduleName;
   get name() {
-    return this.constructor.plugName;
+    return this.constructor.moduleName;
   }
   ac = new AbortController();
   signal = this.ac.signal;
-  rtr;
+  rtrs = /* @__PURE__ */ new Map();
+  rids = /* @__PURE__ */ new WeakMap();
+  // for quick 0(1) lookups over iteration
+  wired = false;
   config;
   state;
   constructor(config, rtr, state) {
     guardAllMethods(this, this.guard);
-    this.rtr = rtr;
     this.config = isObj(config) ? reactive(config) : config;
     this.state = isObj(state) ? reactive(state) : state;
+    rtr && this.attach(rtr);
+  }
+  /**
+   * Connect to a `Reactor` instance, allows managing multiple reactors if needed.
+   * @param target `Reactor` instance or `reactive()` object to connect to.
+   * @param id Optional custom id for the reactor, prefer over default implicit index id when managing multiple reactors, supports paths to merge into a single tree.
+   * @returns Current `ReactorModule` instance for fluent chaining.
+   * @example
+   * const mod = new MyModule().attach(state1).attach(state2); // implicit index-based ids by default, add a .setup() or `Reactor.use()` when ready for init.
+   * @example
+   * const persist = new PersistModule(config).attach(sessState, "session").attach(adminState, "session.admin"); // don't use "*", causes de-serialization issues.
+   */
+  attach(target, id = this.rtrs.size) {
+    const rtr = getReactor(target);
+    if (!rtr || this.rtrs.has(id)) return this;
+    return this.rids.set((this.rtrs.set(id, rtr), rtr), id), this.onAttach(rtr, id), this;
   }
-  /** Entry point called to initialize plugin wiring. */
-  setup(rtr) {
-    this.rtr ??= rtr;
-    this.wire();
+  onAttach(_rtr, _rid) {
+  }
+  /**
+   * Entry point called to initialize module wiring, calls `.attach(target, id)` first, `Reactor.use()` calls this internally.
+   * Should run as last in `.attach()` chain or after all desired reactors if using multiple; so wiring is done safely after.
+   * @param target `Reactor` instance or `reactive()` object to connect to.
+   * @param id Optional id for the reactor, prefer over default implicit index id when managing multiple reactors.
+   * @returns Current `ReactorModule` instance for fluent chaining.
+   * @example
+   * const mod = new MyModule().attach(state1).setup(state2); // if using multiple, this should run last; with same params as `.attach()` for a shorter chain
+   */
+  setup(target, id) {
+    return this.attach(target, id), !this.wired && (this.wire(), this.wired = true), this;
   }
   destroy() {
     this.ac.abort();
     this.onDestroy?.();
   }
   /**
-   * Wraps a function with plugin-scoped error logging.
+   * Wraps a function with module-scoped error logging.
    * Use this when creating functions dynamically (for example, before attaching an anonymous listener on the fly).
    * @example
    * window.addEventListener("resize", this.guard(() => this.syncLayout(true)), { signal: this.signal });
    */
   guard = (fn) => {
-    return guardMethod(fn, (e) => this.rtr.log(`[Reactor "${this.name}" Plug] Error: ${e}`));
+    return guardMethod(fn, (e) => this.rtrs.values().next().value?.log(`[Reactor "${this.name}" Module] Error: ${e}`));
   };
   // `()=>{}`: needs to be bounded even before initialization
 };
 
 // src/ts/utils/store.ts
 var BaseStorageAdapter = class {
-  static name;
+  name = "StorageAdapter";
   config;
   warn = (act = "", mssg = "Support issue or Private Mode", key = "", store = "") => this.config.debug && console.warn(`[${this.constructor.name} \`${act}\`] Failed${key ? `for ${key}` : ""} ${store ? ` on "${store}"` : ""} ${this.config.dbName ? ` at ${this.config.dbName}` : ""} (${mssg})`);
   constructor(config) {
@@ -957,26 +1002,44 @@ var BaseStorageAdapter = class {
   }
 };
 var StorageAdapter = class extends BaseStorageAdapter {
+  name = "SyncStorageAdapter";
 };
 var AsyncStorageAdapter = class extends BaseStorageAdapter {
+  name = "AsyncStorageAdapter";
 };
 var LocalStorageAdapter = class extends StorageAdapter {
-  static name = "LocalStorage";
-  get(key) {
+  name = "LocalStorage";
+  /**
+   * Reads and parses a value from localStorage.
+   * @param key Storage key.
+   * @returns Parsed value, or `undefined` when missing/unreadable.
+   */
+  get(key, reviver = this.config.reviver) {
     try {
       const v = localStorage.getItem(key);
-      return v ? JSON.parse(v) : void 0;
+      return v ? JSON.parse(v, reviver) : void 0;
     } catch {
       return void 0;
     }
   }
-  set(key, value) {
+  /**
+   * Serializes and writes a value to localStorage.
+   * @param key Storage key.
+   * @param value Value to serialize.
+   * @returns `true` when write succeeds, else `false`.
+   */
+  set(key, value, replacer = this.config.replacer) {
     try {
-      return localStorage.setItem(key, JSON.stringify(value)), true;
+      return localStorage.setItem(key, JSON.stringify(value, replacer)), true;
     } catch (e) {
       return this.warn("setItem", void 0, key), false;
     }
   }
+  /**
+   * Removes a single key from localStorage.
+   * @param key Storage key.
+   * @returns `true` when removal succeeds, else `false`.
+   */
   remove(key) {
     try {
       return localStorage.removeItem(key), true;
@@ -984,6 +1047,10 @@ var LocalStorageAdapter = class extends StorageAdapter {
       return this.warn("removeItem", void 0, key), false;
     }
   }
+  /**
+   * Clears all localStorage entries for the current origin.
+   * @returns `true` when clear succeeds, else `false`.
+   */
   clear() {
     try {
       return localStorage.clear(), true;
@@ -992,25 +1059,94 @@ var LocalStorageAdapter = class extends StorageAdapter {
     }
   }
 };
-var MemoryStorageAdapter = class extends StorageAdapter {
+var SessionStorageAdapter = class extends StorageAdapter {
+  name = "SessionStorage";
+  /**
+   * Reads and parses a value from sessionStorage.
+   * @param key Storage key.
+   * @returns Parsed value, or `undefined` when missing/unreadable.
+   */
+  get(key, reviver = this.config.reviver) {
+    try {
+      const v = sessionStorage.getItem(key);
+      return v ? JSON.parse(v, reviver) : void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  /**
+   * Serializes and writes a value to sessionStorage.
+   * @param key Storage key.
+   * @param value Value to serialize.
+   * @returns `true` when write succeeds, else `false`.
+   */
+  set(key, value, replacer = this.config.replacer) {
+    try {
+      return sessionStorage.setItem(key, JSON.stringify(value, replacer)), true;
+    } catch (e) {
+      return this.warn("setItem", void 0, key), false;
+    }
+  }
+  /**
+   * Removes a single key from sessionStorage.
+   * @param key Storage key.
+   * @returns `true` when removal succeeds, else `false`.
+   */
+  remove(key) {
+    try {
+      return sessionStorage.removeItem(key), true;
+    } catch (e) {
+      return this.warn("removeItem", void 0, key), false;
+    }
+  }
+  /**
+   * Clears all sessionStorage entries for the current tab session.
+   * @returns `true` when clear succeeds, else `false`.
+   */
+  clear() {
+    try {
+      return sessionStorage.clear(), true;
+    } catch (e) {
+      return this.warn("clear", void 0), false;
+    }
+  }
+};
+var MemoryAdapter = class extends StorageAdapter {
+  name = "Memory";
   constructor(build) {
     super({ store: /* @__PURE__ */ new Map(), ...build });
   }
-  get(key) {
+  /**
+   * Reads and parses a value from memory storage.
+   * @param key Storage key.
+   * @returns Parsed value, or `undefined` when missing/unreadable.
+   */
+  get(key, reviver = this.config.reviver) {
     try {
       const v = this.config.store.get(key);
-      return v ? JSON.parse(v) : void 0;
+      return v ? JSON.parse(v, reviver) : void 0;
     } catch {
       return void 0;
     }
   }
-  set(key, value) {
+  /**
+   * Serializes and writes a value to memory storage.
+   * @param key Storage key.
+   * @param value Value to serialize.
+   * @returns `true` when write succeeds, else `false`.
+   */
+  set(key, value, replacer = this.config.replacer) {
     try {
-      return this.config.store.set(key, JSON.stringify(value)), true;
+      return this.config.store.set(key, JSON.stringify(value, replacer)), true;
     } catch (e) {
       return this.warn("set", void 0, key), false;
     }
   }
+  /**
+   * Removes a single key from memory storage.
+   * @param key Storage key.
+   * @returns `true` when removal succeeds, else `false`.
+   */
   remove(key) {
     try {
       return this.config.store.delete(key), true;
@@ -1018,6 +1154,10 @@ var MemoryStorageAdapter = class extends StorageAdapter {
       return this.warn("remove", void 0, key), false;
     }
   }
+  /**
+   * Clears all entries from memory storage.
+   * @returns `true` when clear succeeds, else `false`.
+   */
   clear() {
     try {
       return this.config.store.clear(), true;
@@ -1026,23 +1166,100 @@ var MemoryStorageAdapter = class extends StorageAdapter {
     }
   }
 };
+var CookieAdapter = class extends StorageAdapter {
+  name = "Cookie";
+  deets = (opts = NIL, _d = opts.domain ?? this.config.domain, _m = opts.maxAge ?? this.config.maxAge, _e = opts.expires ?? this.config.expires) => `Path=${opts.path ?? this.config.path}; SameSite=${opts.sameSite ?? this.config.sameSite}${_d ? `; Domain=${_d}` : ""}${opts.secure ?? this.config.secure ? "; Secure" : ""}${_m !== void 0 ? `; Max-Age=${_m}` : ""}${_e !== void 0 ? `; Expires=${_e instanceof Date ? _e.toUTCString() : _e}` : ""}`;
+  constructor(build) {
+    super({ secure: "undefined" !== typeof window && location.protocol === "https:", ...COOKIE_ADAPTER_BUILD, ...build });
+  }
+  /**
+   * Reads and parses a cookie visible to the current page scope.
+   * @param key Cookie key.
+   * @returns Parsed value, or `undefined` when missing/unreadable.
+   */
+  get(key, reviver = this.config.reviver) {
+    try {
+      const k = encodeURIComponent(key) + "=";
+      for (const pair of document.cookie ? document.cookie.split("; ") : []) {
+        if (!pair.startsWith(k)) continue;
+        return JSON.parse(decodeURIComponent(pair.slice(k.length)), reviver);
+      }
+      return void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  /**
+   * Writes a cookie with optional per-call scope/lifetime overrides.
+   * @param key Cookie key.
+   * @param value Value to serialize.
+   * @param opts Optional per-call cookie options.
+   * @returns `true` when write succeeds, else `false`.
+   */
+  set(key, value, opts = NIL, replacer = this.config.replacer) {
+    try {
+      return document.cookie = `${encodeURIComponent(key)}=${encodeURIComponent(JSON.stringify(value, replacer))}; ${this.deets(opts)}`, true;
+    } catch {
+      return this.warn("set", void 0, key), false;
+    }
+  }
+  /**
+   * Removes a cookie key using matching scope attributes.
+   * @param key Cookie key.
+   * @param opts Optional per-call scope overrides.
+   * @returns `true` when removal succeeds, else `false`.
+   */
+  remove(key, opts = NIL) {
+    try {
+      return document.cookie = `${encodeURIComponent(key)}=; ${this.deets({ ...opts, maxAge: 0, expires: /* @__PURE__ */ new Date(0) })}`, true;
+    } catch {
+      return this.warn("remove", void 0, key), false;
+    }
+  }
+  /**
+   * Attempts to remove all visible cookie keys for the given scope.
+   * @param opts Optional per-call scope overrides.
+   * @returns `true` when clear succeeds, else `false`.
+   */
+  clear(opts = NIL) {
+    try {
+      for (const pair of document.cookie ? document.cookie.split("; ") : []) {
+        const idx = pair.indexOf("=");
+        document.cookie = `${idx === -1 ? pair : pair.slice(0, idx)}=; ${this.deets({ ...opts, maxAge: 0, expires: /* @__PURE__ */ new Date(0) })}`;
+      }
+      return true;
+    } catch {
+      return this.warn("clear"), false;
+    }
+  }
+};
 var IndexedDBAdapter = class extends AsyncStorageAdapter {
+  name = "IndexedDB";
   db;
-  warn = (act = "", mssg = "Support issue or Private Mode", store = "", key = "") => console.warn(`[IndexedDB \`${act}\`] Failed${store ? ` for ${key} on "${store}"` : ""} at ${this.config.dbName} (${mssg})`);
   constructor(build) {
     super({ ...INDEXED_DB_ADAPTER_BUILD, ...build });
   }
+  /**
+   * Returns a connected IndexedDB instance, opening it when needed.
+   * @returns Connected database handle.
+   */
   async idb() {
     const idb = this.config.onidb();
     if (idb || this.db) return Promise.resolve(idb || this.db);
     return new Promise((res, rej) => {
       const req = indexedDB.open(this.config.dbName, this.config.version);
       req.onupgradeneeded = (e) => (this.config.onupgradeneeded(req.result, e), this.config.stores.forEach((s) => !req.result.objectStoreNames.contains(s) && req.result.createObjectStore(s)));
-      req.onsuccess = (e) => (this.config.onsuccess(req.result, e), req.result.onversionchange = (e2) => (this.warn("update", "Updated in another tab"), this.config.onversionchange(req.result, e2), req.result.close()), res(this.db = req.result));
+      req.onsuccess = (e) => (this.config.onsuccess(req.result, e), req.result.onversionchange = (e2) => (this.config.onversionchange(req.result, e2), this.warn("update", "Updated in another tab"), req.result.close()), res(this.db = req.result));
       req.onerror = (e) => (this.config.onerror(req.error, e), this.warn("open", "Something went wrong"), rej(req.error));
       req.onblocked = (e) => (this.config.onblocked(e), this.warn("open", "Close other tabs for updates"));
     });
   }
+  /**
+   * Reads a value by key from an object store.
+   * @param key Record key.
+   * @param store Optional object-store override.
+   * @returns Stored value, or `undefined` when missing/unreadable.
+   */
   async get(key, store = this.config.stores[0]) {
     try {
       const req = (await this.idb()).transaction(store).objectStore(store).get(key);
@@ -1051,6 +1268,13 @@ var IndexedDBAdapter = class extends AsyncStorageAdapter {
       return this.warn("get", void 0, store), void 0;
     }
   }
+  /**
+   * Writes a value by key into an object store.
+   * @param key Record key.
+   * @param value Value to store.
+   * @param store Optional object-store override.
+   * @returns `true` when write succeeds, else `false`.
+   */
   async set(key, value, store = this.config.stores[0]) {
     try {
       const req = (await this.idb()).transaction(store, "readwrite").objectStore(store).put(value, key);
@@ -1059,6 +1283,12 @@ var IndexedDBAdapter = class extends AsyncStorageAdapter {
       return this.warn("put", void 0, store), false;
     }
   }
+  /**
+   * Deletes a value by key from an object store.
+   * @param key Record key.
+   * @param store Optional object-store override.
+   * @returns `true` when delete succeeds, else `false`.
+   */
   async remove(key, store = this.config.stores[0]) {
     try {
       const req = (await this.idb()).transaction(store, "readwrite").objectStore(store).delete(key);
@@ -1067,6 +1297,11 @@ var IndexedDBAdapter = class extends AsyncStorageAdapter {
       return this.warn("delete", void 0, store), false;
     }
   }
+  /**
+   * Clears one or more object stores.
+   * @param stores Store name or list of store names to clear.
+   * @returns `true` when all clears succeed, else `false`.
+   */
   async clear(stores = this.config.stores) {
     let success = true;
     for (const store of Array.isArray(stores) ? stores : [stores])
@@ -1079,6 +1314,7 @@ var IndexedDBAdapter = class extends AsyncStorageAdapter {
     return success;
   }
 };
+var COOKIE_ADAPTER_BUILD = { path: "/", sameSite: "Lax", domain: void 0, debug: false };
 var INDEXED_DB_ADAPTER_BUILD = { dbName: "REACTOR_IDB", stores: ["VAULT"], version: 1, onidb: NOOP, onupgradeneeded: NOOP, onversionchange: NOOP, onsuccess: NOOP, onerror: NOOP, onblocked: NOOP };
 
 // src/ts/utils/fn.ts
@@ -1091,93 +1327,123 @@ function setTimeout2(handler, timeout, ...args) {
   return sig.addEventListener("abort", kill, { once: true }), id;
 }
 
-// src/ts/plugins/persist.ts
-var PersistPlugin = class extends BaseReactorPlugin {
-  static plugName = "persist";
+// src/ts/modules/persist.ts
+var PersistModule = class extends BaseReactorModule {
+  static moduleName = "persist";
   adapter;
+  hydrateSeq = 0;
   saveTimeoutId = 0;
   get payload() {
-    const snap = this.config.useSnapshot ? this.rtr.snapshot() : this.rtr.core;
-    return this.config.paths ? this.config.paths.reduce((acc, p) => (setAny(acc, p, getAny(snap, p)), acc), {}) : snap;
+    let res = this.rtrs.size > 1 ? {} : void 0;
+    for (const [rid, rtr] of this.rtrs) {
+      const snap = this.config.useSnapshot ? (this.config.useSnapshot === true && (rtr.config.referenceTracking = rtr.config.smartCloning = true), rtr.snapshot()) : rtr.core, val = this.config.paths ? this.config.paths.reduce((acc, p) => (setAny(acc, p, getAny(snap, p)), acc), {}) : snap;
+      this.rtrs.size > 1 ? setAny(res, rid, val) : res = val;
+    }
+    return res;
   }
   constructor(config, rtr) {
-    super({ ...PERSIST_PLUGIN_BUILD, ...config }, rtr);
+    super({ ...PERSIST_MODULE_BUILD, ...config }, rtr, { hydrated: false });
   }
   wire() {
     "undefined" !== typeof window && window.addEventListener("pagehide", this.onDestroy, { signal: this.signal });
     "undefined" !== typeof document && document.addEventListener("visibilitychange", () => document.visibilityState === "hidden" && this.onDestroy(), { signal: this.signal });
-    this.config.on("adapter", this.handleAdapterChange, { signal: this.signal, immediate: true });
-    this.config.on("disabled", this.handleDisabledChange, { signal: this.signal, immediate: true });
-    this.config.on("paths", this.handlePathsState, { signal: this.signal, immediate: true });
+    this.config.on("adapter", this.handleAdapter, { signal: this.signal, immediate: true });
+    this.config.on("disabled", this.handleDisabled, { signal: this.signal, immediate: true });
+    this.config.on("paths", this.handlePaths, { signal: this.signal, immediate: true });
   }
-  async handleAdapterChange({ value = LocalStorageAdapter }) {
+  onAttach(rtr) {
+    for (const p of this.config.paths ?? wpArr) !this.config.disabled ? rtr.on(p, this.handleSave, { signal: this.signal, immediate: true }) : rtr.off(p, this.handleSave);
+  }
+  async handleAdapter({ value = LocalStorageAdapter }) {
+    const seq = ++this.hydrateSeq;
     if (this.adapter && value === this.adapter.constructor) return;
+    this.state.hydrated = false;
     this.adapter?.remove(this.config.key);
-    this.adapter = "function" === typeof value ? new value({ debug: this.rtr.canLog }) : value;
-    let saved = this.adapter.get(this.config.key);
-    const isAsync = saved instanceof Promise;
-    saved = !isAsync ? saved : await saved;
-    const set = (p, news, olds) => setAny(this.rtr.core, p, isPOJO(news, this.rtr.config) && isPOJO(olds, this.rtr.config) ? mergeObjs(news, olds) : olds);
-    if (saved) for (const p of this.config.paths ?? ["*"]) set(p, getAny(this.rtr.core, p), getAny(saved, p));
-    saved && this.rtr.tick(this.config.paths ?? "*");
-  }
-  handleDisabledChange({ value }) {
-    for (const p of this.config.paths ?? ["*"]) this.rtr.off(p, this.throttleSave), !value && this.rtr.on(p, this.throttleSave, { signal: this.signal, immediate: true });
+    this.adapter = "function" === typeof value ? new value({ debug: !!this.rtrs.values().next().value?.canLog }) : value;
+    try {
+      let saved = this.adapter.get(this.config.key);
+      const isAsync = saved instanceof Promise, depth = this.config.fanout ?? isAsync;
+      saved = !isAsync ? saved : await saved;
+      if (seq !== this.hydrateSeq || !saved) return;
+      for (const [rid, rtr] of this.rtrs) {
+        const entry = this.rtrs.size > 1 ? getAny(saved, rid) : saved;
+        if (!entry) continue;
+        const set = (p, news, olds) => (depth ? fanout : setAny)(rtr.core, p, isPOJO(news, rtr.config) && isPOJO(olds, rtr.config) ? mergeObjs(news, olds) : olds, depth ? { depth } : void 0);
+        for (const p of this.config.paths ?? wpArr) set(p, getAny(rtr.core, p), getAny(entry, p));
+      }
+      for (const rtr of this.rtrs.values()) rtr.tick(!depth ? this.config.paths ?? "*" : "*");
+    } catch {
+    } finally {
+      if (seq === this.hydrateSeq) this.state.hydrated = true;
+    }
+  }
+  handleDisabled({ value }) {
+    for (const rtr of this.rtrs.values()) this.onAttach(rtr);
     value && this.adapter?.remove(this.config.key);
   }
-  handlePathsState({ value: paths = ["*"], oldValue: prevs = ["*"] }) {
-    for (const p of prevs) this.rtr.off(p, this.throttleSave);
-    for (const p of paths) this.rtr.off(p, this.throttleSave), !this.config.disabled && this.rtr.on(p, this.throttleSave, { signal: this.signal, immediate: true });
+  handlePaths({ value: paths = wpArr, oldValue: prevs = wpArr }) {
+    for (const rtr of this.rtrs.values()) {
+      for (const p of prevs) rtr.off(p, this.handleSave);
+      for (const p of paths) rtr.off(p, this.handleSave), !this.config.disabled && rtr.on(p, this.handleSave, { signal: this.signal, immediate: true });
+    }
   }
-  throttleSave() {
+  handleSave(e) {
+    if (!this.state.hydrated) return e.stopImmediatePropagation();
     if (!this.saveTimeoutId) this.saveTimeoutId = setTimeout2(() => (this.adapter.set(this.config.key, this.payload), this.saveTimeoutId = 0), this.config.throttle, this.signal);
   }
-  /** Clears persisted payload for this plugin instance and drops any pending save. */
+  /** Clears persisted payload for this module instance and drops any pending save. */
   clear() {
     clearTimeout(this.saveTimeoutId);
-    this.saveTimeoutId = -1, this.rtr.stall(() => this.saveTimeoutId = 0);
+    this.saveTimeoutId = -1;
+    for (const rtr of this.rtrs.values()) rtr.stall(() => this.saveTimeoutId = 0);
     this.adapter?.remove(this.config.key);
   }
   onDestroy() {
-    !this.config.disabled && this.adapter?.set(this.config.key, this.payload);
+    this.state.hydrated && !this.config.disabled && this.adapter?.set(this.config.key, this.payload);
   }
 };
-var PERSIST_PLUGIN_BUILD = { disabled: false, key: "REACTOR_STORE", throttle: 2500, useSnapshot: false };
+var PERSIST_MODULE_BUILD = { disabled: false, key: "REACTOR_STORE", throttle: 2500, useSnapshot: false };
 
 // src/ts/utils/num.ts
 function clamp(min = 0, val, max = Infinity) {
   return Math.min(Math.max(val, min), max);
 }
 
-// src/ts/plugins/timeTravel.ts
-var TimeTravelPlugin = class extends BaseReactorPlugin {
-  static plugName = "timeTravel";
+// src/ts/modules/timeTravel.ts
+var TimeTravelModule = class extends BaseReactorModule {
+  static moduleName = "timeTravel";
   lastTimestamp = 0;
   playbackTimeoutId = -1;
   constructor(config, rtr) {
-    super({ ...TIME_TRAVEL_PLUGIN_BUILD, ...config }, rtr, { initialState: null, history: [], currentFrame: 0, paused: true });
+    super({ ...TIME_TRAVEL_MODULE_BUILD, ...config }, rtr, { initialState: {}, history: [], currentFrame: 0, paused: true });
   }
   // ===========================================================================
   // THE FOUNDATION & WIRETAP (Passive Recording)
   // ===========================================================================
   wire() {
-    this.rtr.config.referenceTracking = this.rtr.config.smartCloning = this.rtr.config.eventTimeStamps = true;
-    if (!this.state.history.length || this.state.initialState == null) this.state.initialState = this.rtr.snapshot();
     this.lastTimestamp = performance.now();
     this.state.set("currentFrame", (v = 0) => clamp(0, v, this.state.history.length), { signal: this.signal, immediate: true });
-    this.config.on("paths", this.handlePathsState, { signal: this.signal, immediate: true });
+    this.config.on("paths", this.handlePaths, { signal: this.signal, immediate: true });
     !this.state.paused && this.play();
   }
-  handlePathsState({ value: paths = ["*"], oldValue: prevs = ["*"] }) {
-    for (const p of prevs) this.rtr.off(p, this.record);
-    for (const p of paths) this.rtr.off(p, this.record), this.rtr.on(p, this.record, { signal: this.signal });
+  onAttach(rtr, rid) {
+    rtr.config.referenceTracking = rtr.config.smartCloning = rtr.config.eventTimeStamps = true;
+    if (!this.state.history.length || !this.state.initialState[rid]) this.state.initialState[rid] = rtr.snapshot();
+    for (const p of this.config.paths ?? wpArr) rtr.on(p, this.record, { signal: this.signal });
+  }
+  handlePaths({ value: paths = wpArr, oldValue: prevs = wpArr }) {
+    for (const rtr of this.rtrs.values()) {
+      for (const p of prevs) rtr.off(p, this.record);
+      for (const p of paths) rtr.off(p, this.record), rtr.on(p, this.record, { signal: this.signal });
+    }
   }
   /** Chronicling the lifecycle of the system, Captures the essence of every mutation wave that bubbles up. */
-  record(e) {
+  record(e, rid = this.rids.get(e.reactor)) {
     if (!this.state.paused) return;
     if (this.state.currentFrame < this.state.history.length) this.state.history = this.state.history.slice(0, this.state.currentFrame);
     if (this.state.history.length >= this.config.maxHistoryLength) this.state.history = this.state.history.slice(1);
-    this.state.history.push({ path: e.target.path, value: this.rtr.snapshot(false, e.target.value), oldValue: this.rtr.snapshot(false, e.target.oldValue), type: e.staticType, rejected: e.rejected, timedelta: e.timestamp - this.lastTimestamp, hadKey: e.target.hadKey });
+    this.state.history.push({ path: e.target.path, value: e.reactor.snapshot(false, e.target.value), oldValue: e.reactor.snapshot(false, e.target.oldValue), type: e.staticType, hadKey: e.target.hadKey, deltat: e.timestamp - this.lastTimestamp, rid });
+    if (e.rejected) this.state.history[this.state.history.length - 1].rejected = e.rejected;
     this.state.currentFrame = this.state.history.length;
     this.lastTimestamp = e.timestamp;
   }
@@ -1186,7 +1452,7 @@ var TimeTravelPlugin = class extends BaseReactorPlugin {
     this.pause();
     this.playbackTimeoutId = -1;
     this.state.history.length = this.state.currentFrame = 0;
-    this.state.initialState = this.rtr.snapshot();
+    this.state.initialState = Object.fromEntries(this.rtrs.entries().map(([rid, rtr]) => [rid, rtr.snapshot()]));
     this.lastTimestamp = performance.now();
   }
   // ===========================================================================
@@ -1199,12 +1465,13 @@ var TimeTravelPlugin = class extends BaseReactorPlugin {
     while (this.state.currentFrame !== target) {
       const e = this.state.history[forward ? this.state.currentFrame : this.state.currentFrame - 1];
       if (!e) break;
-      if (forward) e.type === "delete" ? deleteAny(this.rtr.core, e.path) : setAny(this.rtr.core, e.path, deepClone(e.value, this.rtr.config));
-      else !e.hadKey ? deleteAny(this.rtr.core, e.path) : setAny(this.rtr.core, e.path, deepClone(e.oldValue, this.rtr.config));
+      const rtr = this.rtrs.get(e.rid) || this.rtrs.values().next().value;
+      if (forward) e.type === "delete" ? deleteAny(rtr.core, e.path) : setAny(rtr.core, e.path, deepClone(e.value, rtr.config));
+      else !e.hadKey ? deleteAny(rtr.core, e.path) : setAny(rtr.core, e.path, deepClone(e.oldValue, rtr.config));
       forward ? this.state.currentFrame++ : this.state.currentFrame--;
-      if (e.rejected) this.rtr.log(`[Reactor ${this.name} Plug] ${forward ? "Replaying" : "Reversing"} REJECTED intent at "${e.path}"`);
+      if (e.rejected) rtr.log(`[Reactor ${this.name} Module] ${forward ? "Replaying" : "Reversing"} REJECTED intent at "${e.path}"`);
     }
-    this.rtr.tick();
+    for (const rtr of this.rtrs.values()) rtr.tick();
     if (!keepShield) this.state.paused = true;
   }
   /** Step through time, Moves the playhead and teleports the state. */
@@ -1223,9 +1490,9 @@ var TimeTravelPlugin = class extends BaseReactorPlugin {
   async automove(forward = true) {
     this.state.paused = false;
     while ((forward ? this.state.currentFrame < this.state.history.length : this.state.currentFrame > 0) && !this.state.paused) {
-      const currIndex = forward ? this.state.currentFrame : this.state.currentFrame - 1, e = this.state.history[forward ? currIndex + 1 : currIndex - 1];
+      const idx = forward ? this.state.currentFrame : this.state.currentFrame - 1, e = this.state.history[forward ? idx + 1 : idx - 1];
       this.jumpTo(this.state.currentFrame + (forward ? 1 : -1), true);
-      if (e?.timedelta > 0) await new Promise((res) => this.playbackTimeoutId = setTimeout2(() => res(0), Math.min(e.timedelta, this.config.maxPlaybackDelay), this.signal));
+      if (e?.deltat > 0) await new Promise((res) => this.playbackTimeoutId = setTimeout2(() => res(0), Math.min(e.deltat, this.config.maxPlaybackDelay), this.signal));
     }
     this.state.paused = true;
   }
@@ -1243,35 +1510,39 @@ var TimeTravelPlugin = class extends BaseReactorPlugin {
     try {
       return JSON.stringify(this.state, replacer, space);
     } catch (e) {
-      return this.rtr.log(`[Reactor ${this.name} Plug] Failed to export session`), "";
+      return this.rtrs.values().next().value?.log(`[Reactor ${this.name} Module] Failed to export session`), "";
     }
   }
   /** Imports a session from a JSON string, allowing you to replay or analyze past states. */
-  import(json) {
+  import(json, reviver) {
     try {
-      setAny(this.state, "*", JSON.parse(json));
+      setAny(this.state, "*", JSON.parse(json, reviver));
       this.lastTimestamp = performance.now();
       const resume = !this.state.paused, target = this.state.currentFrame;
       this.state.paused = false;
-      setAny(this.rtr.core, "*", deepClone(this.state.initialState, this.rtr.config)), this.rtr.tick();
+      for (const [rid, rtr] of this.rtrs) setAny(rtr.core, "*", deepClone(this.state.initialState[rid], rtr.config)), rtr.tick();
       this.state.currentFrame = 0, this.jumpTo(target), resume && this.play();
     } catch (e) {
-      this.rtr.log(`[Reactor ${this.name} Plug] Failed to load session`);
+      this.rtrs.values().next().value?.log(`[Reactor ${this.name} Module] Failed to load session`);
     }
   }
 };
-var TIME_TRAVEL_PLUGIN_BUILD = { maxPlaybackDelay: 2e3 };
+var TIME_TRAVEL_MODULE_BUILD = { maxPlaybackDelay: 2e3 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  BaseReactorPlugin,
+  AsyncStorageAdapter,
+  BaseReactorModule,
   BaseStorageAdapter,
+  COOKIE_ADAPTER_BUILD,
+  CookieAdapter,
   INDEXED_DB_ADAPTER_BUILD,
   IndexedDBAdapter,
   LocalStorageAdapter,
-  MemoryStorageAdapter,
-  PERSIST_PLUGIN_BUILD,
-  PersistPlugin,
+  MemoryAdapter,
+  PERSIST_MODULE_BUILD,
+  PersistModule,
+  SessionStorageAdapter,
   StorageAdapter,
-  TIME_TRAVEL_PLUGIN_BUILD,
-  TimeTravelPlugin
+  TIME_TRAVEL_MODULE_BUILD,
+  TimeTravelModule
 });