@but212/atom-effect 0.15.1 → 0.15.3

package/dist/index.mjs

@@ -31,7 +31,7 @@ const ne = {
   MAX_SIZE: 1e3,
   /** Number of objects to pre-allocate for performance-critical paths */
   WARMUP_SIZE: 100
-}, T = {
+}, R = {
   /** Maximum effect executions per second to detect infinite loops (Legacy/Fallback) */
   MAX_EXECUTIONS_PER_SECOND: 1e3,
   /** Threshold for cleaning up old execution timestamps */
@@ -58,7 +58,7 @@ const ne = {
   /** Enable infinite loop detection warnings */
   WARN_INFINITE_LOOP: !0
 }, A = 1073741823, E = typeof process < "u" && process.env && process.env.NODE_ENV !== "production", re = Object.freeze([]);
-class C extends Error {
+class N extends Error {
   /**
    * Creates a new AtomError
    * @param message - Error message describing what went wrong
@@ -69,7 +69,7 @@ class C extends Error {
     super(e), this.name = "AtomError", this.cause = t, this.recoverable = s, this.timestamp = /* @__PURE__ */ new Date();
   }
 }
-class R extends C {
+class D extends N {
   /**
    * Creates a new ComputedError
    * @param message - Error message
@@ -79,7 +79,7 @@ class R extends C {
     super(e, t, !0), this.name = "ComputedError";
   }
 }
-class y extends C {
+class y extends N {
   /**
    * Creates a new EffectError
    * @param message - Error message
@@ -89,7 +89,7 @@ class y extends C {
     super(e, t, !1), this.name = "EffectError";
   }
 }
-class P extends C {
+class P extends N {
   /**
    * Creates a new SchedulerError
    * @param message - Error message
@@ -131,6 +131,10 @@ const l = {
    * Error thrown when subscribing to a dependency fails.
    */
   COMPUTED_DEPENDENCY_SUBSCRIPTION_FAILED: "Failed to subscribe to dependency",
+  /**
+   * Error thrown when accessing a disposed computed value.
+   */
+  COMPUTED_DISPOSED: "Cannot access a disposed computed",
   // ─────────────────────────────────────────────────────────────────
   // Atom errors
   // ─────────────────────────────────────────────────────────────────
@@ -199,7 +203,7 @@ let q = 0;
 function K(i, e, t) {
   if (i._visitedEpoch !== t) {
     if (i._visitedEpoch = t, i === e)
-      throw new R("Indirect circular dependency detected");
+      throw new D("Indirect circular dependency detected");
     if (ce(i)) {
       const s = i.dependencies;
       for (let n = 0; n < s.length; n++) {
@@ -223,7 +227,7 @@ const I = {
    */
   checkCircular(i, e) {
     if (i === e)
-      throw new R("Direct circular dependency detected");
+      throw new D("Direct circular dependency detected");
     this.enabled && (q++, K(i, e, q));
   },
   attachDebugInfo(i, e, t) {
@@ -267,7 +271,7 @@ class Z extends W {
       );
     if (e !== null && typeof e == "object" && "execute" in e)
       return this._addSubscriber(this._objSubs, e, g.HAS_OBJ_SUBS);
-    throw new C(l.ATOM_SUBSCRIBER_MUST_BE_FUNCTION);
+    throw new N(l.ATOM_SUBSCRIBER_MUST_BE_FUNCTION);
   }
   /**
    * Gets the total number of active subscribers.
@@ -312,7 +316,7 @@ class Z extends W {
               h(e, t);
             } catch (_) {
               console.error(
-                new C(l.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED, _)
+                new N(l.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED, _)
               );
             }
         }
@@ -326,7 +330,7 @@ class Z extends W {
               h.execute();
             } catch (_) {
               console.error(
-                new C(l.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED, _)
+                new N(l.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED, _)
               );
             }
         }
@@ -397,8 +401,8 @@ class z {
     E && e && (e.acquired = 0, e.released = 0, e.rejected.frozen = 0, e.rejected.tooLarge = 0, e.rejected.poolFull = 0);
   }
 }
-const d = Object.freeze([]), O = Object.freeze([]), p = Object.freeze([]), x = new z(), U = new z(), D = new z();
-function N(i, e, t, s) {
+const d = Object.freeze([]), O = Object.freeze([]), p = Object.freeze([]), x = new z(), U = new z(), C = new z();
+function T(i, e, t, s) {
   if (e != null) {
     if ((typeof e == "object" || typeof e == "function") && typeof e.addDependency == "function") {
       e.addDependency(i);
@@ -458,18 +462,24 @@ function fe() {
 }
 class Ee {
   constructor() {
-    this._queueBuffer = [[], []], this._bufferIndex = 0, this._size = 0, this._epoch = 0, this.isProcessing = !1, this.isBatching = !1, this.batchDepth = 0, this.batchQueue = [], this.batchQueueSize = 0, this.isFlushingSync = !1, this.maxFlushIterations = T.MAX_FLUSH_ITERATIONS;
+    this._queueBuffer = [[], []], this._bufferIndex = 0, this._size = 0, this._epoch = 0, this.isProcessing = !1, this._isBatching = !1, this.batchDepth = 0, this.batchQueue = [], this.batchQueueSize = 0, this.isFlushingSync = !1, this.maxFlushIterations = R.MAX_FLUSH_ITERATIONS;
   }
   /**
    * Returns the current operational phase of the scheduler.
    */
   get phase() {
-    return this.isProcessing || this.isFlushingSync ? 2 : this.isBatching ? 1 : 0;
+    return this.isProcessing || this.isFlushingSync ? 2 : this._isBatching ? 1 : 0;
   }
   /** Current number of pending jobs. */
   get queueSize() {
     return this._size;
   }
+  /**
+   * Returns whether the scheduler is currently batching updates.
+   */
+  get isBatching() {
+    return this._isBatching;
+  }
   /**
    * Schedules a task for execution.
    */
@@ -478,7 +488,7 @@ class Ee {
       throw new P("Scheduler callback must be a function");
     const t = this._epoch;
     if (e._nextEpoch !== t) {
-      if (e._nextEpoch = t, this.isBatching || this.isFlushingSync) {
+      if (e._nextEpoch = t, this._isBatching || this.isFlushingSync) {
         this.batchQueue[this.batchQueueSize++] = e;
         return;
       }
@@ -496,7 +506,7 @@ class Ee {
         const e = J();
         this._drainQueue(), e && $();
       } finally {
-        this.isProcessing = !1, this._size > 0 && !this.isBatching && this.flush();
+        this.isProcessing = !1, this._size > 0 && !this._isBatching && this.flush();
       }
     }));
   }
@@ -526,7 +536,7 @@ class Ee {
       const c = s[o];
       c._nextEpoch !== t && (c._nextEpoch = t, n[r++] = c);
     }
-    this._size = r, this.batchQueueSize = 0, s.length > T.BATCH_QUEUE_SHRINK_THRESHOLD && (s.length = 0);
+    this._size = r, this.batchQueueSize = 0, s.length > R.BATCH_QUEUE_SHRINK_THRESHOLD && (s.length = 0);
   }
   _drainQueue() {
     let e = 0;
@@ -562,19 +572,19 @@ class Ee {
     e.length = 0;
   }
   startBatch() {
-    this.batchDepth++, this.isBatching = !0;
+    this.batchDepth++, this._isBatching = !0;
   }
   endBatch() {
     if (this.batchDepth === 0) {
       E && console.warn("endBatch() called without matching startBatch(). Ignoring.");
       return;
     }
-    this.batchDepth--, this.batchDepth === 0 && (this.flushSync(), this.isBatching = !1);
+    this.batchDepth--, this.batchDepth === 0 && (this.flushSync(), this._isBatching = !1);
   }
   setMaxFlushIterations(e) {
-    if (e < T.MIN_FLUSH_ITERATIONS)
+    if (e < R.MIN_FLUSH_ITERATIONS)
       throw new P(
-        `Max flush iterations must be at least ${T.MIN_FLUSH_ITERATIONS}`
+        `Max flush iterations must be at least ${R.MIN_FLUSH_ITERATIONS}`
       );
     this.maxFlushIterations = e;
   }
@@ -610,7 +620,7 @@ class de {
 const f = new de();
 function pe(i) {
   if (typeof i != "function")
-    throw new C("Untracked callback must be a function");
+    throw new N("Untracked callback must be a function");
   const e = f.current;
   f.current = null;
   try {
@@ -628,7 +638,7 @@ class Se extends Z {
    */
   get value() {
     const e = f.current;
-    return e && N(this, e, this._fnSubs, this._objSubs), this._value;
+    return e && T(this, e, this._fnSubs, this._objSubs), this._value;
   }
   /**
    * Sets a new value and schedules notifications if the value has changed.
@@ -683,7 +693,7 @@ function m(i, e, t) {
     return new e(`Type error (${t}): ${i.message}`, i);
   if (i instanceof ReferenceError)
     return new e(`Reference error (${t}): ${i.message}`, i);
-  if (i instanceof C)
+  if (i instanceof N)
     return i;
   const s = i instanceof Error ? i.message : String(i), n = i instanceof Error ? i : null;
   return new e(`Unexpected error (${t}): ${s}`, n);
@@ -699,16 +709,16 @@ function Ne(i) {
   }
   return ge(i) && "invalidate" in i && typeof i.invalidate == "function";
 }
-function Re(i) {
+function Te(i) {
   return i !== null && typeof i == "object" && "dispose" in i && "run" in i && typeof i.dispose == "function" && typeof i.run == "function";
 }
 function te(i) {
   return i != null && typeof i.then == "function";
 }
-const se = u.RESOLVED | u.PENDING | u.REJECTED, V = Array(se + 1).fill(M.IDLE);
-V[u.RESOLVED] = M.RESOLVED;
-V[u.PENDING] = M.PENDING;
-V[u.REJECTED] = M.REJECTED;
+const se = u.RESOLVED | u.PENDING | u.REJECTED, B = Array(se + 1).fill(M.IDLE);
+B[u.RESOLVED] = M.RESOLVED;
+B[u.PENDING] = M.PENDING;
+B[u.REJECTED] = M.REJECTED;
 class be {
   constructor(e) {
     this._owner = e, this._epoch = -1, this._nextDeps = d, this._nextVersions = p, this._depCount = 0;
@@ -730,7 +740,7 @@ class be {
 class ie extends Z {
   constructor(e, t = {}) {
     if (typeof e != "function")
-      throw new R(l.COMPUTED_MUST_BE_FUNCTION);
+      throw new D(l.COMPUTED_MUST_BE_FUNCTION);
     if (super(), this.MAX_ASYNC_RETRIES = 3, this._value = void 0, this.flags = u.DIRTY | u.IDLE, this._error = null, this._promiseId = 0, this._equal = t.equal ?? Object.is, this._fn = e, this._defaultValue = "defaultValue" in t ? t.defaultValue : Y, this._hasDefaultValue = this._defaultValue !== Y, this._onError = t.onError ?? null, this.MAX_PROMISE_ID = Number.MAX_SAFE_INTEGER - 1, this._fnSubs = [], this._objSubs = [], this._dependencies = d, this._dependencyVersions = p, this._unsubscribes = O, this._cachedErrors = null, this._errorCacheEpoch = -1, this._asyncStartAggregateVersion = 0, this._asyncRetryCount = 0, this._trackable = new be(this), I.attachDebugInfo(this, "computed", this.id), I.enabled) {
       const s = this;
       s.subscriberCount = this.subscriberCount.bind(this), s.isDirty = () => (this.flags & u.DIRTY) !== 0, s.dependencies = this._dependencies, s.stateFlags = "";
@@ -743,11 +753,13 @@ class ie extends Z {
   }
   get value() {
     const e = f.current;
-    e && N(this, e, this._fnSubs, this._objSubs);
+    e && T(this, e, this._fnSubs, this._objSubs);
     const t = this.flags;
+    if (t & u.DISPOSED)
+      throw new D(l.COMPUTED_DISPOSED);
     if (t & u.RECOMPUTING) {
       if (this._hasDefaultValue) return this._defaultValue;
-      throw new R(l.COMPUTED_CIRCULAR_DEPENDENCY);
+      throw new D(l.COMPUTED_CIRCULAR_DEPENDENCY);
     }
     t & (u.DIRTY | u.IDLE) && this._recompute();
     const s = this.flags;
@@ -758,11 +770,11 @@ class ie extends Z {
   }
   get state() {
     const e = f.current;
-    return e && N(this, e, this._fnSubs, this._objSubs), V[this.flags & se];
+    return e && T(this, e, this._fnSubs, this._objSubs), B[this.flags & se];
   }
   get hasError() {
     const e = f.current;
-    if (e && N(this, e, this._fnSubs, this._objSubs), this.flags & (u.REJECTED | u.HAS_ERROR)) return !0;
+    if (e && T(this, e, this._fnSubs, this._objSubs), this.flags & (u.REJECTED | u.HAS_ERROR)) return !0;
     const s = this._dependencies;
     for (let n = 0, r = s.length; n < r; n++) {
       const o = s[n];
@@ -775,7 +787,7 @@ class ie extends Z {
   }
   get errors() {
     const e = f.current;
-    if (e && N(this, e, this._fnSubs, this._objSubs), !this.hasError) return re;
+    if (e && T(this, e, this._fnSubs, this._objSubs), !this.hasError) return re;
     const t = ae();
     if (this._errorCacheEpoch === t && this._cachedErrors !== null)
       return this._cachedErrors;
@@ -786,7 +798,7 @@ class ie extends Z {
       const h = n[o];
       if (h && "errors" in h) {
         const _ = h.errors;
-        for (let a = 0, B = _.length; a < B; a++) {
+        for (let a = 0, V = _.length; a < V; a++) {
           const X = _[a];
           X && s.add(X);
         }
@@ -797,20 +809,20 @@ class ie extends Z {
   }
   get lastError() {
     const e = f.current;
-    return e && N(this, e, this._fnSubs, this._objSubs), this._error;
+    return e && T(this, e, this._fnSubs, this._objSubs), this._error;
   }
   get isPending() {
     const e = f.current;
-    return e && N(this, e, this._fnSubs, this._objSubs), (this.flags & u.PENDING) !== 0;
+    return e && T(this, e, this._fnSubs, this._objSubs), (this.flags & u.PENDING) !== 0;
   }
   get isResolved() {
     const e = f.current;
-    return e && N(this, e, this._fnSubs, this._objSubs), (this.flags & u.RESOLVED) !== 0;
+    return e && T(this, e, this._fnSubs, this._objSubs), (this.flags & u.RESOLVED) !== 0;
   }
   invalidate() {
     this._markDirty();
     const e = this._dependencyVersions;
-    e !== p && (D.release(e), this._dependencyVersions = p), this._errorCacheEpoch = -1, this._cachedErrors = null;
+    e !== p && (C.release(e), this._dependencyVersions = p), this._errorCacheEpoch = -1, this._cachedErrors = null;
   }
   dispose() {
     const e = this._unsubscribes;
@@ -824,7 +836,7 @@ class ie extends Z {
     const t = this._dependencies;
     t !== d && (x.release(t), this._dependencies = d);
     const s = this._dependencyVersions;
-    s !== p && (D.release(s), this._dependencyVersions = p), this._fnSubs = [], this._objSubs = [], this.flags = u.DISPOSED | u.DIRTY | u.IDLE, this._error = null, this._value = void 0, this._promiseId = (this._promiseId + 1) % this.MAX_PROMISE_ID, this._cachedErrors = null, this._errorCacheEpoch = -1;
+    s !== p && (C.release(s), this._dependencyVersions = p), this._fnSubs = [], this._objSubs = [], this.flags = u.DISPOSED | u.DIRTY | u.IDLE, this._error = null, this._value = void 0, this._promiseId = (this._promiseId + 1) % this.MAX_PROMISE_ID, this._cachedErrors = null, this._errorCacheEpoch = -1;
   }
   _clearDirty() {
     this.flags &= -9;
@@ -853,7 +865,7 @@ class ie extends Z {
       return;
     this._setRecomputing(!0);
     const e = this._trackable, t = this._dependencies, s = this._dependencyVersions;
-    e._epoch = ee(), e._nextDeps = x.acquire(), e._nextVersions = D.acquire(), e._depCount = 0;
+    e._epoch = ee(), e._nextDeps = x.acquire(), e._nextVersions = C.acquire(), e._depCount = 0;
     let n = !1;
     try {
       const r = f.run(e, this._fn), o = e._nextDeps, c = e._nextVersions, h = e._depCount;
@@ -869,7 +881,7 @@ class ie extends Z {
         }
       this._handleComputationError(o);
     } finally {
-      n ? (t !== d && x.release(t), s !== p && D.release(s)) : (x.release(e._nextDeps), D.release(e._nextVersions)), e.reset(), this._setRecomputing(!1);
+      n ? (t !== d && x.release(t), s !== p && C.release(s)) : (x.release(e._nextDeps), C.release(e._nextVersions)), e.reset(), this._setRecomputing(!1);
     }
   }
   _handleAsyncComputation(e) {
@@ -882,7 +894,7 @@ class ie extends Z {
           this._asyncRetryCount++, this._markDirty();
           return;
         }
-        const o = new R(
+        const o = new D(
           `Async drift exceeded threshold after ${this.MAX_ASYNC_RETRIES} retries.`
         );
         this._handleAsyncRejection(o);
@@ -906,7 +918,7 @@ class ie extends Z {
     return e;
   }
   _handleAsyncRejection(e) {
-    const t = m(e, R, l.COMPUTED_ASYNC_COMPUTATION_FAILED);
+    const t = m(e, D, l.COMPUTED_ASYNC_COMPUTATION_FAILED);
     this.flags & u.REJECTED || (this.version = this.version + 1 & A), this._error = t, this._setRejected(), this._clearDirty();
     const s = this._onError;
     if (s)
@@ -921,7 +933,7 @@ class ie extends Z {
     (!(this.flags & u.RESOLVED) || !this._equal(this._value, e)) && (this.version = this.version + 1 & A), this._value = e, this._clearDirty(), this._setResolved(), this._error = null, this._setRecomputing(!1), this._cachedErrors = null, this._errorCacheEpoch = -1;
   }
   _handleComputationError(e) {
-    const t = m(e, R, l.COMPUTED_COMPUTATION_FAILED);
+    const t = m(e, D, l.COMPUTED_COMPUTATION_FAILED);
     this._error = t, this._setRejected(), this._clearDirty(), this._setRecomputing(!1);
     const s = this._onError;
     if (s)
@@ -935,7 +947,7 @@ class ie extends Z {
   _handlePending() {
     if (this._hasDefaultValue)
       return this._defaultValue;
-    throw new R(l.COMPUTED_ASYNC_PENDING_NO_DEFAULT);
+    throw new D(l.COMPUTED_ASYNC_PENDING_NO_DEFAULT);
   }
   _handleRejected() {
     const e = this._error;
@@ -953,13 +965,13 @@ class ie extends Z {
   }
 }
 Object.freeze(ie.prototype);
-function Te(i, e = {}) {
+function Re(i, e = {}) {
   return new ie(i, e);
 }
 class Ie extends W {
   constructor(e, t = {}) {
-    super(), this._cleanup = null, this._dependencies = d, this._dependencyVersions = p, this._unsubscribes = O, this._nextDeps = null, this._nextVersions = null, this._nextUnsubs = null, this._executeTask = void 0, this._onError = t.onError ?? null, this._currentEpoch = -1, this._lastFlushEpoch = -1, this._executionsInEpoch = 0, this._fn = e, this._sync = t.sync ?? !1, this._maxExecutions = t.maxExecutionsPerSecond ?? T.MAX_EXECUTIONS_PER_SECOND, this._maxExecutionsPerFlush = t.maxExecutionsPerFlush ?? T.MAX_EXECUTIONS_PER_EFFECT, this._trackModifications = t.trackModifications ?? !1, this._executionCount = 0, this._historyPtr = 0;
-    const s = Number.isFinite(this._maxExecutions), n = s ? Math.min(this._maxExecutions + 1, T.MAX_EXECUTIONS_PER_SECOND + 1) : 0;
+    super(), this._cleanup = null, this._dependencies = d, this._dependencyVersions = p, this._unsubscribes = O, this._nextDeps = null, this._nextVersions = null, this._nextUnsubs = null, this._executeTask = void 0, this._onError = t.onError ?? null, this._currentEpoch = -1, this._lastFlushEpoch = -1, this._executionsInEpoch = 0, this._fn = e, this._sync = t.sync ?? !1, this._maxExecutions = t.maxExecutionsPerSecond ?? R.MAX_EXECUTIONS_PER_SECOND, this._maxExecutionsPerFlush = t.maxExecutionsPerFlush ?? R.MAX_EXECUTIONS_PER_EFFECT, this._trackModifications = t.trackModifications ?? !1, this._executionCount = 0, this._historyPtr = 0;
+    const s = Number.isFinite(this._maxExecutions), n = s ? Math.min(this._maxExecutions + 1, R.MAX_EXECUTIONS_PER_SECOND + 1) : 0;
     this._historyCapacity = n, this._history = E && s && n > 0 ? new Array(n).fill(0) : null, this._execId = 0, I.attachDebugInfo(this, "effect", this.id);
   }
   run() {
@@ -982,7 +994,7 @@ class Ie extends W {
     const s = this._dependencies;
     s !== d && (x.release(s), this._dependencies = d);
     const n = this._dependencyVersions;
-    n !== p && (D.release(n), this._dependencyVersions = p), this._executeTask = void 0;
+    n !== p && (C.release(n), this._dependencyVersions = p), this._executeTask = void 0;
   }
   addDependency(e) {
     if (!(this.flags & S.EXECUTING)) return;
@@ -1010,8 +1022,8 @@ class Ie extends W {
           if (typeof h == "function")
             try {
               h();
-            } catch (B) {
-              this._handleExecutionError(B, l.EFFECT_CLEANUP_FAILED);
+            } catch (V) {
+              this._handleExecutionError(V, l.EFFECT_CLEANUP_FAILED);
             }
           return;
         }
@@ -1026,7 +1038,7 @@ class Ie extends W {
     }
   }
   _prepareEffectExecutionContext() {
-    const e = this._dependencies, t = this._dependencyVersions, s = this._unsubscribes, n = x.acquire(), r = D.acquire(), o = U.acquire(), c = ee();
+    const e = this._dependencies, t = this._dependencyVersions, s = this._unsubscribes, n = x.acquire(), r = C.acquire(), o = U.acquire(), c = ee();
     if (e !== d)
       for (let h = 0, _ = e.length; h < _; h++) {
         const a = e[h];
@@ -1045,9 +1057,9 @@ class Ie extends W {
         }
         x.release(s);
       }
-      e.prevUnsubs !== O && U.release(e.prevUnsubs), e.prevVersions !== p && D.release(e.prevVersions);
+      e.prevUnsubs !== O && U.release(e.prevUnsubs), e.prevVersions !== p && C.release(e.prevVersions);
     } else {
-      x.release(e.nextDeps), D.release(e.nextVersions);
+      x.release(e.nextDeps), C.release(e.nextVersions);
       const n = e.nextUnsubs;
       for (let r = 0, o = n.length; r < o; r++)
         n[r]?.();
@@ -1102,7 +1114,7 @@ class Ie extends W {
   }
   _checkInfiniteLoop() {
     const e = H;
-    this._lastFlushEpoch !== e && (this._lastFlushEpoch = e, this._executionsInEpoch = 0), ++this._executionsInEpoch > this._maxExecutionsPerFlush && this._throwInfiniteLoopError("per-effect"), fe() > T.MAX_EXECUTIONS_PER_FLUSH && this._throwInfiniteLoopError("global"), this._executionCount++;
+    this._lastFlushEpoch !== e && (this._lastFlushEpoch = e, this._executionsInEpoch = 0), ++this._executionsInEpoch > this._maxExecutionsPerFlush && this._throwInfiniteLoopError("per-effect"), fe() > R.MAX_EXECUTIONS_PER_FLUSH && this._throwInfiniteLoopError("global"), this._executionCount++;
     const s = this._history;
     if (s) {
       const n = Date.now(), r = this._historyPtr, o = this._historyCapacity;
@@ -1175,7 +1187,7 @@ function Oe(i, e = {}) {
 }
 function xe(i) {
   if (typeof i != "function")
-    throw new C("Batch callback must be a function");
+    throw new N("Batch callback must be a function");
   F.startBatch();
   try {
     return i();
@@ -1185,21 +1197,21 @@ function xe(i) {
 }
 export {
   M as AsyncState,
-  C as AtomError,
-  R as ComputedError,
+  N as AtomError,
+  D as ComputedError,
   G as DEBUG_CONFIG,
   I as DEBUG_RUNTIME,
   y as EffectError,
   De as POOL_CONFIG,
-  T as SCHEDULER_CONFIG,
+  R as SCHEDULER_CONFIG,
   P as SchedulerError,
   Ce as atom,
   xe as batch,
-  Te as computed,
+  Re as computed,
   Oe as effect,
   ge as isAtom,
   Ne as isComputed,
-  Re as isEffect,
+  Te as isEffect,
   F as scheduler,
   pe as untracked
 };