sia-reactor 0.0.21 → 0.0.23

package/dist/index.cjs

@@ -22,7 +22,6 @@ var index_exports = {};
 __export(index_exports, {
   CTX: () => CTX,
   EVT_OPTS: () => EVT_OPTS,
-  EVT_WARN: () => EVT_WARN,
   INDIFFABLE: () => INDIFFABLE,
   INERTIA: () => INERTIA,
   NIL: () => NIL,
@@ -57,7 +56,9 @@ module.exports = __toCommonJS(index_exports);
 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");
@@ -69,14 +70,13 @@ 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 = () => {
 };
 
 // src/ts/utils/obj.ts
-var arrRx = /^([^\[\]]+)\[(\d+)\]$/;
+var arrRegex = /^([^\[\]]+)\[(\d+)\]$/;
 function isObj(obj, arraycheck = true) {
   return "object" === typeof obj && obj !== null && (arraycheck ? !Array.isArray(obj) : true);
 }
@@ -84,7 +84,7 @@ function isPOJO(obj, config = NIL, typecheck = true) {
   return (typecheck ? isObj(obj, false) : true) && (config.crossRealms ? Object.prototype.toString.call(obj) === "[object Object]" : obj.constructor === Object);
 }
 function canHandle(obj, config = NIL, typecheck = true) {
-  if (typecheck && !isObj(obj, false)) return false;
+  if (typecheck && !isObj(obj, false) || obj[INERTIA]) return false;
   if (Array.isArray(obj) || !config.preserveContext && isPOJO(obj, config, false)) return true;
   if (config.preserveContext) return !(obj instanceof Map) && !(obj instanceof Set) && !(obj instanceof WeakMap) && !(obj instanceof WeakSet) && !(obj instanceof Error) && !(obj instanceof Number) && !(obj instanceof Date) && !(obj instanceof String) && !(obj instanceof RegExp) && !(obj instanceof ArrayBuffer) && !(obj instanceof Promise);
   return false;
@@ -95,7 +95,7 @@ function getAny(source, key, separator = ".", keyFunc) {
   const keys = key.split(separator);
   let currObj = source;
   for (let i = 0, len = keys.length; i < len; i++) {
-    const key2 = keyFunc ? keyFunc(keys[i]) : keys[i], match = key2.includes("[") && key2.match(arrRx);
+    const key2 = keyFunc ? keyFunc(keys[i]) : keys[i], match = key2.includes("[") && key2.match(arrRegex);
     if (match) {
       const [, key3, iStr] = match;
       if (!Array.isArray(currObj[key3]) || !(key3 in currObj)) return void 0;
@@ -112,7 +112,7 @@ function setAny(target, key, value, separator = ".", keyFunc) {
   if (!key.includes(separator)) return void (target[keyFunc ? keyFunc(key) : key] = value);
   const keys = key.split(separator);
   for (let currObj = target, i = 0, len = keys.length; i < len; i++) {
-    const key2 = keyFunc ? keyFunc(keys[i]) : keys[i], match = key2.includes("[") && key2.match(arrRx);
+    const key2 = keyFunc ? keyFunc(keys[i]) : keys[i], match = key2.includes("[") && key2.match(arrRegex);
     if (match) {
       const [, key3, iStr] = match;
       if (!Array.isArray(currObj[key3])) currObj[key3] = [];
@@ -133,7 +133,7 @@ function deleteAny(target, key, separator = ".", keyFunc) {
   if (!key.includes(separator)) return void delete target[keyFunc ? keyFunc(key) : key];
   const keys = key.split(separator);
   for (let currObj = target, i = 0, len = keys.length; i < len; i++) {
-    const key2 = keyFunc ? keyFunc(keys[i]) : keys[i], match = key2.includes("[") && key2.match(arrRx);
+    const key2 = keyFunc ? keyFunc(keys[i]) : keys[i], match = key2.includes("[") && key2.match(arrRegex);
     if (match) {
       const [, key3, iStr] = match;
       if (!Array.isArray(currObj[key3]) || !(key3 in currObj)) return;
@@ -151,7 +151,7 @@ function inAny(source, key, separator = ".", keyFunc) {
   if (!key.includes(separator)) return key in source;
   const keys = key.split(separator);
   for (let currObj = source, i = 0, len = keys.length; i < len; i++) {
-    const key2 = keyFunc ? keyFunc(keys[i]) : keys[i], match = key2.includes("[") && key2.match(arrRx);
+    const key2 = keyFunc ? keyFunc(keys[i]) : keys[i], match = key2.includes("[") && key2.match(arrRegex);
     if (match) {
       const [, key3, iStr] = match;
       if (!Array.isArray(currObj[key3]) || !(key3 in currObj)) return false;
@@ -168,10 +168,6 @@ 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 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;
-}
 function getTrailRecords(obj, path, reverse = false) {
   const parts = path.split("."), chain = [["*", obj, obj]];
   for (let acc = "", currObj = obj, i = 0, len = parts.length; i < len; i++) chain.push([acc += (i ? "." : "") + parts[i], currObj, currObj = currObj?.[parts[i]]]);
@@ -214,35 +210,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;
@@ -251,9 +246,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() {
@@ -283,9 +278,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() {
@@ -298,9 +293,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.
@@ -309,24 +304,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;
@@ -359,7 +352,7 @@ var Reactor = class {
     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 (target[INERTIA] || !canHandle(target, this.config, false)) return target;
+    if (!canHandle(target, this.config, false)) return target;
     rejectable ||= target[REJECTABLE];
     indiffable ||= target[INDIFFABLE];
     const proxy = new Proxy(target, {
@@ -393,7 +386,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("*");
@@ -547,7 +540,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;
@@ -621,8 +614,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 });
@@ -638,7 +631,12 @@ 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 (e) {
+        if (e instanceof RangeError) throw e;
+      }
     if (!raw && this.config.smartCloning) this.snapCache.set(obj, clone), obj[SSVERSION] = version;
     return clone;
   }
@@ -726,7 +724,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) {
@@ -743,7 +741,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.
@@ -792,7 +790,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);
@@ -823,56 +821,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);
@@ -880,7 +861,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;
@@ -891,7 +872,7 @@ function inert(target) {
 function live(target) {
   return delete getRaw(target)[INERTIA], target;
 }
-function isInert(target) {
+function isInert(target = NIL) {
   return !!getRaw(target)[INERTIA];
 }
 function intent(target) {
@@ -900,7 +881,7 @@ function intent(target) {
 function state(target) {
   return delete getRaw(target)[REJECTABLE], target;
 }
-function isIntent(target) {
+function isIntent(target = NIL) {
   return !!getRaw(target)[REJECTABLE];
 }
 function volatile(target) {
@@ -909,26 +890,25 @@ function volatile(target) {
 function stable(target) {
   return delete getRaw(target)[INDIFFABLE], target;
 }
-function isVolatile(target) {
+function isVolatile(target = NIL) {
   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 getRaw(target = NIL) {
+  return target[RAW] || target;
 }
-function getVersion(target) {
+function getVersion(target = NIL) {
   return getRaw(target)[VERSION] || 0;
 }
-function getSnapshotVersion(target) {
+function getSnapshotVersion(target = NIL) {
   return getRaw(target)[SSVERSION] || 0;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CTX,
   EVT_OPTS,
-  EVT_WARN,
   INDIFFABLE,
   INERTIA,
   NIL,

package/dist/index.d.cts

@@ -1 +1 @@
-export { C as CTX, r as ChildPaths, D as DeepKeys, t as DeepMerge, u as DeepPartial, v as DeepRequired, x as Deleter, y as DeleterRecord, z as DirectPayload, F as EVT_OPTS, G as EVT_WARN, E as EffectOptions, H as Getter, J as GetterRecord, K as INDIFFABLE, L as INERTIA, I as Inert, M as Intent, N as Listener, O as ListenerOptions, Q as ListenerOptionsTuple, S as ListenerRecord, T as Live, U as NIL, V as NOOP, X as NoTraverse, Y as PathBranch, Z as PathBranchValue, _ as PathKey, $ as PathLeaf, q as PathValue, P as Paths, a0 as Payload, a1 as Primitive, a2 as RAW, a3 as REJECTABLE, a as REvent, a4 as RTR_BATCH, a5 as RTR_LOG, R as Reactive, a6 as ReactivePreferences, b as Reactor, o as ReactorBuild, a7 as ReactorEvent, a8 as SSVERSION, a9 as Setter, aa as SetterRecord, ab as Stable, ac as State, ad as StrictPathKey, ae as SyncOptions, af as SyncOptionsTuple, ag as TERMINATOR, ah as Target, ai as Unflatten, aj as UnionToIntersection, ak as UpdatePayload, al as VERSION, am as Volatile, an as Watcher, ao as WatcherRecord, W as WildPaths, ap as getRaw, aq as getSnapshotVersion, ar as getVersion, as as inert, at as intent, au as isInert, av as isIntent, aw as isVolatile, ax as live, ay as methods, az as reactive, aA as stable, aB as state, aC as volatile } from './index-Oie9hhE8.cjs';
+export { x as AddDepth, y as AllDepth, C as CTX, z as ChildPaths, D as DeepKeys, G as DeepMerge, H as DeepPartial, J as DeepRequired, K as Deleter, L as DeleterRecord, M as DepthConfig, N as DirectPayload, O as EVT_OPTS, E as EffectOptions, Q as Getter, S as GetterRecord, T as INDIFFABLE, U as INERTIA, I as Inert, V as Intent, X as Listener, Y as ListenerOptions, Z as ListenerOptionsTuple, _ as ListenerRecord, $ as Live, a0 as MaxDepth, a1 as NIL, a2 as NOOP, a3 as NextDepth, a4 as NoTraverse, a5 as PathBranch, a6 as PathBranchValue, a7 as PathDepth, a8 as PathKey, a9 as PathLeaf, v as PathValue, P as Paths, aa as Payload, ab as PrevDepth, ac as Primitive, ad as RAW, ae as REJECTABLE, a as REvent, af as RTR_BATCH, ag as RTR_LOG, d as Reactive, ah as ReactivePreferences, R as Reactor, u as ReactorBuild, ai as ReactorEvent, aj as SSVERSION, ak as Setter, al as SetterRecord, am as Stable, an as State, ao as StrictPathKey, ap as SubtractDepth, aq as SyncOptions, ar as SyncOptionsTuple, as as TERMINATOR, at as Target, au as Unflatten, av as UnionToIntersection, aw as UpdatePayload, ax as VERSION, ay as Volatile, az as Watcher, aA as WatcherRecord, W as WildPaths, aB as getRaw, aC as getSnapshotVersion, aD as getVersion, aE as inert, aF as intent, aG as isInert, aH as isIntent, aI as isVolatile, aJ as live, aK as methods, aL as reactive, aM as stable, aN as state, aO as volatile } from './index-m0aAWxhX.cjs';

package/dist/index.d.ts

@@ -1 +1 @@
-export { C as CTX, r as ChildPaths, D as DeepKeys, t as DeepMerge, u as DeepPartial, v as DeepRequired, x as Deleter, y as DeleterRecord, z as DirectPayload, F as EVT_OPTS, G as EVT_WARN, E as EffectOptions, H as Getter, J as GetterRecord, K as INDIFFABLE, L as INERTIA, I as Inert, M as Intent, N as Listener, O as ListenerOptions, Q as ListenerOptionsTuple, S as ListenerRecord, T as Live, U as NIL, V as NOOP, X as NoTraverse, Y as PathBranch, Z as PathBranchValue, _ as PathKey, $ as PathLeaf, q as PathValue, P as Paths, a0 as Payload, a1 as Primitive, a2 as RAW, a3 as REJECTABLE, a as REvent, a4 as RTR_BATCH, a5 as RTR_LOG, R as Reactive, a6 as ReactivePreferences, b as Reactor, o as ReactorBuild, a7 as ReactorEvent, a8 as SSVERSION, a9 as Setter, aa as SetterRecord, ab as Stable, ac as State, ad as StrictPathKey, ae as SyncOptions, af as SyncOptionsTuple, ag as TERMINATOR, ah as Target, ai as Unflatten, aj as UnionToIntersection, ak as UpdatePayload, al as VERSION, am as Volatile, an as Watcher, ao as WatcherRecord, W as WildPaths, ap as getRaw, aq as getSnapshotVersion, ar as getVersion, as as inert, at as intent, au as isInert, av as isIntent, aw as isVolatile, ax as live, ay as methods, az as reactive, aA as stable, aB as state, aC as volatile } from './index-Oie9hhE8.js';
+export { x as AddDepth, y as AllDepth, C as CTX, z as ChildPaths, D as DeepKeys, G as DeepMerge, H as DeepPartial, J as DeepRequired, K as Deleter, L as DeleterRecord, M as DepthConfig, N as DirectPayload, O as EVT_OPTS, E as EffectOptions, Q as Getter, S as GetterRecord, T as INDIFFABLE, U as INERTIA, I as Inert, V as Intent, X as Listener, Y as ListenerOptions, Z as ListenerOptionsTuple, _ as ListenerRecord, $ as Live, a0 as MaxDepth, a1 as NIL, a2 as NOOP, a3 as NextDepth, a4 as NoTraverse, a5 as PathBranch, a6 as PathBranchValue, a7 as PathDepth, a8 as PathKey, a9 as PathLeaf, v as PathValue, P as Paths, aa as Payload, ab as PrevDepth, ac as Primitive, ad as RAW, ae as REJECTABLE, a as REvent, af as RTR_BATCH, ag as RTR_LOG, d as Reactive, ah as ReactivePreferences, R as Reactor, u as ReactorBuild, ai as ReactorEvent, aj as SSVERSION, ak as Setter, al as SetterRecord, am as Stable, an as State, ao as StrictPathKey, ap as SubtractDepth, aq as SyncOptions, ar as SyncOptionsTuple, as as TERMINATOR, at as Target, au as Unflatten, av as UnionToIntersection, aw as UpdatePayload, ax as VERSION, ay as Volatile, az as Watcher, aA as WatcherRecord, W as WildPaths, aB as getRaw, aC as getSnapshotVersion, aD as getVersion, aE as inert, aF as intent, aG as isInert, aH as isIntent, aI as isVolatile, aJ as live, aK as methods, aL as reactive, aM as stable, aN as state, aO as volatile } from './index-m0aAWxhX.js';

package/dist/index.js

@@ -15,11 +15,10 @@ import {
   stable,
   state,
   volatile
-} from "./chunk-2WBPGSRL.js";
+} from "./chunk-MSTHQVNK.js";
 import {
   CTX,
   EVT_OPTS,
-  EVT_WARN,
   INDIFFABLE,
   INERTIA,
   NIL,
@@ -31,11 +30,10 @@ import {
   SSVERSION,
   TERMINATOR,
   VERSION
-} from "./chunk-DP74DVRT.js";
+} from "./chunk-MKL3JUPO.js";
 export {
   CTX,
   EVT_OPTS,
-  EVT_WARN,
   INDIFFABLE,
   INERTIA,
   NIL,