@solidjs/signals 2.0.0-beta.25 → 2.0.0-beta.27

package/dist/prod/core/scheduler.js

@@ -19,14 +19,14 @@ const transitions = new Set;
 const dirtyQueue = {
     eE: new Array(2e3).fill(undefined),
     tE: false,
-    Fe: 0,
+    He: 0,
     EE: 0
 };
 
 const zombieQueue = {
     eE: new Array(2e3).fill(undefined),
     tE: false,
-    Fe: 0,
+    He: 0,
     EE: 0
 };
 
@@ -56,7 +56,7 @@ function registerTransientStoreNode(e) {
 
 function canUseSimpleSyncFlush(e) {
     const t = e.m;
-    return transitions.size === 0 && activeLanes.size === 0 && e.vt.length === 0 && t.Ze.length === 0 && t.A.length === 0 && t.cn.size === 0 && transientStoreNodes.size === 0;
+    return transitions.size === 0 && activeLanes.size === 0 && e.vt.length === 0 && t.je.length === 0 && t.A.length === 0 && t.cn.size === 0 && transientStoreNodes.size === 0;
 }
 
 function sweepTransientStoreNodes() {
@@ -66,14 +66,14 @@ function sweepTransientStoreNodes() {
             transientStoreNodes.delete(e);
             continue;
         }
-        if (e.Ne !== NOT_PENDING) continue;
-        if (e.Ee !== undefined && e.Ee !== NOT_PENDING) continue;
+        if (e.De !== NOT_PENDING) continue;
+        if (e.Ae !== undefined && e.Ae !== NOT_PENDING) continue;
         // A live affects() mark keeps the node addressable: sweeping it would
         // detach the refcount from the slot (a fresh probe would upsert a new,
         // unmarked node for the same property).
                 if (e.t) continue;
         transientStoreNodes.delete(e);
-        e.it?.();
+        e.ut?.();
     }
 }
 
@@ -100,15 +100,15 @@ function setProjectionWriteActive(e) {
  * land there directly — no per-field aliasing.
  */ function createBatch() {
     return {
-        ce: clock,
+        Se: clock,
         Qt: [],
-        yt: new Map,
-        Ze: [],
+        Ee: new Map,
+        je: [],
         A: [],
         cn: new Set,
         ie: [],
-        gt: {
-            bt: [ [], [] ],
+        yt: {
+            gt: [ [], [] ],
             vt: []
         },
         fn: false,
@@ -119,13 +119,13 @@ function setProjectionWriteActive(e) {
 function mergeTransitionState(e, t) {
     t.fn = e;
     e.ie.push(...t.ie);
-    for (const i of activeLanes) if (i.Ue === t) i.Ue = e;
-    if (t.Ze.length) {
+    for (const i of activeLanes) if (i.Ie === t) i.Ie = e;
+    if (t.je.length) {
         // Move (don't copy): the global queue's batch may still be the outgoing
         // transition, and the adoption pass in initTransition would re-push its
         // contents into the target — duplicating every entry.
-        e.Ze.push(...t.Ze);
-        t.Ze.length = 0;
+        e.je.push(...t.je);
+        t.je.length = 0;
     }
     if (t.A.length) {
         // Move (don't copy): the global queue's batch may still be the outgoing
@@ -135,9 +135,9 @@ function mergeTransitionState(e, t) {
         t.A.length = 0;
     }
     for (const i of t.cn) e.cn.add(i);
-    for (const [i, n] of t.yt) {
-        let t = e.yt.get(i);
-        if (!t) e.yt.set(i, t = new Set);
+    for (const [i, n] of t.Ee) {
+        let t = e.Ee.get(i);
+        if (!t) e.Ee.set(i, t = new Set);
         for (const e of n) t.add(e);
     }
     for (const i of t.ln) e.ln.add(i);
@@ -150,7 +150,7 @@ function schedule() {
     }
     if (scheduled) return;
     scheduled = true;
-    if (!syncDepth && !globalQueue.kt && !projectionWriteActive) queueMicrotask(flush);
+    if (!syncDepth && !globalQueue.bt && !projectionWriteActive) queueMicrotask(flush);
 }
 
 /**
@@ -179,33 +179,58 @@ function notifyHalted() {
     haltNotified = false;
 }
 
+// Identifies one child-traversal pass in `Queue.run` so a rescan after the
+// child list shifts can tell "already run this pass" from "still pending".
+let queueRunToken = 0;
+
 class Queue {
-    Ge=null;
-    bt=[ [], [] ];
+    ve=null;
+    gt=[ [], [] ];
     vt=[];
+    kt=0;
     created=clock;
     addChild(e) {
         this.vt.push(e);
-        e.Ge = this;
+        e.ve = this;
     }
     removeChild(e) {
         const t = this.vt.indexOf(e);
         if (t >= 0) {
             this.vt.splice(t, 1);
-            e.Ge = null;
+            e.ve = null;
         }
     }
     notify(e, t, i, n) {
-        if (this.Ge) return this.Ge.notify(e, t, i, n);
+        if (this.ve) return this.ve.notify(e, t, i, n);
         return false;
     }
     run(e) {
-        if (this.bt[e - 1].length) {
-            const t = this.bt[e - 1];
-            this.bt[e - 1] = [];
+        if (this.gt[e - 1].length) {
+            const t = this.gt[e - 1];
+            this.gt[e - 1] = [];
             runQueue(t, e);
         }
-        for (let t = 0; t < this.vt.length; t++) this.vt[t].run?.(e);
+        // Effects run here can dispose owners, and disposal removes queues from
+        // this list — the running child itself, an earlier sibling, or several at
+        // once. A plain index walk then skips whatever shifted into the cursor.
+        // Stamping each child before it runs makes the pass idempotent, so a shift
+        // can be recovered by rescanning from the front and every child still runs
+        // exactly once. Children appended mid-pass carry a stale stamp and run,
+        // matching the previous live-array behaviour.
+                const t = this.vt;
+        const i = ++queueRunToken;
+        for (let n = 0; n < t.length; ) {
+            const s = t[n];
+            if (s.kt !== i) {
+                s.kt = i;
+                s.run?.(e);
+                if (t[n] !== s) {
+                    n = 0;
+                    continue;
+                }
+            }
+            n++;
+        }
     }
     enqueue(e, t) {
         if (e) {
@@ -214,21 +239,21 @@ class Queue {
                 const i = findLane(currentOptimisticLane);
                 i.rn[e - 1].push(t);
             } else {
-                this.bt[e - 1].push(t);
+                this.gt[e - 1].push(t);
             }
         }
         schedule();
     }
     stashQueues(e) {
-        e.bt[0].push(...this.bt[0]);
-        e.bt[1].push(...this.bt[1]);
-        this.bt = [ [], [] ];
+        e.gt[0].push(...this.gt[0]);
+        e.gt[1].push(...this.gt[1]);
+        this.gt = [ [], [] ];
         for (let t = 0; t < this.vt.length; t++) {
             let i = this.vt[t];
             let n = e.vt[t];
             if (!n) {
                 n = {
-                    bt: [ [], [] ],
+                    gt: [ [], [] ],
                     vt: []
                 };
                 e.vt[t] = n;
@@ -237,8 +262,8 @@ class Queue {
         }
     }
     restoreQueues(e) {
-        this.bt[0].push(...e.bt[0]);
-        this.bt[1].push(...e.bt[1]);
+        this.gt[0].push(...e.gt[0]);
+        this.gt[1].push(...e.gt[1]);
         for (let t = 0; t < e.vt.length; t++) {
             const i = e.vt[t];
             let n = this.vt[t];
@@ -248,13 +273,13 @@ class Queue {
 }
 
 class GlobalQueue extends Queue {
-    kt=false;
+    bt=false;
     // The current transaction-shaped batch: a plain ambient batch while no
     // transition is active, the active transition itself after initTransition.
     m=createBatch();
-    static pe;
     static Ce;
-    static Je;
+    static me;
+    static Xe;
     static Dt=null;
     // Store-side hook: drops a keyless affects() mark's identity scope when the
     // carrier node's last registration releases (wired by store.ts, mirroring
@@ -269,7 +294,7 @@ class GlobalQueue extends Queue {
     static h=null;
     // External-source bridge (wired by enableExternalSource(); null while no
     // config is active — including after _resetExternalSourceConfig()).
-    static Tt=null;
+    static dt=null;
     static It=null;
     // Verdict-layer hooks (wired by verdict.ts when isPending()/latest() are
     // imported; null in apps that never use them). Call sites either guard for
@@ -277,14 +302,14 @@ class GlobalQueue extends Queue {
     // there: `_pendingSignal`/`_latestValueComputed` are only ever assigned by
     // verdict.ts, and `pendingCheckActive`/`latestReadActive` only flip inside
     // isPending()/latest()).
-    static Ie=null;
-    static ae=null;
-    static he=null;
+    static _e=null;
+    static ce=null;
+    static Ge=null;
     static un=null;
-    static dt=null;
     static St=null;
-    static Rt=null;
-    static ze=null;
+    static At=null;
+    static Pt=null;
+    static $e=null;
     static k=null;
     static Lt=null;
     // Optimistic-engine hooks (wired by core/optimistic.ts via
@@ -294,29 +319,29 @@ class GlobalQueue extends Queue {
     // `_overrideValue` slot, a lane in `activeLanes`, an `_optimisticNodes`
     // entry, or a non-null `currentOptimisticLane`, so `!` invocations are safe
     // once the gate holds.
-    static Pt=null;
+    static ht=null;
     static En=null;
     static dn=null;
     static Tn=null;
     static In=null;
-    static Ct=null;
-    static At=null;
     static Ot=null;
-    static Ye=null;
+    static Ct=null;
+    static Rt=null;
+    static Ze=null;
+    static ze=null;
     static Ke=null;
-    static Me=null;
     static Nn=null;
     flush() {
-        if (this.kt) return;
-        this.kt = true;
+        if (this.bt) return;
+        this.bt = true;
         try {
             if (false) ;
-            runHeap(dirtyQueue, GlobalQueue.pe);
+            runHeap(dirtyQueue, GlobalQueue.Ce);
             if (activeTransition) {
                 const e = transitionComplete(activeTransition);
                 if (!e) {
                     const e = activeTransition;
-                    runHeap(zombieQueue, GlobalQueue.pe);
+                    runHeap(zombieQueue, GlobalQueue.Ce);
                     // Detach: the stashed transition keeps its batch; ambient work that
                     // follows lands in a fresh one. If the batch is already a separate
                     // ambient one — action done() restored activeTransition without
@@ -329,12 +354,12 @@ class GlobalQueue extends Queue {
                         GlobalQueue.In(EFFECT_RENDER);
                         GlobalQueue.In(EFFECT_USER);
                     }
-                    this.stashQueues(e.gt);
+                    this.stashQueues(e.yt);
                     clock++;
                     // A kept ambient batch may hold pending nodes (#2916): stay
                     // scheduled so the outer drain loop commits them via the plain
                     // flush path instead of leaving them until the next natural flush.
-                                        scheduled = dirtyQueue.EE >= dirtyQueue.Fe || this.m.Qt.length > 0;
+                                        scheduled = dirtyQueue.EE >= dirtyQueue.He || this.m.Qt.length > 0;
                     reassignPendingTransition(e.Qt);
                     activeTransition = null;
                     finalizePureQueue(null, true);
@@ -343,7 +368,7 @@ class GlobalQueue extends Queue {
                 const t = activeTransition;
                 const i = this.m;
                 i !== t && i.Qt.push(...t.Qt);
-                this.restoreQueues(t.gt);
+                this.restoreQueues(t.yt);
                 transitions.delete(t);
                 activeTransition = null;
                 reassignPendingTransition(i.Qt);
@@ -354,7 +379,7 @@ class GlobalQueue extends Queue {
                     // there and must survive to the next flush.
                     const e = createBatch();
                     e.Qt = i.Qt;
-                    e.Ze = i.Ze;
+                    e.je = i.je;
                     e.A = i.A;
                     e.cn = i.cn;
                     currentBatch = this.m = e;
@@ -362,18 +387,18 @@ class GlobalQueue extends Queue {
             } else {
                 if (canUseSimpleSyncFlush(this)) {
                     commitPendingNodes();
-                    if (dirtyQueue.EE >= dirtyQueue.Fe) {
-                        runHeap(dirtyQueue, GlobalQueue.pe);
+                    if (dirtyQueue.EE >= dirtyQueue.He) {
+                        runHeap(dirtyQueue, GlobalQueue.Ce);
                         commitPendingNodes();
                     }
                 } else {
-                    if (transitions.size) runHeap(zombieQueue, GlobalQueue.pe);
+                    if (transitions.size) runHeap(zombieQueue, GlobalQueue.Ce);
                     finalizePureQueue();
                 }
             }
             clock++;
             // Check if finalization added items to the heap (from optimistic reversion)
-                        scheduled = dirtyQueue.EE >= dirtyQueue.Fe;
+                        scheduled = dirtyQueue.EE >= dirtyQueue.He;
             // Run lane effects first (for ready lanes), then regular effects
                         activeLanes.size && GlobalQueue.In(EFFECT_RENDER);
             this.run(EFFECT_RENDER);
@@ -383,7 +408,7 @@ class GlobalQueue extends Queue {
             if (false && !scheduled && !activeTransition && transitions.size === 0 && activeLanes.size === 0) ;
             if (false) ;
         } finally {
-            this.kt = false;
+            this.bt = false;
         }
     }
     notify(e, t, i, n) {
@@ -398,8 +423,8 @@ class GlobalQueue extends Queue {
                                 if (t?.l) return true;
                 if (activeTransition && t) {
                     const i = t.source;
-                    let n = activeTransition.yt.get(i);
-                    if (!n) activeTransition.yt.set(i, n = new Set);
+                    let n = activeTransition.Ee.get(i);
+                    if (!n) activeTransition.Ee.set(i, n = new Set);
                     const s = n.size;
                     n.add(e);
                     if (n.size !== s) schedule();
@@ -412,7 +437,7 @@ class GlobalQueue extends Queue {
     initTransition(e) {
         if (e) e = currentTransition(e);
         if (e && e === activeTransition) return;
-        if (!e && activeTransition && activeTransition.ce === clock) return;
+        if (!e && activeTransition && activeTransition.Se === clock) return;
         if (!activeTransition) {
             activeTransition = e ?? createBatch();
         } else if (e) {
@@ -422,7 +447,7 @@ class GlobalQueue extends Queue {
             activeTransition = e;
         }
         transitions.add(activeTransition);
-        activeTransition.ce = clock;
+        activeTransition.Se = clock;
         const t = this.m;
         if (t !== activeTransition) {
             // Adopt the ambient batch into the transaction, then make the
@@ -434,20 +459,20 @@ class GlobalQueue extends Queue {
             // nodes, see propagateAffectsMark, #2893.
             for (let e = 0; e < t.Qt.length; e++) {
                 const i = t.Qt[e];
-                i.Ue = activeTransition;
+                i.Ie = activeTransition;
                 activeTransition.Qt.push(i);
             }
-            for (let e = 0; e < t.Ze.length; e++) {
-                const i = t.Ze[e];
-                i.Ue = activeTransition;
-                activeTransition.Ze.push(i);
+            for (let e = 0; e < t.je.length; e++) {
+                const i = t.je[e];
+                i.Ie = activeTransition;
+                activeTransition.je.push(i);
             }
             if (t.A.length) activeTransition.A.push(...t.A);
             for (const e of t.cn) activeTransition.cn.add(e);
             currentBatch = this.m = activeTransition;
         }
         for (const e of activeLanes) {
-            if (!e.Ue) e.Ue = activeTransition;
+            if (!e.Ie) e.Ie = activeTransition;
         }
     }
 }
@@ -468,8 +493,8 @@ function armReaskClear() {
 function insertSubs(e, t = false) {
     // Get source lane: prefer node's own lane over current context
     // This is important for isPending signals which need their own lane to flush immediately
-    const i = e.je || currentOptimisticLane;
-    const n = e.Ve !== undefined;
+    const i = e.Me || currentOptimisticLane;
+    const n = e.xe !== undefined;
     const s = reaskArmed;
     for (let r = e.o; r !== null; r = r.ue) {
         // A value-change notification is a new question for the subscriber: any
@@ -485,7 +510,7 @@ function insertSubs(e, t = false) {
         } else if (t) {
             r.le.se |= REACTIVE_OPTIMISTIC_DIRTY;
             // No source lane means reversion - clear subscriber's lane so effects go to regular queue
-                        r.le.je = undefined;
+                        r.le.Me = undefined;
         }
         enqueueSub(r.le);
     }
@@ -493,24 +518,24 @@ function insertSubs(e, t = false) {
 
 function commitPendingNode(e) {
     const t = e;
-    if (!t.ke) {
-        if (e.Ne !== NOT_PENDING) {
-            e.Pe = e.Ne;
-            e.Ne = NOT_PENDING;
+    if (!t.ae) {
+        if (e.De !== NOT_PENDING) {
+            e.Ue = e.De;
+            e.De = NOT_PENDING;
         }
-        if (e.be || e.ge) GlobalQueue.un(e);
+        if (e.he || e.pe) GlobalQueue.un(e);
         return;
     }
-    if (e.Ne !== NOT_PENDING) {
-        e.Pe = e.Ne;
-        e.Ne = NOT_PENDING;
+    if (e.De !== NOT_PENDING) {
+        e.Ue = e.De;
+        e.De = NOT_PENDING;
         // Set _modified for effects, but not for tracked effects (they handle their own scheduling)
-                if (e.Ae && e.Ae !== EFFECT_TRACKED) e.$e = true;
+                if (e.Pe && e.Pe !== EFFECT_TRACKED) e.Be = true;
     }
     t.se &= ~REACTIVE_MANUAL_WRITE;
     if (!(t.S & STATUS_PENDING)) t.S &= ~STATUS_UNINITIALIZED;
-    if (t.ye !== null || t.Le !== null) GlobalQueue.Ce(t, false, true);
-    if (e.be || e.ge) GlobalQueue.un(e);
+    if (t.Qe !== null || t.ye !== null) GlobalQueue.me(t, false, true);
+    if (e.he || e.pe) GlobalQueue.un(e);
 }
 
 function commitPendingNodes() {
@@ -527,15 +552,15 @@ function finalizePureQueue(e = null, t = false) {
     const i = !t;
     if (i) commitPendingNodes();
     if (!t && globalQueue.vt.length) checkBoundaryChildren(globalQueue);
-    const n = dirtyQueue.EE >= dirtyQueue.Fe;
-    if (n) runHeap(dirtyQueue, GlobalQueue.pe);
+    const n = dirtyQueue.EE >= dirtyQueue.He;
+    if (n) runHeap(dirtyQueue, GlobalQueue.Ce);
     if (i) {
         if (n) commitPendingNodes();
         // The settling batch: the completing transaction's, or the ambient one.
                 const t = e ?? globalQueue.m;
         // Optimistic reversion: a non-empty batch means _optimisticWrite ran,
         // which installed the engine's hooks.
-                if (t.Ze.length) GlobalQueue.En(t.Ze);
+                if (t.je.length) GlobalQueue.En(t.je);
         // Replay entanglement: subs recorded by the read-time gate get rescheduled
         // so they re-run with the now-committed values visible.
                 if (e && e.ln.size) {
@@ -591,7 +616,7 @@ function checkBoundaryChildren(e) {
 
 function reassignPendingTransition(e) {
     for (let t = 0; t < e.length; t++) {
-        e[t].Ue = activeTransition;
+        e[t].Ie = activeTransition;
     }
 }
 
@@ -619,7 +644,7 @@ function flush(e) {
             }
         }
     }
-    if (globalQueue.kt) {
+    if (globalQueue.bt) {
         return;
     }
     if (halted) return;
@@ -637,10 +662,10 @@ function runQueue(e, t) {
 function reporterBlocksSource(e, t) {
     if (e.se & (REACTIVE_ZOMBIE | REACTIVE_DISPOSED)) return false;
     if (e.oe?.has(t)) return true;
-    for (let i = e.Xe; i; i = i.et) {
-        let e = i.tt;
+    for (let i = e.et; i; i = i.tt) {
+        let e = i.nt;
         while (e) {
-            if (e === t || e.nt === t) return true;
+            if (e === t || e.it === t) return true;
             e = e.nn;
         }
     }
@@ -651,7 +676,7 @@ function transitionComplete(e) {
     if (e.fn) return true;
     if (e.ie.length) return false;
     let t = true;
-    for (const [i, n] of e.yt) {
+    for (const [i, n] of e.Ee) {
         let s = false;
         for (const e of n) {
             if (reporterBlocksSource(e, i)) {
@@ -660,15 +685,15 @@ function transitionComplete(e) {
             }
             n.delete(e);
         }
-        if (!s) e.yt.delete(i); else if (i.S & STATUS_PENDING && i._?.source === i) {
+        if (!s) e.Ee.delete(i); else if (i.S & STATUS_PENDING && i._?.source === i) {
             t = false;
             break;
         }
     }
-    // Override blockage lives with the engine. Absent hook = "no optimistic
-    // blockage", which is exact: only _optimisticWrite (engine) pushes to
-    // _optimisticNodes, so without the engine the loop was vacuous anyway.
-        if (t && e.Ze.length && GlobalQueue.dn(e)) t = false;
+    // Override blockage lives with the engine (absent hook = "no optimistic
+    // blockage"); the hook's loops over _optimisticNodes/_optimisticStores are
+    // no-ops when the transition holds neither, so no pre-check is needed.
+        if (t && GlobalQueue.dn?.(e)) t = false;
     t && (e.fn = true);
     return t;
 }
@@ -678,10 +703,6 @@ function currentTransition(e) {
     return e;
 }
 
-function setActiveTransition(e) {
-    activeTransition = e;
-}
-
 function runInTransition(e, t) {
     const i = activeTransition;
     try {
@@ -692,4 +713,4 @@ function runInTransition(e, t) {
     }
 }
 
-export { GlobalQueue, Queue, activeAffectsMarks, activeLanes, activeTransition, armReaskClear, assignOrMergeLane, clock, currentTransition, dirtyQueue, enforceLoadingBoundary, finalizePureQueue, findLane, flush, globalQueue, haltReactivity, insertSubs, projectionWriteActive, queuePendingNode, registerTransientStoreNode, resetErrorHalt, runInTransition, schedule, setActiveTransition, setProjectionWriteActive, shiftAffectsMarks, zombieQueue };
+export { GlobalQueue, Queue, activeAffectsMarks, activeLanes, activeTransition, armReaskClear, assignOrMergeLane, clock, currentTransition, dirtyQueue, enforceLoadingBoundary, finalizePureQueue, findLane, flush, globalQueue, haltReactivity, insertSubs, projectionWriteActive, queuePendingNode, registerTransientStoreNode, resetErrorHalt, runInTransition, schedule, setProjectionWriteActive, shiftAffectsMarks, zombieQueue };