@solidjs/signals 2.0.0-beta.29 → 2.0.0-beta.31

package/dist/dev.js

@@ -429,6 +429,16 @@ const zombieQueue = {
   _min: 0,
   _max: 0
 };
+/** runHeap callback that discards a queued zombie recompute instead of running
+ * it: unlink pure recompute entries; strip just the recompute bit from dirtied
+ * height-adjust entries so their height work still happens. */
+function cancelZombieRecompute(el) {
+  if (el._flags & REACTIVE_IN_HEAP_HEIGHT) el._flags &= -12;
+  else {
+    deleteFromHeap(el, zombieQueue);
+    el._flags &= -4;
+  }
+}
 let clock = 0;
 let activeTransition = null;
 let scheduled = false;
@@ -748,7 +758,18 @@ class GlobalQueue extends Queue {
         const isComplete = transitionComplete(activeTransition);
         if (!isComplete) {
           const stashedTransition = activeTransition;
-          runHeap(zombieQueue, GlobalQueue._update);
+          // When the parking batch IS the transition, all of its writes commit
+          // only with it — every zombie recompute they queued would run against
+          // a world the zombie never displays (zombies render mainline until
+          // commit), so cancel them instead of running them. Only an ambient
+          // batch's mainline writes (the #2916 shape below) legitimately reach
+          // zombies here. Height-adjust entries still process normally: a
+          // dirtied one keeps its height flag and falls through to runHeap's
+          // adjustHeight path on the next pass of the bucket.
+          runHeap(
+            zombieQueue,
+            this._batch === stashedTransition ? cancelZombieRecompute : GlobalQueue._update
+          );
           // 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
@@ -895,6 +916,12 @@ class GlobalQueue extends Queue {
       }
       if (batch._affectsNodes.length) activeTransition._affectsNodes.push(...batch._affectsNodes);
       for (const store of batch._optimisticStores) activeTransition._optimisticStores.add(store);
+      // Gated readers recorded against the ambient batch move with it: their
+      // replay-at-commit now happens at the transaction's completion.
+      if (batch._gatedSubs.size) {
+        for (const sub of batch._gatedSubs) activeTransition._gatedSubs.add(sub);
+        batch._gatedSubs.clear();
+      }
       currentBatch = this._batch = activeTransition;
     }
     for (const lane of activeLanes) {
@@ -982,13 +1009,19 @@ function finalizePureQueue(completingTransition = null, incomplete = false) {
     // which installed the engine's hooks.
     if (batch._optimisticNodes.length) GlobalQueue._resolveOptimistic(batch._optimisticNodes);
     // Replay entanglement: subs recorded by the read-time gate get rescheduled
-    // so they re-run with the now-committed values visible.
-    if (completingTransition && completingTransition._gatedSubs.size) {
-      for (const sub of completingTransition._gatedSubs) {
+    // so they re-run with the now-committed values visible. The ambient batch
+    // replays too — laneReadsCommitted records readers whose committed-view
+    // read hid a same-tick plain write that just committed above (#2963).
+    if (batch._gatedSubs.size) {
+      for (const sub of batch._gatedSubs) {
         if (sub._flags & REACTIVE_DISPOSED) continue;
         enqueueSub(sub);
       }
-      completingTransition._gatedSubs.clear();
+      batch._gatedSubs.clear();
+      // A completing transition keeps the outer flush loop alive by itself;
+      // the ambient batch needs the re-arm or the replay sits in the heap
+      // until the next unrelated write.
+      schedule();
     }
     // Declared motion ends with the transaction: settle (or plain flush end
     // for ambient marks) releases each registration's refcount. A non-empty
@@ -3482,12 +3515,25 @@ function gatedRead(el, owner, c) {
  * optimistic/lane-assigned signals, stale-mode reads, and pending owners.
  */
 function laneReadsCommitted(el, owner, c) {
-  return (
+  if (
     el._overrideValue !== undefined ||
     !!el._optimisticLane ||
-    (owner === el && stale && c._parentSource !== el) ||
     !!(owner._statusFlags & STATUS_PENDING)
-  );
+  )
+    return true;
+  if (owner === el && stale && c._parentSource !== el) {
+    // The committed view can hide a same-tick ambient write (a lane member —
+    // even just an isPending companion flip — puts the reader "under a lane"
+    // against unrelated plain writes). With no transaction the write commits
+    // at THIS flush's end with no re-delivery, so record the reader for
+    // replay at commit — the same contract gatedRead provides when a
+    // transaction is active (#2963). If a transaction forms mid-flush,
+    // initTransition carries the recording over to it.
+    if (el._pendingValue !== NOT_PENDING && activeTransition === null)
+      globalQueue._batch._gatedSubs.add(c);
+    return true;
+  }
+  return false;
 }
 /**
  * recompute()'s lane posture: resolve the node's own lane (own=true), or adopt