sia-reactor 0.0.19 → 0.0.21

package/dist/plugins.cjs

@@ -17,7 +17,7 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/plugins.ts
+// src/ts/plugins.ts
 var plugins_exports = {};
 __export(plugins_exports, {
   BaseReactorPlugin: () => BaseReactorPlugin,
@@ -34,8 +34,10 @@ __export(plugins_exports, {
 });
 module.exports = __toCommonJS(plugins_exports);
 
-// src/core/consts.ts
+// 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. */
   autotracker: null
 };
@@ -54,7 +56,7 @@ var NIL = Object.freeze({});
 var NOOP = () => {
 };
 
-// src/utils/obj.ts
+// src/ts/utils/obj.ts
 var arrRx = /^([^\[\]]+)\[(\d+)\]$/;
 function isObj(obj, arraycheck = true) {
   return "object" === typeof obj && obj !== null && (arraycheck ? !Array.isArray(obj) : true);
@@ -181,7 +183,7 @@ function nuke(target) {
   }
 }
 
-// src/core/event.ts
+// src/ts/core/event.ts
 var ReactorEvent = class _ReactorEvent {
   /** No active propagation phase. */
   static NONE = 0;
@@ -304,7 +306,7 @@ var ReactorEvent = class _ReactorEvent {
   }
 };
 
-// src/core/reactor.ts
+// src/ts/core/reactor.ts
 var Reactor = class {
   log = NOOP;
   core;
@@ -332,27 +334,27 @@ var Reactor = class {
   listeners;
   /**
    * Creates a new Reactor instance.
-   * @param object Initial state object.
+   * @param target Initial state target.
    * @param build Reactor bootstrap/build configuration.
    * @example
    * const rtr = new Reactor({ count: 0 });
    */
-  constructor(object = {}, build) {
+  constructor(target = {}, build) {
     this[INERTIA] = true;
     this.config = { crossRealms: false, smartCloning: false, eventBubbling: true, lineageTracing: false, preserveContext: false, equalityFunction: Object.is, batchingFunction: RTR_BATCH, ...build };
-    this.core = this.proxied(object);
+    this.core = this.proxied(target);
     if (build) this.canLog = !!build.debug;
   }
-  proxied(obj, rejectable = false, indiffable = false, parent, key, path) {
-    if (!obj || "object" !== typeof obj) return obj;
-    obj = obj[RAW] || obj;
-    if (this.config.referenceTracking && parent && key && !this.link(obj, parent, key, false)) return obj;
-    const cached = this.proxyCache.get(obj);
+  proxied(target, rejectable = false, indiffable = false, parent, key, path) {
+    if (!target || "object" !== typeof target) return target;
+    target = target[RAW] || target;
+    if (this.config.referenceTracking && parent && key && !this.link(target, parent, key, false)) return target;
+    const cached = this.proxyCache.get(target);
     if (cached) return cached;
-    if (obj[INERTIA] || !canHandle(obj, this.config, false)) return obj;
-    rejectable ||= obj[REJECTABLE];
-    indiffable ||= obj[INDIFFABLE];
-    const proxy = new Proxy(obj, {
+    if (target[INERTIA] || !canHandle(target, this.config, false)) return target;
+    rejectable ||= target[REJECTABLE];
+    indiffable ||= target[INDIFFABLE];
+    const proxy = new Proxy(target, {
       // Robust Proxy handler
       get: (object, key2, receiver) => {
         if (key2 === RAW) return this.log(`\u{1F440} [Reactor \`get\` Trap] Peeked at ${object}`), object;
@@ -365,10 +367,10 @@ var Reactor = class {
           for (let i = 0, len = this.config.lineageTracing ? paths.length : 1; i < len; i++) {
             const currPath = this.config.lineageTracing ? paths[i] : fullPath, cords = this.getters.get(currPath);
             if (!cords && !wildcords) continue;
-            const target = { path: currPath, value, key: keyStr, keyExisted: true, object: receiver }, payload = { type: "get", target, currentTarget: target, root: this.core, rejectable };
+            const target2 = { path: currPath, value, key: keyStr, hadKey: true, object: receiver }, payload = { type: "get", target: target2, currentTarget: target2, root: this.core, rejectable };
             if (cords) value = this.mediate(currPath, payload, "get", cords);
             if (!wildcords) continue;
-            target.value = value;
+            target2.value = value;
             value = this.mediate("*", payload, "get", wildcords);
           }
         }
@@ -376,7 +378,7 @@ var Reactor = class {
       },
       set: (object, key2, value, receiver) => {
         let unchanged, safeValue, safeOldValue, terminated = false;
-        const keyStr = String(key2), fullPath = path ? path + "." + keyStr : keyStr, paths = this.config.lineageTracing ? this.trace(object, keyStr) : fullPath, loopLen = this.config.lineageTracing ? paths.length : 1, oldValue = !this.config.preserveContext ? object[key2] : Reflect.get(object, key2, receiver), keyExisted = !this.config.preserveContext ? key2 in object : Reflect.has(object, key2);
+        const keyStr = String(key2), fullPath = path ? path + "." + keyStr : keyStr, paths = this.config.lineageTracing ? this.trace(object, keyStr) : fullPath, loopLen = this.config.lineageTracing ? paths.length : 1, oldValue = !this.config.preserveContext ? object[key2] : Reflect.get(object, key2, receiver), hadKey = !this.config.preserveContext ? key2 in object : Reflect.has(object, key2);
         this.log(`\u270F\uFE0F [Reactor \`set\` Trap] Initiated for "${keyStr}" on "${paths}"`), CTX.autotracker?.track(fullPath, this, true);
         if (this.config.referenceTracking || !indiffable) {
           safeOldValue = oldValue?.[RAW] || oldValue;
@@ -390,13 +392,13 @@ var Reactor = class {
           for (let i = 0; i < loopLen; i++) {
             const currPath = this.config.lineageTracing ? paths[i] : fullPath, cords = this.setters.get(currPath);
             if (!cords && !wildcords) continue;
-            const target = { path: currPath, value, oldValue, key: keyStr, keyExisted, object: receiver }, payload = { type: "set", target, currentTarget: target, root: this.core, terminated, rejectable };
+            const target2 = { path: currPath, value, oldValue, key: keyStr, hadKey, object: receiver }, payload = { type: "set", target: target2, currentTarget: target2, root: this.core, terminated, rejectable };
             if (cords) {
               const result2 = this.mediate(currPath, payload, "set", cords);
               if (!(terminated ||= payload.terminated)) value = result2;
             }
             if (!wildcords) continue;
-            target.value = value;
+            target2.value = value;
             const result = this.mediate("*", payload, "set", wildcords);
             if (!(terminated ||= payload.terminated)) value = result;
           }
@@ -407,14 +409,14 @@ var Reactor = class {
         if (this.config.referenceTracking && !unchanged) this.config.smartCloning && this.stamp(object), this.unlink(safeOldValue, object, keyStr), this.link(safeValue, object, keyStr);
         if (this.watchers || this.listeners)
           for (let i = 0; i < loopLen; i++) {
-            const currPath = this.config.lineageTracing ? paths[i] : fullPath, target = { path: currPath, value, oldValue, key: keyStr, keyExisted, object: receiver };
-            this.notify(currPath, { type: "set", target, currentTarget: target, root: this.core, terminated, rejectable });
+            const currPath = this.config.lineageTracing ? paths[i] : fullPath, target2 = { path: currPath, value, oldValue, key: keyStr, hadKey, object: receiver };
+            this.notify(currPath, { type: "set", target: target2, currentTarget: target2, root: this.core, terminated, rejectable });
           }
         return true;
       },
       deleteProperty: (object, key2) => {
         let value, receiver = this.proxyCache.get(object), terminated = false;
-        const keyStr = String(key2), fullPath = path ? path + "." + keyStr : keyStr, paths = this.config.lineageTracing ? this.trace(object, keyStr) : fullPath, loopLen = this.config.lineageTracing ? paths.length : 1, oldValue = !this.config.preserveContext ? object[key2] : Reflect.get(object, key2, receiver), keyExisted = !this.config.preserveContext ? key2 in object : Reflect.has(object, key2);
+        const keyStr = String(key2), fullPath = path ? path + "." + keyStr : keyStr, paths = this.config.lineageTracing ? this.trace(object, keyStr) : fullPath, loopLen = this.config.lineageTracing ? paths.length : 1, oldValue = !this.config.preserveContext ? object[key2] : Reflect.get(object, key2, receiver), hadKey = !this.config.preserveContext ? key2 in object : Reflect.has(object, key2);
         this.log(`\u{1F5D1}\uFE0F [Reactor \`deleteProperty\` Trap] Initiated for "${keyStr}" on "${paths}"`), CTX.autotracker?.track(fullPath, this, true);
         if (this.config.deleteProperty) terminated = (value = this.config.deleteProperty(object, key2, oldValue, receiver, paths)) === TERMINATOR;
         if (this.deleters) {
@@ -422,7 +424,7 @@ var Reactor = class {
           for (let i = 0; i < loopLen; i++) {
             const currPath = this.config.lineageTracing ? paths[i] : fullPath, cords = this.deleters.get(currPath);
             if (!cords && !wildcords) continue;
-            const target = { path: currPath, value, oldValue, key: keyStr, keyExisted, object: receiver }, payload = { type: "delete", target, currentTarget: target, root: this.core, rejectable };
+            const target2 = { path: currPath, value, oldValue, key: keyStr, hadKey, object: receiver }, payload = { type: "delete", target: target2, currentTarget: target2, root: this.core, rejectable };
             if (cords) {
               const result2 = this.mediate(currPath, payload, "delete", cords);
               if (!(terminated ||= payload.terminated)) value = result2;
@@ -438,8 +440,8 @@ var Reactor = class {
         if (this.config.referenceTracking) this.config.smartCloning && this.stamp(object), this.unlink(oldValue?.[RAW] || oldValue, object, keyStr);
         if (this.watchers || this.listeners)
           for (let i = 0; i < loopLen; i++) {
-            const currPath = this.config.lineageTracing ? paths[i] : fullPath, target = { path: currPath, value, oldValue, key: keyStr, keyExisted, object: receiver };
-            this.notify(currPath, { type: "delete", target, currentTarget: target, root: this.core, rejectable });
+            const currPath = this.config.lineageTracing ? paths[i] : fullPath, target2 = { path: currPath, value, oldValue, key: keyStr, hadKey, object: receiver };
+            this.notify(currPath, { type: "delete", target: target2, currentTarget: target2, root: this.core, rejectable });
           }
         return true;
       },
@@ -465,7 +467,7 @@ var Reactor = class {
         return ownKeys;
       }
     });
-    return this.proxyCache.set(obj, proxy), proxy;
+    return this.proxyCache.set(target, proxy), proxy;
   }
   trace(target, path, paths = [], seen = /* @__PURE__ */ new WeakSet()) {
     if (Object.is(target, this.core[RAW] || this.core)) return paths.push(path), paths;
@@ -557,7 +559,7 @@ var Reactor = class {
   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) || "", keyExisted: e.type !== "update" ? e.target.keyExisted : true, object };
+    e.currentTarget = { path, value, oldValue: e.type !== "update" ? e.target.oldValue : void 0, key: e.type !== "update" ? path : path.slice(path.lastIndexOf(".") + 1) || "", hadKey: e.type !== "update" ? e.target.hadKey : true, object };
     for (let i = 0, len = cords.length, tDepth; i < len; i++) {
       if (e.immediatePropagationStopped) break;
       if (cords[i].capture !== isCapture) continue;
@@ -612,21 +614,20 @@ var Reactor = class {
   }
   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) || "", keyExisted: true, object };
+    return { path, value, key: path.slice(lastDot + 1) || "", hadKey: true, object };
   }
   bindSignal(cord, sig) {
     if (sig) sig.aborted ? cord.clup() : sig.addEventListener("abort", cord.clup, { once: true });
     return cord.sclup = !sig || sig.aborted ? NOOP : () => sig.removeEventListener("abort", cord.clup), cord.clup;
   }
-  cloned(obj, raw, seen = /* @__PURE__ */ new WeakMap()) {
-    if (!obj || "object" !== typeof obj) return obj;
-    obj = obj[RAW] || obj;
-    const cloned = seen.get(obj);
+  cloned(target, raw, seen = /* @__PURE__ */ new WeakMap()) {
+    if (!target || "object" !== typeof target) return target;
+    const obj = target[RAW] || target, cloned = seen.get(obj);
     if (cloned) return cloned;
     if (!canHandle(obj, this.config, false)) return obj;
     const version = obj[VERSION] || 0, cached = !raw && this.config.smartCloning && (this.snapCache ??= /* @__PURE__ */ new WeakMap()).get(obj);
     if (cached && obj[SSVERSION] === version) return cached;
-    const clone = !raw ? this.config.preserveContext ? Object.create(Object.getPrototypeOf(obj)) : Array.isArray(obj) ? [] : {} : obj[RAW] || obj;
+    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);
@@ -810,19 +811,8 @@ var Reactor = class {
     for (let i = 0, len = cords.length; i < len; i++) if (Object.is(cords[i].cb, callback) && cords[i].capture === capture) return cords[i].sclup(), cords.splice((len--, i--), 1), !cords.length && this.listeners.delete(path), true;
     return false;
   }
-  /**
-   * Creates a snapshot; possibly clone of state (or a state branch).
-   * You could alternatively use or serialize your proxied state "as is" except the environment demands no proxies or new references.
-   * @param raw Use raw (deep unproxied & uncloned) version of branch.
-   * @param branch Branch to clone.
-   * @returns Snapshot deep or smart (structurally shared) clone.
-   * @example
-   * const snap = rtr.snapshot();
-   * @example
-   * const snap = rtr.snapshot(false, rtr.core.history.past);
-   */
-  snapshot(raw = !this.config.smartCloning, branch = this.core) {
-    return this.cloned(branch, raw);
+  snapshot(raw = !this.config.smartCloning, branch) {
+    return this.cloned(arguments.length < 2 ? this.core : branch, raw);
   }
   /**
    * Cascades object updates into direct child paths.
@@ -873,11 +863,11 @@ var Reactor = class {
   }
 };
 
-// src/core/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"];
+// 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"];
 function reactive(target, build, preferences = NIL) {
   if ("__Reactor__" in target) return target;
-  const descriptors = {}, rtr = target instanceof Reactor ? target : new Reactor(target, build), locks = { enumerable: false, configurable: true, writable: false }, hasAffix = !!(preferences.prefix || preferences.suffix);
+  const descriptors = {}, rtr = getReactor(target, true, build), locks = { enumerable: false, configurable: true, writable: false }, hasAffix = !!(preferences.prefix || preferences.suffix);
   for (let i = 0, len = methods.length; i < len; i++) {
     let key = methods[i];
     if (hasAffix) (preferences.whitelist?.includes(key) ?? true) && (key = `${preferences.prefix || ""}${key}${preferences.suffix || ""}`);
@@ -887,8 +877,11 @@ function reactive(target, build, preferences = NIL) {
   descriptors["__Reactor__"] = { value: rtr, ...locks };
   return Object.defineProperties(rtr.core, descriptors), rtr.core;
 }
+function getReactor(target, create = false, build) {
+  return (target instanceof Reactor ? target : target.__Reactor__) || (create ? new Reactor(target, build) : void 0);
+}
 
-// src/utils/methd.ts
+// src/ts/utils/methd.ts
 function onAllMethods(owner, callback, skipOwn = true, nested = false) {
   let proto = owner;
   while (proto && proto !== Object.prototype) {
@@ -916,7 +909,7 @@ function guardMethod(fn, onError = (e) => console.error(e)) {
   });
 }
 
-// src/plugins/base.ts
+// src/ts/plugins/base.ts
 var BaseReactorPlugin = class {
   static plugName;
   get name() {
@@ -954,7 +947,7 @@ var BaseReactorPlugin = class {
   // `()=>{}`: needs to be bounded even before initialization
 };
 
-// src/utils/store.ts
+// src/ts/utils/store.ts
 var BaseStorageAdapter = class {
   static name;
   config;
@@ -1088,7 +1081,7 @@ var IndexedDBAdapter = class extends AsyncStorageAdapter {
 };
 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/utils/fn.ts
+// src/ts/utils/fn.ts
 function setTimeout2(handler, timeout, ...args) {
   const sig = args[0] instanceof AbortSignal ? args.shift() : void 0;
   if (sig?.aborted) return -1;
@@ -1098,7 +1091,7 @@ function setTimeout2(handler, timeout, ...args) {
   return sig.addEventListener("abort", kill, { once: true }), id;
 }
 
-// src/plugins/persist.ts
+// src/ts/plugins/persist.ts
 var PersistPlugin = class extends BaseReactorPlugin {
   static plugName = "persist";
   adapter;
@@ -1151,17 +1144,18 @@ var PersistPlugin = class extends BaseReactorPlugin {
 };
 var PERSIST_PLUGIN_BUILD = { disabled: false, key: "REACTOR_STORE", throttle: 2500, useSnapshot: false };
 
-// src/utils/num.ts
+// src/ts/utils/num.ts
 function clamp(min = 0, val, max = Infinity) {
   return Math.min(Math.max(val, min), max);
 }
 
-// src/plugins/timeTravel.ts
+// src/ts/plugins/timeTravel.ts
 var TimeTravelPlugin = class extends BaseReactorPlugin {
   static plugName = "timeTravel";
+  lastTimestamp = 0;
   playbackTimeoutId = -1;
   constructor(config, rtr) {
-    super({ ...TIME_TRAVEL_PLUGIN_BUILD, ...config }, rtr, { history: [], initialState: null, currentFrame: 0, paused: true });
+    super({ ...TIME_TRAVEL_PLUGIN_BUILD, ...config }, rtr, { initialState: null, history: [], currentFrame: 0, paused: true });
   }
   // ===========================================================================
   // THE FOUNDATION & WIRETAP (Passive Recording)
@@ -1169,6 +1163,7 @@ var TimeTravelPlugin = class extends BaseReactorPlugin {
   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.state.paused && this.play();
@@ -1182,16 +1177,17 @@ var TimeTravelPlugin = class extends BaseReactorPlugin {
     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({ timestamp: e.timestamp ?? performance.now(), path: e.target.path, type: e.staticType, value: this.rtr.snapshot(false, e.target.value), oldValue: this.rtr.snapshot(false, e.target.oldValue), keyExisted: e.target.keyExisted, rejected: e.rejected });
+    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.currentFrame = this.state.history.length;
+    this.lastTimestamp = e.timestamp;
   }
   /** Clears timeline history and resets playhead/genesis to the current reactor state. */
   clear() {
     this.pause();
     this.playbackTimeoutId = -1;
-    this.state.history = [];
-    this.state.currentFrame = 0;
+    this.state.history.length = this.state.currentFrame = 0;
     this.state.initialState = this.rtr.snapshot();
+    this.lastTimestamp = performance.now();
   }
   // ===========================================================================
   // THE TIME MACHINE (Manual Controls)
@@ -1204,7 +1200,7 @@ var TimeTravelPlugin = class extends BaseReactorPlugin {
       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.keyExisted ? deleteAny(this.rtr.core, e.path) : setAny(this.rtr.core, e.path, deepClone(e.oldValue, this.rtr.config));
+      else !e.hadKey ? deleteAny(this.rtr.core, e.path) : setAny(this.rtr.core, e.path, deepClone(e.oldValue, this.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}"`);
     }
@@ -1227,9 +1223,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[currIndex], nextE = this.state.history[forward ? currIndex + 1 : currIndex - 1], delay = nextE && e ? Math.abs(nextE.timestamp - e.timestamp) : 0;
+      const currIndex = forward ? this.state.currentFrame : this.state.currentFrame - 1, e = this.state.history[forward ? currIndex + 1 : currIndex - 1];
       this.jumpTo(this.state.currentFrame + (forward ? 1 : -1), true);
-      if (delay > 0) await new Promise((res) => this.playbackTimeoutId = setTimeout2(() => res(0), clamp(0, delay, this.config.maxPlaybackDelay), this.signal));
+      if (e?.timedelta > 0) await new Promise((res) => this.playbackTimeoutId = setTimeout2(() => res(0), Math.min(e.timedelta, this.config.maxPlaybackDelay), this.signal));
     }
     this.state.paused = true;
   }
@@ -1243,21 +1239,24 @@ var TimeTravelPlugin = class extends BaseReactorPlugin {
   // TELEMETRY & I/O (Session Import/Export)
   // ===========================================================================
   /** Exports the current session as a JSON string. */
-  export() {
-    return JSON.stringify(this.state);
+  export(replacer, space) {
+    try {
+      return JSON.stringify(this.state, replacer, space);
+    } catch (e) {
+      return this.rtr.log(`[Reactor ${this.name} Plug] Failed to export session`), "";
+    }
   }
   /** Imports a session from a JSON string, allowing you to replay or analyze past states. */
   import(json) {
     try {
       setAny(this.state, "*", JSON.parse(json));
+      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();
-      this.state.currentFrame = 0;
-      this.jumpTo(target), resume && this.play();
+      setAny(this.rtr.core, "*", deepClone(this.state.initialState, this.rtr.config)), this.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`, "error");
+      this.rtr.log(`[Reactor ${this.name} Plug] Failed to load session`);
     }
   }
 };

package/dist/plugins.d.cts

@@ -1,5 +1,6 @@
-import { P as Paths, I as Inert, B as BaseReactorPlugin, R as Reactor, a as REvent } from './index-C2hyIh0K.cjs';
-export { b as ReactorPluginConstructor } from './index-C2hyIh0K.cjs';
+import { P as Paths, I as Inert, B as BaseReactorPlugin, b as Reactor, a as REvent } from './index-Oie9hhE8.cjs';
+export { c as ReactorPluginConstructor } from './index-Oie9hhE8.cjs';
+export { H as HistoryEntry, a as TIME_TRAVEL_PLUGIN_BUILD, b as TimeTravelConfig, T as TimeTravelPlugin, c as TimeTravelState } from './timeTravel-WpgWmKu-.cjs';
 
 interface StorageAdapterConfig {
     debug: boolean;
@@ -108,76 +109,4 @@ declare class PersistPlugin<T extends object = any> extends BaseReactorPlugin<T,
 }
 declare const PERSIST_PLUGIN_BUILD: Partial<PersistConfig<any>>;
 
-/** The DNA of a specific moment in time, Records the 'Desire' (Intent) or the 'Fact' (State). */
-interface HistoryEntry {
-    /**  Was it a 'set' or a 'delete' surgery? */
-    type: REvent<any, any>["staticType"];
-    /** The surgical address in the Reactor */
-    path: string;
-    /** The data payload at that moment */
-    value: any;
-    /** The "Undo" antidote (Previous value), if applicable */
-    oldValue: any;
-    /** Did the key for the value exist on its parent object? */
-    keyExisted: boolean;
-    /** Did the Power Line disapprove?; why? */
-    rejected: string;
-    /** For chronological re-enactment */
-    timestamp: number;
-}
-interface TimeTravelConfig<T extends object = any> {
-    /** Specific paths only, no "*"; instead don't pass anything */
-    paths?: Paths<T>[];
-    /** Maximum number of history entries to keep (Memory Cap), you lose replaying Sessions or the Genesis */
-    maxHistoryLength: number;
-    /** Max delay between events during playback (ms) */
-    maxPlaybackDelay: number;
-}
-interface TimeTravelState {
-    /** The "Timeline" of mutations (Chronological Log) */
-    history: HistoryEntry[];
-    /** The "Genesis" snapshot (Raw Data) */
-    initialState: any;
-    /** The manual playhead (Index in the Timeline) */
-    currentFrame: number;
-    /** Whether playback is currently paused (Automatic Replay) */
-    paused: boolean;
-}
-/**
- * The Flight Recorder (Black Box).
- * - Implements S.I.A. logic to allow playback, teleportation, redos and undos.
- */
-declare class TimeTravelPlugin<T extends object = any> extends BaseReactorPlugin<T, TimeTravelConfig<T>, TimeTravelState> {
-    static readonly plugName = "timeTravel";
-    protected playbackTimeoutId: number;
-    constructor(config?: Partial<TimeTravelConfig<T>>, rtr?: Reactor<T>);
-    wire(): void;
-    protected handlePathsState({ value: paths, oldValue: prevs }: REvent<TimeTravelConfig<T>, "paths">): void;
-    /** Chronicling the lifecycle of the system, Captures the essence of every mutation wave that bubbles up. */
-    protected record(e: REvent<T, any>): void;
-    /** Clears timeline history and resets playhead/genesis to the current reactor state. */
-    clear(): void;
-    /** Instant state reconstruction (Teleport). Glides through deltas natively. */
-    jumpTo(index?: number, keepShield?: boolean): void;
-    /** Step through time, Moves the playhead and teleports the state. */
-    step(stride?: number, forward?: boolean): void;
-    /** Step back in time, Moves the playhead backward and teleports the state. */
-    undo: () => void;
-    /** Step forward in time, Restores previously undone actions. */
-    redo: () => void;
-    /** Core automove engine. Replays or rewinds the "Story" by respecting time gaps. */
-    automove(forward?: boolean): Promise<void>;
-    /** Start chronological re-enactment of the session. */
-    play: () => Promise<void>;
-    /** Start reverse chronological re-enactment of the session. */
-    rewind: () => Promise<void>;
-    /** Pauses the live VCR playback. */
-    pause: () => void;
-    /** Exports the current session as a JSON string. */
-    export(): string;
-    /** Imports a session from a JSON string, allowing you to replay or analyze past states. */
-    import(json: string): void;
-}
-declare const TIME_TRAVEL_PLUGIN_BUILD: Partial<TimeTravelConfig>;
-
-export { type AsyncStorageAdapterConstructor, BaseReactorPlugin, BaseStorageAdapter, type HistoryEntry, INDEXED_DB_ADAPTER_BUILD, IndexedDBAdapter, type IndexedDBAdapterConfig, LocalStorageAdapter, MemoryStorageAdapter, type MemoryStorageAdapterConfig, PERSIST_PLUGIN_BUILD, type PersistConfig, PersistPlugin, StorageAdapter, type StorageAdapterConfig, type StorageAdapterConstructor, TIME_TRAVEL_PLUGIN_BUILD, type TimeTravelConfig, TimeTravelPlugin, type TimeTravelState };
+export { type AsyncStorageAdapterConstructor, BaseReactorPlugin, BaseStorageAdapter, INDEXED_DB_ADAPTER_BUILD, IndexedDBAdapter, type IndexedDBAdapterConfig, LocalStorageAdapter, MemoryStorageAdapter, type MemoryStorageAdapterConfig, PERSIST_PLUGIN_BUILD, type PersistConfig, PersistPlugin, StorageAdapter, type StorageAdapterConfig, type StorageAdapterConstructor };

package/dist/plugins.d.ts

@@ -1,5 +1,6 @@
-import { P as Paths, I as Inert, B as BaseReactorPlugin, R as Reactor, a as REvent } from './index-C2hyIh0K.js';
-export { b as ReactorPluginConstructor } from './index-C2hyIh0K.js';
+import { P as Paths, I as Inert, B as BaseReactorPlugin, b as Reactor, a as REvent } from './index-Oie9hhE8.js';
+export { c as ReactorPluginConstructor } from './index-Oie9hhE8.js';
+export { H as HistoryEntry, a as TIME_TRAVEL_PLUGIN_BUILD, b as TimeTravelConfig, T as TimeTravelPlugin, c as TimeTravelState } from './timeTravel-B1vedDQc.js';
 
 interface StorageAdapterConfig {
     debug: boolean;
@@ -108,76 +109,4 @@ declare class PersistPlugin<T extends object = any> extends BaseReactorPlugin<T,
 }
 declare const PERSIST_PLUGIN_BUILD: Partial<PersistConfig<any>>;
 
-/** The DNA of a specific moment in time, Records the 'Desire' (Intent) or the 'Fact' (State). */
-interface HistoryEntry {
-    /**  Was it a 'set' or a 'delete' surgery? */
-    type: REvent<any, any>["staticType"];
-    /** The surgical address in the Reactor */
-    path: string;
-    /** The data payload at that moment */
-    value: any;
-    /** The "Undo" antidote (Previous value), if applicable */
-    oldValue: any;
-    /** Did the key for the value exist on its parent object? */
-    keyExisted: boolean;
-    /** Did the Power Line disapprove?; why? */
-    rejected: string;
-    /** For chronological re-enactment */
-    timestamp: number;
-}
-interface TimeTravelConfig<T extends object = any> {
-    /** Specific paths only, no "*"; instead don't pass anything */
-    paths?: Paths<T>[];
-    /** Maximum number of history entries to keep (Memory Cap), you lose replaying Sessions or the Genesis */
-    maxHistoryLength: number;
-    /** Max delay between events during playback (ms) */
-    maxPlaybackDelay: number;
-}
-interface TimeTravelState {
-    /** The "Timeline" of mutations (Chronological Log) */
-    history: HistoryEntry[];
-    /** The "Genesis" snapshot (Raw Data) */
-    initialState: any;
-    /** The manual playhead (Index in the Timeline) */
-    currentFrame: number;
-    /** Whether playback is currently paused (Automatic Replay) */
-    paused: boolean;
-}
-/**
- * The Flight Recorder (Black Box).
- * - Implements S.I.A. logic to allow playback, teleportation, redos and undos.
- */
-declare class TimeTravelPlugin<T extends object = any> extends BaseReactorPlugin<T, TimeTravelConfig<T>, TimeTravelState> {
-    static readonly plugName = "timeTravel";
-    protected playbackTimeoutId: number;
-    constructor(config?: Partial<TimeTravelConfig<T>>, rtr?: Reactor<T>);
-    wire(): void;
-    protected handlePathsState({ value: paths, oldValue: prevs }: REvent<TimeTravelConfig<T>, "paths">): void;
-    /** Chronicling the lifecycle of the system, Captures the essence of every mutation wave that bubbles up. */
-    protected record(e: REvent<T, any>): void;
-    /** Clears timeline history and resets playhead/genesis to the current reactor state. */
-    clear(): void;
-    /** Instant state reconstruction (Teleport). Glides through deltas natively. */
-    jumpTo(index?: number, keepShield?: boolean): void;
-    /** Step through time, Moves the playhead and teleports the state. */
-    step(stride?: number, forward?: boolean): void;
-    /** Step back in time, Moves the playhead backward and teleports the state. */
-    undo: () => void;
-    /** Step forward in time, Restores previously undone actions. */
-    redo: () => void;
-    /** Core automove engine. Replays or rewinds the "Story" by respecting time gaps. */
-    automove(forward?: boolean): Promise<void>;
-    /** Start chronological re-enactment of the session. */
-    play: () => Promise<void>;
-    /** Start reverse chronological re-enactment of the session. */
-    rewind: () => Promise<void>;
-    /** Pauses the live VCR playback. */
-    pause: () => void;
-    /** Exports the current session as a JSON string. */
-    export(): string;
-    /** Imports a session from a JSON string, allowing you to replay or analyze past states. */
-    import(json: string): void;
-}
-declare const TIME_TRAVEL_PLUGIN_BUILD: Partial<TimeTravelConfig>;
-
-export { type AsyncStorageAdapterConstructor, BaseReactorPlugin, BaseStorageAdapter, type HistoryEntry, INDEXED_DB_ADAPTER_BUILD, IndexedDBAdapter, type IndexedDBAdapterConfig, LocalStorageAdapter, MemoryStorageAdapter, type MemoryStorageAdapterConfig, PERSIST_PLUGIN_BUILD, type PersistConfig, PersistPlugin, StorageAdapter, type StorageAdapterConfig, type StorageAdapterConstructor, TIME_TRAVEL_PLUGIN_BUILD, type TimeTravelConfig, TimeTravelPlugin, type TimeTravelState };
+export { type AsyncStorageAdapterConstructor, BaseReactorPlugin, BaseStorageAdapter, INDEXED_DB_ADAPTER_BUILD, IndexedDBAdapter, type IndexedDBAdapterConfig, LocalStorageAdapter, MemoryStorageAdapter, type MemoryStorageAdapterConfig, PERSIST_PLUGIN_BUILD, type PersistConfig, PersistPlugin, StorageAdapter, type StorageAdapterConfig, type StorageAdapterConstructor };