@solidjs/signals 2.0.0-rc.10 → 2.0.0-rc.13

package/dist/prod/core/scheduler.js

@@ -100,7 +100,7 @@ const transientStoreNodes = new Set;
 
 function canUseSimpleSyncFlush(e) {
     const t = e.m;
-    return transitions.size === 0 && activeLanes.size === 0 && e.ft.length === 0 && t.cn.length === 0 && t.A.length === 0 && t.ri.size === 0 && transientStoreNodes.size === 0 && pendingRearms.size === 0;
+    return transitions.size === 0 && activeLanes.size === 0 && e.ft.length === 0 && t.cn.length === 0 && t.A.length === 0 && t.ti.size === 0 && transientStoreNodes.size === 0 && pendingRearms.size === 0;
 }
 
 function sweepTransientStoreNodes() {
@@ -149,7 +149,7 @@ function setProjectionWriteActive(e) {
         le: new Map,
         cn: [],
         A: [],
-        ri: new Set,
+        ti: new Set,
         pe: [],
         dt: {
             Tt: [ [], [] ],
@@ -180,7 +180,7 @@ function mergeTransitionState(e, t) {
         e.A.push(...t.A);
         t.A.length = 0;
     }
-    for (const n of t.ri) e.ri.add(n);
+    for (const n of t.ti) e.ti.add(n);
     for (const [n, i] of t.le) {
         let t = e.le.get(n);
         if (!t) e.le.set(n, t = new Set);
@@ -547,7 +547,7 @@ class GlobalQueue extends Queue {
     static Ve=null;
     static Ge=null;
     static We=null;
-    static ti=null;
+    static ri=null;
     static et=null;
     static nt=null;
     static rt=null;
@@ -625,7 +625,11 @@ class GlobalQueue extends Queue {
      * commit whatever its relation to the committed value — a landing equal to
      * committed still differs from the override — then _supersedeOverride
      * decides. Installed with the optimistic engine; only reachable on a node
-     * that has an override. */
+     * that has an override — or, from `mapArray` once a lane pass has run over
+     * the map, on a per-slot signal (never CONFIG_OPTIMISTIC): the slot arm
+     * publishes a lane pass's write as the slot's derived override, lands a
+     * plain pass's write over one, and is the plain `setSignal` otherwise (F1,
+     * see optimistic.ts landOnOverride). */
     static st=null;
     static fi=null;
     flush() {
@@ -751,7 +755,7 @@ class GlobalQueue extends Queue {
                     e.Gn = n.Gn;
                     e.cn = n.cn;
                     e.A = n.A;
-                    e.ri = n.ri;
+                    e.ti = n.ti;
                     currentBatch = this.m = e;
                 }
             } else {
@@ -787,8 +791,13 @@ class GlobalQueue extends Queue {
             // sweep or recompute wrote a node it owns): effects computed under it
             // since are its to apply, not this flush's — runEffect leaves them queued
             // and the next pass parks them with it (#3319). Everything computed
-            // mainline applies now.
-                        scheduled = dirtyQueue.EE >= dirtyQueue.ln || activeTransition !== null;
+            // mainline applies now. A write the finalize staged in the ambient
+            // batch with no subscriber to dirty (an optimistic store settle's
+            // keyset bump under a reader that never tracks the key set) is work
+            // too — the fast drain and the park exit already count it — so the
+            // next round commits it and the woken re-entry below does not adopt
+            // it into a parked transaction it never belonged to (matrix F6).
+                        scheduled = dirtyQueue.EE >= dirtyQueue.ln || activeTransition !== null || this.m.Gn.length !== 0;
             // Run lane effects first (for ready lanes), then regular effects
                         activeLanes.size && GlobalQueue.si(EFFECT_RENDER);
             this.run(EFFECT_RENDER);
@@ -802,9 +811,14 @@ class GlobalQueue extends Queue {
             // idle pass: entering adopts the ambient batch, and staged or dirty
             // ambient work would be held behind flights it never read. `scheduled`
             // is that test here — after the park exit as well as the normal one:
-            // it was recomputed from the heap this pass, every write since re-armed
-            // it, and optimistic ambient nodes reverted with the finalize — so a
-            // wake in a pass with work simply falls to the next. Entering re-arms
+            // it was recomputed from the heap and the ambient batch's staged nodes
+            // this pass, every write since re-armed it, and optimistic ambient
+            // nodes reverted with the finalize — so a wake in a pass with work
+            // simply falls to the next. (A staged node with no subscriber — the
+            // finalize's keyset bump under a length-only reader — used to be
+            // missed here: the wake adopted it, stamped it, and a later ambient
+            // write to the same node joined the parked transaction and never
+            // reverted; matrix F6.) Entering re-arms
             // it itself; a dead (completed) wake is a bare return in
             // initTransition, and the loop moves on to the next.
             while (!scheduled && !activeTransition && wokenTransitions.length) this.initTransition(wokenTransitions.pop());
@@ -924,7 +938,7 @@ class GlobalQueue extends Queue {
                 activeTransition.cn.push(n);
             }
             if (t.A.length) activeTransition.A.push(...t.A);
-            for (const e of t.ri) activeTransition.ri.add(e);
+            for (const e of t.ti) activeTransition.ti.add(e);
             // Gated readers recorded against the ambient batch move with it: their
             // replay-at-commit now happens at the transaction's completion.
                         if (t.In.size) {
@@ -1043,7 +1057,7 @@ function commitPendingNode(e) {
             e.ce = e._e;
             e._e = NOT_PENDING;
         }
-        if (e.C & CONFIG_HAS_COMPANIONS) GlobalQueue.ti(e);
+        if (e.C & CONFIG_HAS_COMPANIONS) GlobalQueue.ri(e);
         return;
     }
     if (e._e !== NOT_PENDING) {
@@ -1081,7 +1095,7 @@ function commitPendingNode(e) {
     // against the frame. read()'s reveal carve-out keys on the mark (#3305).
      else e.C |= CONFIG_INPUTS_PUBLISHED;
     if (t.o != null && (t.o._n !== null || t.o.fn !== null)) GlobalQueue.en(t, false, true);
-    if (e.C & CONFIG_HAS_COMPANIONS) GlobalQueue.ti(e);
+    if (e.C & CONFIG_HAS_COMPANIONS) GlobalQueue.ri(e);
 }
 
 // Store commit hook (INTERNALS-STORE-STATE.md §3): installed by the store
@@ -1213,7 +1227,7 @@ function finalizePureQueue(e = null, t = false) {
         // hook; the hook iterates, clears, and schedules (keeping the loop out of
         // core lets esbuild shake it — rollup already folds the null guard). The
         // completing transition scopes the clear to its own layer keys (#2899).
-                if (t.ri.size) GlobalQueue._t(t.ri, e);
+                if (t.ti.size) GlobalQueue._t(t.ti, e);
         // Held-truth reveal wake (#3164), post-revert by construction: this
         // finalize committed confirming truth whose subscribers were masked all
         // hold — some re-derived against the committed view (the staging, or a

package/dist/prod/core/verdict.js

@@ -655,7 +655,7 @@ GlobalQueue.Ge = updatePendingSignal;
 
 GlobalQueue.We = updateChildCompanions;
 
-GlobalQueue.ti = snapCompanionsToState;
+GlobalQueue.ri = snapCompanionsToState;
 
 GlobalQueue.et = latestRead;