sia-reactor 0.0.21 → 0.0.22

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

package/dist/index.js

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