@but212/atom-effect 0.19.0 → 0.20.0

package/dist/index.mjs

@@ -1,17 +1,15 @@
-const tt = {
-  ONE_SECOND_MS: 1e3
-}, m = {
+const k = {
   IDLE: "idle",
   PENDING: "pending",
   RESOLVED: "resolved",
   REJECTED: "rejected"
-}, M = {
-  DISPOSED: 1
-}, a = {
-  ...M,
+}, l = {
+  DISPOSED: 1,
   EXECUTING: 8
-}, o = {
-  ...M,
+}, q = {
+  DISPOSED: 1,
+  /** Marker bit: identifies this node as a computed. */
+  IS_COMPUTED: 2,
   DIRTY: 8,
   IDLE: 16,
   PENDING: 32,
@@ -19,15 +17,15 @@ const tt = {
   REJECTED: 128,
   RECOMPUTING: 256,
   HAS_ERROR: 512
-}, d = {
-  ...M,
+}, E = {
+  DISPOSED: 1,
   SYNC: 8,
   NOTIFICATION_SCHEDULED: 16
-}, pt = {
+}, St = {
   MAX_SIZE: 1e3,
   WARMUP_SIZE: 100,
   ENABLE_STATS: !1
-}, I = {
+}, S = {
   // Infinite loop protection
   MAX_EXECUTIONS_PER_SECOND: 1e3,
   MAX_EXECUTIONS_PER_EFFECT: 100,
@@ -40,71 +38,71 @@ const tt = {
   BATCH_QUEUE_SHRINK_THRESHOLD: 1e3
 }, et = {
   WARN_INFINITE_LOOP: !0
-}, O = 1073741823, _ = typeof process < "u" && process.env && process.env.NODE_ENV !== "production" || typeof __DEV__ < "u" && !!__DEV__, st = Object.freeze([]);
-class T extends Error {
+}, z = 1073741823, u = typeof process < "u" && process.env && process.env.NODE_ENV !== "production" || typeof __DEV__ < "u" && !!__DEV__, st = Object.freeze([]);
+class O extends Error {
   constructor(t, e = null, s = !0) {
-    super(t), this.cause = e, this.recoverable = s, this.timestamp = /* @__PURE__ */ new Date(), this.name = "AtomError";
+    super(t), this.cause = e, this.recoverable = s, this.name = "AtomError";
   }
 }
-class p extends T {
+class d extends O {
   constructor(t, e = null) {
     super(t, e, !0), this.name = "ComputedError";
   }
 }
-class S extends T {
+class I extends O {
   constructor(t, e = null) {
     super(t, e, !1), this.name = "EffectError";
   }
 }
-class N extends T {
+class L extends O {
   constructor(t, e = null) {
     super(t, e, !1), this.name = "SchedulerError";
   }
 }
-const z = /* @__PURE__ */ Symbol("AtomEffect.DebugName"), it = /* @__PURE__ */ Symbol("AtomEffect.Id"), G = /* @__PURE__ */ Symbol("AtomEffect.Type"), x = /* @__PURE__ */ Symbol("AtomEffect.NoDefaultValue"), nt = (i) => "dependencies" in i && Array.isArray(i.dependencies);
-function Q(i, t, e) {
+const X = /* @__PURE__ */ Symbol("AtomEffect.DebugName"), it = /* @__PURE__ */ Symbol("AtomEffect.Id"), G = /* @__PURE__ */ Symbol("AtomEffect.Type"), v = /* @__PURE__ */ Symbol("AtomEffect.NoDefaultValue"), nt = (i) => "dependencies" in i && Array.isArray(i.dependencies);
+function $(i, t, e) {
   if (i === t)
-    throw new p(
+    throw new d(
       "Circular dependency detected: The computation refers to itself explicitly or implicitly."
     );
   if (!e.has(i.id) && (e.add(i.id), nt(i))) {
     const s = i.dependencies;
     for (let n = 0; n < s.length; n++) {
       const r = s[n];
-      r && Q(r, t, e);
+      r && $(r, t, e);
     }
   }
 }
-const g = {
+const D = {
   // Dev mode flag
-  enabled: _,
+  enabled: u,
   warnInfiniteLoop: et.WARN_INFINITE_LOOP,
   warn(i, t) {
-    _ && this.enabled && i && console.warn(`[Atom Effect] ${t}`);
+    u && this.enabled && i && console.warn(`[Atom Effect] ${t}`);
   },
   checkCircular(i, t) {
     if (i === t)
-      throw new p("Direct circular dependency detected");
-    _ && this.enabled && Q(i, t, /* @__PURE__ */ new Set());
+      throw new d("Direct circular dependency detected");
+    u && this.enabled && $(i, t, /* @__PURE__ */ new Set());
   },
   attachDebugInfo(i, t, e) {
-    if (!_ || !this.enabled) return;
+    if (!u || !this.enabled) return;
     const s = i;
-    s[z] = `${t}_${e}`, s[it] = e, s[G] = t;
+    s[X] = `${t}_${e}`, s[it] = e, s[G] = t;
   },
-  getDebugName: (i) => i?.[z],
+  getDebugName: (i) => i?.[X],
   getDebugType: (i) => i?.[G]
 };
 let rt = 1;
 const ot = () => rt++;
-function j(i, t, e) {
+function K(i, t, e) {
   if (typeof t == "function") {
     const n = t;
-    for (let r = 0, h = e.length; r < h; r++) {
-      const c = e[r];
-      if (c && c.fn === n) return;
+    for (let r = 0, o = e.length; r < o; r++) {
+      const h = e[r];
+      if (h && h.fn === n) return;
     }
-    e.push(new k(n, void 0));
+    e.push(new M(n, void 0));
     return;
   }
   if ("addDependency" in t) {
@@ -113,41 +111,37 @@ function j(i, t, e) {
   }
   const s = t;
   for (let n = 0, r = e.length; n < r; n++) {
-    const h = e[n];
-    if (h && h.sub === s) return;
+    const o = e[n];
+    if (o && o.sub === s) return;
   }
-  e.push(new k(void 0, s));
+  e.push(new M(void 0, s));
 }
-function ht(i, t, e) {
-  for (let s = 0, n = t.length; s < n; s++) {
-    const r = t[s];
-    r && (r.node._tempUnsub = r.unsub);
-  }
-  for (let s = 0, n = i.length; s < n; s++) {
-    const r = i[s];
-    if (!r) continue;
-    const h = r.node;
-    h._tempUnsub !== void 0 ? (r.unsub = h._tempUnsub, h._tempUnsub = void 0) : (g.checkCircular(h, e), r.unsub = h.subscribe(e));
-  }
-  for (let s = 0, n = t.length; s < n; s++) {
-    const r = t[s];
-    if (r) {
-      const h = r.node;
-      h._tempUnsub !== void 0 && (h._tempUnsub(), h._tempUnsub = void 0), r.unsub = void 0;
-    }
-  }
+function Q(i, t, e) {
+  const s = /* @__PURE__ */ new Map();
+  for (let n = 0, r = t.length; n < r; n++) {
+    const o = t[n];
+    o?.unsub && s.set(o.node, o.unsub);
+  }
+  for (let n = 0, r = i.length; n < r; n++) {
+    const o = i[n];
+    if (!o) continue;
+    const h = o.node, f = s.get(h);
+    f !== void 0 ? (o.unsub = f, s.delete(h)) : (D.checkCircular(h, e), o.unsub = h.subscribe(e));
+  }
+  for (const n of s.values())
+    n();
 }
-class b {
+class x {
   constructor(t, e, s = void 0) {
     this.node = t, this.version = e, this.unsub = s;
   }
 }
-class k {
+class M {
   constructor(t, e) {
     this.fn = t, this.sub = e;
   }
 }
-const u = {
+const c = {
   // Computed Errors
   COMPUTED_MUST_BE_FUNCTION: "Computed target must be a function",
   COMPUTED_ASYNC_PENDING_NO_DEFAULT: "Async computation pending with no default value",
@@ -170,40 +164,37 @@ const u = {
   // Effect frequency
   EFFECT_FREQUENCY_LIMIT_EXCEEDED: "Effect executed too frequently within 1 second. Suspected infinite loop."
 };
-function C(i, t, e) {
-  if (i instanceof T)
+function b(i, t, e) {
+  if (i instanceof O)
     return i;
-  const s = i instanceof Error, n = s ? i.message : String(i), r = s ? i : void 0;
-  let h = "Unexpected error";
-  i instanceof TypeError ? h = "Type error" : i instanceof ReferenceError && (h = "Reference error");
-  const c = `${h} (${e}): ${n}`;
-  return new t(c, r);
+  const s = i instanceof Error, n = s ? i.message : String(i), r = s ? i : void 0, h = `${s ? i.constructor.name : "Unexpected error"} (${e}): ${n}`;
+  return new t(h, r);
 }
-class q {
+class W {
   constructor() {
-    this.flags = 0, this.version = 0, this._lastSeenEpoch = -1, this._modifiedAtEpoch = -1, this.id = ot() & O, this._tempUnsub = void 0;
+    this.flags = 0, this.version = 0, this._lastSeenEpoch = -1, this.id = ot() & z;
   }
 }
-class $ extends q {
+class J extends W {
   /**
    * Adds subscriber.
    */
   subscribe(t) {
     const e = typeof t == "function";
     if (!e && (!t || typeof t.execute != "function"))
-      throw C(
+      throw b(
         new TypeError("Invalid subscriber"),
-        T,
-        u.ATOM_SUBSCRIBER_MUST_BE_FUNCTION
+        O,
+        c.ATOM_SUBSCRIBER_MUST_BE_FUNCTION
       );
     const s = this._subscribers;
-    for (let r = 0, h = s.length; r < h; r++) {
-      const c = s[r];
-      if (c && (e ? c.fn === t : c.sub === t))
-        return _ && console.warn("Duplicate subscription ignored."), () => {
+    for (let r = 0, o = s.length; r < o; r++) {
+      const h = s[r];
+      if (h && (e ? h.fn === t : h.sub === t))
+        return u && console.warn("Duplicate subscription ignored."), () => {
         };
     }
-    const n = new k(
+    const n = new M(
       e ? t : void 0,
       e ? void 0 : t
     );
@@ -222,157 +213,145 @@ class $ extends q {
     if (this._subscribers.length === 0) return;
     const s = this._subscribers.slice(0), n = s.length;
     for (let r = 0; r < n; r++) {
-      const h = s[r];
-      if (h)
+      const o = s[r];
+      if (o)
         try {
-          h.fn ? h.fn(t, e) : h.sub && h.sub.execute();
-        } catch (c) {
-          this._handleNotifyError(c);
+          o.fn ? o.fn(t, e) : o.sub && o.sub.execute();
+        } catch (h) {
+          this._handleNotifyError(h);
         }
     }
   }
   _handleNotifyError(t) {
-    console.error(C(t, T, u.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED));
+    console.error(b(t, O, c.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED));
   }
 }
-let R = 0;
-const J = () => (R = R + 1 & O || 1, R), ct = () => R, P = (i) => i + 1 & O;
-let v = 0, w = 0, A = !1;
-function H() {
-  return A ? (_ && console.warn("startFlush() called during flush - ignored"), !1) : (A = !0, v = v + 1 & O || 1, w = 0, !0);
+let w = 0;
+const V = () => (w = w + 1 & z || 1, w), B = (i) => i + 1 & z;
+let H = 0, U = !1, Z = 0;
+const ht = () => Z;
+function Y() {
+  return U ? (u && console.warn("startFlush() called during flush - ignored"), !1) : (U = !0, Z = V(), H = 0, !0);
 }
-const X = () => {
-  A = !1;
-}, ut = () => A ? ++w : 0, f = {
-  /** Queue buffer */
-  _queueBuffer: [[], []],
-  _bufferIndex: 0,
-  _size: 0,
-  /** Epoch counter */
-  _epoch: 0,
-  /** State flags */
-  _isProcessing: !1,
-  _isBatching: !1,
-  _isFlushingSync: !1,
-  /** Batching state */
-  _batchDepth: 0,
-  _batchQueue: [],
-  _batchQueueSize: 0,
-  /** Config */
-  _maxFlushIterations: I.MAX_FLUSH_ITERATIONS,
+const j = () => {
+  U = !1;
+}, ct = () => U ? ++H : 0;
+class ut {
+  constructor() {
+    this._queueBuffer = [[], []], this._bufferIndex = 0, this._size = 0, this._epoch = 0, this._isProcessing = !1, this._isBatching = !1, this._isFlushingSync = !1, this._batchDepth = 0, this._batchQueue = [], this._batchQueueSize = 0, this._maxFlushIterations = S.MAX_FLUSH_ITERATIONS, this.onOverflow = null, this._boundRunLoop = this._runLoop.bind(this);
+  }
   get phase() {
     return this._isProcessing || this._isFlushingSync ? 2 : this._isBatching ? 1 : 0;
-  },
+  }
   get queueSize() {
     return this._size;
-  },
+  }
   get isBatching() {
     return this._isBatching;
-  },
+  }
   /**
    * Schedules job.
    */
-  schedule(i) {
-    if (_ && typeof i != "function")
-      throw new N("Scheduler callback must be a function");
-    if (i._nextEpoch !== this._epoch) {
-      if (i._nextEpoch = this._epoch, this._isBatching || this._isFlushingSync) {
-        this._batchQueue[this._batchQueueSize++] = i;
+  schedule(t) {
+    if (u && typeof t != "function")
+      throw new L("Scheduler callback must be a function");
+    if (t._nextEpoch !== this._epoch) {
+      if (t._nextEpoch = this._epoch, this._isBatching || this._isFlushingSync) {
+        this._batchQueue[this._batchQueueSize++] = t;
         return;
       }
-      this._queueBuffer[this._bufferIndex][this._size++] = i, this._isProcessing || this._flush();
+      this._queueBuffer[this._bufferIndex][this._size++] = t, this._isProcessing || this._flush();
     }
-  },
+  }
   /**
    * Triggers flush.
    */
   _flush() {
-    this._isProcessing || this._size === 0 || (this._isProcessing = !0, queueMicrotask(this._runLoop));
-  },
+    this._isProcessing || this._size === 0 || (this._isProcessing = !0, queueMicrotask(this._boundRunLoop));
+  }
   /**
    * Scheduler loop.
    */
-  _runLoop: () => {
+  _runLoop() {
     try {
-      if (f._size === 0) return;
-      const i = H();
-      f._drainQueue(), i && X();
+      if (this._size === 0) return;
+      const t = Y();
+      this._drainQueue(), t && j();
     } finally {
-      f._isProcessing = !1, f._size > 0 && !f._isBatching && f._flush();
+      this._isProcessing = !1, this._size > 0 && !this._isBatching && this._flush();
     }
-  },
+  }
   _flushSync() {
     this._isFlushingSync = !0;
-    const i = H();
+    const t = Y();
     try {
       this._mergeBatchQueue(), this._drainQueue();
     } finally {
-      this._isFlushingSync = !1, i && X();
+      this._isFlushingSync = !1, t && j();
     }
-  },
+  }
   _mergeBatchQueue() {
     if (this._batchQueueSize === 0) return;
-    const i = ++this._epoch, t = this._batchQueue, e = this._queueBuffer[this._bufferIndex];
-    let s = this._size;
-    for (let n = 0; n < this._batchQueueSize; n++) {
-      const r = t[n];
-      r._nextEpoch !== i && (r._nextEpoch = i, e[s++] = r);
+    const t = ++this._epoch, e = this._batchQueue, s = this._queueBuffer[this._bufferIndex];
+    let n = this._size;
+    for (let r = 0; r < this._batchQueueSize; r++) {
+      const o = e[r];
+      o._nextEpoch !== t && (o._nextEpoch = t, s[n++] = o);
     }
-    this._size = s, this._batchQueueSize = 0, t.length > I.BATCH_QUEUE_SHRINK_THRESHOLD && (t.length = 0);
-  },
+    this._size = n, this._batchQueueSize = 0, e.length > S.BATCH_QUEUE_SHRINK_THRESHOLD && (e.length = 0);
+  }
   _drainQueue() {
-    let i = 0;
+    let t = 0;
     for (; this._size > 0; ) {
-      if (++i > this._maxFlushIterations) {
+      if (++t > this._maxFlushIterations) {
         this._handleFlushOverflow();
         return;
       }
       this._processQueue(), this._mergeBatchQueue();
     }
-  },
+  }
   _processQueue() {
-    const i = this._bufferIndex, t = this._queueBuffer[i], e = this._size;
-    this._bufferIndex = i ^ 1, this._size = 0, this._epoch++;
-    for (let s = 0; s < e; s++)
+    const t = this._bufferIndex, e = this._queueBuffer[t], s = this._size;
+    this._bufferIndex = t ^ 1, this._size = 0, this._epoch++;
+    for (let n = 0; n < s; n++)
       try {
-        t[s]();
-      } catch (n) {
-        console.error(new N("Error occurred during scheduler execution", n));
+        e[n]();
+      } catch (r) {
+        console.error(new L("Error occurred during scheduler execution", r));
       }
-    t.length = 0;
-  },
-  /** Overflow callback */
-  onOverflow: null,
+    e.length = 0;
+  }
   _handleFlushOverflow() {
-    const i = this._size + this._batchQueueSize;
+    const t = this._size + this._batchQueueSize;
     if (console.error(
-      new N(
-        u.SCHEDULER_FLUSH_OVERFLOW(this._maxFlushIterations, i)
+      new L(
+        c.SCHEDULER_FLUSH_OVERFLOW(this._maxFlushIterations, t)
       )
     ), this._size = 0, this._queueBuffer[this._bufferIndex].length = 0, this._batchQueueSize = 0, this.onOverflow)
       try {
-        this.onOverflow(i);
+        this.onOverflow(t);
       } catch {
       }
-  },
+  }
   startBatch() {
     this._batchDepth++, this._isBatching = !0;
-  },
+  }
   endBatch() {
     if (this._batchDepth === 0) {
-      _ && console.warn("endBatch() called without matching startBatch(). Ignoring.");
+      u && console.warn("endBatch() called without matching startBatch(). Ignoring.");
       return;
     }
     --this._batchDepth === 0 && (this._flushSync(), this._isBatching = !1);
-  },
-  setMaxFlushIterations(i) {
-    if (i < I.MIN_FLUSH_ITERATIONS)
-      throw new N(
-        `Max flush iterations must be at least ${I.MIN_FLUSH_ITERATIONS}`
+  }
+  setMaxFlushIterations(t) {
+    if (t < S.MIN_FLUSH_ITERATIONS)
+      throw new L(
+        `Max flush iterations must be at least ${S.MIN_FLUSH_ITERATIONS}`
       );
-    this._maxFlushIterations = i;
+    this._maxFlushIterations = t;
   }
-}, E = {
+}
+const N = new ut(), a = {
   /** Active listener. */
   current: null,
   /**
@@ -392,35 +371,35 @@ const X = () => {
     }
   }
 };
-function It(i) {
-  const t = E.current;
+function Dt(i) {
+  const t = a.current;
   if (t === null) return i();
-  E.current = null;
+  a.current = null;
   try {
     return i();
   } finally {
-    E.current = t;
+    a.current = t;
   }
 }
-class _t extends $ {
+class lt extends J {
   constructor(t, e) {
-    super(), this._pendingOldValue = void 0, this._notifyTask = void 0, this._subscribers = [], this._value = t, e && (this.flags |= d.SYNC), g.attachDebugInfo(this, "atom", this.id);
+    super(), this._pendingOldValue = void 0, this._notifyTask = void 0, this._subscribers = [], this._value = t, e && (this.flags |= E.SYNC), D.attachDebugInfo(this, "atom", this.id);
   }
   get value() {
-    const t = E.current;
-    return t && j(this, t, this._subscribers), this._value;
+    const t = a.current;
+    return t && K(this, t, this._subscribers), this._value;
   }
   set value(t) {
     const e = this._value;
     if (Object.is(e, t)) return;
-    this._value = t, this.version = P(this.version);
+    this._value = t, this.version = B(this.version);
     const s = this.flags;
-    if (!(this._subscribers.length === 0 || s & d.NOTIFICATION_SCHEDULED)) {
-      if (this._pendingOldValue = e, this.flags = s | d.NOTIFICATION_SCHEDULED, s & d.SYNC && !f.isBatching) {
+    if (!(this._subscribers.length === 0 || s & E.NOTIFICATION_SCHEDULED)) {
+      if (this._pendingOldValue = e, this.flags = s | E.NOTIFICATION_SCHEDULED, s & E.SYNC && !N.isBatching) {
         this._flushNotifications();
         return;
       }
-      this._notifyTask || (this._notifyTask = () => this._flushNotifications()), f.schedule(this._notifyTask);
+      this._notifyTask || (this._notifyTask = () => this._flushNotifications()), N.schedule(this._notifyTask);
     }
   }
   /**
@@ -428,7 +407,7 @@ class _t extends $ {
    */
   _flushNotifications() {
     const t = this.flags;
-    if (!(t & d.NOTIFICATION_SCHEDULED) || t & d.DISPOSED)
+    if (!(t & E.NOTIFICATION_SCHEDULED) || t & E.DISPOSED)
       return;
     const e = this._pendingOldValue;
     this._pendingOldValue = void 0, this.flags &= -17, this._notifySubscribers(this._value, e);
@@ -437,20 +416,20 @@ class _t extends $ {
     return this._value;
   }
   dispose() {
-    this.flags & d.DISPOSED || (this._subscribers.length = 0, this.flags |= d.DISPOSED, this._value = void 0, this._pendingOldValue = void 0, this._notifyTask = void 0);
+    this.flags & E.DISPOSED || (this._subscribers.length = 0, this.flags |= E.DISPOSED, this._value = void 0, this._pendingOldValue = void 0, this._notifyTask = void 0);
   }
 }
-function Dt(i, t = {}) {
-  return new _t(i, t.sync ?? !1);
+function Ct(i, t = {}) {
+  return new lt(i, t.sync ?? !1);
 }
-class lt {
+class _t {
   /**
    * @param limit - Max unique arrays to hold (default: 50). Prevents the pool itself from consuming too much memory.
    * @param capacity - Max length of an array to accept (default: 256).
    * @param enableStats - Force-enable stats even in production (default: false).
    */
   constructor(t = 50, e = 256, s = !1) {
-    this.limit = t, this.capacity = e, this.pool = [], this.stats = null, this.stats = _ || s ? {
+    this.limit = t, this.capacity = e, this.pool = [], this.stats = null, this.stats = u || s ? {
       acquired: 0,
       released: 0,
       rejected: { frozen: 0, tooLarge: 0, poolFull: 0 }
@@ -510,63 +489,59 @@ class lt {
     });
   }
 }
-const y = (i) => Object.freeze(i);
-y([]);
-y([]);
-y([]);
-y([]);
-const l = y([]), D = new lt();
+const _ = Object.freeze(
+  []
+), p = new _t();
 function at(i) {
   return i !== null && typeof i == "object" && "value" in i && typeof i.subscribe == "function";
 }
-function St(i) {
+function Tt(i) {
   return at(i) && typeof i.invalidate == "function";
 }
-function gt(i) {
+function bt(i) {
   return i !== null && typeof i == "object" && typeof i.dispose == "function" && typeof i.run == "function";
 }
-function K(i) {
+function tt(i) {
   return i !== null && typeof i == "object" && typeof i.then == "function";
 }
-const W = o.RESOLVED | o.PENDING | o.REJECTED, U = Array(W + 1).fill(m.IDLE);
-U[o.RESOLVED] = m.RESOLVED;
-U[o.PENDING] = m.PENDING;
-U[o.REJECTED] = m.REJECTED;
-const ft = 3, Y = Number.MAX_SAFE_INTEGER - 1, Et = o.REJECTED | o.HAS_ERROR;
-class Z extends $ {
+const ft = 3, Et = Number.MAX_SAFE_INTEGER - 1, { IDLE: F, DIRTY: T, PENDING: R, RESOLVED: g, REJECTED: A, HAS_ERROR: m, RECOMPUTING: y, DISPOSED: P, IS_COMPUTED: dt } = q;
+function pt(i) {
+  return i & g ? k.RESOLVED : i & R ? k.PENDING : i & A ? k.REJECTED : k.IDLE;
+}
+class It extends J {
   constructor(t, e = {}) {
-    if (typeof t != "function") throw new p(u.COMPUTED_MUST_BE_FUNCTION);
-    super(), this._error = null, this._promiseId = 0, this._subscribers = [], this._links = l, this._cachedErrors = null, this._errorCacheEpoch = -1, this._asyncStartAggregateVersion = 0, this._asyncRetryCount = 0, this._errorDepCount = 0, this._trackEpoch = -1, this._trackLinks = l, this._trackCount = 0, this._value = void 0, this.flags = o.DIRTY | o.IDLE, this._equal = e.equal ?? Object.is, this._fn = t, this._defaultValue = "defaultValue" in e ? e.defaultValue : x, this._onError = e.onError ?? null;
+    if (typeof t != "function") throw new d(c.COMPUTED_MUST_BE_FUNCTION);
+    super(), this._error = null, this._promiseId = 0, this._subscribers = [], this._links = _, this._asyncStartAggregateVersion = 0, this._asyncRetryCount = 0, this._trackEpoch = -1, this._trackLinks = _, this._trackCount = 0, this._value = void 0, this.flags = dt | T | F, this._equal = e.equal ?? Object.is, this._fn = t, this._defaultValue = "defaultValue" in e ? e.defaultValue : v, this._onError = e.onError ?? null;
     const s = e.maxAsyncRetries;
-    if (this._maxAsyncRetries = s != null && s >= 0 ? s : ft, g.attachDebugInfo(this, "computed", this.id), e.lazy === !1)
+    if (this._maxAsyncRetries = s != null && s >= 0 ? s : ft, D.attachDebugInfo(this, "computed", this.id), e.lazy === !1)
       try {
         this._recompute();
       } catch {
       }
   }
   _track() {
-    const t = E.current;
-    t && j(this, t, this._subscribers);
+    const t = a.current;
+    t && K(this, t, this._subscribers);
   }
   get value() {
     this._track();
     const t = this.flags;
-    if ((t & (o.RESOLVED | o.DIRTY | o.IDLE)) === o.RESOLVED)
+    if ((t & (g | T | F)) === g)
       return this._value;
-    if (t & o.DISPOSED)
-      throw new p(u.COMPUTED_DISPOSED);
-    if (t & o.RECOMPUTING) {
-      if (this._defaultValue !== x) return this._defaultValue;
-      throw new p(u.COMPUTED_CIRCULAR_DEPENDENCY);
+    if (t & P)
+      throw new d(c.COMPUTED_DISPOSED);
+    if (t & y) {
+      if (this._defaultValue !== v) return this._defaultValue;
+      throw new d(c.COMPUTED_CIRCULAR_DEPENDENCY);
     }
-    if (t & (o.DIRTY | o.IDLE) && (this._recompute(), this.flags & o.RESOLVED))
+    if (t & (T | F) && (this._recompute(), this.flags & g))
       return this._value;
-    const e = this._defaultValue, s = e !== x;
-    if (this.flags & o.PENDING) {
+    const e = this._defaultValue, s = e !== v;
+    if (this.flags & R) {
       if (s) return e;
-      throw new p(u.COMPUTED_ASYNC_PENDING_NO_DEFAULT);
+      throw new d(c.COMPUTED_ASYNC_PENDING_NO_DEFAULT);
     }
-    if (this.flags & o.REJECTED) {
+    if (this.flags & A) {
       if (this._error?.recoverable && s) return e;
       throw this._error;
     }
@@ -576,65 +551,61 @@ class Z extends $ {
     return this._value;
   }
   get state() {
-    return this._track(), U[this.flags & W];
+    return this._track(), pt(this.flags);
   }
   get hasError() {
-    if (this._track(), this.flags & (o.REJECTED | o.HAS_ERROR) || this._errorDepCount > 0) return !0;
+    if (this._track(), this.flags & (A | m)) return !0;
     const t = this._links;
     for (let e = 0, s = t.length; e < s; e++) {
       const n = t[e]?.node;
-      if (n && n.flags & o.HAS_ERROR) return !0;
+      if (n && n.flags & m) return !0;
     }
     return !1;
   }
-  // ... (isValid, errors, lastError getters remain structurally similar, omitted for brevity if mostly unchanged) ...
   get isValid() {
     return !this.hasError;
   }
   get errors() {
     if (this._track(), !this.hasError) return st;
-    const t = ct();
-    if (this._errorCacheEpoch === t && this._cachedErrors) return this._cachedErrors;
-    const e = [];
-    this._error && e.push(this._error);
-    const s = this._links;
-    for (let r = 0, h = s.length; r < h; r++) {
-      const c = s[r].node;
-      if (c.flags & o.HAS_ERROR) {
-        const B = c;
-        if (B.errors) {
-          const V = B.errors;
-          for (let L = 0; L < V.length; L++) {
-            const F = V[L];
-            F && e.indexOf(F) === -1 && e.push(F);
+    const t = [];
+    this._error && t.push(this._error);
+    const e = this._links;
+    for (let s = 0, n = e.length; s < n; s++) {
+      const r = e[s].node;
+      if (r.flags & m) {
+        const o = r;
+        if (o.errors) {
+          const h = o.errors;
+          for (let f = 0; f < h.length; f++) {
+            const C = h[f];
+            C && t.indexOf(C) === -1 && t.push(C);
           }
         }
       }
     }
-    const n = Object.freeze(e);
-    return this._errorCacheEpoch = t, this._cachedErrors = n, n;
+    return Object.freeze(t);
   }
   get lastError() {
     return this._track(), this._error;
   }
   get isPending() {
-    return this._track(), (this.flags & o.PENDING) !== 0;
+    return this._track(), (this.flags & R) !== 0;
   }
   get isResolved() {
-    return this._track(), (this.flags & o.RESOLVED) !== 0;
+    return this._track(), (this.flags & g) !== 0;
   }
   invalidate() {
-    this._markDirty(), this._errorCacheEpoch = -1, this._cachedErrors = null;
+    this._markDirty();
   }
   dispose() {
-    if (this.flags & o.DISPOSED) return;
+    if (this.flags & P) return;
     const t = this._links;
-    if (t !== l) {
+    if (t !== _) {
       for (let e = 0, s = t.length; e < s; e++)
         t[e].unsub?.();
-      D.release(t), this._links = l;
+      p.release(t), this._links = _;
     }
-    this._subscribers.length = 0, this.flags = o.DISPOSED | o.DIRTY | o.IDLE, this._error = null, this._value = void 0, this._promiseId = (this._promiseId + 1) % Y, this._cachedErrors = null, this._errorCacheEpoch = -1;
+    this._subscribers.length = 0, this.flags = P | T | F, this._error = null, this._value = void 0;
   }
   addDependency(t) {
     if (t._lastSeenEpoch !== this._trackEpoch) {
@@ -642,151 +613,146 @@ class Z extends $ {
         const e = this._trackLinks[this._trackCount];
         e.node = t, e.version = t.version;
       } else
-        this._trackLinks.push(new b(t, t.version));
+        this._trackLinks.push(new x(t, t.version));
       this._trackCount++;
     }
   }
-  _commitDeps(t) {
-    this._trackLinks.length = this._trackCount, ht(this._trackLinks, t, this), this._links = this._trackLinks;
-  }
-  _updateErrorDepCount() {
-    let t = 0;
-    const e = this._links;
-    for (let s = 0, n = e.length; s < n; s++) {
-      const r = e[s]?.node;
-      r && r.flags & o.HAS_ERROR && t++;
-    }
-    this._errorDepCount = t;
-  }
   _recompute() {
-    if (this.flags & o.RECOMPUTING) return;
-    this.flags |= o.RECOMPUTING;
+    if (this.flags & y) return;
+    this.flags |= y;
     const t = this._links;
-    this._trackEpoch = J(), this._trackLinks = D.acquire(), this._trackCount = 0;
+    this._trackEpoch = V(), this._trackLinks = p.acquire(), this._trackCount = 0;
     let e = !1;
     try {
-      const s = E.run(this, this._fn);
-      this._commitDeps(t), e = !0, this._updateErrorDepCount(), K(s) ? this._handleAsyncComputation(s) : this._finalizeResolution(s);
+      const s = a.run(this, this._fn);
+      this._trackLinks.length = this._trackCount, Q(this._trackLinks, t, this), this._links = this._trackLinks, e = !0, tt(s) ? this._handleAsyncComputation(s) : this._finalizeResolution(s);
     } catch (s) {
       if (!e)
         try {
-          this._commitDeps(t), e = !0, this._updateErrorDepCount();
+          this._trackLinks.length = this._trackCount, Q(this._trackLinks, t, this), this._links = this._trackLinks, e = !0;
         } catch (n) {
-          _ && console.warn("[atom-effect] _commitDeps failed during error recovery:", n);
+          u && console.warn("[atom-effect] _commitDeps failed during error recovery:", n);
         }
-      this._handleError(s, u.COMPUTED_COMPUTATION_FAILED, !0);
+      this._handleError(s, c.COMPUTED_COMPUTATION_FAILED, !0);
     } finally {
-      e && t !== l ? D.release(t) : e || D.release(this._trackLinks), this._trackEpoch = -1, this._trackLinks = l, this._trackCount = 0, this.flags &= -257;
+      e && t !== _ ? p.release(t) : e || p.release(this._trackLinks), this._trackEpoch = -1, this._trackLinks = _, this._trackCount = 0, this.flags &= ~y;
     }
   }
   _handleAsyncComputation(t) {
-    this.flags = (this.flags | o.PENDING) & -217, this._notifySubscribers(void 0, void 0), this._asyncStartAggregateVersion = this._captureVersionSnapshot(), this._asyncRetryCount = 0, this._promiseId = (this._promiseId + 1) % Y;
+    this.flags = (this.flags | R) & -217, this._notifySubscribers(void 0, void 0), this._asyncStartAggregateVersion = this._captureVersionSnapshot(), this._asyncRetryCount = 0, this._promiseId = (this._promiseId + 1) % Et;
     const e = this._promiseId;
     t.then(
       (s) => {
         if (e === this._promiseId) {
           if (this._captureVersionSnapshot() !== this._asyncStartAggregateVersion)
             return this._asyncRetryCount++ < this._maxAsyncRetries ? this._markDirty() : this._handleError(
-              new p(
+              new d(
                 `Async drift threshold exceeded after ${this._maxAsyncRetries} retries.`
               ),
-              u.COMPUTED_ASYNC_COMPUTATION_FAILED
+              c.COMPUTED_ASYNC_COMPUTATION_FAILED
             );
           this._finalizeResolution(s), this._notifySubscribers(s, void 0);
         }
       },
-      (s) => e === this._promiseId && this._handleError(s, u.COMPUTED_ASYNC_COMPUTATION_FAILED)
+      (s) => e === this._promiseId && this._handleError(s, c.COMPUTED_ASYNC_COMPUTATION_FAILED)
     );
   }
   _captureVersionSnapshot() {
     let t = 0;
     const e = this._links;
     for (let s = 0, n = e.length; s < n; s++)
-      t = ((t << 5) - t | 0) + e[s].node.version & O;
+      t += e[s].node.version;
     return t;
   }
   _handleError(t, e, s = !1) {
-    const n = C(t, p, e);
-    if (!s && !(this.flags & o.REJECTED) && (this.version = P(this.version)), this._error = n, this.flags = this.flags & -121 | Et, this._onError)
+    const n = b(t, d, e);
+    if (!s && !(this.flags & A) && (this.version = B(this.version)), this._error = n, this.flags = this.flags & -121 | A | m, this._onError)
       try {
         this._onError(n);
       } catch (r) {
-        console.error(u.CALLBACK_ERROR_IN_ERROR_HANDLER, r);
+        console.error(c.CALLBACK_ERROR_IN_ERROR_HANDLER, r);
       }
     if (s) throw n;
     this._notifySubscribers(void 0, void 0);
   }
   _finalizeResolution(t) {
-    (!(this.flags & o.RESOLVED) || !this._equal(this._value, t)) && (this.version = P(this.version)), this._value = t, this._error = null, this.flags = (this.flags | o.RESOLVED) & -697, this._cachedErrors = null, this._errorCacheEpoch = -1;
+    (!(this.flags & g) || !this._equal(this._value, t)) && (this.version = B(this.version)), this._value = t, this._error = null, this.flags = (this.flags | g) & -697;
   }
   execute() {
     this._markDirty();
   }
   /** @internal */
   _markDirty() {
-    this.flags & (o.RECOMPUTING | o.DIRTY) || (this.flags |= o.DIRTY, this._notifySubscribers(void 0, void 0));
+    this.flags & (y | T) || (this.flags |= T, this._notifySubscribers(void 0, void 0));
   }
 }
-Object.freeze(Z.prototype);
-function Ct(i, t = {}) {
-  return new Z(i, t);
+function Ot(i, t = {}) {
+  return new It(i, t);
 }
-class dt extends q {
+class gt extends W {
   constructor(t, e = {}) {
-    super(), this._cleanup = null, this._links = l, this._nextLinks = null, this._currentEpoch = -1, this._lastFlushEpoch = -1, this._executionsInEpoch = 0, this._executionCount = 0, this._historyPtr = 0, this._execId = 0, this._fn = t, this._onError = e.onError ?? null, this._sync = e.sync ?? !1, this._maxExecutions = e.maxExecutionsPerSecond ?? I.MAX_EXECUTIONS_PER_SECOND, this._maxExecutionsPerFlush = e.maxExecutionsPerFlush ?? I.MAX_EXECUTIONS_PER_EFFECT, this._trackModifications = e.trackModifications ?? !1;
-    const s = Number.isFinite(this._maxExecutions), n = s ? Math.min(this._maxExecutions + 1, I.MAX_EXECUTIONS_PER_SECOND + 1) : 0;
-    this._historyCapacity = n, this._history = _ && s && n > 0 ? new Array(n).fill(0) : null, g.attachDebugInfo(this, "effect", this.id);
+    super(), this._cleanup = null, this._links = _, this._nextLinks = null, this._prevLinks = null, this._currentEpoch = -1, this._lastFlushEpoch = -1, this._executionsInEpoch = 0, this._executionCount = 0, this._windowStart = 0, this._windowCount = 0, this._execId = 0, this._fn = t, this._onError = e.onError ?? null, this._sync = e.sync ?? !1, this._maxExecutions = e.maxExecutionsPerSecond ?? S.MAX_EXECUTIONS_PER_SECOND, this._maxExecutionsPerFlush = e.maxExecutionsPerFlush ?? S.MAX_EXECUTIONS_PER_EFFECT, this._trackModifications = e.trackModifications ?? !1, D.attachDebugInfo(this, "effect", this.id);
   }
   run() {
-    if (this.flags & a.DISPOSED)
-      throw new S(u.EFFECT_DISPOSED);
+    if (this.flags & l.DISPOSED)
+      throw new I(c.EFFECT_DISPOSED);
     this.execute(!0);
   }
   dispose() {
-    this.flags & a.DISPOSED || (this.flags |= a.DISPOSED, this._execCleanup(), this._releaseLinks(this._links), this._links = l, this._executeTask = void 0);
+    this.flags & l.DISPOSED || (this.flags |= l.DISPOSED, this._execCleanup(), this._unsubLinks(this._links), this._links !== _ && p.release(this._links), this._links = _, this._executeTask = void 0);
   }
   addDependency(t) {
-    if (!(this.flags & a.EXECUTING) || t._lastSeenEpoch === this._currentEpoch) return;
+    if (!(this.flags & l.EXECUTING) || t._lastSeenEpoch === this._currentEpoch) return;
     t._lastSeenEpoch = this._currentEpoch;
-    const e = this._nextLinks;
-    if (t._tempUnsub) {
-      e.push(new b(t, t.version, t._tempUnsub)), t._tempUnsub = void 0;
-      return;
-    }
+    const e = this._nextLinks, s = this._prevLinks;
+    if (s)
+      for (let n = 0, r = s.length; n < r; n++) {
+        const o = s[n];
+        if (o && o.node === t && o.unsub) {
+          e.push(new x(t, t.version, o.unsub)), o.unsub = void 0;
+          return;
+        }
+      }
     try {
-      const s = t.subscribe(() => {
-        if (this._trackModifications && this.flags & a.EXECUTING && (t._modifiedAtEpoch = this._currentEpoch), this._sync) return this.execute();
-        this._executeTask || (this._executeTask = () => this.execute()), f.schedule(this._executeTask);
+      const n = t.subscribe(() => {
+        if (this._trackModifications && this.flags & l.EXECUTING && (t._modifiedAtEpoch = this._currentEpoch), this._sync) return this.execute();
+        this._executeTask || (this._executeTask = () => this.execute()), N.schedule(this._executeTask);
       });
-      e.push(new b(t, t.version, s));
-    } catch (s) {
-      const n = C(s, S, u.EFFECT_EXECUTION_FAILED);
-      if (console.error(n), this._onError)
+      e.push(new x(t, t.version, n));
+    } catch (n) {
+      const r = b(n, I, c.EFFECT_EXECUTION_FAILED);
+      if (console.error(r), this._onError)
         try {
-          this._onError(n);
+          this._onError(r);
         } catch {
         }
-      e.push(new b(t, t.version, void 0));
+      e.push(new x(t, t.version, void 0));
     }
   }
   /**
    * Executes effect with tracking.
    */
   execute(t = !1) {
-    if (this.flags & (a.DISPOSED | a.EXECUTING) || !t && this._links.length > 0 && !this._isDirty()) return;
-    this._checkInfiniteLoops(), this.flags |= a.EXECUTING, this._execCleanup();
+    if (this.flags & (l.DISPOSED | l.EXECUTING) || !t && this._links.length > 0 && !this._isDirty()) return;
+    this._checkInfiniteLoops(), this.flags |= l.EXECUTING, this._execCleanup();
     const e = this._links;
-    if (e !== l)
-      for (let r = 0, h = e.length; r < h; r++) {
-        const c = e[r];
-        c && (c.node._tempUnsub = c.unsub);
-      }
-    const s = D.acquire();
-    this._nextLinks = s, this._currentEpoch = J();
+    this._prevLinks = e !== _ ? e : null;
+    const s = p.acquire();
+    this._nextLinks = s, this._currentEpoch = V();
     let n = !1;
     try {
-      const r = E.run(this, this._fn);
-      this._links = s, n = !0, this._checkLoopWarnings(), K(r) ? this._handleAsyncResult(r) : this._cleanup = typeof r == "function" ? r : null;
+      const r = a.run(this, this._fn);
+      if (this._links = s, n = !0, this._trackModifications && D.enabled) {
+        const o = this._currentEpoch;
+        for (let h = 0, f = s.length; h < f; h++) {
+          const C = s[h].node;
+          C._modifiedAtEpoch === o && D.warn(
+            !0,
+            `Effect is reading a dependency (${D.getDebugName(C) || "unknown"}) that it just modified. Infinite loop may occur`
+          );
+        }
+      }
+      tt(r) ? this._handleAsyncResult(r) : this._cleanup = typeof r == "function" ? r : null;
     } catch (r) {
       n = !0, this._handleExecutionError(r), this._cleanup = null;
     } finally {
@@ -797,12 +763,12 @@ class dt extends q {
     const e = ++this._execId;
     t.then(
       (s) => {
-        if (e !== this._execId || this.flags & a.DISPOSED) {
+        if (e !== this._execId || this.flags & l.DISPOSED) {
           if (typeof s == "function")
             try {
               s();
             } catch (n) {
-              this._handleExecutionError(n, u.EFFECT_CLEANUP_FAILED);
+              this._handleExecutionError(n, c.EFFECT_CLEANUP_FAILED);
             }
           return;
         }
@@ -813,41 +779,36 @@ class dt extends q {
   }
   _finalizeDependencies(t, e, s) {
     if (this._nextLinks = null, t) {
-      if (e !== l) {
-        for (let n = 0, r = e.length; n < r; n++) {
-          const h = e[n], c = h?.node._tempUnsub;
-          c && (c(), h && (h.node._tempUnsub = void 0));
-        }
-        D.release(e);
-      }
-    } else if (this._releaseLinks(s), D.release(s), e !== l)
-      for (let n = 0, r = e.length; n < r; n++)
-        e[n] && (e[n].node._tempUnsub = void 0);
-  }
-  _releaseLinks(t) {
-    if (t !== l) {
-      for (let e = 0, s = t.length; e < s; e++)
-        t[e]?.unsub?.();
-      D.release(t);
-    }
+      const n = this._prevLinks;
+      if (n)
+        for (let r = 0, o = n.length; r < o; r++)
+          n[r]?.unsub?.();
+      e !== _ && p.release(e);
+    } else
+      this._unsubLinks(s), p.release(s);
+    this._prevLinks = null;
+  }
+  _unsubLinks(t) {
+    for (let e = 0, s = t.length; e < s; e++)
+      t[e]?.unsub?.();
   }
   _isDirty() {
-    const t = this._links, e = E.current;
-    E.current = null;
+    const t = this._links, e = a.current;
+    a.current = null;
     try {
       for (let s = 0, n = t.length; s < n; s++) {
-        const r = t[s], h = r.node;
-        if ("value" in h)
+        const r = t[s], o = r.node;
+        if (o.flags & q.IS_COMPUTED)
           try {
-            h.value;
+            o.value;
           } catch {
-            return _ && console.warn(`[atom-effect] Dependency #${h.id} threw during dirty check`), !0;
+            return u && console.warn(`[atom-effect] Dependency #${o.id} threw during dirty check`), !0;
           }
-        if (h.version !== r.version) return !0;
+        if (o.version !== r.version) return !0;
       }
       return !1;
     } finally {
-      E.current = e;
+      a.current = e;
     }
   }
   _execCleanup() {
@@ -855,94 +816,82 @@ class dt extends q {
       try {
         this._cleanup();
       } catch (t) {
-        this._handleExecutionError(t, u.EFFECT_CLEANUP_FAILED);
+        this._handleExecutionError(t, c.EFFECT_CLEANUP_FAILED);
       }
       this._cleanup = null;
     }
   }
   _checkInfiniteLoops() {
-    const t = v;
-    if (this._lastFlushEpoch !== t && (this._lastFlushEpoch = t, this._executionsInEpoch = 0), ++this._executionsInEpoch > this._maxExecutionsPerFlush && this._throwInfiniteLoopError("per-effect"), ut() > I.MAX_EXECUTIONS_PER_FLUSH && this._throwInfiniteLoopError("global"), this._executionCount++, this._history) {
+    const t = ht();
+    if (this._lastFlushEpoch !== t && (this._lastFlushEpoch = t, this._executionsInEpoch = 0), ++this._executionsInEpoch > this._maxExecutionsPerFlush && this._throwInfiniteLoopError("per-effect"), ct() > S.MAX_EXECUTIONS_PER_FLUSH && this._throwInfiniteLoopError("global"), this._executionCount++, u && Number.isFinite(this._maxExecutions)) {
       const e = Date.now();
-      this._history[this._historyPtr] = e, this._historyPtr = (this._historyPtr + 1) % this._historyCapacity;
-      const s = this._history[this._historyPtr] || 0;
-      if (s > 0 && e - s < tt.ONE_SECOND_MS) {
-        const n = new S(u.EFFECT_FREQUENCY_LIMIT_EXCEEDED);
-        if (this.dispose(), this._handleExecutionError(n), _) throw n;
+      if (e - this._windowStart >= 1e3)
+        this._windowStart = e, this._windowCount = 1;
+      else if (++this._windowCount > this._maxExecutions) {
+        const s = new I(c.EFFECT_FREQUENCY_LIMIT_EXCEEDED);
+        throw this.dispose(), this._handleExecutionError(s), s;
       }
     }
   }
   get isDisposed() {
-    return (this.flags & a.DISPOSED) !== 0;
+    return (this.flags & l.DISPOSED) !== 0;
   }
   get executionCount() {
     return this._executionCount;
   }
   get isExecuting() {
-    return (this.flags & a.EXECUTING) !== 0;
+    return (this.flags & l.EXECUTING) !== 0;
   }
   _throwInfiniteLoopError(t) {
-    const e = new S(
-      `Infinite loop detected (${t}): effect executed ${this._executionsInEpoch} times in current flush. Total executions in flush: ${w}`
+    const e = new I(
+      `Infinite loop detected (${t}): effect executed ${this._executionsInEpoch} times in current flush. Total executions in flush: ${H}`
     );
     throw this.dispose(), console.error(e), e;
   }
-  _handleExecutionError(t, e = u.EFFECT_EXECUTION_FAILED) {
-    const s = C(t, S, e);
+  _handleExecutionError(t, e = c.EFFECT_EXECUTION_FAILED) {
+    const s = b(t, I, e);
     if (console.error(s), this._onError)
       try {
         this._onError(s);
       } catch (n) {
-        console.error(C(n, S, u.CALLBACK_ERROR_IN_ERROR_HANDLER));
-      }
-  }
-  _checkLoopWarnings() {
-    if (this._trackModifications && g.enabled) {
-      const t = this._currentEpoch, e = this._links;
-      for (let s = 0, n = e.length; s < n; s++) {
-        const r = e[s].node;
-        r._modifiedAtEpoch === t && g.warn(
-          !0,
-          `Effect is reading a dependency (${g.getDebugName(r) || "unknown"}) that it just modified. Infinite loop may occur`
-        );
+        console.error(b(n, I, c.CALLBACK_ERROR_IN_ERROR_HANDLER));
       }
-    }
   }
 }
-function Tt(i, t = {}) {
+function yt(i, t = {}) {
   if (typeof i != "function")
-    throw new S(u.EFFECT_MUST_BE_FUNCTION);
-  const e = new dt(i, t);
+    throw new I(c.EFFECT_MUST_BE_FUNCTION);
+  const e = new gt(i, t);
   return e.execute(), e;
 }
-function Ot(i) {
+function At(i) {
   if (typeof i != "function")
     throw new TypeError("Batch callback must be a function");
-  f.startBatch();
+  N.startBatch();
   try {
     return i();
   } finally {
-    f.endBatch();
+    N.endBatch();
   }
 }
 export {
-  m as AsyncState,
-  T as AtomError,
-  p as ComputedError,
+  k as AsyncState,
+  O as AtomError,
+  d as ComputedError,
   et as DEBUG_CONFIG,
-  g as DEBUG_RUNTIME,
-  S as EffectError,
-  pt as POOL_CONFIG,
-  I as SCHEDULER_CONFIG,
-  N as SchedulerError,
-  Dt as atom,
-  Ot as batch,
-  Ct as computed,
-  Tt as effect,
+  D as DEBUG_RUNTIME,
+  I as EffectError,
+  St as POOL_CONFIG,
+  S as SCHEDULER_CONFIG,
+  L as SchedulerError,
+  Ct as atom,
+  At as batch,
+  Ot as computed,
+  yt as effect,
   at as isAtom,
-  St as isComputed,
-  gt as isEffect,
-  f as scheduler,
-  It as untracked
+  Tt as isComputed,
+  bt as isEffect,
+  N as scheduler,
+  Dt as untracked
 };
 //# sourceMappingURL=index.mjs.map