@solidjs/signals 2.0.0-beta.30 → 2.0.0-beta.32

package/dist/dev.js

@@ -916,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) {
@@ -1003,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
@@ -2071,9 +2083,22 @@ function handleAsync(el, result, setter) {
         resolved = false,
         rejected = false,
         isSync = true;
-      it.next().then(
+      // Protocol tolerance, matching `for await`: `await` unwraps whatever
+      // next() returns — a thenable OR a bare IteratorResult. Real producers
+      // use the bare form as a promise-free fast path when a value is already
+      // buffered (seroval's deserialized streams do), so a bare result is
+      // assimilated as an already-settled step instead of crashing on `.then`.
+      const step = it.next();
+      const settled = isThenable(step) ? step : { then: onSettle => void onSettle(step) };
+      settled.then(
         r => {
-          if (isSync) {
+          // The sync stash only serves the INITIAL drain (handleAsync's caller
+          // consumes syncValue / throws NotReady from it). A sync-settled step
+          // after an async gap — seroval buffering values between pulls, a
+          // sync-thenable producer mid-stream — has no caller reading the
+          // stash: it must write through the async path or the value is
+          // silently dropped.
+          if (isSync && initialRead) {
             syncResult = r;
             resolved = true;
             if (r.done) completed = true;
@@ -3503,12 +3528,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