@but212/atom-effect-jquery 0.10.0 → 0.11.0

package/dist/index.mjs

@@ -1,14 +1,14 @@
 import u from "jquery";
-import { default as Tt } from "jquery";
-const Ve = {
+import { default as Ot } from "jquery";
+const Be = {
   /** One second in milliseconds */
   ONE_SECOND_MS: 1e3
-}, re = {
+}, ue = {
   IDLE: "idle",
   PENDING: "pending",
   RESOLVED: "resolved",
   REJECTED: "rejected"
-}, W = {
+}, te = {
   DISPOSED: 1,
   // 0001 - Effect has been disposed
   EXECUTING: 2
@@ -28,7 +28,10 @@ const Ve = {
   // 100000 - Currently recomputing
   HAS_ERROR: 64
   // 1000000 - Has error state
-}, L = {
+}, Y = {
+  SYNC: 1,
+  NOTIFICATION_SCHEDULED: 2
+}, z = {
   /** Maximum effect executions per second to detect infinite loops (Legacy/Fallback) */
   MAX_EXECUTIONS_PER_SECOND: 1e3,
   /**
@@ -45,13 +48,13 @@ const Ve = {
   MAX_FLUSH_ITERATIONS: 1e3,
   /** Minimum allowed value for max flush iterations */
   MIN_FLUSH_ITERATIONS: 10
-}, be = {
+}, De = {
   /** Maximum dependencies before warning about large dependency graphs */
   MAX_DEPENDENCIES: 1e3,
   /** Enable infinite loop detection warnings */
   WARN_INFINITE_LOOP: !0
-}, B = 1073741823, x = typeof process < "u" && process.env && process.env.NODE_ENV !== "production", Le = Object.freeze([]);
-class k extends Error {
+}, V = 1073741823, _e = 1 << 19, v = typeof process < "u" && process.env && process.env.NODE_ENV !== "production", qe = Object.freeze([]);
+class w extends Error {
   /**
    * Creates a new AtomError
    * @param message - Error message describing what went wrong
@@ -62,7 +65,7 @@ class k extends Error {
     super(e), this.name = "AtomError", this.cause = s, this.recoverable = n, this.timestamp = /* @__PURE__ */ new Date();
   }
 }
-class z extends k {
+class q extends w {
   /**
    * Creates a new ComputedError
    * @param message - Error message
@@ -72,7 +75,7 @@ class z extends k {
     super(e, s, !0), this.name = "ComputedError";
   }
 }
-class V extends k {
+class B extends w {
   /**
    * Creates a new EffectError
    * @param message - Error message
@@ -82,7 +85,7 @@ class V extends k {
     super(e, s, !1), this.name = "EffectError";
   }
 }
-class Z extends k {
+class se extends w {
   /**
    * Creates a new SchedulerError
    * @param message - Error message
@@ -92,7 +95,7 @@ class Z extends k {
     super(e, s, !1), this.name = "SchedulerError";
   }
 }
-const y = {
+const g = {
   // ─────────────────────────────────────────────────────────────────
   // Computed errors
   // ─────────────────────────────────────────────────────────────────
@@ -144,28 +147,28 @@ const y = {
    * @remarks This prevents cascading failures from masking the original error.
    */
   CALLBACK_ERROR_IN_ERROR_HANDLER: "Error occurred during onError callback execution"
-}, ue = /* @__PURE__ */ Symbol("debugName"), je = /* @__PURE__ */ Symbol("id"), he = /* @__PURE__ */ Symbol("type"), Ee = /* @__PURE__ */ Symbol("noDefaultValue");
-function Be(t) {
+}, fe = /* @__PURE__ */ Symbol("debugName"), ze = /* @__PURE__ */ Symbol("id"), de = /* @__PURE__ */ Symbol("type"), Ie = /* @__PURE__ */ Symbol("noDefaultValue");
+function Qe(t) {
   return "dependencies" in t && Array.isArray(t.dependencies);
 }
-let ge = 0;
-function Ie(t, e, s) {
+let Ce = 0;
+function Re(t, e, s) {
   if (t._visitedEpoch !== s) {
     if (t._visitedEpoch = s, t === e)
-      throw new z("Indirect circular dependency detected");
-    if (Be(t)) {
+      throw new q("Indirect circular dependency detected");
+    if (Qe(t)) {
       const n = t.dependencies;
       for (let i = 0; i < n.length; i++) {
         const r = n[i];
-        r && Ie(r, e, s);
+        r && Re(r, e, s);
       }
     }
   }
 }
-const A = {
+const R = {
   enabled: typeof process < "u" && process.env?.NODE_ENV === "development",
-  maxDependencies: be.MAX_DEPENDENCIES,
-  warnInfiniteLoop: be.WARN_INFINITE_LOOP,
+  maxDependencies: De.MAX_DEPENDENCIES,
+  warnInfiniteLoop: De.WARN_INFINITE_LOOP,
   warn(t, e) {
     this.enabled && t && console.warn(`[Atom Effect] ${e}`);
   },
@@ -176,34 +179,73 @@ const A = {
    */
   checkCircular(t, e) {
     if (t === e)
-      throw new z("Direct circular dependency detected");
-    this.enabled && (ge++, Ie(t, e, ge));
+      throw new q("Direct circular dependency detected");
+    this.enabled && (Ce++, Re(t, e, Ce));
   },
   attachDebugInfo(t, e, s) {
     if (!this.enabled)
       return;
     const n = t;
-    n[ue] = `${e}_${s}`, n[je] = s, n[he] = e;
+    n[fe] = `${e}_${s}`, n[ze] = s, n[de] = e;
   },
   getDebugName(t) {
-    if (t != null && ue in t)
-      return t[ue];
+    if (t != null && fe in t)
+      return t[fe];
   },
   getDebugType(t) {
-    if (t != null && he in t)
-      return t[he];
+    if (t != null && de in t)
+      return t[de];
   }
 };
-let qe = 1;
-const ze = () => qe++;
-class Ce {
+let Xe = 1;
+const Ge = () => Xe++;
+class xe {
   constructor() {
-    this.id = ze() & B, this.flags = 0;
+    this.id = Ge() & V, this.flags = 0, this.version = 0;
+  }
+  /**
+   * Rotates the phase by 1, automatically incrementing cycle on overflow.
+   *
+   * Performance Benefits:
+   * - Branchless: No conditional statements
+   * - O(1): Single bitwise AND operation
+   * - Smi-safe: Result always within 30-bit range (0x3fffffff)
+   *
+   * When Phase reaches 0xfffff (1,048,575), the next increment:
+   * - Overflows into Cycle bits
+   * - Phase resets to 0
+   * - Cycle increments by 1
+   *
+   * @returns The new version after phase rotation
+   */
+  rotatePhase() {
+    return this.version = this.version + 1 & V, this.version;
+  }
+  /**
+   * Calculates the logical distance (shift) between current and cached version.
+   *
+   * Uses modular arithmetic to handle cycle wraparound correctly.
+   * The result represents how many phase rotations have occurred since
+   * the cached version was recorded.
+   *
+   * Performance Benefits:
+   * - Branchless: Single subtraction with mask
+   * - Handles wraparound: Works correctly even when version overflows
+   *
+   * Use Cases:
+   * - Scheduler priority: Large shifts indicate stale updates
+   * - Dependency staleness: Detect how outdated a cached value is
+   *
+   * @param cachedVersion - The previously cached version to compare against
+   * @returns Non-negative shift distance (0 to 0x3fffffff)
+   */
+  getShift(e) {
+    return this.version - e & V;
   }
 }
-class ve extends Ce {
+class Ue extends xe {
   constructor() {
-    super(), this.version = 0, this._lastSeenEpoch = -1;
+    super(), this._lastSeenEpoch = -1;
   }
   /**
    * Subscribes a listener function or Subscriber object to value changes.
@@ -216,7 +258,7 @@ class ve extends Ce {
     if (typeof e == "object" && e !== null && "execute" in e)
       return this._objectSubscribers.add(e);
     if (typeof e != "function")
-      throw new k(y.ATOM_SUBSCRIBER_MUST_BE_FUNCTION);
+      throw new w(g.ATOM_SUBSCRIBER_MUST_BE_FUNCTION);
     return this._functionSubscribers.add(e);
   }
   /**
@@ -234,68 +276,98 @@ class ve extends Ce {
   _notifySubscribers(e, s) {
     this._functionSubscribers.forEachSafe(
       (n) => n(e, s),
-      (n) => console.error(new k(y.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED, n))
+      (n) => console.error(new w(g.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED, n))
     ), this._objectSubscribers.forEachSafe(
       (n) => n.execute(),
-      (n) => console.error(new k(y.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED, n))
+      (n) => console.error(new w(g.ATOM_INDIVIDUAL_SUBSCRIBER_FAILED, n))
     );
   }
 }
-let ee = 0;
-function Ne() {
-  return ee = ee + 1 & B || 1, ee;
+let ne = 0;
+function Oe() {
+  return ne = ne + 1 & V || 1, ne;
 }
-function Xe() {
-  return ee;
+function He() {
+  return ne;
 }
-let se = 0, le = 0, ne = !1;
-function me() {
-  return ne ? (x && console.warn(
+let re = 0, be = 0, oe = !1;
+function ve() {
+  return oe ? (v && console.warn(
     "Warning: startFlush() called during flush - ignored to prevent infinite loop detection bypass"
-  ), !1) : (ne = !0, se = se + 1 & B, le = 0, !0);
+  ), !1) : (oe = !0, re = re + 1 & V, be = 0, !0);
 }
-function ye() {
-  ne = !1;
+function Te() {
+  oe = !1;
 }
-function Ge() {
-  return ne ? ++le : 0;
+function Ye() {
+  return oe ? ++be : 0;
 }
-class Qe {
+class Je {
   constructor() {
-    this.queueA = [], this.queueB = [], this.queue = this.queueA, this.queueSize = 0, this._epoch = 0, this.isProcessing = !1, this.isBatching = !1, this.batchDepth = 0, this.batchQueue = [], this.batchQueueSize = 0, this.isFlushingSync = !1, this.maxFlushIterations = L.MAX_FLUSH_ITERATIONS;
+    this.queueA = [], this.queueB = [], this.queue = this.queueA, this.queueSize = 0, this.urgentQueueA = [], this.urgentQueueB = [], this.urgentQueue = this.urgentQueueA, this.urgentQueueSize = 0, this._epoch = 0, this.isProcessing = !1, this.isBatching = !1, this.batchDepth = 0, this.batchQueue = [], this.batchQueueSize = 0, this.isFlushingSync = !1, this.maxFlushIterations = z.MAX_FLUSH_ITERATIONS;
   }
   get phase() {
     return this.isProcessing || this.isFlushingSync ? 2 : this.isBatching ? 1 : 0;
   }
   /**
-   * Schedules a task for execution.
-   * Tasks are deduplicated within the same flush cycle using epoch tracking.
-   * @param callback - The function to execute.
-   * @throws {SchedulerError} If the callback is not a function.
+   * Schedules a task for execution with optional priority based on phase shift.
+   *
+   * Priority Calculation (Branchless):
+   * - If sourceNode and cachedVersion are provided, calculates shift
+   * - Jobs with shift >= PHASE_THRESHOLD go to urgentQueue
+   * - Uses branchless bit manipulation: ((shift - THRESHOLD) >>> 31) ^ 1
+   *
+   * @param callback - The function to execute
+   * @param sourceNode - Optional reactive node for shift calculation
+   * @throws {SchedulerError} If the callback is not a function
    */
-  schedule(e) {
+  schedule(e, s) {
     if (typeof e != "function")
-      throw new Z("Scheduler callback must be a function");
-    e._nextEpoch !== this._epoch && (e._nextEpoch = this._epoch, this.isBatching || this.isFlushingSync ? this.batchQueue[this.batchQueueSize++] = e : (this.queue[this.queueSize++] = e, this.isProcessing || this.flush()));
+      throw new se("Scheduler callback must be a function");
+    if (e._nextEpoch !== this._epoch)
+      if (e._nextEpoch = this._epoch, this.isBatching || this.isFlushingSync)
+        this.batchQueue[this.batchQueueSize++] = e;
+      else {
+        const n = this._calculateUrgency(e, s);
+        this.urgentQueue[this.urgentQueueSize] = e, this.queue[this.queueSize] = e, this.urgentQueueSize += n, this.queueSize += n ^ 1, this.isProcessing || this.flush();
+      }
+  }
+  /**
+   * Calculates urgency flag using branchless bit manipulation.
+   *
+   * Formula: ((shift - PHASE_THRESHOLD) >>> 31) ^ 1
+   * - If shift >= THRESHOLD: (negative >>> 31) = 0, XOR 1 = 1 (urgent)
+   * - If shift < THRESHOLD: (positive >>> 31) = 0... wait, that's wrong
+   *
+   * Correct formula: (shift >= THRESHOLD) ? 1 : 0
+   * Branchless: ((PHASE_THRESHOLD - 1 - shift) >>> 31)
+   *
+   * @returns 1 if urgent, 0 if normal
+   */
+  _calculateUrgency(e, s) {
+    if (!s || e._cachedVersion === void 0)
+      return 0;
+    const n = s.getShift(e._cachedVersion);
+    return _e - 1 - n >>> 31 & 1;
   }
   flush() {
-    this.isProcessing || this.queueSize === 0 || (this.isProcessing = !0, queueMicrotask(() => {
+    this.isProcessing || this.queueSize === 0 && this.urgentQueueSize === 0 || (this.isProcessing = !0, queueMicrotask(() => {
       try {
-        if (this.queueSize === 0) return;
-        const e = me();
-        this._drainQueue(), e && ye();
+        if (this.queueSize === 0 && this.urgentQueueSize === 0) return;
+        const e = ve();
+        this._drainQueue(), e && Te();
       } finally {
-        this.isProcessing = !1, this.queueSize > 0 && !this.isBatching && this.flush();
+        this.isProcessing = !1, (this.queueSize > 0 || this.urgentQueueSize > 0) && !this.isBatching && this.flush();
       }
     }));
   }
   flushSync() {
     this.isFlushingSync = !0;
-    const e = me();
+    const e = ve();
     try {
       this._mergeBatchQueue(), this._drainQueue();
     } finally {
-      this.isFlushingSync = !1, e && ye();
+      this.isFlushingSync = !1, e && Te();
     }
   }
   _mergeBatchQueue() {
@@ -307,26 +379,44 @@ class Qe {
       this.batchQueueSize = 0;
     }
   }
+  /**
+   * Drains all queues, processing urgent queue completely first.
+   *
+   * Processing Order:
+   * 1. Process all urgent jobs (high phase shift = stale updates)
+   * 2. Process normal jobs
+   * 3. Repeat until both queues are empty
+   *
+   * This ordering reduces glitches by ensuring that the most
+   * impactful state changes are propagated first.
+   */
   _drainQueue() {
     let e = 0;
-    for (; this.queueSize > 0; ) {
+    for (; this.urgentQueueSize > 0 || this.queueSize > 0; ) {
       if (++e > this.maxFlushIterations) {
         this._handleFlushOverflow();
         break;
       }
-      this._processCurrentQueue(), this._mergeBatchQueue();
+      this.urgentQueueSize > 0 && this._processUrgentQueue(), this.queueSize > 0 && this._processCurrentQueue(), this._mergeBatchQueue();
     }
   }
+  /**
+   * Processes the urgent queue using double-buffering.
+   */
+  _processUrgentQueue() {
+    const e = this.urgentQueue, s = this.urgentQueueSize;
+    this.urgentQueue = this.urgentQueue === this.urgentQueueA ? this.urgentQueueB : this.urgentQueueA, this.urgentQueueSize = 0, this._epoch++, this._processJobs(e, s);
+  }
   _processCurrentQueue() {
     const e = this.queue, s = this.queueSize;
     this.queue = this.queue === this.queueA ? this.queueB : this.queueA, this.queueSize = 0, this._epoch++, this._processJobs(e, s);
   }
   _handleFlushOverflow() {
     console.error(
-      new Z(
+      new se(
         `Maximum flush iterations (${this.maxFlushIterations}) exceeded. Possible infinite loop.`
       )
-    ), this.queueSize = 0, this.queue.length = 0, this.batchQueueSize = 0;
+    ), this.queueSize = 0, this.queue.length = 0, this.urgentQueueSize = 0, this.urgentQueue.length = 0, this.batchQueueSize = 0;
   }
   _processJobs(e, s) {
     for (let n = 0; n < s; n++)
@@ -334,7 +424,7 @@ class Qe {
         e[n]?.();
       } catch (i) {
         console.error(
-          new Z("Error occurred during scheduler execution", i)
+          new se("Error occurred during scheduler execution", i)
         );
       }
     e.length = 0;
@@ -355,25 +445,25 @@ class Qe {
    * @param max - Maximum iterations count.
    */
   setMaxFlushIterations(e) {
-    if (e < L.MIN_FLUSH_ITERATIONS)
-      throw new Z(
-        `Max flush iterations must be at least ${L.MIN_FLUSH_ITERATIONS}`
+    if (e < z.MIN_FLUSH_ITERATIONS)
+      throw new se(
+        `Max flush iterations must be at least ${z.MIN_FLUSH_ITERATIONS}`
       );
     this.maxFlushIterations = e;
   }
 }
-const J = new Qe();
-function He(t) {
+const Z = new Je();
+function Ke(t) {
   if (typeof t != "function")
-    throw new k("Batch callback must be a function");
-  J.startBatch();
+    throw new w("Batch callback must be a function");
+  Z.startBatch();
   try {
     return t();
   } finally {
-    J.endBatch();
+    Z.endBatch();
   }
 }
-class Je {
+class We {
   constructor() {
     this.current = null;
   }
@@ -400,19 +490,19 @@ class Je {
     return this.current;
   }
 }
-const q = new Je();
-function xe(t) {
+const X = new We();
+function we(t) {
   if (typeof t != "function")
-    throw new k("Untracked callback must be a function");
-  const e = q.current;
-  q.current = null;
+    throw new w("Untracked callback must be a function");
+  const e = X.current;
+  X.current = null;
   try {
     return t();
   } finally {
-    q.current = e;
+    X.current = e;
   }
 }
-class ie {
+class ce {
   constructor() {
     this.subscribers = null;
   }
@@ -468,9 +558,9 @@ class ie {
     return this.subscribers ? [...this.subscribers] : [];
   }
 }
-class fe {
+class Ee {
   constructor() {
-    this.pool = [], this.maxPoolSize = 50, this.maxReusableCapacity = 256, this.stats = x ? {
+    this.pool = [], this.maxPoolSize = 50, this.maxReusableCapacity = 256, this.stats = v ? {
       acquired: 0,
       released: 0,
       rejected: { frozen: 0, tooLarge: 0, poolFull: 0 }
@@ -478,7 +568,7 @@ class fe {
   }
   /** Acquires an array from the pool or creates a new one if the pool is empty. */
   acquire() {
-    return x && this.stats && this.stats.acquired++, this.pool.pop() ?? [];
+    return v && this.stats && this.stats.acquired++, this.pool.pop() ?? [];
   }
   /**
    * Releases an array back to the pool.
@@ -489,23 +579,23 @@ class fe {
   release(e, s) {
     if (!(s && e === s)) {
       if (Object.isFrozen(e)) {
-        x && this.stats && this.stats.rejected.frozen++;
+        v && this.stats && this.stats.rejected.frozen++;
         return;
       }
       if (e.length > this.maxReusableCapacity) {
-        x && this.stats && this.stats.rejected.tooLarge++;
+        v && this.stats && this.stats.rejected.tooLarge++;
         return;
       }
       if (this.pool.length >= this.maxPoolSize) {
-        x && this.stats && this.stats.rejected.poolFull++;
+        v && this.stats && this.stats.rejected.poolFull++;
         return;
       }
-      e.length = 0, this.pool.push(e), x && this.stats && this.stats.released++;
+      e.length = 0, this.pool.push(e), v && this.stats && this.stats.released++;
     }
   }
   /** Returns current stats for the pool (dev mode only). */
   getStats() {
-    if (!x || !this.stats) return null;
+    if (!v || !this.stats) return null;
     const { acquired: e, released: s, rejected: n } = this.stats, i = n.frozen + n.tooLarge + n.poolFull;
     return {
       acquired: e,
@@ -517,142 +607,145 @@ class fe {
   }
   /** Resets the pool and its stats. */
   reset() {
-    this.pool.length = 0, x && this.stats && (this.stats.acquired = 0, this.stats.released = 0, this.stats.rejected = { frozen: 0, tooLarge: 0, poolFull: 0 });
+    this.pool.length = 0, v && this.stats && (this.stats.acquired = 0, this.stats.released = 0, this.stats.rejected = { frozen: 0, tooLarge: 0, poolFull: 0 });
   }
 }
-const S = Object.freeze([]), U = Object.freeze([]), D = Object.freeze([]), M = new fe(), j = new fe(), O = new fe();
-function ae(t) {
+const S = Object.freeze([]), A = Object.freeze([]), y = Object.freeze([]), F = new Ee(), Q = new Ee(), N = new Ee();
+function pe(t) {
   return t !== null && typeof t == "object" && "value" in t && "subscribe" in t && typeof t.subscribe == "function";
 }
-function Se(t) {
-  if (A.enabled && (t == null || typeof t == "object")) {
-    const e = A.getDebugType(t);
+function Ae(t) {
+  if (R.enabled && (t == null || typeof t == "object")) {
+    const e = R.getDebugType(t);
     if (e)
       return e === "computed";
   }
-  return ae(t) && "invalidate" in t && typeof t.invalidate == "function";
+  return pe(t) && "invalidate" in t && typeof t.invalidate == "function";
 }
-function Te(t) {
+function ke(t) {
   return t != null && typeof t.then == "function";
 }
-function Ye(t) {
+function Ze(t) {
   return typeof t == "object" && t !== null;
 }
-function Ke(t) {
+function et(t) {
   return (typeof t == "object" || typeof t == "function") && t !== null && typeof t.addDependency == "function";
 }
-function We(t) {
+function tt(t) {
   return typeof t == "function" && typeof t.addDependency != "function";
 }
-function Ze(t) {
-  return Ye(t) && typeof t.execute == "function";
+function st(t) {
+  return Ze(t) && typeof t.execute == "function";
 }
-function Re(t, e, s, n) {
+function Fe(t, e, s, n) {
   if (e) {
-    if (Ke(e)) {
+    if (et(e)) {
       e.addDependency(t);
       return;
     }
-    if (We(e)) {
+    if (tt(e)) {
       s.add(e);
       return;
     }
-    Ze(e) && n.add(e);
+    st(e) && n.add(e);
   }
 }
-function et(t, e, s, n) {
-  if (e !== S && s !== U)
+function nt(t, e, s, n) {
+  if (e !== S && s !== A)
     for (let r = 0; r < e.length; r++) {
       const o = e[r];
       o && (o._tempUnsub = s[r]);
     }
-  const i = j.acquire();
+  const i = Q.acquire();
   i.length = t.length;
   for (let r = 0; r < t.length; r++) {
     const o = t[r];
-    o && (o._tempUnsub ? (i[r] = o._tempUnsub, o._tempUnsub = void 0) : (A.checkCircular(o, n), i[r] = o.subscribe(n)));
+    o && (o._tempUnsub ? (i[r] = o._tempUnsub, o._tempUnsub = void 0) : (R.checkCircular(o, n), i[r] = o.subscribe(n)));
   }
   if (e !== S)
     for (let r = 0; r < e.length; r++) {
       const o = e[r];
       o?._tempUnsub && (o._tempUnsub(), o._tempUnsub = void 0);
     }
-  return s !== U && j.release(s), i;
+  return s !== A && Q.release(s), i;
 }
-class tt extends ve {
+class it extends Ue {
   constructor(e, s) {
-    super(), this._isNotificationScheduled = !1, this._value = e, this._functionSubscribersStore = new ie(), this._objectSubscribersStore = new ie(), this._sync = s, this._notifyTask = this._flushNotifications.bind(this), A.attachDebugInfo(this, "atom", this.id);
+    super(), this._functionSubscribersStore = null, this._objectSubscribersStore = null, this._value = e, s && (this.flags |= Y.SYNC), R.attachDebugInfo(this, "atom", this.id);
   }
-  /** Gets the manager for function-based subscribers. */
   get _functionSubscribers() {
-    return this._functionSubscribersStore;
+    return this._functionSubscribersStore || (this._functionSubscribersStore = new ce()), this._functionSubscribersStore;
   }
-  /** Gets the manager for object-based subscribers. */
   get _objectSubscribers() {
-    return this._objectSubscribersStore;
+    return this._objectSubscribersStore || (this._objectSubscribersStore = new ce()), this._objectSubscribersStore;
   }
   /**
-   * Returns the current value and registers the atom as a dependency in the current tracking context.
+   * Returns the current value and registers the atom as a dependency if in a tracking context.
    */
   get value() {
-    const e = q.getCurrent();
-    return e && this._track(e), this._value;
+    const e = X.current;
+    return e && Fe(this, e, this._functionSubscribers, this._objectSubscribers), this._value;
   }
   /**
    * Sets a new value and schedules notifications if the value has changed.
-   * Uses `Object.is` for comparison.
    */
   set value(e) {
     if (Object.is(this._value, e)) return;
     const s = this._value;
-    this.version = this.version + 1 & B, this._value = e, !(!this._functionSubscribersStore.hasSubscribers && !this._objectSubscribersStore.hasSubscribers) && this._scheduleNotification(s);
-  }
-  _track(e) {
-    Re(this, e, this._functionSubscribersStore, this._objectSubscribersStore);
+    this._value = e, this.rotatePhase();
+    const n = this._functionSubscribersStore?.hasSubscribers, i = this._objectSubscribersStore?.hasSubscribers;
+    (n || i) && this._scheduleNotification(s);
   }
+  /**
+   * Schedules or flushes notifications based on sync mode and batching state.
+   */
   _scheduleNotification(e) {
-    this._isNotificationScheduled || (this._pendingOldValue = e, this._isNotificationScheduled = !0), this._sync && !J.isBatching ? this._flushNotifications() : J.schedule(this._notifyTask);
+    if (this.flags & Y.NOTIFICATION_SCHEDULED || (this._pendingOldValue = e, this.flags |= Y.NOTIFICATION_SCHEDULED), this.flags & Y.SYNC && !Z.isBatching) {
+      this._flushNotifications();
+      return;
+    }
+    this._notifyTask || (this._notifyTask = () => this._flushNotifications()), Z.schedule(this._notifyTask);
   }
   _flushNotifications() {
-    if (!this._isNotificationScheduled) return;
+    if (!(this.flags & Y.NOTIFICATION_SCHEDULED)) return;
     const e = this._pendingOldValue, s = this._value;
-    this._pendingOldValue = void 0, this._isNotificationScheduled = !1, this._notifySubscribers(s, e);
+    this._pendingOldValue = void 0, this.flags &= -3, this._notifySubscribers(s, e);
   }
   /**
-   * Returns the current value without registering as a dependency in the tracking context.
+   * Overridden to avoid unnecessary manager creation during notification loop.
    */
+  _notifySubscribers(e, s) {
+    this._functionSubscribersStore && this._functionSubscribersStore.forEachSafe((n) => n(e, s)), this._objectSubscribersStore && this._objectSubscribersStore.forEachSafe((n) => n.execute());
+  }
   peek() {
     return this._value;
   }
-  /**
-   * Disposes of the atom, clearing all subscribers and resetting the value.
-   */
   dispose() {
-    this._functionSubscribersStore.clear(), this._objectSubscribersStore.clear(), this._value = void 0;
+    this._functionSubscribersStore?.clear(), this._objectSubscribersStore?.clear(), this._value = void 0, this._notifyTask = void 0;
   }
 }
-function st(t, e = {}) {
-  return new tt(t, e.sync ?? !1);
+function rt(t, e = {}) {
+  return new it(t, e.sync ?? !1);
 }
-function Q(t, e, s) {
+function K(t, e, s) {
   if (t instanceof TypeError)
     return new e(`Type error (${s}): ${t.message}`, t);
   if (t instanceof ReferenceError)
     return new e(`Reference error (${s}): ${t.message}`, t);
-  if (t instanceof k)
+  if (t instanceof w)
     return t;
   const n = t instanceof Error ? t.message : String(t), i = t instanceof Error ? t : null;
   return new e(`Unexpected error (${s}): ${n}`, i);
 }
-const Ue = d.RESOLVED | d.PENDING | d.REJECTED, oe = Array(Ue + 1).fill(re.IDLE);
-oe[d.RESOLVED] = re.RESOLVED;
-oe[d.PENDING] = re.PENDING;
-oe[d.REJECTED] = re.REJECTED;
-class Oe extends ve {
+const Ve = d.RESOLVED | d.PENDING | d.REJECTED, he = Array(Ve + 1).fill(ue.IDLE);
+he[d.RESOLVED] = ue.RESOLVED;
+he[d.PENDING] = ue.PENDING;
+he[d.REJECTED] = ue.REJECTED;
+class Me extends Ue {
   constructor(e, s = {}) {
     if (typeof e != "function")
-      throw new z(y.COMPUTED_MUST_BE_FUNCTION);
-    if (super(), this._cachedErrors = null, this._errorCacheEpoch = -1, this._value = void 0, this.flags = d.DIRTY | d.IDLE, this._error = null, this._promiseId = 0, this._equal = s.equal ?? Object.is, this._fn = e, this._defaultValue = "defaultValue" in s ? s.defaultValue : Ee, this._hasDefaultValue = this._defaultValue !== Ee, this._onError = s.onError ?? null, this.MAX_PROMISE_ID = Number.MAX_SAFE_INTEGER - 1, this._functionSubscribersStore = new ie(), this._objectSubscribersStore = new ie(), this._dependencies = S, this._dependencyVersions = D, this._unsubscribes = U, this._notifyJob = () => {
+      throw new q(g.COMPUTED_MUST_BE_FUNCTION);
+    if (super(), this._cachedErrors = null, this._errorCacheEpoch = -1, this._asyncStartAggregateVersion = 0, this._asyncRetryCount = 0, this.MAX_ASYNC_RETRIES = 3, this._value = void 0, this.flags = d.DIRTY | d.IDLE, this._error = null, this._promiseId = 0, this._equal = s.equal ?? Object.is, this._fn = e, this._defaultValue = "defaultValue" in s ? s.defaultValue : Ie, this._hasDefaultValue = this._defaultValue !== Ie, this._onError = s.onError ?? null, this.MAX_PROMISE_ID = Number.MAX_SAFE_INTEGER - 1, this._functionSubscribersStore = new ce(), this._objectSubscribersStore = new ce(), this._dependencies = S, this._dependencyVersions = y, this._unsubscribes = A, this._notifyJob = () => {
       this._functionSubscribersStore.forEachSafe(
         (n) => n(),
         (n) => console.error(n)
@@ -663,7 +756,7 @@ class Oe extends ve {
     }, this._trackable = Object.assign(() => this._markDirty(), {
       addDependency: (n) => {
       }
-    }), A.attachDebugInfo(this, "computed", this.id), A.enabled) {
+    }), R.attachDebugInfo(this, "computed", this.id), R.enabled) {
       const n = this;
       n.subscriberCount = () => this._functionSubscribersStore.size + this._objectSubscribersStore.size, n.isDirty = () => this._isDirty(), n.dependencies = this._dependencies, n.stateFlags = this._getFlagsAsString();
     }
@@ -703,8 +796,8 @@ class Oe extends ve {
   }
   get errors() {
     if (this._registerTracking(), !this.hasError)
-      return Le;
-    const e = Xe();
+      return qe;
+    const e = He();
     if (this._errorCacheEpoch === e && this._cachedErrors !== null)
       return this._cachedErrors;
     const s = /* @__PURE__ */ new Set();
@@ -731,17 +824,17 @@ class Oe extends ve {
     return this._registerTracking(), this._isResolved();
   }
   invalidate() {
-    this._markDirty(), this._dependencyVersions !== D && (O.release(this._dependencyVersions), this._dependencyVersions = D), this._errorCacheEpoch = -1, this._cachedErrors = null;
+    this._markDirty(), this._dependencyVersions !== y && (N.release(this._dependencyVersions), this._dependencyVersions = y), this._errorCacheEpoch = -1, this._cachedErrors = null;
   }
   dispose() {
-    if (this._unsubscribes !== U) {
+    if (this._unsubscribes !== A) {
       for (let e = 0; e < this._unsubscribes.length; e++) {
         const s = this._unsubscribes[e];
         s && s();
       }
-      j.release(this._unsubscribes), this._unsubscribes = U;
+      Q.release(this._unsubscribes), this._unsubscribes = A;
     }
-    this._dependencies !== S && (M.release(this._dependencies), this._dependencies = S), this._dependencyVersions !== D && (O.release(this._dependencyVersions), this._dependencyVersions = D), this._functionSubscribersStore.clear(), this._objectSubscribersStore.clear(), this.flags = d.DIRTY | d.IDLE, this._error = null, this._value = void 0, this._promiseId = (this._promiseId + 1) % this.MAX_PROMISE_ID, this._cachedErrors = null, this._errorCacheEpoch = -1;
+    this._dependencies !== S && (F.release(this._dependencies), this._dependencies = S), this._dependencyVersions !== y && (N.release(this._dependencyVersions), this._dependencyVersions = y), this._functionSubscribersStore.clear(), this._objectSubscribersStore.clear(), this.flags = d.DIRTY | d.IDLE, this._error = null, this._value = void 0, this._promiseId = (this._promiseId + 1) % this.MAX_PROMISE_ID, this._cachedErrors = null, this._errorCacheEpoch = -1;
   }
   // State flag operations
   _isDirty() {
@@ -785,7 +878,7 @@ class Oe extends ve {
     this.flags = this.flags & ~s | -Number(e) & s;
   }
   _getAsyncState() {
-    return oe[this.flags & Ue];
+    return he[this.flags & Ve];
   }
   _getFlagsAsString() {
     const e = [];
@@ -800,8 +893,8 @@ class Oe extends ve {
     const e = this._prepareComputationContext();
     let s = !1;
     try {
-      const n = q.run(this._trackable, this._fn);
-      this._commitDependencies(e), s = !0, Te(n) ? this._handleAsyncComputation(n) : this._handleSyncResult(n);
+      const n = X.run(this._trackable, this._fn);
+      this._commitDependencies(e), s = !0, ke(n) ? this._handleAsyncComputation(n) : this._handleSyncResult(n);
     } catch (n) {
       if (!s)
         try {
@@ -815,59 +908,112 @@ class Oe extends ve {
     }
   }
   _prepareComputationContext() {
-    const e = this._dependencies, s = this._dependencyVersions, n = M.acquire(), i = O.acquire(), r = Ne(), o = { depCount: 0 }, c = (_) => {
+    const e = this._dependencies, s = this._dependencyVersions, n = F.acquire(), i = N.acquire(), r = Oe(), o = { depCount: 0 }, c = (_) => {
       _._lastSeenEpoch !== r && (_._lastSeenEpoch = r, o.depCount < n.length ? (n[o.depCount] = _, i[o.depCount] = _.version) : (n.push(_), i.push(_.version)), o.depCount++);
-    }, f = this._trackable.addDependency;
-    return this._trackable.addDependency = c, { prevDeps: e, prevVersions: s, nextDeps: n, nextVersions: i, originalAdd: f, state: o };
+    }, h = this._trackable.addDependency;
+    return this._trackable.addDependency = c, { prevDeps: e, prevVersions: s, nextDeps: n, nextVersions: i, originalAdd: h, state: o };
   }
   _commitDependencies(e) {
     const { nextDeps: s, nextVersions: n, state: i, prevDeps: r } = e;
-    s.length = i.depCount, n.length = i.depCount, this._unsubscribes = et(s, r, this._unsubscribes, this), this._dependencies = s, this._dependencyVersions = n;
+    s.length = i.depCount, n.length = i.depCount, this._unsubscribes = nt(s, r, this._unsubscribes, this), this._dependencies = s, this._dependencyVersions = n;
   }
   _cleanupContext(e, s) {
-    this._trackable.addDependency = e.originalAdd, s ? (e.prevDeps !== S && M.release(e.prevDeps), e.prevVersions !== D && O.release(e.prevVersions)) : (M.release(e.nextDeps), O.release(e.nextVersions));
+    this._trackable.addDependency = e.originalAdd, s ? (e.prevDeps !== S && F.release(e.prevDeps), e.prevVersions !== y && N.release(e.prevVersions)) : (F.release(e.nextDeps), N.release(e.nextVersions));
+  }
+  /**
+   * Calculates aggregate shift from all dependencies.
+   * Used for scheduling priority in computed chains.
+   *
+   * Performance: O(N) where N = dependency count
+   * Branchless: Each dep.getShift uses modular arithmetic
+   *
+   * @returns Sum of all dependency shifts (capped at SMI_MAX)
+   */
+  _getAggregateShift() {
+    let e = 0;
+    const s = this._dependencies, n = this._dependencyVersions;
+    for (let i = 0; i < s.length; i++) {
+      const r = s[i], o = n[i];
+      r && o !== void 0 && (e = e + r.getShift(o) & V);
+    }
+    return e;
+  }
+  /**
+   * Checks if this computed should be scheduled with urgent priority.
+   * Based on aggregate shift from all dependencies.
+   *
+   * @returns true if aggregate shift exceeds PHASE_THRESHOLD
+   */
+  isUrgent() {
+    return this._getAggregateShift() >= _e;
   }
   _handleSyncResult(e) {
-    const s = !this._isResolved() || !this._equal(this._value, e);
-    this.version = this.version + Number(s) & B, this._value = e, this._clearDirty(), this._setResolved(), this._error = null, this._setRecomputing(!1), this._cachedErrors = null, this._errorCacheEpoch = -1;
+    (!this._isResolved() || !this._equal(this._value, e)) && this.rotatePhase(), this._value = e, this._clearDirty(), this._setResolved(), this._error = null, this._setRecomputing(!1), this._cachedErrors = null, this._errorCacheEpoch = -1;
   }
   _handleAsyncComputation(e) {
-    this._setPending(), this._clearDirty(), this._notifyJob(), this._promiseId = this._promiseId >= this.MAX_PROMISE_ID ? 1 : this._promiseId + 1;
+    this._setPending(), this._clearDirty(), this._notifyJob(), this._asyncStartAggregateVersion = this._captureVersionSnapshot(), this._asyncRetryCount = 0, this._promiseId = this._promiseId >= this.MAX_PROMISE_ID ? 1 : this._promiseId + 1;
     const s = this._promiseId;
     e.then((n) => {
-      s === this._promiseId && this._handleAsyncResolution(n);
+      if (s !== this._promiseId) return;
+      const i = this._captureVersionSnapshot() - this._asyncStartAggregateVersion & V;
+      if (_e - 1 - i >>> 31 & 1) {
+        if (this._asyncRetryCount < this.MAX_ASYNC_RETRIES) {
+          this._asyncRetryCount++, this._markDirty();
+          return;
+        }
+        const r = new q(
+          `Async drift exceeded threshold after ${this.MAX_ASYNC_RETRIES} retries. Dependencies changed too rapidly for stable computation.`
+        );
+        this._handleAsyncRejection(r);
+        return;
+      }
+      this._handleAsyncResolution(n);
     }).catch((n) => {
       s === this._promiseId && this._handleAsyncRejection(n);
     });
   }
+  /**
+   * Captures the aggregate version of all dependencies.
+   * Used for phase drift validation in async computations.
+   *
+   * @returns Sum of all dependency versions (capped at SMI_MAX)
+   */
+  _captureVersionSnapshot() {
+    let e = 0;
+    const s = this._dependencies;
+    for (let n = 0; n < s.length; n++) {
+      const i = s[n];
+      i && (e = e + i.version & V);
+    }
+    return e;
+  }
   _handleAsyncResolution(e) {
-    const s = !this._isResolved() || !this._equal(this._value, e);
-    this.version = this.version + Number(s) & B, this._value = e, this._clearDirty(), this._setResolved(), this._error = null, this._setRecomputing(!1), this._cachedErrors = null, this._errorCacheEpoch = -1, this._notifyJob();
+    (!this._isResolved() || !this._equal(this._value, e)) && this.rotatePhase(), this._value = e, this._clearDirty(), this._setResolved(), this._error = null, this._setRecomputing(!1), this._cachedErrors = null, this._errorCacheEpoch = -1, this._notifyJob();
   }
   _handleAsyncRejection(e) {
-    const s = Q(e, z, y.COMPUTED_ASYNC_COMPUTATION_FAILED), n = !this._isRejected();
-    if (this.version = this.version + Number(n) & B, this._error = s, this._setRejected(), this._clearDirty(), this._setRecomputing(!1), this._onError)
+    const s = K(e, q, g.COMPUTED_ASYNC_COMPUTATION_FAILED);
+    if (!this._isRejected() && this.rotatePhase(), this._error = s, this._setRejected(), this._clearDirty(), this._setRecomputing(!1), this._onError)
       try {
         this._onError(s);
-      } catch (i) {
-        console.error(y.CALLBACK_ERROR_IN_ERROR_HANDLER, i);
+      } catch (n) {
+        console.error(g.CALLBACK_ERROR_IN_ERROR_HANDLER, n);
       }
     this._notifyJob();
   }
   _handleComputationError(e) {
-    const s = Q(e, z, y.COMPUTED_COMPUTATION_FAILED);
+    const s = K(e, q, g.COMPUTED_COMPUTATION_FAILED);
     if (this._error = s, this._setRejected(), this._clearDirty(), this._setRecomputing(!1), this._onError)
       try {
         this._onError(s);
       } catch (n) {
-        console.error(y.CALLBACK_ERROR_IN_ERROR_HANDLER, n);
+        console.error(g.CALLBACK_ERROR_IN_ERROR_HANDLER, n);
       }
     throw s;
   }
   _handlePending() {
     if (this._hasDefaultValue)
       return this._defaultValue;
-    throw new z(y.COMPUTED_ASYNC_PENDING_NO_DEFAULT);
+    throw new q(g.COMPUTED_ASYNC_PENDING_NO_DEFAULT);
   }
   _handleRejected() {
     if (this._error?.recoverable && this._hasDefaultValue)
@@ -882,19 +1028,19 @@ class Oe extends ve {
     this._isRecomputing() || this._isDirty() || (this._setDirty(), this._notifyJob());
   }
   _registerTracking() {
-    Re(
+    Fe(
       this,
-      q.getCurrent(),
+      X.getCurrent(),
       this._functionSubscribersStore,
       this._objectSubscribersStore
     );
   }
 }
-Object.freeze(Oe.prototype);
-function nt(t, e = {}) {
-  return new Oe(t, e);
+Object.freeze(Me.prototype);
+function ot(t, e = {}) {
+  return new Me(t, e);
 }
-class it extends Ce {
+class ct extends xe {
   /**
    * Creates a new EffectImpl instance.
    * @param fn - The effect function to run.
@@ -903,18 +1049,18 @@ class it extends Ce {
   constructor(e, s = {}) {
     super(), this.run = () => {
       if (this.isDisposed)
-        throw new V(y.EFFECT_MUST_BE_FUNCTION);
-      this._dependencyVersions !== D && (O.release(this._dependencyVersions), this._dependencyVersions = D), this.execute();
+        throw new B(g.EFFECT_MUST_BE_FUNCTION);
+      this._dependencyVersions !== y && (N.release(this._dependencyVersions), this._dependencyVersions = y), this.execute();
     }, this.dispose = () => {
       if (!this.isDisposed) {
-        if (this._setDisposed(), this._safeCleanup(), this._unsubscribes !== U) {
+        if (this._setDisposed(), this._safeCleanup(), this._unsubscribes !== A) {
           for (let i = 0; i < this._unsubscribes.length; i++) {
             const r = this._unsubscribes[i];
             r && r();
           }
-          j.release(this._unsubscribes), this._unsubscribes = U;
+          Q.release(this._unsubscribes), this._unsubscribes = A;
         }
-        this._dependencies !== S && (M.release(this._dependencies), this._dependencies = S), this._dependencyVersions !== D && (O.release(this._dependencyVersions), this._dependencyVersions = D);
+        this._dependencies !== S && (F.release(this._dependencies), this._dependencies = S), this._dependencyVersions !== y && (N.release(this._dependencyVersions), this._dependencyVersions = y);
       }
     }, this.addDependency = (i) => {
       if (this.isExecuting && this._nextDeps && this._nextUnsubs && this._nextVersions) {
@@ -928,8 +1074,8 @@ class it extends Ce {
       const i = this._prepareEffectContext();
       let r = !1;
       try {
-        const o = q.run(this, this._fn);
-        this._commitEffect(i), r = !0, this._checkLoopWarnings(), Te(o) ? o.then((c) => {
+        const o = X.run(this, this._fn);
+        this._commitEffect(i), r = !0, this._checkLoopWarnings(), ke(o) ? o.then((c) => {
           !this.isDisposed && typeof c == "function" && (this._cleanup = c);
         }).catch((c) => {
           this._handleExecutionError(c);
@@ -939,20 +1085,20 @@ class it extends Ce {
       } finally {
         this._cleanupEffect(i, r), this._setExecuting(!1);
       }
-    }, this._currentEpoch = -1, this._lastFlushEpoch = -1, this._executionsInEpoch = 0, this._fn = e, this._sync = s.sync ?? !1, this._maxExecutions = s.maxExecutionsPerSecond ?? L.MAX_EXECUTIONS_PER_SECOND, this._maxExecutionsPerFlush = s.maxExecutionsPerFlush ?? L.MAX_EXECUTIONS_PER_EFFECT, this._trackModifications = s.trackModifications ?? !1, this._cleanup = null, this._dependencies = S, this._dependencyVersions = D, this._unsubscribes = U, this._nextDeps = null, this._nextVersions = null, this._nextUnsubs = null, this._onError = s.onError ?? null, this._historyPtr = 0;
+    }, this._currentEpoch = -1, this._lastFlushEpoch = -1, this._executionsInEpoch = 0, this._fn = e, this._sync = s.sync ?? !1, this._maxExecutions = s.maxExecutionsPerSecond ?? z.MAX_EXECUTIONS_PER_SECOND, this._maxExecutionsPerFlush = s.maxExecutionsPerFlush ?? z.MAX_EXECUTIONS_PER_EFFECT, this._trackModifications = s.trackModifications ?? !1, this._cleanup = null, this._dependencies = S, this._dependencyVersions = y, this._unsubscribes = A, this._nextDeps = null, this._nextVersions = null, this._nextUnsubs = null, this._onError = s.onError ?? null, this._historyPtr = 0;
     const n = Number.isFinite(this._maxExecutions);
-    this._historyCapacity = n ? Math.min(this._maxExecutions + 1, L.MAX_EXECUTIONS_PER_SECOND + 1) : 0, this._history = x && n && this._historyCapacity > 0 ? new Array(this._historyCapacity).fill(0) : null, this._executionCount = 0, A.attachDebugInfo(this, "effect", this.id);
+    this._historyCapacity = n ? Math.min(this._maxExecutions + 1, z.MAX_EXECUTIONS_PER_SECOND + 1) : 0, this._history = v && n && this._historyCapacity > 0 ? new Array(this._historyCapacity).fill(0) : null, this._executionCount = 0, R.attachDebugInfo(this, "effect", this.id);
   }
   /**
    * Prepares the execution context by acquiring pools and setting up epoch.
    * @returns The prepared EffectContext.
    */
   _prepareEffectContext() {
-    const e = this._dependencies, s = this._dependencyVersions, n = this._unsubscribes, i = M.acquire(), r = O.acquire(), o = j.acquire(), c = Ne();
-    if (e !== S && n !== U)
-      for (let f = 0; f < e.length; f++) {
-        const _ = e[f];
-        _ && (_._tempUnsub = n[f]);
+    const e = this._dependencies, s = this._dependencyVersions, n = this._unsubscribes, i = F.acquire(), r = N.acquire(), o = Q.acquire(), c = Oe();
+    if (e !== S && n !== A)
+      for (let h = 0; h < e.length; h++) {
+        const _ = e[h];
+        _ && (_._tempUnsub = n[h]);
       }
     return this._nextDeps = i, this._nextVersions = r, this._nextUnsubs = o, this._currentEpoch = c, { prevDeps: e, prevVersions: s, prevUnsubs: n, nextDeps: i, nextVersions: r, nextUnsubs: o };
   }
@@ -976,14 +1122,14 @@ class it extends Ce {
           const i = e.prevDeps[n];
           i?._tempUnsub && (i._tempUnsub(), i._tempUnsub = void 0);
         }
-        M.release(e.prevDeps);
+        F.release(e.prevDeps);
       }
-      e.prevUnsubs !== U && j.release(e.prevUnsubs), e.prevVersions !== D && O.release(e.prevVersions);
+      e.prevUnsubs !== A && Q.release(e.prevUnsubs), e.prevVersions !== y && N.release(e.prevVersions);
     } else {
-      M.release(e.nextDeps), O.release(e.nextVersions);
+      F.release(e.nextDeps), N.release(e.nextVersions);
       for (let n = 0; n < e.nextUnsubs.length; n++)
         e.nextUnsubs[n]?.();
-      if (j.release(e.nextUnsubs), e.prevDeps !== S)
+      if (Q.release(e.nextUnsubs), e.prevDeps !== S)
         for (let n = 0; n < e.prevDeps.length; n++) {
           const i = e.prevDeps[n];
           i && (i._tempUnsub = void 0);
@@ -997,11 +1143,11 @@ class it extends Ce {
   _subscribeTo(e) {
     try {
       const s = e.subscribe(() => {
-        this._trackModifications && this.isExecuting && (e._modifiedAtEpoch = this._currentEpoch), this._sync ? this.execute() : J.schedule(this.execute);
+        this._trackModifications && this.isExecuting && (e._modifiedAtEpoch = this._currentEpoch), this._sync ? this.execute() : Z.schedule(this.execute);
       });
       this._nextUnsubs && this._nextUnsubs.push(s);
     } catch (s) {
-      console.error(Q(s, V, y.EFFECT_EXECUTION_FAILED)), this._nextUnsubs && this._nextUnsubs.push(() => {
+      console.error(K(s, B, g.EFFECT_EXECUTION_FAILED)), this._nextUnsubs && this._nextUnsubs.push(() => {
       });
     }
   }
@@ -1009,7 +1155,7 @@ class it extends Ce {
    * Whether the effect has been disposed.
    */
   get isDisposed() {
-    return (this.flags & W.DISPOSED) !== 0;
+    return (this.flags & te.DISPOSED) !== 0;
   }
   /**
    * Total number of times this effect has executed.
@@ -1021,13 +1167,13 @@ class it extends Ce {
    * Whether the effect is currently executing.
    */
   get isExecuting() {
-    return (this.flags & W.EXECUTING) !== 0;
+    return (this.flags & te.EXECUTING) !== 0;
   }
   _setDisposed() {
-    this.flags |= W.DISPOSED;
+    this.flags |= te.DISPOSED;
   }
   _setExecuting(e) {
-    const s = W.EXECUTING;
+    const s = te.EXECUTING;
     this.flags = this.flags & ~s | -Number(e) & s;
   }
   /**
@@ -1038,7 +1184,7 @@ class it extends Ce {
       try {
         this._cleanup();
       } catch (e) {
-        console.error(Q(e, V, y.EFFECT_CLEANUP_FAILED));
+        console.error(K(e, B, g.EFFECT_CLEANUP_FAILED));
       }
       this._cleanup = null;
     }
@@ -1048,22 +1194,22 @@ class it extends Ce {
    * @throws {EffectError} If an infinite loop is detected.
    */
   _checkInfiniteLoop() {
-    if (this._lastFlushEpoch !== se && (this._lastFlushEpoch = se, this._executionsInEpoch = 0), this._executionsInEpoch++, this._executionsInEpoch > this._maxExecutionsPerFlush && this._throwInfiniteLoopError("per-effect"), Ge() > L.MAX_EXECUTIONS_PER_FLUSH && this._throwInfiniteLoopError("global"), this._executionCount++, this._history && this._maxExecutions > 0) {
+    if (this._lastFlushEpoch !== re && (this._lastFlushEpoch = re, this._executionsInEpoch = 0), this._executionsInEpoch++, this._executionsInEpoch > this._maxExecutionsPerFlush && this._throwInfiniteLoopError("per-effect"), Ye() > z.MAX_EXECUTIONS_PER_FLUSH && this._throwInfiniteLoopError("global"), this._executionCount++, this._history && this._maxExecutions > 0) {
       const e = Date.now(), s = this._historyPtr, n = this._historyCapacity;
       this._history[s] = e;
       const i = (s + 1) % n, r = this._history[i] ?? 0;
-      if (this._historyPtr = i, r > 0 && e - r < Ve.ONE_SECOND_MS) {
-        const o = new V(
+      if (this._historyPtr = i, r > 0 && e - r < Be.ONE_SECOND_MS) {
+        const o = new B(
           `Effect executed ${n} times within 1 second. Infinite loop suspected`
         );
-        if (this.dispose(), console.error(o), this._onError && this._onError(o), x)
+        if (this.dispose(), console.error(o), this._onError && this._onError(o), v)
           throw o;
       }
     }
   }
   _throwInfiniteLoopError(e) {
-    const s = new V(
-      `Infinite loop detected (${e}): effect executed ${this._executionsInEpoch} times in current flush. Total executions in flush: ${le}`
+    const s = new B(
+      `Infinite loop detected (${e}): effect executed ${this._executionsInEpoch} times in current flush. Total executions in flush: ${be}`
     );
     throw this.dispose(), console.error(s), s;
   }
@@ -1072,14 +1218,14 @@ class it extends Ce {
    * @returns true if any dependency has changed or if it's the first run.
    */
   _shouldExecute() {
-    if (this._dependencies === S || this._dependencyVersions === D)
+    if (this._dependencies === S || this._dependencyVersions === y)
       return !0;
     for (let e = 0; e < this._dependencies.length; e++) {
       const s = this._dependencies[e];
       if (s) {
         if ("value" in s)
           try {
-            xe(() => s.value);
+            we(() => s.value);
           } catch {
             return !0;
           }
@@ -1094,7 +1240,7 @@ class it extends Ce {
    * Wraps the error, logs it to console, and calls onError callback if provided.
    */
   _handleExecutionError(e) {
-    const s = Q(e, V, y.EFFECT_EXECUTION_FAILED);
+    const s = K(e, B, g.EFFECT_EXECUTION_FAILED);
     console.error(s), this._onError && this._onError(s);
   }
   /**
@@ -1102,31 +1248,31 @@ class it extends Ce {
    * Only active if trackModifications is enabled and debug is on.
    */
   _checkLoopWarnings() {
-    if (this._trackModifications && A.enabled) {
+    if (this._trackModifications && R.enabled) {
       const e = this._dependencies;
       for (let s = 0; s < e.length; s++) {
         const n = e[s];
-        n && n._modifiedAtEpoch === this._currentEpoch && A.warn(
+        n && n._modifiedAtEpoch === this._currentEpoch && R.warn(
           !0,
-          `Effect is reading a dependency (${A.getDebugName(n) || "unknown"}) that it just modified. Infinite loop may occur`
+          `Effect is reading a dependency (${R.getDebugName(n) || "unknown"}) that it just modified. Infinite loop may occur`
         );
       }
     }
   }
 }
-function I(t, e = {}) {
+function D(t, e = {}) {
   if (typeof t != "function")
-    throw new V(y.EFFECT_MUST_BE_FUNCTION);
-  const s = new it(t, e);
+    throw new B(g.EFFECT_MUST_BE_FUNCTION);
+  const s = new ct(t, e);
   return s.execute(), s;
 }
-function b(t) {
+function p(t) {
   return t !== null && typeof t == "object" && "value" in t && "subscribe" in t;
 }
-function E(t) {
-  return b(t) ? t.value : t;
+function k(t) {
+  return p(t) ? t.value : t;
 }
-function ce(t) {
+function ae(t) {
   if (!t) return "unknown";
   const e = "jquery" in t ? t[0] : t;
   if (!e) return "unknown";
@@ -1137,7 +1283,7 @@ function ce(t) {
   }
   return e.tagName.toLowerCase();
 }
-function rt() {
+function ut() {
   if (typeof window < "u") {
     const t = window.__ATOM_DEBUG__;
     if (typeof t == "boolean")
@@ -1150,36 +1296,36 @@ function rt() {
   }
   return !1;
 }
-let P = rt();
-const h = {
+let j = ut();
+const l = {
   get enabled() {
-    return P;
+    return j;
   },
   set enabled(t) {
-    P = t;
+    j = t;
   },
   log(t, ...e) {
-    P && console.log(`[atom-effect-jquery] ${t}:`, ...e);
+    j && console.log(`[atom-effect-jquery] ${t}:`, ...e);
   },
   atomChanged(t, e, s) {
-    P && console.log(`[atom-effect-jquery] Atom "${t || "anonymous"}" changed:`, e, "→", s);
+    j && console.log(`[atom-effect-jquery] Atom "${t || "anonymous"}" changed:`, e, "→", s);
   },
   /**
    * Logs DOM updates and triggers visual highlight.
    */
   domUpdated(t, e, s) {
-    if (!P) return;
-    const n = ce(t);
-    console.log(`[atom-effect-jquery] DOM updated: ${n}.${e} =`, s), ot(t);
+    if (!j) return;
+    const n = ae(t);
+    console.log(`[atom-effect-jquery] DOM updated: ${n}.${e} =`, s), ht(t);
   },
   cleanup(t) {
-    P && console.log(`[atom-effect-jquery] Cleanup: ${t}`);
+    j && console.log(`[atom-effect-jquery] Cleanup: ${t}`);
   },
   warn(...t) {
-    P && console.warn("[atom-effect-jquery]", ...t);
+    j && console.warn("[atom-effect-jquery]", ...t);
   }
 };
-function ot(t) {
+function ht(t) {
   const e = t[0];
   if (!e || !document.contains(e)) return;
   const s = "atom_debug_timer", n = "atom_debug_cleanup_timer", i = "atom_debug_org_style";
@@ -1208,83 +1354,76 @@ function ot(t) {
   }, 100);
   t.data(s, r);
 }
-const ct = /* @__PURE__ */ new WeakMap();
-function Ae(t, e = {}) {
-  const s = st(t, e);
-  return e.name && ct.set(s, { name: e.name }), s;
+const at = /* @__PURE__ */ new WeakMap();
+function Pe(t, e = {}) {
+  const s = rt(t, e);
+  return e.name && at.set(s, { name: e.name }), s;
 }
-Object.defineProperty(Ae, "debug", {
+Object.defineProperty(Pe, "debug", {
   get() {
-    return h.enabled;
+    return l.enabled;
   },
   set(t) {
-    h.enabled = t;
+    l.enabled = t;
   }
 });
-function ut() {
+function lt() {
   return new Promise((t) => setTimeout(t, 0));
 }
 u.extend({
-  atom: Ae,
-  computed: nt,
-  effect: I,
-  batch: He,
-  untracked: xe,
-  isAtom: ae,
-  isComputed: Se,
-  isReactive: (t) => ae(t) || Se(t),
-  nextTick: ut
+  atom: Pe,
+  computed: ot,
+  effect: D,
+  batch: Ke,
+  untracked: we,
+  isAtom: pe,
+  isComputed: Ae,
+  isReactive: (t) => pe(t) || Ae(t),
+  nextTick: lt
 });
-function we() {
+function $e() {
   return { timeoutId: null, phase: "idle", hasFocus: !1 };
 }
-function ke(t, e, s = {}) {
+function Le(t, e, s = {}) {
   const {
     debounce: n,
     event: i = "input",
-    parse: r = (p) => p,
-    format: o = (p) => String(p ?? "")
-  } = s, c = we(), f = () => {
+    parse: r = (I) => I,
+    format: o = (I) => String(I ?? "")
+  } = s, c = $e(), h = () => {
     c.phase = "composing";
   }, _ = () => {
-    c.phase = "idle", F();
+    c.phase = "idle", T();
   };
-  t.on("compositionstart", f), t.on("compositionend", _);
-  const w = () => {
+  t.on("compositionstart", h), t.on("compositionend", _);
+  const m = () => {
     c.hasFocus = !0;
-  }, m = () => {
+  }, G = () => {
     c.hasFocus = !1;
-    const p = o(e.value);
-    t.val() !== p && t.val(p);
+    const I = o(e.value);
+    t.val() !== I && t.val(I);
   };
-  t.on("focus", w), t.on("blur", m);
-  const F = () => {
+  t.on("focus", m), t.on("blur", G);
+  const T = () => {
     c.phase === "idle" && (c.phase = "syncing-to-atom", e.value = r(t.val()), c.phase = "idle");
-  }, C = () => {
-    c.phase === "idle" && (n ? (c.timeoutId && clearTimeout(c.timeoutId), c.timeoutId = window.setTimeout(F, n)) : F());
+  }, x = () => {
+    c.phase === "idle" && (n ? (c.timeoutId && clearTimeout(c.timeoutId), c.timeoutId = window.setTimeout(T, n)) : T());
   };
-  return t.on(i, C), t.on("change", C), { effect: () => {
-    const p = o(e.value), $ = t.val();
-    if ($ !== p) {
-      if (c.hasFocus && r($) === e.value)
+  return t.on(i, x), t.on("change", x), { effect: () => {
+    const I = o(e.value), H = t.val();
+    if (H !== I) {
+      if (c.hasFocus && r(H) === e.value)
         return;
-      c.phase = "syncing-to-dom", t.val(p), h.domUpdated(t, "val", p), c.phase = "idle";
+      c.phase = "syncing-to-dom", t.val(I), l.domUpdated(t, "val", I), c.phase = "idle";
     }
   }, cleanup: () => {
-    t.off(i, C), t.off("change", C), t.off("compositionstart", f), t.off("compositionend", _), t.off("focus", w), t.off("blur", m), c.timeoutId && clearTimeout(c.timeoutId);
+    t.off(i, x), t.off("change", x), t.off("compositionstart", h), t.off("compositionend", _), t.off("focus", m), t.off("blur", G), c.timeoutId && clearTimeout(c.timeoutId);
   } };
 }
-class ht {
-  // DOM Element -> Effect Array (for disposal)
+class ft {
   effects = /* @__PURE__ */ new WeakMap();
-  // DOM Element -> Custom Cleanup Function Array
   cleanups = /* @__PURE__ */ new WeakMap();
-  // Track bound elements (Performance optimization)
   boundElements = /* @__PURE__ */ new WeakSet();
-  /**
-   * Tracks elements that are temporarily detached (e.g. via .detach())
-   * so they are NOT cleaned up by the MutationObserver.
-   */
   preservedNodes = /* @__PURE__ */ new WeakSet();
   keep(e) {
     this.preservedNodes.add(e);
@@ -1292,183 +1431,156 @@ class ht {
   isKept(e) {
     return this.preservedNodes.has(e);
   }
-  /**
-   * Registers an Effect to be disposed later.
-   */
   trackEffect(e, s) {
-    const n = this.effects.get(e) || [];
-    n.push(s), this.effects.set(e, n), this.boundElements.add(e);
+    let n = this.effects.get(e);
+    n || (n = [], this.effects.set(e, n), this.boundElements.add(e)), n.push(s);
   }
-  /**
-   * Registers a custom cleanup function (e.g., event listener removal).
-   */
   trackCleanup(e, s) {
-    const n = this.cleanups.get(e) || [];
-    n.push(s), this.cleanups.set(e, n), this.boundElements.add(e);
+    let n = this.cleanups.get(e);
+    n || (n = [], this.cleanups.set(e, n), this.boundElements.add(e)), n.push(s);
   }
-  /**
-   * Checks if an element has bindings (Fast check).
-   */
   hasBind(e) {
     return this.boundElements.has(e);
   }
-  /**
-   * Cleans up a single element.
-   * - Disposes all Effects (severs connection with Atom).
-   * - Executes all custom cleanups.
-   */
   cleanup(e) {
-    if (!this.boundElements.has(e)) return;
-    h.cleanup(ce(e));
+    if (!this.boundElements.delete(e)) return;
+    l.cleanup(ae(e));
     const s = this.effects.get(e);
-    s && (this.effects.delete(e), s.forEach((i) => {
-      try {
-        i.dispose();
-      } catch (r) {
-        h.warn("Effect dispose error:", r);
+    if (s) {
+      this.effects.delete(e);
+      for (let i = 0, r = s.length; i < r; i++) {
+        const o = s[i];
+        if (o)
+          try {
+            o.dispose();
+          } catch (c) {
+            l.warn("Effect dispose error:", c);
+          }
       }
-    }));
+    }
     const n = this.cleanups.get(e);
-    n && (this.cleanups.delete(e), n.forEach((i) => {
-      try {
-        i();
-      } catch (r) {
-        h.warn("Cleanup error:", r);
+    if (n) {
+      this.cleanups.delete(e);
+      for (let i = 0, r = n.length; i < r; i++) {
+        const o = n[i];
+        if (o)
+          try {
+            o();
+          } catch (c) {
+            l.warn("Cleanup error:", c);
+          }
       }
-    })), this.boundElements.delete(e);
+    }
   }
-  /**
-   * Cleans up the element and all its descendants (Recursive).
-   * - Essential for deep removal (empty(), remove(), etc.).
-   */
   cleanupTree(e) {
-    e.querySelectorAll("*").forEach((n) => {
-      this.boundElements.has(n) && this.cleanup(n);
-    }), this.cleanup(e);
+    const s = e.querySelectorAll("*");
+    for (let n = 0, i = s.length; n < i; n++) {
+      const r = s[n];
+      r && this.boundElements.has(r) && this.cleanup(r);
+    }
+    this.cleanup(e);
   }
 }
-const l = new ht();
-let H = null;
-function at(t = document.body) {
-  H || (H = new MutationObserver((e) => {
-    for (const s of e)
-      s.removedNodes.forEach((n) => {
-        l.isKept(n) || n.isConnected || n.nodeType === 1 && l.cleanupTree(n);
-      });
-  }), H.observe(t, { childList: !0, subtree: !0 }));
+const f = new ft();
+let W = null;
+function dt(t = document.body) {
+  W || (W = new MutationObserver((e) => {
+    for (let s = 0, n = e.length; s < n; s++) {
+      const i = e[s];
+      if (!i) continue;
+      const r = i.removedNodes;
+      for (let o = 0, c = r.length; o < c; o++) {
+        const h = r[o];
+        h && (f.isKept(h) || h.isConnected || h.nodeType === 1 && f.cleanupTree(h));
+      }
+    }
+  }), W.observe(t, { childList: !0, subtree: !0 }));
 }
-function Ct() {
-  H?.disconnect(), H = null;
+function Nt() {
+  W?.disconnect(), W = null;
 }
 u.fn.atomText = function(t, e) {
-  return this.each(function() {
-    const s = u(this);
-    if (b(t)) {
-      const n = I(() => {
-        const i = E(t), r = e ? e(i) : String(i ?? "");
-        s.text(r), h.domUpdated(s, "text", r);
+  if (p(t))
+    return this.each(function() {
+      const n = u(this), i = D(() => {
+        const r = t.value, o = e ? e(r) : String(r ?? "");
+        n.text(o), l.domUpdated(n, "text", o);
       });
-      l.trackEffect(this, n);
-    } else {
-      const n = e ? e(t) : String(t ?? "");
-      s.text(n);
-    }
-  });
+      f.trackEffect(this, i);
+    });
+  const s = e ? e(t) : String(t ?? "");
+  return this.text(s);
 };
 u.fn.atomHtml = function(t) {
-  return this.each(function() {
-    const e = u(this);
-    if (b(t)) {
-      const s = I(() => {
-        const n = String(E(t) ?? "");
-        e.html(n), h.domUpdated(e, "html", n);
-      });
-      l.trackEffect(this, s);
-    } else
-      e.html(String(t ?? ""));
-  });
+  return p(t) ? this.each(function() {
+    const e = u(this), s = D(() => {
+      const n = String(t.value ?? "");
+      e.html(n), l.domUpdated(e, "html", n);
+    });
+    f.trackEffect(this, s);
+  }) : this.html(String(t ?? ""));
 };
 u.fn.atomClass = function(t, e) {
-  return this.each(function() {
-    const s = u(this);
-    if (b(e)) {
-      const n = I(() => {
-        const i = !!E(e);
-        s.toggleClass(t, i), h.domUpdated(s, `class.${t}`, i);
-      });
-      l.trackEffect(this, n);
-    } else
-      s.toggleClass(t, !!e);
-  });
+  return p(e) ? this.each(function() {
+    const s = u(this), n = D(() => {
+      const i = !!e.value;
+      s.toggleClass(t, i), l.domUpdated(s, `class.${t}`, i);
+    });
+    f.trackEffect(this, n);
+  }) : this.toggleClass(t, !!e);
 };
 u.fn.atomCss = function(t, e, s) {
-  return this.each(function() {
-    const n = u(this);
-    if (b(e)) {
-      const i = I(() => {
-        const r = E(e), o = s ? `${r}${s}` : r;
-        n.css(t, o), h.domUpdated(n, `css.${t}`, o);
+  if (p(e))
+    return this.each(function() {
+      const i = u(this), r = D(() => {
+        const o = e.value, c = s ? `${o}${s}` : o;
+        i.css(t, c), l.domUpdated(i, `css.${t}`, c);
       });
-      l.trackEffect(this, i);
-    } else
-      n.css(t, s ? `${e}${s}` : e);
-  });
+      f.trackEffect(this, r);
+    });
+  const n = s ? `${e}${s}` : e;
+  return this.css(t, n);
 };
 u.fn.atomAttr = function(t, e) {
-  return this.each(function() {
-    const s = u(this), n = (i) => {
-      i == null || i === !1 ? s.removeAttr(t) : i === !0 ? s.attr(t, t) : s.attr(t, String(i)), h.domUpdated(s, `attr.${t}`, i);
-    };
-    if (b(e)) {
-      const i = I(() => n(E(e)));
-      l.trackEffect(this, i);
-    } else
-      n(e);
-  });
+  return p(e) ? this.each(function() {
+    const s = u(this), n = D(() => {
+      const i = e.value;
+      i == null || i === !1 ? s.removeAttr(t) : i === !0 ? s.attr(t, t) : s.attr(t, String(i)), l.domUpdated(s, `attr.${t}`, i);
+    });
+    f.trackEffect(this, n);
+  }) : e == null || e === !1 ? this.removeAttr(t) : e === !0 ? this.attr(t, t) : this.attr(t, String(e));
 };
 u.fn.atomProp = function(t, e) {
-  return this.each(function() {
-    const s = u(this);
-    if (b(e)) {
-      const n = I(() => {
-        const i = E(e);
-        s.prop(t, i), h.domUpdated(s, `prop.${t}`, i);
-      });
-      l.trackEffect(this, n);
-    } else
-      s.prop(t, e);
-  });
+  return p(e) ? this.each(function() {
+    const s = u(this), n = D(() => {
+      const i = e.value;
+      s.prop(t, i), l.domUpdated(s, `prop.${t}`, i);
+    });
+    f.trackEffect(this, n);
+  }) : this.prop(t, e);
 };
 u.fn.atomShow = function(t) {
-  return this.each(function() {
-    const e = u(this);
-    if (b(t)) {
-      const s = I(() => {
-        const n = !!E(t);
-        e.toggle(n), h.domUpdated(e, "show", n);
-      });
-      l.trackEffect(this, s);
-    } else
-      e.toggle(!!t);
-  });
+  return p(t) ? this.each(function() {
+    const e = u(this), s = D(() => {
+      const n = !!t.value;
+      e.toggle(n), l.domUpdated(e, "show", n);
+    });
+    f.trackEffect(this, s);
+  }) : this.toggle(!!t);
 };
 u.fn.atomHide = function(t) {
-  return this.each(function() {
-    const e = u(this);
-    if (b(t)) {
-      const s = I(() => {
-        const n = !E(t);
-        e.toggle(n), h.domUpdated(e, "hide", !n);
-      });
-      l.trackEffect(this, s);
-    } else
-      e.toggle(!t);
-  });
+  return p(t) ? this.each(function() {
+    const e = u(this), s = D(() => {
+      const n = !t.value;
+      e.toggle(n), l.domUpdated(e, "hide", !n);
+    });
+    f.trackEffect(this, s);
+  }) : this.toggle(!t);
 };
 u.fn.atomVal = function(t, e = {}) {
   return this.each(function() {
-    const { effect: s, cleanup: n } = ke(u(this), t, e), i = I(s);
-    l.trackEffect(this, i), l.trackCleanup(this, n);
+    const s = u(this), { effect: n, cleanup: i } = Le(s, t, e), r = D(n);
+    f.trackEffect(this, r), f.trackCleanup(this, i);
   });
 };
 u.fn.atomChecked = function(t) {
@@ -1476,100 +1588,100 @@ u.fn.atomChecked = function(t) {
     const e = u(this);
     let s = !1;
     const n = () => {
-      s || (t.value = e.prop("checked"));
+      s || (t.value = !!e.prop("checked"));
     };
-    e.on("change", n), l.trackCleanup(this, () => e.off("change", n));
-    const i = I(() => {
-      s = !0, e.prop("checked", t.value), h.domUpdated(e, "checked", t.value), s = !1;
+    e.on("change", n), f.trackCleanup(this, () => e.off("change", n));
+    const i = D(() => {
+      s = !0;
+      const r = !!t.value;
+      e.prop("checked", r), l.domUpdated(e, "checked", r), s = !1;
     });
-    l.trackEffect(this, i);
+    f.trackEffect(this, i);
   });
 };
 u.fn.atomOn = function(t, e) {
   return this.each(function() {
-    const s = u(this), n = function(i) {
-      e.call(this, i);
-    };
-    s.on(t, n), l.trackCleanup(this, () => s.off(t, n));
+    const s = u(this);
+    s.on(t, e), f.trackCleanup(this, () => s.off(t, e));
   });
 };
 u.fn.atomUnbind = function() {
   return this.each(function() {
-    l.cleanupTree(this);
+    f.cleanupTree(this);
   });
 };
-function lt(t, e) {
-  b(e) ? t.effects.push(() => {
-    const s = String(E(e) ?? "");
-    t.$el.text(s), h.domUpdated(t.$el, "text", s);
+function _t(t, e) {
+  p(e) ? t.effects.push(() => {
+    const s = String(k(e) ?? "");
+    t.$el.text(s), l.domUpdated(t.$el, "text", s);
   }) : t.$el.text(String(e ?? ""));
 }
-function ft(t, e) {
-  b(e) ? t.effects.push(() => {
-    const s = String(E(e) ?? "");
-    t.$el.html(s), h.domUpdated(t.$el, "html", s);
+function pt(t, e) {
+  p(e) ? t.effects.push(() => {
+    const s = String(k(e) ?? "");
+    t.$el.html(s), l.domUpdated(t.$el, "html", s);
   }) : t.$el.html(String(e ?? ""));
 }
-function dt(t, e) {
+function bt(t, e) {
   for (const [s, n] of Object.entries(e))
-    b(n) ? t.effects.push(() => {
-      const i = !!E(n);
-      t.$el.toggleClass(s, i), h.domUpdated(t.$el, `class.${s}`, i);
+    p(n) ? t.effects.push(() => {
+      const i = !!k(n);
+      t.$el.toggleClass(s, i), l.domUpdated(t.$el, `class.${s}`, i);
     }) : t.$el.toggleClass(s, !!n);
 }
-function _t(t, e) {
+function Et(t, e) {
   for (const [s, n] of Object.entries(e))
     if (Array.isArray(n)) {
       const [i, r] = n;
-      b(i) ? t.effects.push(() => {
-        const o = `${E(i)}${r}`;
-        t.$el.css(s, o), h.domUpdated(t.$el, `css.${s}`, o);
+      p(i) ? t.effects.push(() => {
+        const o = `${k(i)}${r}`;
+        t.$el.css(s, o), l.domUpdated(t.$el, `css.${s}`, o);
       }) : t.$el.css(s, `${i}${r}`);
-    } else b(n) ? t.effects.push(() => {
-      const i = E(n);
-      t.$el.css(s, i), h.domUpdated(t.$el, `css.${s}`, i);
+    } else p(n) ? t.effects.push(() => {
+      const i = k(n);
+      t.$el.css(s, i), l.domUpdated(t.$el, `css.${s}`, i);
     }) : t.$el.css(s, n);
 }
-function pt(t, e) {
+function gt(t, e) {
   for (const [s, n] of Object.entries(e)) {
     const i = (r) => {
-      r == null || r === !1 ? t.$el.removeAttr(s) : r === !0 ? t.$el.attr(s, s) : t.$el.attr(s, String(r)), h.domUpdated(t.$el, `attr.${s}`, r);
+      r == null || r === !1 ? t.$el.removeAttr(s) : r === !0 ? t.$el.attr(s, s) : t.$el.attr(s, String(r)), l.domUpdated(t.$el, `attr.${s}`, r);
     };
-    b(n) ? t.effects.push(() => i(E(n))) : i(n);
+    p(n) ? t.effects.push(() => i(k(n))) : i(n);
   }
 }
-function bt(t, e) {
+function mt(t, e) {
   for (const [s, n] of Object.entries(e))
-    b(n) ? t.effects.push(() => {
-      const i = E(n);
-      t.$el.prop(s, i), h.domUpdated(t.$el, `prop.${s}`, i);
+    p(n) ? t.effects.push(() => {
+      const i = k(n);
+      t.$el.prop(s, i), l.domUpdated(t.$el, `prop.${s}`, i);
     }) : t.$el.prop(s, n);
 }
-function Et(t, e) {
-  b(e) ? t.effects.push(() => {
-    const s = !!E(e);
-    t.$el.toggle(s), h.domUpdated(t.$el, "show", s);
+function St(t, e) {
+  p(e) ? t.effects.push(() => {
+    const s = !!k(e);
+    t.$el.toggle(s), l.domUpdated(t.$el, "show", s);
   }) : t.$el.toggle(!!e);
 }
-function gt(t, e) {
-  b(e) ? t.effects.push(() => {
-    const s = !E(e);
-    t.$el.toggle(s), h.domUpdated(t.$el, "hide", !s);
+function yt(t, e) {
+  p(e) ? t.effects.push(() => {
+    const s = !k(e);
+    t.$el.toggle(s), l.domUpdated(t.$el, "hide", !s);
   }) : t.$el.toggle(!e);
 }
-function mt(t, e) {
-  const s = Array.isArray(e) ? e[0] : e, n = Array.isArray(e) ? e[1] : {}, { effect: i, cleanup: r } = ke(t.$el, s, n);
+function Dt(t, e) {
+  const s = Array.isArray(e) ? e[0] : e, n = Array.isArray(e) ? e[1] : {}, { effect: i, cleanup: r } = Le(t.$el, s, n);
   t.effects.push(i), t.trackCleanup(r);
 }
-function yt(t, e) {
-  const s = we(), n = () => {
+function It(t, e) {
+  const s = $e(), n = () => {
     s.phase === "idle" && (e.value = t.$el.prop("checked"));
   };
   t.$el.on("change", n), t.trackCleanup(() => t.$el.off("change", n)), t.effects.push(() => {
-    s.phase = "syncing-to-dom", t.$el.prop("checked", e.value), h.domUpdated(t.$el, "checked", e.value), s.phase = "idle";
+    s.phase = "syncing-to-dom", t.$el.prop("checked", e.value), l.domUpdated(t.$el, "checked", e.value), s.phase = "idle";
   });
 }
-function St(t, e) {
+function Ct(t, e) {
   for (const [s, n] of Object.entries(e)) {
     const i = function(r) {
       n.call(this, r);
@@ -1583,148 +1695,151 @@ u.fn.atomBind = function(t) {
       $el: e,
       el: this,
       effects: s,
-      trackCleanup: (i) => l.trackCleanup(this, i)
+      trackCleanup: (i) => f.trackCleanup(this, i)
     };
-    t.text !== void 0 && lt(n, t.text), t.html !== void 0 && ft(n, t.html), t.class && dt(n, t.class), t.css && _t(n, t.css), t.attr && pt(n, t.attr), t.prop && bt(n, t.prop), t.show !== void 0 && Et(n, t.show), t.hide !== void 0 && gt(n, t.hide), t.val !== void 0 && mt(n, t.val), t.checked !== void 0 && yt(n, t.checked), t.on && St(n, t.on), s.forEach((i) => {
-      const r = I(i);
-      l.trackEffect(this, r);
+    t.text !== void 0 && _t(n, t.text), t.html !== void 0 && pt(n, t.html), t.class && bt(n, t.class), t.css && Et(n, t.css), t.attr && gt(n, t.attr), t.prop && mt(n, t.prop), t.show !== void 0 && St(n, t.show), t.hide !== void 0 && yt(n, t.hide), t.val !== void 0 && Dt(n, t.val), t.checked !== void 0 && It(n, t.checked), t.on && Ct(n, t.on), s.forEach((i) => {
+      const r = D(i);
+      f.trackEffect(this, r);
     });
   });
 };
-function Dt(t) {
-  if (t.length === 0) return [];
-  const e = t.slice(), s = [0];
-  let n, i, r, o;
-  const c = t.length;
-  for (n = 0; n < c; n++) {
-    const w = t[n];
-    if (w !== -1) {
-      const m = s[s.length - 1];
-      if (t[m] < w) {
-        e[n] = m, s.push(n);
-        continue;
-      }
-      for (i = 0, r = s.length - 1; i < r; )
-        o = (i + r) / 2 | 0, t[s[o]] < w ? i = o + 1 : r = o;
-      w < t[s[i]] && (i > 0 && (e[n] = s[i - 1]), s[i] = n);
+function vt(t) {
+  const e = t.length;
+  if (e === 0) return new Int32Array(0);
+  const s = new Int32Array(e), n = new Int32Array(e);
+  let i = 0;
+  for (let o = 0; o < e; o++) {
+    const c = t[o];
+    if (c === -1) continue;
+    if (i === 0 || t[n[i - 1]] < c) {
+      s[o] = i > 0 ? n[i - 1] : -1, n[i++] = o;
+      continue;
     }
+    let h = 0, _ = i - 1;
+    for (; h < _; ) {
+      const m = h + _ >>> 1;
+      t[n[m]] < c ? h = m + 1 : _ = m;
+    }
+    c < t[n[h]] && (h > 0 && (s[o] = n[h - 1]), n[h] = o);
   }
-  let f = s.length, _ = s[f - 1];
-  for (; f-- > 0; )
-    s[f] = _, _ = e[_];
-  return s;
+  const r = new Int32Array(i);
+  for (let o = i - 1, c = n[i - 1]; o >= 0; o--)
+    r[o] = c, c = s[c];
+  return r;
 }
 u.fn.atomList = function(t, e) {
+  const { key: s, render: n, bind: i, update: r, onAdd: o, onRemove: c, empty: h } = e, _ = typeof s == "function" ? s : (m) => m[s];
   return this.each(function() {
-    const s = u(this), n = ce(this), { key: i, render: r, bind: o, onAdd: c, onRemove: f, empty: _ } = e, w = typeof i == "function" ? i : (p) => p[i], m = /* @__PURE__ */ new Map();
-    let F = [], C = null;
-    const Y = /* @__PURE__ */ new Set(), de = I(() => {
-      const p = t.value, $ = [], _e = /* @__PURE__ */ new Set();
-      for (let a = 0; a < p.length; a++) {
-        const g = p[a], N = w(g, a);
-        $.push(N), _e.add(N);
+    const m = u(this), G = ae(this), T = /* @__PURE__ */ new Map(), x = /* @__PURE__ */ new Set();
+    let M = [], P = null;
+    const I = D(() => {
+      const H = t.value, U = H.length;
+      if (U === 0 ? h && !P && (P = u(h).appendTo(m)) : P && (P.remove(), P = null), U === 0 && T.size === 0) {
+        M = [];
+        return;
       }
-      if (h.log("list", `${n} updating with ${p.length} items`), p.length === 0 && _) {
-        C || (C = u(_), s.append(C));
-        for (const [, a] of m) {
-          a.$el.remove();
-          const g = a.$el[0];
-          g && l.cleanup(g);
-        }
-        m.clear(), F = [];
+      l.log("list", `${G} updating with ${U} items`);
+      const ee = new Array(U), ge = /* @__PURE__ */ new Set();
+      for (let a = 0; a < U; a++) {
+        const b = H[a], C = _(b, a);
+        ee[a] = C, ge.add(C);
+      }
+      for (const [a, b] of T) {
+        if (ge.has(a) || x.has(a)) continue;
+        const C = () => {
+          b.$el.remove();
+          const E = b.$el[0];
+          E && f.cleanup(E), x.delete(a), l.log("list", `${G} removed item:`, a);
+        };
+        if (T.delete(a), x.add(a), c) {
+          const E = c(b.$el);
+          E instanceof Promise ? E.then(C) : C();
+        } else
+          C();
+      }
+      if (U === 0) {
+        M = [];
         return;
-      } else C && (C.remove(), C = null);
-      for (const [a, g] of m)
-        if (!_e.has(a)) {
-          if (Y.has(a)) continue;
-          const N = () => {
-            g.$el.remove();
-            const K = g.$el[0];
-            K && l.cleanup(K), Y.delete(a), h.log("list", `${n} removed item:`, a);
-          };
-          m.delete(a), Y.add(a), f ? Promise.resolve(f(g.$el)).then(N) : N();
-        }
-      const pe = /* @__PURE__ */ new Map();
-      F.forEach((a, g) => pe.set(a, g));
-      const Me = $.map((a) => pe.get(a) ?? -1), $e = Dt(Me), Pe = new Set($e);
-      let T = null;
-      for (let a = p.length - 1; a >= 0; a--) {
-        const g = $[a], N = p[a], K = Pe.has(a);
-        if (m.has(g)) {
-          const v = m.get(g);
-          if (!v) continue;
-          v.item = N;
-          const R = v.$el[0];
-          if (!R) continue;
-          if (e.update && e.update(v.$el, N, a), !K)
-            T ? v.$el.insertBefore(T) : v.$el.appendTo(s);
-          else {
-            const X = R.nextSibling;
-            T && X !== T ? v.$el.insertBefore(T) : !T && X && v.$el.appendTo(s);
-          }
-          T = R;
+      }
+      const me = /* @__PURE__ */ new Map();
+      for (let a = 0; a < M.length; a++) {
+        const b = M[a];
+        b !== void 0 && me.set(b, a);
+      }
+      const Se = new Int32Array(U);
+      for (let a = 0; a < U; a++) {
+        const b = ee[a];
+        Se[a] = b !== void 0 ? me.get(b) ?? -1 : -1;
+      }
+      const ye = vt(Se);
+      let le = ye.length - 1, O = null;
+      for (let a = U - 1; a >= 0; a--) {
+        const b = ee[a], C = H[a], E = T.get(b);
+        if (E) {
+          E.item = C;
+          const $ = E.$el[0];
+          if (!$) continue;
+          r && r(E.$el, C, a), le >= 0 && ye[le] === a ? (le--, $.nextSibling !== O && (O ? E.$el.insertBefore(O) : E.$el.appendTo(m))) : O ? E.$el.insertBefore(O) : E.$el.appendTo(m), O = $;
         } else {
-          const v = r(N, a), R = v instanceof Element ? u(v) : u(v);
-          m.set(g, { $el: R, item: N }), T ? R.insertBefore(T) : R.appendTo(s), o && o(R, N, a), c && c(R), h.log("list", `${n} added item:`, g);
-          const X = R[0];
-          X && (T = X);
+          const $ = n(C, a), L = $ instanceof Element ? u($) : u($);
+          T.set(b, { $el: L, item: C }), O ? L.insertBefore(O) : L.appendTo(m), i && i(L, C, a), o && o(L), l.log("list", `${G} added item:`, b), O = L[0] || null;
         }
       }
-      F = $;
+      M = ee;
     });
-    l.trackEffect(this, de), l.trackCleanup(this, () => {
-      m.clear(), F = [], C?.remove();
+    f.trackEffect(this, I), f.trackCleanup(this, () => {
+      T.clear(), x.clear(), M = [], P?.remove();
     });
   });
 };
-const te = /* @__PURE__ */ new WeakMap();
+const ie = /* @__PURE__ */ new WeakMap();
 u.fn.atomMount = function(t, e = {}) {
   return this.each(function() {
-    const s = u(this), n = ce(this), i = te.get(this);
-    i && (h.log("mount", `${n} unmounting existing component`), i()), h.log("mount", `${n} mounting component`);
+    const s = u(this), n = ae(this), i = ie.get(this);
+    i && (l.log("mount", `${n} unmounting existing component`), i()), l.log("mount", `${n} mounting component`);
     let r;
     try {
       r = t(s, e);
-    } catch (f) {
-      console.error("[atom-effect-jquery] Mount error:", f);
+    } catch (h) {
+      console.error("[atom-effect-jquery] Mount error:", h);
       return;
     }
     let o = !1;
     const c = () => {
       if (!o) {
-        if (o = !0, h.log("mount", `${n} full cleanup`), typeof r == "function")
+        if (o = !0, l.log("mount", `${n} full cleanup`), typeof r == "function")
           try {
             r();
           } catch {
           }
-        l.cleanupTree(this), te.delete(this);
+        f.cleanupTree(this), ie.delete(this);
       }
     };
-    te.set(this, c), l.trackCleanup(this, c);
+    ie.set(this, c), f.trackCleanup(this, c);
   });
 };
 u.fn.atomUnmount = function() {
   return this.each(function() {
-    te.get(this)?.();
+    ie.get(this)?.();
   });
 };
-const G = /* @__PURE__ */ new WeakMap();
-let De = !1;
-function Fe() {
-  if (De) return;
-  De = !0;
+const J = /* @__PURE__ */ new WeakMap();
+let Ne = !1;
+function je() {
+  if (Ne) return;
+  Ne = !0;
   const t = u.fn.on, e = u.fn.off, s = u.fn.remove, n = u.fn.empty, i = u.fn.detach;
   u.fn.remove = function(r) {
     return (r ? this.filter(r) : this).each(function() {
-      l.cleanupTree(this);
+      f.cleanupTree(this);
     }), s.call(this, r);
   }, u.fn.empty = function() {
     return this.each(function() {
-      this.querySelectorAll("*").forEach((o) => l.cleanup(o));
+      this.querySelectorAll("*").forEach((o) => f.cleanup(o));
     }), n.call(this);
   }, u.fn.detach = function(r) {
     return (r ? this.filter(r) : this).each(function() {
-      l.keep(this);
+      f.keep(this);
     }), i.call(this, r);
   }, u.fn.on = function(...r) {
     let o = -1;
@@ -1735,10 +1850,10 @@ function Fe() {
       }
     if (o !== -1) {
       const c = r[o];
-      let f;
-      G.has(c) ? f = G.get(c) : (f = function(..._) {
+      let h;
+      J.has(c) ? h = J.get(c) : (h = function(..._) {
         return c.apply(this, _);
-      }, G.set(c, f)), r[o] = f;
+      }, J.set(c, h)), r[o] = h;
     }
     return t.apply(this, r);
   }, u.fn.off = function(...r) {
@@ -1750,27 +1865,27 @@ function Fe() {
       }
     if (o !== -1) {
       const c = r[o];
-      G.has(c) && (r[o] = G.get(c));
+      J.has(c) && (r[o] = J.get(c));
     }
     return e.apply(this, r);
   };
 }
-const vt = Fe;
-Fe();
+const Rt = je;
+je();
 u(() => {
-  at(document.body);
+  dt(document.body);
 });
 export {
-  st as atom,
-  He as batch,
-  nt as computed,
-  Tt as default,
-  Ct as disableAutoCleanup,
-  I as effect,
-  at as enableAutoCleanup,
-  vt as enablejQueryBatching,
-  Fe as enablejQueryOverrides,
-  l as registry,
-  xe as untracked
+  rt as atom,
+  Ke as batch,
+  ot as computed,
+  Ot as default,
+  Nt as disableAutoCleanup,
+  D as effect,
+  dt as enableAutoCleanup,
+  Rt as enablejQueryBatching,
+  je as enablejQueryOverrides,
+  f as registry,
+  we as untracked
 };
 //# sourceMappingURL=index.mjs.map