@but212/atom-effect 0.22.1 → 0.23.0

package/dist/index.mjs

@@ -1,12 +1,12 @@
-const b = {
+const N = {
   IDLE: "idle",
   PENDING: "pending",
   RESOLVED: "resolved",
   REJECTED: "rejected"
-}, u = {
+}, _ = {
   DISPOSED: 1,
   EXECUTING: 8
-}, $ = {
+}, W = {
   DISPOSED: 1,
   /** Marker bit: identifies this node as a computed. */
   IS_COMPUTED: 2,
@@ -21,10 +21,6 @@ const b = {
   DISPOSED: 1,
   SYNC: 8,
   NOTIFICATION_SCHEDULED: 16
-}, Dt = {
-  MAX_SIZE: 1e3,
-  WARMUP_SIZE: 100,
-  ENABLE_STATS: !1
 }, d = {
   // Infinite loop protection
   MAX_EXECUTIONS_PER_SECOND: 1e3,
@@ -35,85 +31,65 @@ const b = {
   MIN_FLUSH_ITERATIONS: 10,
   // Memory management
   BATCH_QUEUE_SHRINK_THRESHOLD: 1e3
-}, rt = {
+}, ht = {
   WARN_INFINITE_LOOP: !0,
   EFFECT_FREQUENCY_WINDOW: 1e3
-}, H = {
+}, V = {
   MAX_ASYNC_RETRIES: 3,
   MAX_PROMISE_ID: Number.MAX_SAFE_INTEGER - 1
-}, L = 1073741823, W = typeof process < "u" && process.env && !1 || !1, ot = Object.freeze([]);
-class D extends Error {
-  constructor(t, e = null, s = !0) {
-    super(t), this.cause = e, this.recoverable = s, this.name = "AtomError";
-  }
+}, g = {
+  /** Uninitialized epoch marker. Used as initial value before any flush has occurred. */
+  UNINITIALIZED: -1
+}, F = 1073741823, Z = typeof process < "u" && process.env && !1 || !1, ot = Object.freeze([]);
+function X(n, t, s) {
+  const e = /* @__PURE__ */ new Map();
+  for (let i = 0; i < t.length; i++) {
+    const r = t[i];
+    r?.unsub && e.set(r.node, r.unsub);
+  }
+  for (let i = 0; i < n.length; i++) {
+    const r = n[i];
+    if (!r) continue;
+    const h = r.node, o = e.get(h);
+    o !== void 0 ? (r.unsub = o, e.delete(h)) : r.unsub || (r.unsub = h.subscribe(s));
+  }
+  for (const i of e.values())
+    i();
 }
-class f extends D {
-  constructor(t, e = null) {
-    super(t, e, !0), this.name = "ComputedError";
+class y {
+  constructor(t, s, e = void 0) {
+    this.node = t, this.version = s, this.unsub = e;
   }
 }
-class I extends D {
-  constructor(t, e = null) {
-    super(t, e, !1), this.name = "EffectError";
+class ct {
+  constructor(t, s) {
+    this.fn = t, this.sub = s;
   }
-}
-class m extends D {
-  constructor(t, e = null) {
-    super(t, e, !1), this.name = "SchedulerError";
+  notify(t, s) {
+    this.fn ? this.fn(t, s) : this.sub && this.sub.execute();
   }
 }
-const ht = /* @__PURE__ */ Symbol("AtomEffect.DebugName"), ct = /* @__PURE__ */ Symbol("AtomEffect.Type"), x = /* @__PURE__ */ Symbol("AtomEffect.NoDefaultValue"), F = {
-  // Dev mode flag
-  enabled: W,
-  warnInfiniteLoop: rt.WARN_INFINITE_LOOP,
-  warn(i, t) {
-  },
-  checkCircular(i, t) {
-    if (i === t)
-      throw new f("Direct circular dependency detected");
-  },
-  attachDebugInfo(i, t, e) {
-  },
-  getDebugName: (i) => i?.[ht],
-  getDebugType: (i) => i?.[ct]
-};
-let ut = 1;
-const _t = () => ut++;
-function K(i, t, e) {
-  if (typeof t == "function") {
-    const n = t;
-    if (e.some((r) => r && r.fn === n)) return;
-    e.push(new P(n, void 0));
-    return;
-  }
-  if ("addDependency" in t) {
-    t.addDependency(i);
-    return;
-  }
-  const s = t;
-  e.some((n) => n && n.sub === s) || e.push(new P(void 0, s));
+class k extends Error {
+  constructor(t, s = null, e = !0) {
+    super(t), this.cause = s, this.recoverable = e, this.name = "AtomError";
+  }
 }
-function V(i, t, e) {
-  const s = /* @__PURE__ */ new Map();
-  t.forEach((n) => {
-    n?.unsub && s.set(n.node, n.unsub);
-  }), i.forEach((n) => {
-    if (!n) return;
-    const r = n.node, o = s.get(r);
-    o !== void 0 ? (n.unsub = o, s.delete(r)) : (F.checkCircular(r, e), n.unsub = r.subscribe(e));
-  }), s.forEach((n) => n());
+class I extends k {
+  constructor(t, s = null) {
+    super(t, s, !0), this.name = "ComputedError";
+  }
 }
-class v {
-  constructor(t, e, s = void 0) {
-    this.node = t, this.version = e, this.unsub = s;
+class C extends k {
+  constructor(t, s = null) {
+    super(t, s, !1), this.name = "EffectError";
   }
 }
-class P {
-  constructor(t, e) {
-    this.fn = t, this.sub = e;
+class m extends k {
+  constructor(t, s = null) {
+    super(t, s, !1), this.name = "SchedulerError";
   }
 }
-const h = {
+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",
@@ -130,81 +106,138 @@ const h = {
   EFFECT_CLEANUP_FAILED: "Effect cleanup failed",
   EFFECT_DISPOSED: "Attempted to run disposed effect",
   // Scheduler Errors
-  SCHEDULER_FLUSH_OVERFLOW: (i, t) => `Maximum flush iterations (${i}) exceeded. ${t} jobs dropped. Possible infinite loop.`,
+  SCHEDULER_FLUSH_OVERFLOW: (n, t) => `Maximum flush iterations (${n}) exceeded. ${t} jobs dropped. Possible infinite loop.`,
   // System / Debug
   CALLBACK_ERROR_IN_ERROR_HANDLER: "Exception encountered in onError handler",
   // Effect frequency
   EFFECT_FREQUENCY_LIMIT_EXCEEDED: "Effect executed too frequently within 1 second. Suspected infinite loop.",
   SCHEDULER_CALLBACK_MUST_BE_FUNCTION: "Scheduler callback must be a function",
-  SCHEDULER_END_BATCH_WITHOUT_START: "endBatch() called without matching startBatch(). Ignoring."
+  SCHEDULER_END_BATCH_WITHOUT_START: "endBatch() called without matching startBatch(). Ignoring.",
+  BATCH_CALLBACK_MUST_BE_FUNCTION: "Batch callback must be a function"
+}, ut = /* @__PURE__ */ Symbol("AtomEffect.DebugName"), _t = /* @__PURE__ */ Symbol("AtomEffect.Type"), x = /* @__PURE__ */ Symbol("AtomEffect.NoDefaultValue"), B = {
+  // Dev mode flag
+  enabled: Z,
+  warnInfiniteLoop: ht.WARN_INFINITE_LOOP,
+  warn(n, t) {
+  },
+  attachDebugInfo(n, t, s) {
+  },
+  getDebugName: (n) => n?.[ut],
+  getDebugType: (n) => n?.[_t]
 };
-function S(i, t, e) {
-  if (i instanceof D)
-    return i;
-  const s = i instanceof Error, n = s ? i.message : String(i), r = s ? i : void 0, O = `${s ? i.constructor.name : "Unexpected error"} (${e}): ${n}`;
-  return new t(O, r);
+let lt = 1;
+const at = () => lt++;
+function S(n, t, s) {
+  if (n instanceof k)
+    return n;
+  const e = n instanceof Error, i = e ? n.message : String(n), r = e ? n : void 0, o = `${e ? n.constructor.name : "Unexpected error"} (${s}): ${i}`;
+  return new t(o, r);
 }
 class J {
   constructor() {
-    this.flags = 0, this.version = 0, this._lastSeenEpoch = -1, this.id = _t() & L;
+    this.flags = 0, this.version = 0, this._lastSeenEpoch = g.UNINITIALIZED, this.id = at() & F;
   }
 }
-class Z extends J {
+class tt extends J {
+  constructor() {
+    super(...arguments), this._notifying = 0;
+  }
   /**
    * Adds subscriber.
    */
   subscribe(t) {
-    const e = typeof t == "function";
-    if (!e && (!t || typeof t.execute != "function"))
+    const s = typeof t == "function";
+    if (!s && (!t || typeof t.execute != "function"))
       throw S(
         new TypeError("Invalid subscriber"),
-        D,
-        h.ATOM_SUBSCRIBER_MUST_BE_FUNCTION
+        k,
+        c.ATOM_SUBSCRIBER_MUST_BE_FUNCTION
       );
-    if (this._subscribers.some((r) => r ? e ? r.fn === t : r.sub === t : !1))
+    const e = this._subscribers, i = e.length;
+    let r = !1;
+    for (let o = 0; o < i; o++) {
+      const U = e[o];
+      if (U != null && (s ? U.fn === t : U.sub === t)) {
+        r = !0;
+        break;
+      }
+    }
+    if (r)
       return () => {
       };
-    const s = new P(
-      e ? t : void 0,
-      e ? void 0 : t
+    const h = new ct(
+      s ? t : void 0,
+      s ? void 0 : t
     );
-    return this._subscribers.push(s), () => this._unsubscribe(s);
+    return e.push(h), () => this._unsubscribe(h);
   }
   _unsubscribe(t) {
-    const e = this._subscribers, s = e.indexOf(t);
-    if (s === -1) return;
-    const n = e.pop();
-    s < e.length && n && (e[s] = n);
+    const s = this._subscribers;
+    let e = -1;
+    for (let r = 0; r < s.length; r++)
+      if (s[r] === t) {
+        e = r;
+        break;
+      }
+    if (e === -1) return;
+    if (this._notifying > 0) {
+      s[e] = null;
+      return;
+    }
+    const i = s.pop();
+    e < s.length && i !== void 0 && (s[e] = i);
   }
   subscriberCount() {
-    return this._subscribers.length;
+    let t = 0;
+    const s = this._subscribers;
+    for (let e = 0; e < s.length; e++)
+      s[e] != null && t++;
+    return t;
   }
-  _notifySubscribers(t, e) {
-    if (this._subscribers.length === 0) return;
-    this._subscribers.slice(0).forEach((n) => {
-      if (n)
-        try {
-          n.fn ? n.fn(t, e) : n.sub && n.sub.execute();
-        } catch (r) {
-          this._handleNotifyError(r);
+  _notifySubscribers(t, s) {
+    const e = this._subscribers, i = e.length;
+    if (i !== 0) {
+      this._notifying++;
+      try {
+        for (let r = 0; r < i; r++) {
+          const h = e[r];
+          if (h != null)
+            try {
+              h.notify(t, s);
+            } catch (o) {
+              this._handleNotifyError(o);
+            }
         }
-    });
+      } finally {
+        this._notifying--, this._notifying === 0 && this._cleanupTombstones();
+      }
+    }
+  }
+  _cleanupTombstones() {
+    const t = this._subscribers;
+    let s = 0;
+    for (; s < t.length; )
+      if (t[s] === null) {
+        const e = t.pop();
+        s < t.length && e !== void 0 && (t[s] = e);
+      } else
+        s++;
   }
   _handleNotifyError(t) {
-    console.error(S(t, D, h.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED));
+    console.error(S(t, k, c.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED));
   }
 }
-let k = 0;
-const w = () => (k = k + 1 & L || 1, k), M = (i) => i + 1 & L;
-let B = 0, R = !1, tt = 0;
-const et = () => tt;
-function X() {
-  return R ? !1 : (R = !0, tt = w(), B = 0, !0);
+let v = 0;
+const w = () => (v = v + 1 & F || 1, v), M = (n) => n + 1 & F;
+let z = 0, R = !1, st = 0;
+const et = () => st;
+function G() {
+  return R ? !1 : (R = !0, st = w(), z = 0, !0);
 }
-const G = () => {
+const Q = () => {
   R = !1;
-}, at = () => R ? ++B : 0;
-class lt {
+}, ft = () => R ? ++z : 0;
+class Et {
   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 = d.MAX_FLUSH_ITERATIONS, this.onOverflow = null, this._boundRunLoop = this._runLoop.bind(this);
   }
@@ -241,28 +274,28 @@ class lt {
   _runLoop() {
     try {
       if (this._size === 0) return;
-      const t = X();
-      this._drainQueue(), t && G();
+      const t = G();
+      this._drainQueue(), t && Q();
     } finally {
       this._isProcessing = !1, this._size > 0 && !this._isBatching && this._flush();
     }
   }
   _flushSync() {
     this._isFlushingSync = !0;
-    const t = X();
+    const t = G();
     try {
       this._mergeBatchQueue(), this._drainQueue();
     } finally {
-      this._isFlushingSync = !1, t && G();
+      this._isFlushingSync = !1, t && Q();
     }
   }
   _mergeBatchQueue() {
     if (this._batchQueueSize === 0) return;
-    const t = ++this._epoch, e = this._batchQueue, s = this._queueBuffer[this._bufferIndex];
-    let n = this._size;
-    e.slice(0, this._batchQueueSize).forEach((r) => {
-      r._nextEpoch !== t && (r._nextEpoch = t, s[n++] = r);
-    }), this._size = n, this._batchQueueSize = 0, e.length > d.BATCH_QUEUE_SHRINK_THRESHOLD && (e.length = 0);
+    const t = ++this._epoch, s = this._batchQueue, e = this._queueBuffer[this._bufferIndex];
+    let i = this._size;
+    s.slice(0, this._batchQueueSize).forEach((r) => {
+      r._nextEpoch !== t && (r._nextEpoch = t, e[i++] = r);
+    }), this._size = i, this._batchQueueSize = 0, s.length > d.BATCH_QUEUE_SHRINK_THRESHOLD && (s.length = 0);
   }
   _drainQueue() {
     let t = 0;
@@ -275,21 +308,22 @@ class lt {
     }
   }
   _processQueue() {
-    const t = this._bufferIndex, e = this._queueBuffer[t], s = this._size;
+    const t = this._bufferIndex, s = this._queueBuffer[t], e = this._size;
     this._bufferIndex = t ^ 1, this._size = 0, this._epoch++;
-    for (let n = 0; n < s; n++)
+    for (let i = 0; i < e; i++)
       try {
-        e[n]();
+        const r = s[i];
+        typeof r == "function" ? r() : r.execute();
       } catch (r) {
         console.error(new m("Error occurred during scheduler execution", r));
       }
-    e.length = 0;
+    s.length = 0;
   }
   _handleFlushOverflow() {
     const t = this._size + this._batchQueueSize;
     if (console.error(
       new m(
-        h.SCHEDULER_FLUSH_OVERFLOW(this._maxFlushIterations, t)
+        c.SCHEDULER_FLUSH_OVERFLOW(this._maxFlushIterations, t)
       )
     ), this._size = 0, this._queueBuffer[this._bufferIndex].length = 0, this._batchQueueSize = 0, this.onOverflow)
       try {
@@ -311,7 +345,7 @@ class lt {
     this._maxFlushIterations = t;
   }
 }
-const T = new lt(), z = /* @__PURE__ */ Symbol.for("atom-effect/atom"), st = /* @__PURE__ */ Symbol.for("atom-effect/computed"), it = /* @__PURE__ */ Symbol.for("atom-effect/effect"), _ = {
+const T = new Et(), H = /* @__PURE__ */ Symbol.for("atom-effect/atom"), it = /* @__PURE__ */ Symbol.for("atom-effect/computed"), nt = /* @__PURE__ */ Symbol.for("atom-effect/effect"), dt = /* @__PURE__ */ Symbol.for("atom-effect/writable"), l = {
   /** Active listener. */
   current: null,
   /**
@@ -321,48 +355,54 @@ const T = new lt(), z = /* @__PURE__ */ Symbol.for("atom-effect/atom"), st = /*
    * @param fn - The logic to execute.
    * @returns The result of `fn`.
    */
-  run(i, t) {
-    const e = this.current;
-    this.current = i;
+  run(n, t) {
+    const s = this.current;
+    this.current = n;
     try {
       return t();
     } finally {
-      this.current = e;
+      this.current = s;
     }
   }
 };
-function Ct(i) {
-  const t = _.current;
-  if (t === null) return i();
-  _.current = null;
+function Dt(n) {
+  const t = l.current;
+  if (t === null) return n();
+  l.current = null;
   try {
-    return i();
+    return n();
   } finally {
-    _.current = t;
+    l.current = t;
   }
 }
-var Q;
-class ft extends Z {
-  constructor(t, e) {
-    super(), this._pendingOldValue = void 0, this._notifyTask = () => this._flushNotifications(), this._subscribers = [], this[Q] = !0, this._value = t, e && (this.flags |= a.SYNC), F.attachDebugInfo(this, "atom", this.id);
+var Y, q;
+class It extends tt {
+  constructor(t, s) {
+    super(), this._pendingOldValue = void 0, this._subscribers = [], this[q] = !0, this[Y] = !0, this._value = t, s && (this.flags |= a.SYNC), B.attachDebugInfo(this, "atom", this.id);
   }
   get value() {
-    const t = _.current;
-    return t && K(this, t, this._subscribers), this._value;
+    return l.current?.addDependency(this), this._value;
   }
   set value(t) {
-    const e = this._value;
-    if (Object.is(e, t)) return;
+    const s = this._value;
+    if (Object.is(s, t)) return;
     this._value = t, this.version = M(this.version);
-    const s = this.flags;
-    if (!(this._subscribers.length === 0 || s & a.NOTIFICATION_SCHEDULED)) {
-      if (this._pendingOldValue = e, this.flags = s | a.NOTIFICATION_SCHEDULED, s & a.SYNC && !T.isBatching) {
+    const e = this.flags;
+    if (!(this._subscribers.length === 0 || e & a.NOTIFICATION_SCHEDULED)) {
+      if (this._pendingOldValue = s, this.flags = e | a.NOTIFICATION_SCHEDULED, e & a.SYNC && !T.isBatching) {
         this._flushNotifications();
         return;
       }
-      T.schedule(this._notifyTask);
+      T.schedule(this);
     }
   }
+  /**
+   * Executes scheduled notification.
+   * @internal
+   */
+  execute() {
+    this._flushNotifications();
+  }
   /**
    * Triggers subscribers.
    */
@@ -370,8 +410,8 @@ class ft extends Z {
     const t = this.flags;
     if (!(t & a.NOTIFICATION_SCHEDULED) || t & a.DISPOSED)
       return;
-    const e = this._pendingOldValue;
-    this._pendingOldValue = void 0, this.flags &= -17, this._notifySubscribers(this._value, e);
+    const s = this._pendingOldValue;
+    this._pendingOldValue = void 0, this.flags &= -17, this._notifySubscribers(this._value, s);
   }
   peek() {
     return this._value;
@@ -379,21 +419,21 @@ class ft extends Z {
   dispose() {
     this.flags & a.DISPOSED || (this._subscribers.length = 0, this.flags |= a.DISPOSED, this._value = void 0, this._pendingOldValue = void 0);
   }
-  [(Q = z, Symbol.dispose)]() {
+  [(q = H, Y = dt, Symbol.dispose)]() {
     this.dispose();
   }
 }
-function gt(i, t = {}) {
-  return new ft(i, t.sync ?? !1);
+function bt(n, t = {}) {
+  return new It(n, t.sync ?? !1);
 }
-class Et {
+class pt {
   /**
    * @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 ? {
+  constructor(t = 50, s = 256, e = !1) {
+    this.limit = t, this.capacity = s, this.pool = [], this.stats = null, this.stats = e ? {
       acquired: 0,
       released: 0,
       rejected: { frozen: 0, tooLarge: 0, poolFull: 0 }
@@ -411,8 +451,8 @@ class Et {
    * @param arr - Array to release.
    * @param emptyConst - Optional empty constant.
    */
-  release(t, e) {
-    if (!(e && t === e)) {
+  release(t, s) {
+    if (!(s && t === s)) {
       if (t.length > this.capacity) {
         this.stats && this.stats.rejected.tooLarge++;
         return;
@@ -433,12 +473,12 @@ class Et {
    */
   getStats() {
     if (!this.stats) return null;
-    const { acquired: t, released: e, rejected: s } = this.stats, n = t - e - (s.frozen + s.tooLarge + s.poolFull);
+    const { acquired: t, released: s, rejected: e } = this.stats, i = t - s - (e.frozen + e.tooLarge + e.poolFull);
     return {
       acquired: t,
-      released: e,
-      rejected: { ...s },
-      leaked: n,
+      released: s,
+      rejected: { ...e },
+      leaked: i,
       poolSize: this.pool.length
     };
   }
@@ -453,61 +493,60 @@ class Et {
     });
   }
 }
-const c = Object.freeze(
+const u = Object.freeze(
   []
-), l = new Et();
-function Tt(i) {
-  return i !== null && typeof i == "object" && z in i;
+), f = new pt();
+function Tt(n) {
+  return n !== null && typeof n == "object" && H in n;
 }
-function Ot(i) {
-  return i !== null && typeof i == "object" && st in i;
+function Nt(n) {
+  return n !== null && typeof n == "object" && it in n;
 }
-function bt(i) {
-  return i !== null && typeof i == "object" && it in i;
+function Lt(n) {
+  return n !== null && typeof n == "object" && nt in n;
 }
-function nt(i) {
-  return i !== null && typeof i == "object" && typeof i.then == "function";
+function rt(n) {
+  return n !== null && typeof n == "object" && typeof n.then == "function";
 }
-var Y, q;
-const { IDLE: A, DIRTY: p, PENDING: N, RESOLVED: E, REJECTED: g, HAS_ERROR: y, RECOMPUTING: C, DISPOSED: U, IS_COMPUTED: dt } = $;
-function pt(i) {
-  return i & E ? b.RESOLVED : i & N ? b.PENDING : i & g ? b.REJECTED : b.IDLE;
+var j, $;
+const { IDLE: L, DIRTY: p, PENDING: O, RESOLVED: E, REJECTED: b, HAS_ERROR: A, RECOMPUTING: D, DISPOSED: P, IS_COMPUTED: Ct } = W;
+function gt(n) {
+  return n & E ? N.RESOLVED : n & O ? N.PENDING : n & b ? N.REJECTED : N.IDLE;
 }
-class It extends Z {
-  constructor(t, e = {}) {
-    if (typeof t != "function") throw new f(h.COMPUTED_MUST_BE_FUNCTION);
-    super(), this[q] = !0, this[Y] = !0, this._error = null, this._promiseId = 0, this._subscribers = [], this._links = c, this._asyncStartAggregateVersion = 0, this._asyncRetryCount = 0, this._lastDriftEpoch = -1, this._trackEpoch = -1, this._trackLinks = c, this._trackCount = 0, this._value = void 0, this.flags = dt | p | A, this._equal = e.equal ?? Object.is, this._fn = t, this._defaultValue = "defaultValue" in e ? e.defaultValue : x, this._onError = e.onError ?? null;
-    const s = e.maxAsyncRetries;
-    if (this._maxAsyncRetries = (s ?? H.MAX_ASYNC_RETRIES) & L, F.attachDebugInfo(this, "computed", this.id), e.lazy === !1)
+class St extends tt {
+  constructor(t, s = {}) {
+    if (typeof t != "function") throw new I(c.COMPUTED_MUST_BE_FUNCTION);
+    super(), this[$] = !0, this[j] = !0, this._error = null, this._promiseId = 0, this._subscribers = [], this._links = u, this._asyncStartAggregateVersion = 0, this._asyncRetryCount = 0, this._lastDriftEpoch = g.UNINITIALIZED, this._trackEpoch = g.UNINITIALIZED, this._trackLinks = u, this._trackCount = 0, this._value = void 0, this.flags = Ct | p | L, this._equal = s.equal ?? Object.is, this._fn = t, this._defaultValue = "defaultValue" in s ? s.defaultValue : x, this._onError = s.onError ?? null;
+    const e = s.maxAsyncRetries;
+    if (this._maxAsyncRetries = (e ?? V.MAX_ASYNC_RETRIES) & F, B.attachDebugInfo(this, "computed", this.id), s.lazy === !1)
       try {
         this._recompute();
       } catch {
       }
   }
   _track() {
-    const t = _.current;
-    t && K(this, t, this._subscribers);
+    l.current?.addDependency(this);
   }
   get value() {
     this._track();
     const t = this.flags;
-    if ((t & (E | p | A)) === E)
+    if ((t & (E | p | L)) === E)
       return this._value;
-    if (t & U)
-      throw new f(h.COMPUTED_DISPOSED);
-    if (t & C) {
+    if (t & P)
+      throw new I(c.COMPUTED_DISPOSED);
+    if (t & D) {
       if (this._defaultValue !== x) return this._defaultValue;
-      throw new f(h.COMPUTED_CIRCULAR_DEPENDENCY);
+      throw new I(c.COMPUTED_CIRCULAR_DEPENDENCY);
     }
-    if (t & (p | A) && (this._recompute(), this.flags & E))
+    if (t & (p | L) && (this._recompute(), this.flags & E))
       return this._value;
-    const e = this._defaultValue, s = e !== x;
-    if (this.flags & N) {
-      if (s) return e;
-      throw new f(h.COMPUTED_ASYNC_PENDING_NO_DEFAULT);
+    const s = this._defaultValue, e = s !== x;
+    if (this.flags & O) {
+      if (e) return s;
+      throw new I(c.COMPUTED_ASYNC_PENDING_NO_DEFAULT);
     }
-    if (this.flags & g) {
-      if (s) return e;
+    if (this.flags & b) {
+      if (e) return s;
       throw this._error;
     }
     return this._value;
@@ -516,10 +555,10 @@ class It extends Z {
     return this._value;
   }
   get state() {
-    return this._track(), pt(this.flags);
+    return this._track(), gt(this.flags);
   }
   get hasError() {
-    return this._track(), this.flags & (g | y) ? !0 : this._links.some((t) => t?.node?.flags & y);
+    return this._track(), this.flags & (b | A) ? !0 : this._links.some((t) => t?.node?.flags & A);
   }
   get isValid() {
     return !this.hasError;
@@ -527,10 +566,10 @@ class It extends Z {
   get errors() {
     if (this._track(), !this.hasError) return ot;
     const t = [];
-    return this._error && t.push(this._error), this._links.forEach((s) => {
-      const n = s.node;
-      n.flags & y && n.errors.forEach((o) => {
-        o && !t.includes(o) && t.push(o);
+    return this._error && t.push(this._error), this._links.forEach((e) => {
+      const i = e.node;
+      i.flags & A && i.errors.forEach((h) => {
+        h && !t.includes(h) && t.push(h);
       });
     }), Object.freeze(t);
   }
@@ -538,7 +577,7 @@ class It extends Z {
     return this._track(), this._error;
   }
   get isPending() {
-    return this._track(), (this.flags & N) !== 0;
+    return this._track(), (this.flags & O) !== 0;
   }
   get isResolved() {
     return this._track(), (this.flags & E) !== 0;
@@ -547,80 +586,100 @@ class It extends Z {
     this._markDirty();
   }
   dispose() {
-    if (this.flags & U) return;
+    if (this.flags & P) return;
     const t = this._links;
-    t !== c && (t.forEach((e) => e.unsub?.()), l.release(t), this._links = c), this._subscribers.length = 0, this.flags = U | p | A, this._error = null, this._value = void 0;
+    t !== u && (t.forEach((s) => s.unsub?.()), f.release(t), this._links = u), this._subscribers.length = 0, this.flags = P | p | L, this._error = null, this._value = void 0;
   }
-  [(q = z, Y = st, Symbol.dispose)]() {
+  [($ = H, j = it, Symbol.dispose)]() {
     this.dispose();
   }
   addDependency(t) {
     if (t._lastSeenEpoch !== this._trackEpoch) {
-      if (t._lastSeenEpoch = this._trackEpoch, this._trackCount < this._trackLinks.length) {
-        const e = this._trackLinks[this._trackCount];
-        e.node = t, e.version = t.version;
-      } else
-        this._trackLinks.push(new v(t, t.version));
-      this._trackCount++;
+      if (t._lastSeenEpoch = this._trackEpoch, this._trackLinks === this._links && this._trackCount < this._links.length && this._links[this._trackCount].node === t) {
+        this._links[this._trackCount].version = t.version, this._trackCount++;
+        return;
+      }
+      if (this._trackLinks === this._links) {
+        const s = f.acquire();
+        for (let e = 0; e < this._trackCount; e++)
+          s[e] = this._links[e];
+        this._trackLinks = s;
+      }
+      this._trackCount < this._trackLinks.length ? this._trackLinks[this._trackCount] = new y(t, t.version) : this._trackLinks.push(new y(t, t.version)), this._trackCount++;
     }
   }
   _recompute() {
-    if (this.flags & C) return;
-    this.flags |= C;
+    if (this.flags & D) return;
+    this.flags |= D;
     const t = this._links;
-    this._trackEpoch = w(), this._trackLinks = l.acquire(), this._trackCount = 0;
-    let e = !1;
+    this._trackEpoch = w(), this._trackLinks = t, this._trackCount = 0;
+    let s = !1;
     try {
-      const s = _.run(this, this._fn);
-      this._trackLinks.length = this._trackCount, V(this._trackLinks, t, this), this._links = this._trackLinks, e = !0, nt(s) ? this._handleAsyncComputation(s) : this._finalizeResolution(s);
-    } catch (s) {
-      if (!e)
+      const e = l.run(this, this._fn);
+      if (this._trackLinks === t)
+        if (this._trackCount === t.length)
+          s = !0;
+        else {
+          for (let i = this._trackCount; i < t.length; i++)
+            t[i].unsub?.();
+          t.length = this._trackCount, s = !0;
+        }
+      else
+        this._trackLinks.length = this._trackCount, X(this._trackLinks, t, this), this._links = this._trackLinks, s = !0;
+      rt(e) ? this._handleAsyncComputation(e) : this._finalizeResolution(e);
+    } catch (e) {
+      if (!s)
         try {
-          this._trackLinks.length = this._trackCount, V(this._trackLinks, t, this), this._links = this._trackLinks, e = !0;
+          if (this._trackLinks === t) {
+            for (let i = this._trackCount; i < t.length; i++)
+              t[i].unsub?.();
+            t.length = this._trackCount, s = !0;
+          } else
+            this._trackLinks.length = this._trackCount, X(this._trackLinks, t, this), this._links = this._trackLinks, s = !0;
         } catch {
         }
-      this._handleError(s, h.COMPUTED_COMPUTATION_FAILED, !0);
+      this._handleError(e, c.COMPUTED_COMPUTATION_FAILED, !0);
     } finally {
-      e && t !== c ? l.release(t) : e || l.release(this._trackLinks), this._trackEpoch = -1, this._trackLinks = c, this._trackCount = 0, this.flags &= ~C;
+      s ? this._links !== t && t !== u && f.release(t) : this._trackLinks !== t && this._trackLinks !== u && f.release(this._trackLinks), this._trackEpoch = g.UNINITIALIZED, this._trackLinks = u, this._trackCount = 0, this.flags &= ~D;
     }
   }
   _handleAsyncComputation(t) {
-    this.flags = (this.flags | N) & -217, this._notifySubscribers(void 0, void 0), this._asyncStartAggregateVersion = this._captureVersionSnapshot(), this._asyncRetryCount = 0, this._promiseId = (this._promiseId + 1) % H.MAX_PROMISE_ID;
-    const e = this._promiseId;
+    this.flags = (this.flags | O) & -217, this._notifySubscribers(void 0, void 0), this._asyncStartAggregateVersion = this._captureVersionSnapshot(), this._asyncRetryCount = 0, this._promiseId = (this._promiseId + 1) % V.MAX_PROMISE_ID;
+    const s = this._promiseId;
     t.then(
-      (s) => {
-        if (e === this._promiseId) {
+      (e) => {
+        if (s === this._promiseId) {
           if (this._captureVersionSnapshot() !== this._asyncStartAggregateVersion) {
-            const n = et();
-            return this._lastDriftEpoch !== n && (this._lastDriftEpoch = n, this._asyncRetryCount = 0), this._asyncRetryCount++ < this._maxAsyncRetries ? this._markDirty() : this._handleError(
-              new f(
+            const i = et();
+            return this._lastDriftEpoch !== i && (this._lastDriftEpoch = i, this._asyncRetryCount = 0), this._asyncRetryCount++ < this._maxAsyncRetries ? this._markDirty() : this._handleError(
+              new I(
                 `Async drift threshold exceeded after ${this._maxAsyncRetries} retries.`
               ),
-              h.COMPUTED_ASYNC_COMPUTATION_FAILED
+              c.COMPUTED_ASYNC_COMPUTATION_FAILED
             );
           }
-          this._finalizeResolution(s), this._notifySubscribers(s, void 0);
+          this._finalizeResolution(e), this._notifySubscribers(e, void 0);
         }
       },
-      (s) => e === this._promiseId && this._handleError(s, h.COMPUTED_ASYNC_COMPUTATION_FAILED)
+      (e) => s === this._promiseId && this._handleError(e, 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 + e[s].node.version | 0;
+    const s = this._links;
+    for (let e = 0, i = s.length; e < i; e++)
+      t = (t << 5) - t + s[e].node.version | 0;
     return t;
   }
-  _handleError(t, e, s = !1) {
-    const n = S(t, f, e);
-    if (!s && !(this.flags & g) && (this.version = M(this.version)), this._error = n, this.flags = this.flags & -121 | g | y, this._onError)
+  _handleError(t, s, e = !1) {
+    const i = S(t, I, s);
+    if (!e && !(this.flags & b) && (this.version = M(this.version)), this._error = i, this.flags = this.flags & -121 | b | A, this._onError)
       try {
-        this._onError(n);
+        this._onError(i);
       } catch (r) {
-        console.error(h.CALLBACK_ERROR_IN_ERROR_HANDLER, r);
+        console.error(c.CALLBACK_ERROR_IN_ERROR_HANDLER, r);
       }
-    if (s) throw n;
+    if (e) throw i;
     this._notifySubscribers(void 0, void 0);
   }
   _finalizeResolution(t) {
@@ -631,110 +690,144 @@ class It extends Z {
   }
   /** @internal */
   _markDirty() {
-    this.flags & (C | p) || (this.flags |= p, this._notifySubscribers(void 0, void 0));
+    this.flags & (D | p) || (this.flags |= p, this._notifySubscribers(void 0, void 0));
   }
 }
-function At(i, t = {}) {
-  return new It(i, t);
+function At(n, t = {}) {
+  return new St(n, t);
 }
-var j;
-class St extends J {
-  constructor(t, e = {}) {
-    super(), this[j] = !0, this._cleanup = null, this._links = c, this._nextLinks = null, this._prevLinks = c, 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 ?? d.MAX_EXECUTIONS_PER_SECOND, this._maxExecutionsPerFlush = e.maxExecutionsPerFlush ?? d.MAX_EXECUTIONS_PER_EFFECT, this._sync ? (this._executeTask = void 0, this._notifyCallback = () => this.execute()) : (this._executeTask = () => this.execute(), this._notifyCallback = () => T.schedule(this._executeTask)), F.attachDebugInfo(this, "effect", this.id);
+var K;
+class kt extends J {
+  constructor(t, s = {}) {
+    super(), this[K] = !0, this._cleanup = null, this._links = u, this._nextLinks = null, this._prevLinks = u, this._currentEpoch = g.UNINITIALIZED, this._lastFlushEpoch = g.UNINITIALIZED, this._executionsInEpoch = 0, this._executionCount = 0, this._windowStart = 0, this._windowCount = 0, this._execId = 0, this._trackCount = 0, this._fn = t, this._onError = s.onError ?? null, this._sync = s.sync ?? !1, this._maxExecutions = s.maxExecutionsPerSecond ?? d.MAX_EXECUTIONS_PER_SECOND, this._maxExecutionsPerFlush = s.maxExecutionsPerFlush ?? d.MAX_EXECUTIONS_PER_EFFECT, this._sync ? this._notifyCallback = () => this.execute() : this._notifyCallback = () => T.schedule(this), B.attachDebugInfo(this, "effect", this.id);
   }
   run() {
-    if (this.flags & u.DISPOSED)
-      throw new I(h.EFFECT_DISPOSED);
+    if (this.flags & _.DISPOSED)
+      throw new C(c.EFFECT_DISPOSED);
     this.execute(!0);
   }
   dispose() {
-    this.flags & u.DISPOSED || (this.flags |= u.DISPOSED, this._execCleanup(), this._unsubLinks(this._links), this._links !== c && l.release(this._links), this._links = c, this._prevLinks = c);
+    this.flags & _.DISPOSED || (this.flags |= _.DISPOSED, this._execCleanup(), this._unsubLinks(this._links), this._links !== u && f.release(this._links), this._links = u, this._prevLinks = u);
   }
-  [(j = it, Symbol.dispose)]() {
+  [(K = nt, Symbol.dispose)]() {
     this.dispose();
   }
   addDependency(t) {
-    if (!(this.flags & u.EXECUTING)) return;
-    const e = this._currentEpoch;
-    if (t._lastSeenEpoch === e) return;
-    t._lastSeenEpoch = e;
-    const s = this._nextLinks, n = this._prevLinks, r = n.findIndex((o) => o && o.node === t && o.unsub);
-    if (r !== -1) {
-      const o = n[r];
-      o.version = t.version, s.push(o), n[r] = null;
+    if (!(this.flags & _.EXECUTING)) return;
+    const s = this._currentEpoch;
+    if (t._lastSeenEpoch === s) return;
+    t._lastSeenEpoch = s;
+    const e = this._prevLinks;
+    if (this._nextLinks === e && this._trackCount < e.length && e[this._trackCount].node === t) {
+      e[this._trackCount].version = t.version, this._trackCount++;
       return;
     }
-    try {
-      const o = t.subscribe(this._notifyCallback);
-      s.push(new v(t, t.version, o));
-    } catch (o) {
-      const O = S(o, I, h.EFFECT_EXECUTION_FAILED);
-      if (console.error(O), this._onError)
-        try {
-          this._onError(O);
-        } catch {
-        }
-      s.push(new v(t, t.version, void 0));
+    if (this._nextLinks === e) {
+      const h = f.acquire();
+      for (let o = 0; o < this._trackCount; o++)
+        h[o] = e[o];
+      this._nextLinks = h;
+    }
+    const i = this._nextLinks;
+    let r = -1;
+    for (let h = this._trackCount; h < e.length; h++) {
+      const o = e[h];
+      if (o && o.node === t && o.unsub) {
+        r = h;
+        break;
+      }
     }
+    if (r !== -1) {
+      const h = e[r];
+      h.version = t.version, i[this._trackCount] = h, e[r] = null;
+    } else
+      try {
+        const h = t.subscribe(this._notifyCallback);
+        i[this._trackCount] = new y(t, t.version, h);
+      } catch (h) {
+        const o = S(h, C, c.EFFECT_EXECUTION_FAILED);
+        if (console.error(o), this._onError)
+          try {
+            this._onError(o);
+          } catch {
+          }
+        i[this._trackCount] = new y(t, t.version, void 0);
+      }
+    this._trackCount++;
   }
   /**
    * Executes effect with tracking.
    */
   execute(t = !1) {
-    if (this.flags & (u.DISPOSED | u.EXECUTING) || !t && this._links.length > 0 && !this._isDirty()) return;
-    this._checkInfiniteLoops(), this.flags |= u.EXECUTING, this._execCleanup(), this._prevLinks = this._links;
-    const e = l.acquire();
-    this._nextLinks = e, this._currentEpoch = w();
+    if (this.flags & (_.DISPOSED | _.EXECUTING) || !t && this._links.length > 0 && !this._isDirty()) return;
+    this._checkInfiniteLoops(), this.flags |= _.EXECUTING, this._execCleanup(), this._prevLinks = this._links, this._nextLinks = this._links, this._currentEpoch = w(), this._trackCount = 0;
     let s = !1;
     try {
-      const n = _.run(this, this._fn);
-      this._links = e, s = !0, nt(n) ? this._handleAsyncResult(n) : this._cleanup = typeof n == "function" ? n : null;
-    } catch (n) {
-      this._links = e, s = !0, this._handleExecutionError(n), this._cleanup = null;
+      const e = l.run(this, this._fn);
+      if (this._nextLinks === this._prevLinks)
+        if (this._trackCount === this._prevLinks.length)
+          s = !0;
+        else {
+          for (let i = this._trackCount; i < this._prevLinks.length; i++)
+            this._prevLinks[i]?.unsub?.();
+          this._prevLinks.length = this._trackCount, s = !0;
+        }
+      else
+        this._nextLinks.length = this._trackCount, s = !0;
+      this._links = this._nextLinks, rt(e) ? this._handleAsyncResult(e) : this._cleanup = typeof e == "function" ? e : null;
+    } catch (e) {
+      if (!s)
+        if (this._nextLinks === this._prevLinks) {
+          for (let i = this._trackCount; i < this._prevLinks.length; i++)
+            this._prevLinks[i]?.unsub?.();
+          this._prevLinks.length = this._trackCount, s = !0;
+        } else
+          this._nextLinks.length = this._trackCount, s = !0;
+      this._links = this._nextLinks, this._handleExecutionError(e), this._cleanup = null;
     } finally {
-      this._finalizeDependencies(s, this._prevLinks, e), this.flags &= -9;
+      this._finalizeDependencies(s, this._prevLinks, this._nextLinks), this.flags &= -9;
     }
   }
   _handleAsyncResult(t) {
-    const e = ++this._execId;
+    const s = ++this._execId;
     t.then(
-      (s) => {
-        if (e !== this._execId || this.flags & u.DISPOSED) {
-          if (typeof s == "function")
+      (e) => {
+        if (s !== this._execId || this.flags & _.DISPOSED) {
+          if (typeof e == "function")
             try {
-              s();
-            } catch (n) {
-              this._handleExecutionError(n, h.EFFECT_CLEANUP_FAILED);
+              e();
+            } catch (i) {
+              this._handleExecutionError(i, c.EFFECT_CLEANUP_FAILED);
             }
           return;
         }
-        typeof s == "function" && (this._cleanup = s);
+        typeof e == "function" && (this._cleanup = e);
       },
-      (s) => e === this._execId && this._handleExecutionError(s)
+      (e) => s === this._execId && this._handleExecutionError(e)
     );
   }
-  _finalizeDependencies(t, e, s) {
-    this._nextLinks = null, this._prevLinks = c, t ? (e.forEach((n) => n?.unsub?.()), e !== c && l.release(e)) : (this._unsubLinks(s), l.release(s));
+  _finalizeDependencies(t, s, e) {
+    this._nextLinks = null, this._prevLinks = u, t ? e !== s && s !== u && (s.forEach((i) => i?.unsub?.()), f.release(s)) : e !== s && e !== u && e && (this._unsubLinks(e), f.release(e));
   }
   _unsubLinks(t) {
-    t.forEach((e) => e?.unsub?.());
+    t.forEach((s) => s?.unsub?.());
   }
   _isDirty() {
-    const t = this._links, e = _.current;
-    _.current = null;
+    const t = this._links, s = l.current;
+    l.current = null;
     try {
-      return t.some((s) => {
-        const n = s.node;
-        if (n.flags & $.IS_COMPUTED)
+      return t.some((e) => {
+        const i = e.node;
+        if (i.flags & W.IS_COMPUTED)
           try {
-            n.value;
+            i.value;
           } catch {
             return !0;
           }
-        return n.version !== s.version;
+        return i.version !== e.version;
       });
     } finally {
-      _.current = e;
+      l.current = s;
     }
   }
   _execCleanup() {
@@ -742,77 +835,73 @@ class St extends J {
       try {
         this._cleanup();
       } catch (t) {
-        this._handleExecutionError(t, h.EFFECT_CLEANUP_FAILED);
+        this._handleExecutionError(t, c.EFFECT_CLEANUP_FAILED);
       }
       this._cleanup = null;
     }
   }
   _checkInfiniteLoops() {
     const t = et();
-    this._lastFlushEpoch !== t && (this._lastFlushEpoch = t, this._executionsInEpoch = 0), ++this._executionsInEpoch > this._maxExecutionsPerFlush && this._throwInfiniteLoopError("per-effect"), at() > d.MAX_EXECUTIONS_PER_FLUSH && this._throwInfiniteLoopError("global"), this._executionCount++;
+    this._lastFlushEpoch !== t && (this._lastFlushEpoch = t, this._executionsInEpoch = 0), ++this._executionsInEpoch > this._maxExecutionsPerFlush && this._throwInfiniteLoopError("per-effect"), ft() > d.MAX_EXECUTIONS_PER_FLUSH && this._throwInfiniteLoopError("global"), this._executionCount++;
   }
   get isDisposed() {
-    return (this.flags & u.DISPOSED) !== 0;
+    return (this.flags & _.DISPOSED) !== 0;
   }
   get executionCount() {
     return this._executionCount;
   }
   get isExecuting() {
-    return (this.flags & u.EXECUTING) !== 0;
+    return (this.flags & _.EXECUTING) !== 0;
   }
   _throwInfiniteLoopError(t) {
-    const e = new I(
-      `Infinite loop detected (${t}): effect executed ${this._executionsInEpoch} times in current flush. Total executions in flush: ${B}`
+    const s = new C(
+      `Infinite loop detected (${t}): effect executed ${this._executionsInEpoch} times in current flush. Total executions in flush: ${z}`
     );
-    throw this.dispose(), console.error(e), e;
+    throw this.dispose(), console.error(s), s;
   }
-  _handleExecutionError(t, e = h.EFFECT_EXECUTION_FAILED) {
-    const s = S(t, I, e);
-    if (console.error(s), this._onError)
+  _handleExecutionError(t, s = c.EFFECT_EXECUTION_FAILED) {
+    const e = S(t, C, s);
+    if (console.error(e), this._onError)
       try {
-        this._onError(s);
-      } catch (n) {
-        console.error(S(n, I, h.CALLBACK_ERROR_IN_ERROR_HANDLER));
+        this._onError(e);
+      } catch (i) {
+        console.error(S(i, C, c.CALLBACK_ERROR_IN_ERROR_HANDLER));
       }
   }
 }
-function yt(i, t = {}) {
-  if (typeof i != "function")
-    throw new I(h.EFFECT_MUST_BE_FUNCTION);
-  const e = new St(i, t);
-  return e.execute(), e;
+function Ot(n, t = {}) {
+  if (typeof n != "function")
+    throw new C(c.EFFECT_MUST_BE_FUNCTION);
+  const s = new kt(n, t);
+  return s.execute(), s;
 }
-function Nt(i) {
-  if (typeof i != "function")
-    throw new TypeError("Batch callback must be a function");
+function yt(n) {
+  if (typeof n != "function")
+    throw new TypeError(c.BATCH_CALLBACK_MUST_BE_FUNCTION);
   T.startBatch();
   try {
-    return i();
+    return n();
   } finally {
     T.endBatch();
   }
 }
 export {
-  z as ATOM_BRAND,
-  b as AsyncState,
-  D as AtomError,
-  st as COMPUTED_BRAND,
-  f as ComputedError,
-  rt as DEBUG_CONFIG,
-  F as DEBUG_RUNTIME,
-  it as EFFECT_BRAND,
-  I as EffectError,
-  Dt as POOL_CONFIG,
+  N as AsyncState,
+  k as AtomError,
+  I as ComputedError,
+  ht as DEBUG_CONFIG,
+  B as DEBUG_RUNTIME,
+  C as EffectError,
   d as SCHEDULER_CONFIG,
   m as SchedulerError,
-  gt as atom,
-  Nt as batch,
+  bt as atom,
+  yt as batch,
   At as computed,
-  yt as effect,
+  Ot as effect,
   Tt as isAtom,
-  Ot as isComputed,
-  bt as isEffect,
+  Nt as isComputed,
+  Lt as isEffect,
   T as scheduler,
-  Ct as untracked
+  Dt as untracked
 };
 //# sourceMappingURL=index.mjs.map