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

package/dist/dev-shared.js

@@ -1932,7 +1932,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 _landOnOverride = null;
   static _trackOptimisticStore = null;
   flush() {
@@ -2073,8 +2077,16 @@ 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._max >= dirtyQueue._min || 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._max >= dirtyQueue._min ||
+        activeTransition !== null ||
+        this._batch._pendingNodes.length !== 0;
       // Run lane effects first (for ready lanes), then regular effects
       activeLanes.size && GlobalQueue._runLaneEffects(EFFECT_RENDER);
       this.run(EFFECT_RENDER);
@@ -2105,9 +2117,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)
@@ -6967,13 +6984,13 @@ export {
   currentTransition as M,
   NoOwnerError as N,
   OVERRIDE_UNDEFINED as O,
-  queuePendingNode as P,
-  latestReadActive as Q,
+  assignOrMergeLane as P,
+  queuePendingNode as Q,
   REACTIVE_DIRTY as R,
   STATUS_UNINITIALIZED as S,
-  REACTIVE_MANUAL_WRITE as T,
-  REACTIVE_OPTIMISTIC_DIRTY as U,
-  assignOrMergeLane as V,
+  latestReadActive as T,
+  REACTIVE_MANUAL_WRITE as U,
+  REACTIVE_OPTIMISTIC_DIRTY as V,
   LANE_RUN as W,
   attrHooks as X,
   EFFECT_USER as Y,

package/dist/dev.js

@@ -42,11 +42,11 @@ import {
   K as currentOptimisticLane,
   L as enterStagedRead,
   M as currentTransition,
-  P as queuePendingNode,
-  Q as latestReadActive,
-  T as REACTIVE_MANUAL_WRITE,
-  U as REACTIVE_OPTIMISTIC_DIRTY,
-  V as assignOrMergeLane,
+  P as assignOrMergeLane,
+  Q as queuePendingNode,
+  T as latestReadActive,
+  U as REACTIVE_MANUAL_WRITE,
+  V as REACTIVE_OPTIMISTIC_DIRTY,
   W as LANE_RUN,
   X as attrHooks,
   Y as EFFECT_USER,
@@ -750,8 +750,53 @@ function overrideRead(el, c) {
  * 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(el, v) {
+  if (!(el._config & CONFIG_OPTIMISTIC)) {
+    const lane = currentOptimisticLane;
+    if (lane === null) {
+      if (!hasActiveOverride(el)) return setSignal(el, v);
+    } else {
+      // INV-11: the gate compares against the slot this pass publishes to —
+      // the override when one is armed, the committed row otherwise.
+      if (
+        !el._equals ||
+        !el._equals(hasActiveOverride(el) ? unwrapOverride(el._x._overrideValue) : el._value, v)
+      ) {
+        // 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(el, lane);
+        laneOverride(el, v, lane);
+        insertSubs(el, true);
+        schedule();
+      }
+      return v;
+    }
+  }
   const currentValue = el._pendingValue === NOT_PENDING ? el._value : el._pendingValue;
   if (typeof v === "function") v = v(currentValue);
   if (attrHooks !== null) attrHooks.write(el, currentValue, v);
@@ -8960,6 +9005,30 @@ function updateKeyedMap() {
         // entered rows, for the list-identity census.
         removedItems,
         createdItems;
+      // The pass's write to a per-slot signal (a row accessor in index mode,
+      // an index accessor in keyed mode). The list's frame lives in these
+      // writes as much as in the computed's result, so under a LANE pass they
+      // are the lane's frame too (F1): a plain `setSignal` staged them into
+      // the action's transaction and the row readers were served the
+      // committed value until the action landed — `<For>` without `keyed`
+      // showed the pre-action list for the whole action while the keyed modes
+      // showed the optimistic one. The engine publishes the write as a
+      // derived override on the slot (lanes stage, A17) and lands or
+      // supersedes it when a plain pass later writes a slot still carrying
+      // one (A18) — `landOnOverride`'s slot arm. Decided once per pass, not
+      // per slot: a lane pass marks the map (`_laneSlots`: its slots may
+      // carry overrides), a marked map routes every slot write through the
+      // engine while any lane is live — a slot's override resolves with its
+      // lane's transaction, or with the batch for an orphan lane
+      // (resolveOptimisticNodes, then cleanupCompletedLanes, both before the
+      // completion wakes any recompute), so a pass that finds no lane live
+      // knows the slots are clean and drops the mark — and an unmarked map
+      // takes `setSignal` directly. The engine is installed whenever a lane
+      // is active.
+      const write = (this._laneSlots =
+        currentOptimisticLane !== null || (this._laneSlots && activeLanes.size !== 0))
+        ? GlobalQueue._landOnOverride
+        : setSignal;
       // skip common prefix
       for (
         start = 0, end = Math.min(this._len, newLen);
@@ -8968,7 +9037,7 @@ function updateKeyedMap() {
           (this._rows && compare(this._key, this._items[start], newItems[start])));
         start++
       ) {
-        if (this._rows) setSignal(this._rows[start], newItems[start]);
+        if (this._rows) write(this._rows[start], newItems[start]);
       }
       // skip common suffix — counted only; retained entries land in one pass
       // at commit instead of being staged and copied twice
@@ -9069,19 +9138,19 @@ function updateKeyedMap() {
         indexes && (indexes[i] = this._indexes[i]);
       }
       for (j = start; j <= newEnd; j++) {
-        if (rows) setSignal(rows[j], newItems[j]);
-        if (indexes) setSignal(indexes[j], j);
+        if (rows) write(rows[j], newItems[j]);
+        if (indexes) write(indexes[j], j);
       }
       for (j = newEnd + 1; j < newLen; j++) {
         temp[j] = this._mappings[j - dif];
         tempNodes[j] = this._nodes[j - dif];
         if (rows) {
           rows[j] = this._rows[j - dif];
-          setSignal(rows[j], newItems[j]);
+          write(rows[j], newItems[j]);
         }
         if (indexes) {
           indexes[j] = this._indexes[j - dif];
-          if (dif !== 0) setSignal(indexes[j], j);
+          if (dif !== 0) write(indexes[j], j);
         }
       }
       this._mappings = temp;

package/dist/observe/core/optimistic.js

@@ -2,7 +2,7 @@ import { NOT_PENDING, unwrapOverride, STATUS_UNINITIALIZED, REACTIVE_DIRTY, REAC
 
 import { attrHooks } from "./attribution-hooks.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";
 
@@ -27,17 +27,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?.we !== NOT_PENDING;
-    const t = i ? unwrapOverride(e.o?.we) : e.ce;
-    if (typeof n === "function") n = n(t);
-    const r = !!(e.S & STATUS_UNINITIALIZED) || 
+    const r = i ? unwrapOverride(e.o?.we) : e.ce;
+    if (typeof n === "function") n = n(r);
+    const t = !!(e.S & 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.Fe || !e.Fe(t, n);
-    if (!r) {
+    !!((e.oe ?? 0) & (REACTIVE_DIRTY | REACTIVE_CHECK)) || !e.Fe || !e.Fe(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
@@ -164,7 +164,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.S & STATUS_PENDING)) n.S &= ~STATUS_UNINITIALIZED;
-        const t = n.o?.we;
+        const r = n.o?.we;
         // 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
@@ -174,18 +174,18 @@ 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).we = r && !(n.C & CONFIG_OPTIMISTIC) ? undefined : NOT_PENDING;
+                const t = n.C & CONFIG_DERIVED_OVERRIDE;
+        ext(n).we = 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 {
                 // The guess lifts and what was beneath it differs: the screen
                 // changes from the override to the committed value.
-                if (attrHooks !== null) attrHooks.optimisticReverted(n, unwrapOverride(t), n.ce, "reverted");
+                if (attrHooks !== null) attrHooks.optimisticReverted(n, unwrapOverride(r), n.ce, "reverted");
                 insertSubs(n, true);
             }
         }
@@ -198,8 +198,8 @@ function resolveOptimisticNodes(e) {
         for (let i = 0; i < n; i++) {
         const n = e[i];
         if (n.o?.xe || n.o?.Me) GlobalQueue.Qn(n);
-        const t = n.o?.$n;
-        if (t && (t.o?.xe === n || t.o?.Me === n)) GlobalQueue.Qn(t);
+        const r = n.o?.$n;
+        if (r && (r.o?.xe === n || r.o?.Me === n)) GlobalQueue.Qn(r);
     }
     e.splice(0, n);
 }
@@ -257,14 +257,14 @@ function resolveOptimisticNodes(e) {
         const i = e.o?.Ce;
         if (i) {
             const n = findLane(i);
-            const t = [ e ];
-            while (t.length) {
-                const e = t.pop();
+            const r = [ e ];
+            while (r.length) {
+                const e = r.pop();
                 const i = e.o?.Ce;
                 if (!i || findLane(i) !== n) continue;
                 e.o.Ce = undefined;
                 n.ke.delete(e);
-                for (let n = e.u; n !== null; n = n.Pe) t.push(n.Ae);
+                for (let n = e.u; n !== null; n = n.Pe) r.push(n.Ae);
             }
         }
     }
@@ -403,7 +403,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.Fe || !e.Fe(hasActiveOverride(e) ? unwrapOverride(e.o.we) : 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 (attrHooks !== null) attrHooks.write(e, i, n);

package/dist/observe/core/scheduler.js

@@ -631,7 +631,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 Vn=null;
     static Jn=null;
     flush() {
@@ -793,8 +797,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.st || 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.st || activeTransition !== null || this.m.In.length !== 0;
             // Run lane effects first (for ready lanes), then regular effects
                         activeLanes.size && GlobalQueue.Kn(EFFECT_RENDER);
             this.run(EFFECT_RENDER);
@@ -808,9 +817,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());