sia-reactor 0.0.19 → 0.0.21

package/dist/adapters/vanilla.d.cts

@@ -1,5 +1,7 @@
-import { E as EffectOptions } from '../index-C2hyIh0K.cjs';
-export { A as Autotracker, w as withTracker } from '../index-C2hyIh0K.cjs';
+import { E as EffectOptions } from '../index-Oie9hhE8.cjs';
+export { A as Autotracker, w as withTracker } from '../index-Oie9hhE8.cjs';
+export { T as TimeTravelConfig, a as TimeTravelOverlay } from '../TimeTravelOverlay-CJv-S_Km.cjs';
+import '../timeTravel-WpgWmKu-.cjs';
 
 /**
  * Runs a reactive side effect in vanilla JavaScript.

package/dist/adapters/vanilla.d.ts

@@ -1,5 +1,7 @@
-import { E as EffectOptions } from '../index-C2hyIh0K.js';
-export { A as Autotracker, w as withTracker } from '../index-C2hyIh0K.js';
+import { E as EffectOptions } from '../index-Oie9hhE8.js';
+export { A as Autotracker, w as withTracker } from '../index-Oie9hhE8.js';
+export { T as TimeTravelConfig, a as TimeTravelOverlay } from '../TimeTravelOverlay-DxqJL0Zk.js';
+import '../timeTravel-B1vedDQc.js';
 
 /**
  * Runs a reactive side effect in vanilla JavaScript.

package/dist/adapters/vanilla.js

@@ -1,20 +1,16 @@
 import {
   Autotracker,
+  TimeTravelOverlay,
+  effect,
   withTracker
-} from "../chunk-FGUCKMLH.js";
-import "../chunk-4MJUBEI7.js";
-
-// src/adapters/vanilla/effect.ts
-function effect(callback, options) {
-  const atrkr = new Autotracker();
-  let destroyed = false;
-  (function execute() {
-    if (!destroyed) withTracker(atrkr, () => callback()), atrkr.callback(execute, options);
-  })();
-  return () => (destroyed = true, atrkr.destroy());
-}
+} from "../chunk-TFLYCXK4.js";
+import "../chunk-2WBPGSRL.js";
+import "../chunk-5A44QFT6.js";
+import "../chunk-P37ADJMM.js";
+import "../chunk-DP74DVRT.js";
 export {
   Autotracker,
+  TimeTravelOverlay,
   effect,
   withTracker
 };

package/dist/{chunk-Q2AKMIHN.js → chunk-2WBPGSRL.js}

@@ -4,6 +4,7 @@ import {
   EVT_WARN,
   INDIFFABLE,
   INERTIA,
+  NIL,
   NOOP,
   RAW,
   REJECTABLE,
@@ -21,9 +22,9 @@ import {
   nuke,
   parseEvtOpts,
   setAny
-} from "./chunk-4MJUBEI7.js";
+} from "./chunk-DP74DVRT.js";
 
-// src/core/event.ts
+// src/ts/core/event.ts
 var ReactorEvent = class _ReactorEvent {
   /** No active propagation phase. */
   static NONE = 0;
@@ -146,7 +147,7 @@ var ReactorEvent = class _ReactorEvent {
   }
 };
 
-// src/core/reactor.ts
+// src/ts/core/reactor.ts
 var Reactor = class {
   log = NOOP;
   core;
@@ -174,27 +175,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;
@@ -207,10 +208,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);
           }
         }
@@ -218,7 +219,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;
@@ -232,13 +233,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;
           }
@@ -249,14 +250,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) {
@@ -264,7 +265,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;
@@ -280,8 +281,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;
       },
@@ -307,7 +308,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;
@@ -399,7 +400,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;
@@ -454,21 +455,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);
@@ -652,19 +652,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.
@@ -715,7 +704,76 @@ var Reactor = class {
   }
 };
 
+// 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 = 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 || ""}`);
+    else if (preferences.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) {
+  return getRaw(target)[INERTIA] = true, target;
+}
+function live(target) {
+  return delete getRaw(target)[INERTIA], target;
+}
+function isInert(target) {
+  return !!getRaw(target)[INERTIA];
+}
+function intent(target) {
+  return getRaw(target)[REJECTABLE] = true, target;
+}
+function state(target) {
+  return delete getRaw(target)[REJECTABLE], target;
+}
+function isIntent(target) {
+  return !!getRaw(target)[REJECTABLE];
+}
+function volatile(target) {
+  return getRaw(target)[INDIFFABLE] = true, target;
+}
+function stable(target) {
+  return delete getRaw(target)[INDIFFABLE], target;
+}
+function isVolatile(target) {
+  return !!getRaw(target)[INDIFFABLE];
+}
+function getReactor(target, create = false, build) {
+  return (target instanceof Reactor ? target : target.__Reactor__) || (create ? new Reactor(target, build) : void 0);
+}
+function getRaw(target) {
+  return target?.[RAW] || target;
+}
+function getVersion(target) {
+  return getRaw(target)[VERSION] || 0;
+}
+function getSnapshotVersion(target) {
+  return getRaw(target)[SSVERSION] || 0;
+}
+
 export {
   ReactorEvent,
-  Reactor
+  Reactor,
+  methods,
+  reactive,
+  inert,
+  live,
+  isInert,
+  intent,
+  state,
+  isIntent,
+  volatile,
+  stable,
+  isVolatile,
+  getReactor,
+  getRaw,
+  getVersion,
+  getSnapshotVersion
 };

package/dist/chunk-5A44QFT6.js

@@ -0,0 +1,93 @@
+// src/ts/utils/keys.ts
+function parseKeyCombo(combo) {
+  const parts = cleanKeyCombo(combo).toLowerCase().split("+");
+  return { ctrlKey: parts.includes("ctrl"), shiftKey: parts.includes("shift"), altKey: parts.includes("alt"), metaKey: parts.includes("meta") || parts.includes("cmd"), key: parts.find((p) => !["ctrl", "shift", "alt", "meta", "cmd"].includes(p)) || "" };
+}
+function stringifyKeyEvent(e) {
+  const parts = [];
+  if (e.ctrlKey) parts.push("ctrl");
+  if (e.altKey) parts.push("alt");
+  if (e.shiftKey) parts.push("shift");
+  if (e.metaKey) parts.push("meta");
+  parts.push(e.key?.toLowerCase() ?? "");
+  return parts.join("+");
+}
+function cleanKeyCombo(combo) {
+  const clean = (combo2) => {
+    const m = ["ctrl", "alt", "shift", "meta"], alias = { cmd: "meta", space: " " };
+    if (combo2 === " " || combo2 === "+") return combo2;
+    combo2 = combo2.replace(/\+\s*\+$/, "+plus");
+    const p = combo2.toLowerCase().split("+").filter((k) => k !== "").map((k) => alias[k] || (k === "plus" ? "+" : k.trim() || " "));
+    return [...p.filter((k) => m.includes(k)).sort((a, b) => m.indexOf(a) - m.indexOf(b)), ...p.filter((k) => !m.includes(k)) || ""].join("+");
+  };
+  return Array.isArray(combo) ? combo.map(clean) : clean(combo);
+}
+function matchKeys(required, actual, strict = false) {
+  actual = cleanKeyCombo(actual);
+  const match = (required2, actual2) => {
+    required2 = cleanKeyCombo(required2);
+    if (strict) return required2 === actual2;
+    const reqKeys = required2.split("+"), actKeys = actual2.split("+");
+    return reqKeys.every((k) => actKeys.includes(k));
+  };
+  return Array.isArray(required) ? required.some((req) => match(req, actual)) : match(required, actual);
+}
+function getTermsForKey(combo, settings) {
+  const terms = { override: false, block: false, whitelisted: false, action: null }, { overrides = [], shortcuts = {}, blocks = [], strictMatches: s = false, whitelist = [] } = settings || {};
+  combo = cleanKeyCombo(combo);
+  if (matchKeys(overrides, combo, s)) terms.override = true;
+  if (matchKeys(blocks, combo, s)) terms.block = true;
+  if (matchKeys(whitelist, combo)) terms.whitelisted = true;
+  terms.action = Object.keys(shortcuts).find((key) => matchKeys(shortcuts[key], combo, s)) || null;
+  return terms;
+}
+function keyEventAllowed(e, settings) {
+  if (settings.disabled || (e.key === " " || e.key === "Enter") && (e.target?.ownerDocument || document).activeElement?.tagName === "BUTTON" || (e.target?.ownerDocument || document).activeElement?.matches("input,textarea,[contenteditable='true']")) return false;
+  const combo = stringifyKeyEvent(e), { override, block, action, whitelisted } = getTermsForKey(combo, settings);
+  if (block) return false;
+  if (override) e.preventDefault();
+  if (action) return action;
+  if (whitelisted) return e.key.toLowerCase();
+  return false;
+}
+var formatKeyForDisplay = (combo) => ` ${(Array.isArray(combo) ? combo : [combo]).map((c) => `(${cleanKeyCombo(c).replace(" ", "space")})`).join(" or ")}`;
+function formatKeyShortcutsForDisplay(keyShortcuts) {
+  const shortcuts = {};
+  for (const action of Object.keys(keyShortcuts)) shortcuts[action] = formatKeyForDisplay(keyShortcuts[action]);
+  return shortcuts;
+}
+function parseForARIAKS(s, formatted = true) {
+  const m = { ctrl: "Control", cmd: "Meta", space: "Space", plus: "+" };
+  return (formatted && !Array.isArray(s) ? s : formatKeyForDisplay(s)).toLowerCase().replace(/[()]/g, "").replace(/\bor\b/g, " ").replace(/\w+/g, (k) => m[k] || k).replace(/\s+/g, " ").trim();
+}
+
+// src/ts/utils/dom.ts
+function createEl(tag, props, dataset, styles, el = tag ? document?.createElement(tag) : null) {
+  return assignEl(el, props, dataset, styles), el;
+}
+function assignEl(el, props, dataset, styles) {
+  if (!el) return;
+  if (props) {
+    for (const k of Object.keys(props)) if (props[k] !== void 0) el[k] = props[k];
+  }
+  if (dataset) {
+    for (const k of Object.keys(dataset)) if (dataset[k] !== void 0) el.dataset[k] = String(dataset[k]);
+  }
+  if (styles) {
+    for (const k of Object.keys(styles)) if (styles[k] !== void 0) el.style[k] = styles[k];
+  }
+}
+
+export {
+  parseKeyCombo,
+  stringifyKeyEvent,
+  cleanKeyCombo,
+  matchKeys,
+  getTermsForKey,
+  keyEventAllowed,
+  formatKeyForDisplay,
+  formatKeyShortcutsForDisplay,
+  parseForARIAKS,
+  createEl,
+  assignEl
+};

package/dist/{chunk-4MJUBEI7.js → chunk-DP74DVRT.js}

@@ -1,5 +1,7 @@
-// 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
 };
@@ -18,7 +20,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);

package/dist/{chunk-UQIMMJTY.js → chunk-P37ADJMM.js}

@@ -1,4 +1,4 @@
-// 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) {
@@ -31,7 +31,7 @@ function guardMethod(fn, onError = (e) => console.error(e)) {
   });
 }
 
-// src/utils/fn.ts
+// src/ts/utils/fn.ts
 function setTimeout(handler, timeout, ...args) {
   const sig = args[0] instanceof AbortSignal ? args.shift() : void 0;
   if (sig?.aborted) return -1;
@@ -53,7 +53,7 @@ function requestAnimationFrame(callback, sig, win = window) {
   return sig.addEventListener("abort", kill, { once: true }), id;
 }
 
-// src/utils/num.ts
+// src/ts/utils/num.ts
 function clamp(min = 0, val, max = Infinity) {
   return Math.min(Math.max(val, min), max);
 }