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

package/dist/prod/core/optimistic.js

@@ -1,6 +1,6 @@
 import { NOT_PENDING, unwrapOverride, STATUS_UNINITIALIZED, REACTIVE_DIRTY, REACTIVE_CHECK, CONFIG_HAS_LANE, OVERRIDE_UNDEFINED, STATUS_PENDING, CONFIG_DERIVED_OVERRIDE, CONFIG_OPTIMISTIC, CONFIG_OVERRIDE_SUPERSEDED, EFFECT_RENDER, CONFIG_AUTHORITATIVE_OBSERVED, REACTIVE_MANUAL_WRITE, REACTIVE_OPTIMISTIC_DIRTY, LANE_RUN, EFFECT_USER } from "./constants.js";
 
-import { ext, hasActiveOverride, stale, currentOptimisticLane, enterStagedRead, latestReadActive } from "./core.js";
+import { ext, hasActiveOverride, stale, currentOptimisticLane, enterStagedRead, setSignal, latestReadActive } from "./core.js";
 
 import { NotReadyError } from "./error.js";
 
@@ -25,17 +25,17 @@ import { GlobalQueue, activeTransition, globalQueue, origin, clock, insertSubs,
  */
 /** The optimistic half of setSignal, fired when `_overrideValue !== undefined`. */ function optimisticWrite(e, n) {
     const i = e.o?.Fe !== NOT_PENDING;
-    const t = i ? unwrapOverride(e.o?.Fe) : e.ce;
-    if (typeof n === "function") n = n(t);
-    const r = !!(e.h & STATUS_UNINITIALIZED) || 
+    const r = i ? unwrapOverride(e.o?.Fe) : e.ce;
+    if (typeof n === "function") n = n(r);
+    const t = !!(e.h & STATUS_UNINITIALIZED) || 
     // A dirty node's _value is stale (its queued recompute hasn't run — e.g.
     // a latest() shadow marked by the previous landing's companion snap), so
     // equality against it must not swallow the write. Without this, a sync
     // push returning the shadow to that stale value was dropped, the snap
     // recompute then committed the parent's old value, and the banner showed
     // the previous transition's target (#3041 follow-up).
-    !!((e.oe ?? 0) & (REACTIVE_DIRTY | REACTIVE_CHECK)) || !e.xe || !e.xe(t, n);
-    if (!r) {
+    !!((e.oe ?? 0) & (REACTIVE_DIRTY | REACTIVE_CHECK)) || !e.xe || !e.xe(r, n);
+    if (!t) {
         // Same-value write with an active override still entangles the current
         // action's transition — the hold must outlast all overlapping actions —
         // and renews the override's PROVENANCE: the newer action re-asks the
@@ -162,7 +162,7 @@ function resolveOptimisticNodes(e) {
         // override-covered authoritative values hold in _pendingValue and
         // elevate on their OWN transition's schedule (A18 as re-ruled 2026-07-07).
                 if (!(n.h & STATUS_PENDING)) n.h &= ~STATUS_UNINITIALIZED;
-        const t = n.o?.Fe;
+        const r = n.o?.Fe;
         // A derived override (lanes stage, #3479) has no truth of its own: the
         // slot disarms — the memo is plain again — and the override PROMOTES to
         // `_value`. Not superseded, nothing it derives from told it otherwise
@@ -172,15 +172,15 @@ function resolveOptimisticNodes(e) {
         // the override IS what a recompute from the truth yields. Re-deriving
         // instead re-asked an async member's flight and held the transaction on
         // it — a waterfall after the reveal.
-                const r = n.C & CONFIG_DERIVED_OVERRIDE;
-        ext(n).Fe = r && !(n.C & CONFIG_OPTIMISTIC) ? undefined : NOT_PENDING;
+                const t = n.C & CONFIG_DERIVED_OVERRIDE;
+        ext(n).Fe = t && !(n.C & CONFIG_OPTIMISTIC) ? undefined : NOT_PENDING;
         // A superseded override's subscribers already re-derived from the truth
         // when it arrived (#3331) — the drop changes nothing they read. Everyone
         // else learns of the correction here: this drop IS their notification.
                 const u = (n.C & CONFIG_OVERRIDE_SUPERSEDED) !== 0;
         n.C &= -8912897;
-        if (!u && t !== NOT_PENDING && n.ce !== unwrapOverride(t)) {
-            if (r) n.ce = unwrapOverride(t); else {
+        if (!u && r !== NOT_PENDING && n.ce !== unwrapOverride(r)) {
+            if (t) n.ce = unwrapOverride(r); else {
                 insertSubs(n, true);
             }
         }
@@ -192,9 +192,9 @@ function resolveOptimisticNodes(e) {
     // transition that produced them (A19 — pending is a property of the data).
         for (let i = 0; i < n; i++) {
         const n = e[i];
-        if (n.o?.Ze || n.o?.He) GlobalQueue.ti(n);
-        const t = n.o?.kn;
-        if (t && (t.o?.Ze === n || t.o?.He === n)) GlobalQueue.ti(t);
+        if (n.o?.Ze || n.o?.He) GlobalQueue.ri(n);
+        const r = n.o?.kn;
+        if (r && (r.o?.Ze === n || r.o?.He === n)) GlobalQueue.ri(r);
     }
     e.splice(0, n);
 }
@@ -248,14 +248,14 @@ function resolveOptimisticNodes(e) {
         const n = e.o?.me;
         if (n) {
             const i = findLane(n);
-            const t = [ e ];
-            while (t.length) {
-                const e = t.pop();
+            const r = [ e ];
+            while (r.length) {
+                const e = r.pop();
                 const n = e.o?.me;
                 if (!n || findLane(n) !== i) continue;
                 e.o.me = undefined;
                 i.Qe.delete(e);
-                for (let n = e.u; n !== null; n = n.Ae) t.push(n.ge);
+                for (let n = e.u; n !== null; n = n.Ae) r.push(n.ge);
             }
         }
     }
@@ -297,7 +297,7 @@ function resolveOptimisticNodes(e) {
  * the optimistic path so it flushes ahead of the hold — but they answer for
  * their owner and snap at settlement (`_snapCompanions`), not here.
  */ function endOptimism(e) {
-    if (!e.Te || e.pe.length || !e.cn.length || e.ri.size || transitionBlocked(e)) return false;
+    if (!e.Te || e.pe.length || !e.cn.length || e.ti.size || transitionBlocked(e)) return false;
     for (const n of e.le.keys()) if (sourceObserved(e, n, e) && n.o?.ue?.has(n) && !resolveLane(n)) return false;
     let n = false;
     for (const i of e.cn) {
@@ -393,7 +393,49 @@ function resolveOptimisticNodes(e) {
  * action provenance, or an A17-silent confirmation (#3331). Before this the
  * landing took setSignal's plain path: a differing truth staged silently
  * under the override and the graph never moved until the commit.
+ *
+ * Slot arm (list-matrix F1): `mapArray`'s writes to its per-slot signals —
+ * the row accessors of index mode, the index accessors of keyed mode; never
+ * CONFIG_OPTIMISTIC, which is how the arm tells them from the store landings
+ * above — once a lane pass has run over the map. The list's frame lives in
+ * these writes as much as in the computed's result. Under a LANE pass the
+ * write is the lane's frame, as the computed's result is (lanes stage,
+ * `laneOverride`): the slot joins the lane carrying a DERIVED override —
+ * `_value` stays the committed row, the lane's readers and untracked reads
+ * see the override (A17), an off-lane render effect sees the committed frame
+ * (#3460), the revert promotes or drops it with the lane's transaction. The
+ * gate compares against the slot the pass publishes to (INV-11): the override
+ * when armed, the committed row otherwise. A plain `setSignal` here staged
+ * the write into the ACTION's transaction: `<For>` without `keyed` showed the
+ * pre-action list for the whole action while the keyed modes showed the
+ * optimistic one. A PLAIN pass over a slot still carrying the lane's frame —
+ * the landing, the reversion, a mainline re-pass — is the truth arriving
+ * under an override and takes the landing path below: a differing truth
+ * supersedes, an equal one confirms and the revert promotes. Every pass
+ * rewrites every slot whose value differs from the previous frame's (index
+ * mode rewrites every surviving slot), so a slot the landing does NOT write
+ * holds, by construction, what the truth yields. A slot with neither a lane
+ * nor an override is the plain write.
  */ function landOnOverride(e, n) {
+    if (!(e.C & CONFIG_OPTIMISTIC)) {
+        const i = currentOptimisticLane;
+        if (i === null) {
+            if (!hasActiveOverride(e)) return setSignal(e, n);
+        } else {
+            // INV-11: the gate compares against the slot this pass publishes to —
+            // the override when one is armed, the committed row otherwise.
+            if (!e.xe || !e.xe(hasActiveOverride(e) ? unwrapOverride(e.o.Fe) : e.ce, n)) {
+                // Membership before the publish: `laneOverride` files the slot under
+                // the lane's transaction, and the read path routes a tracked reader
+                // of a lane member through `overrideRead` (CONFIG_HAS_LANE).
+                assignOrMergeLane(e, i);
+                laneOverride(e, n, i);
+                insertSubs(e, true);
+                schedule();
+            }
+            return n;
+        }
+    }
     const i = e._e === NOT_PENDING ? e.ce : e._e;
     if (typeof n === "function") n = n(i);
     if (e._e === NOT_PENDING) queuePendingNode(e);
@@ -583,7 +625,7 @@ function cleanupCompletedLanes(e) {
 
 function trackOptimisticStore(e) {
     // After initTransition, globalQueue._batch IS activeTransition (same reference)
-    globalQueue.m.ri.add(e);
+    globalQueue.m.ti.add(e);
     schedule();
 }
 

package/dist/prod/core/owner.js

@@ -58,13 +58,13 @@ function disposeChildren(e, n = false, t) {
         // edge). Snap runs after the DISPOSED flag is set so the oracle reads
         // false, and notifies subscribers still watching the companion.
                 const n = e;
-        if (n.o?.Ze || n.o?.He) GlobalQueue.ti(n);
+        if (n.o?.Ze || n.o?.He) GlobalQueue.ri(n);
         // A firewall's leaves have no lifecycle of their own, so a companion on
         // one of them outlives its source the same way (INV-9's rationale). The
         // firewall knows which leaves carry companions (CONFIG_CHILD_COMPANIONS,
         // #3038): snap them with it — the snap retires a shadow whose firewall is
         // disposed (spec O5).
-                if (n.C & CONFIG_CHILD_COMPANIONS) n.o.Un.forEach(GlobalQueue.ti);
+                if (n.C & CONFIG_CHILD_COMPANIONS) n.o.Un.forEach(GlobalQueue.ri);
         // A pending reader parked in a transaction may be the only thing holding
         // it (#3372): its death is a completion event the transaction must be
         // re-judged for, and nothing else re-enters a parked transaction.

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;