@solidjs/signals 2.0.0-beta.20 → 2.0.0-beta.21

package/README.md

@@ -112,7 +112,7 @@ isPending(data); // true while an unrevealed value change is in flight for this
 latest(data); // last resolved value; follows the not-ready path if no value has resolved yet
 ```
 
-Use `action()` to coordinate async workflows with the reactive graph:
+Use `action()` for mutations — imperative async workflows whose writes span an async gap. Each invocation runs as a single transaction: every write between yields batches into one atomic update, and nothing commits until the action completes or the next `yield` resolves.
 
 ```typescript
 const save = action(function* (item) {
@@ -120,6 +120,10 @@ const save = action(function* (item) {
 });
 ```
 
+Navigation-shaped updates don't need an action. A plain setter call is enough — reads pull the async, downstream async computeds hold their previous values until new ones are ready, and `isPending`/`latest` expose the in-flight state. Reach for `action` when writes happen *after* async work (pairing with optimistic primitives for tentative state that reverts on failure), not when the async is merely downstream of a synchronous write.
+
+Framework-level actions (router form actions, server actions) are specializations of this primitive: the same transactional semantics with form binding, serialization, and submission tracking layered on top.
+
 ## Optimistic Updates
 
 Optimistic signals show an immediate value while async work is pending, then automatically revert when it settles:

package/dist/dev.js

@@ -731,8 +731,12 @@ class GlobalQueue extends Queue {
           const stashedTransition = activeTransition;
           runHeap(zombieQueue, GlobalQueue._update);
           // Detach: the stashed transition keeps its batch; ambient work that
-          // follows lands in a fresh one.
-          currentBatch = this._batch = createBatch();
+          // follows lands in a fresh one. If the batch is already a separate
+          // ambient one — action done() restored activeTransition without
+          // adopting the batch, and an ordinary write landed there before
+          // the scheduled flush (#2916) — keep it: replacing it would strand
+          // its queued pending nodes with held _pendingValues forever.
+          if (this._batch === stashedTransition) currentBatch = this._batch = createBatch();
           // Run lane effects immediately (before stashing) - lanes with no pending async
           if (activeLanes.size) {
             GlobalQueue._runLaneEffects(EFFECT_RENDER);
@@ -740,7 +744,10 @@ class GlobalQueue extends Queue {
           }
           this.stashQueues(stashedTransition._queueStash);
           clock++;
-          scheduled = dirtyQueue._max >= dirtyQueue._min;
+          // A kept ambient batch may hold pending nodes (#2916): stay
+          // scheduled so the outer drain loop commits them via the plain
+          // flush path instead of leaving them until the next natural flush.
+          scheduled = dirtyQueue._max >= dirtyQueue._min || this._batch._pendingNodes.length > 0;
           reassignPendingTransition(stashedTransition._pendingNodes);
           activeTransition = null;
           // The stash pass (committed-view rerun of plain optimistic signals)
@@ -1156,7 +1163,15 @@ function insertIntoHeap(n, heap) {
   if (flags & (REACTIVE_IN_HEAP | REACTIVE_RECOMPUTING_DEPS | REACTIVE_MANUAL_WRITE)) return;
   if (flags & REACTIVE_CHECK) {
     n._flags = (flags & -4) | REACTIVE_DIRTY | REACTIVE_IN_HEAP;
-  } else n._flags = flags | REACTIVE_IN_HEAP;
+  } else {
+    n._flags = flags | REACTIVE_IN_HEAP;
+    // An unmarked node entering a marked heap invalidates the markHeap memo:
+    // `_marked` is only reset by runHeap, so a write between two mid-tick
+    // pulls (read-time markHeap + updateIfNecessary) would otherwise leave
+    // this node unmarked and every downstream pull stale until the next
+    // flush (#2922: the second `latest()` returned the first write's value).
+    if (heap._marked && !(flags & REACTIVE_DIRTY)) heap._marked = false;
+  }
   if (!(flags & REACTIVE_IN_HEAP_HEIGHT)) actualInsertIntoHeap(n, heap);
 }
 function insertIntoHeapHeight(n, heap) {
@@ -3557,6 +3572,19 @@ function latestRead(el) {
       : el._value;
   let value;
   try {
+    // An untracked latest() read has no reading context, so read() never
+    // performs its mid-tick pull — a plain write queued between two latest()
+    // calls left a still-subscribed shadow at its previous speculative value
+    // until the flush (#2922). Mirror the tracked-read pull here: mark the
+    // queued staleness through the graph, then bring the shadow up to date.
+    const queue = queueFor(pendingComputed);
+    if (
+      pendingComputed._height >= queue._min &&
+      !(pendingComputed._flags & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE))
+    ) {
+      markHeap(queue);
+      prepareComputed(pendingComputed, true);
+    }
     value = read(pendingComputed);
   } catch (e) {
     if (e instanceof NotReadyError && (!context || !(el._statusFlags & STATUS_UNINITIALIZED)))
@@ -3573,6 +3601,16 @@ function latestRead(el) {
       return visibleValue;
     }
   }
+  // A shadow recomputed by the pull above (not at creation) holds its fresh
+  // speculative value in _pendingValue; a contextless read() only surfaces
+  // _value. Overrides stay authoritative (A17), and stale readers keep the
+  // other transition's committed view, matching read()'s own selection.
+  if (
+    pendingComputed._pendingValue !== NOT_PENDING &&
+    !hasActiveOverride(pendingComputed) &&
+    !(stale && pendingComputed._transition && activeTransition !== pendingComputed._transition)
+  )
+    return pendingComputed._pendingValue;
   return value;
 }
 /** The isPending()-probe read path, installed as GlobalQueue._pendingCheck. */
@@ -3882,6 +3920,22 @@ function restoreTransition(transition, fn) {
   return result;
 }
 /**
+ * The primitive for mutations: imperative async workflows whose *writes span
+ * an async gap* — optimistic write, server round-trip, reconciling write —
+ * where intermediate state must not leak and failure must revert cleanly
+ * (pair with `createOptimistic` / `createOptimisticStore`).
+ *
+ * Navigation-shaped updates do not need an action. A plain setter call is
+ * enough: reads pull the async, and downstream async computeds hold their
+ * previous values per-node until the new ones are ready (`isPending` /
+ * `latest` expose the in-flight state). Reach for `action` only when writes
+ * happen *after* async work, not merely upstream of it.
+ *
+ * Framework-level actions (router form actions, server actions) are
+ * specializations of this primitive: they are actions in exactly this sense —
+ * the same transactional semantics — with form binding, serialization, and
+ * submission tracking layered on top. The shared name is deliberate.
+ *
  * Wraps a generator function so each invocation runs as a single transaction
  * (a "transition") that batches every signal/store write between yields. The
  * surrounding UI sees one atomic update per yielded step; nothing is committed
@@ -3980,11 +4034,33 @@ function action(genFn) {
       };
       const run = r => {
         if (r.done) return done(r.value);
-        if (isThenable(r.value))
-          return void r.value.then(
-            v => restoreTransition(ctx, () => step(v)),
-            e => restoreTransition(ctx, () => step(e, true))
-          );
+        // Thenable assimilation can itself throw synchronously (a `then`
+        // getter, or a `then()` method that throws — #2918). Match `await`
+        // semantics: the failure is thrown back into the generator at the
+        // yield point (catchable there); if uncaught, step()'s guard settles
+        // the action so its iterator never leaks in the transition. The
+        // settled flag implements A+ 2.3.3.3.4.1: a throw after the thenable
+        // already called a callback is ignored.
+        let settled = false;
+        try {
+          if (isThenable(r.value))
+            return void r.value.then(
+              v => {
+                if (settled) return;
+                settled = true;
+                restoreTransition(ctx, () => step(v));
+              },
+              e => {
+                if (settled) return;
+                settled = true;
+                restoreTransition(ctx, () => step(e, true));
+              }
+            );
+        } catch (e) {
+          if (settled) return;
+          settled = true;
+          return void restoreTransition(ctx, () => step(e, true));
+        }
         restoreTransition(ctx, () => step(r.value));
       };
       step();

package/dist/node.cjs

@@ -634,8 +634,12 @@ class GlobalQueue extends Queue {
                     const e = activeTransition;
                     runHeap(zombieQueue, GlobalQueue.X);
                     // Detach: the stashed transition keeps its batch; ambient work that
-                    // follows lands in a fresh one.
-                                        currentBatch = this.D = createBatch();
+                    // follows lands in a fresh one. If the batch is already a separate
+                    // ambient one — action done() restored activeTransition without
+                    // adopting the batch, and an ordinary write landed there before
+                    // the scheduled flush (#2916) — keep it: replacing it would strand
+                    // its queued pending nodes with held _pendingValues forever.
+                                        if (this.D === e) currentBatch = this.D = createBatch();
                     // Run lane effects immediately (before stashing) - lanes with no pending async
                                         if (activeLanes.size) {
                         GlobalQueue.Ce(EFFECT_RENDER);
@@ -643,7 +647,10 @@ class GlobalQueue extends Queue {
                     }
                     this.stashQueues(e.K);
                     clock++;
-                    scheduled = dirtyQueue.C >= dirtyQueue.P;
+                    // A kept ambient batch may hold pending nodes (#2916): stay
+                    // scheduled so the outer drain loop commits them via the plain
+                    // flush path instead of leaving them until the next natural flush.
+                                        scheduled = dirtyQueue.C >= dirtyQueue.P || this.D.H.length > 0;
                     reassignPendingTransition(e.H);
                     activeTransition = null;
                     // The stash pass (committed-view rerun of plain optimistic signals)
@@ -1038,7 +1045,15 @@ function insertIntoHeap(e, t) {
     if (n & (REACTIVE_IN_HEAP | REACTIVE_RECOMPUTING_DEPS | REACTIVE_MANUAL_WRITE)) return;
     if (n & REACTIVE_CHECK) {
         e.Qe = n & -4 | REACTIVE_DIRTY | REACTIVE_IN_HEAP;
-    } else e.Qe = n | REACTIVE_IN_HEAP;
+    } else {
+        e.Qe = n | REACTIVE_IN_HEAP;
+        // An unmarked node entering a marked heap invalidates the markHeap memo:
+        // `_marked` is only reset by runHeap, so a write between two mid-tick
+        // pulls (read-time markHeap + updateIfNecessary) would otherwise leave
+        // this node unmarked and every downstream pull stale until the next
+        // flush (#2922: the second `latest()` returned the first write's value).
+                if (t.N && !(n & REACTIVE_DIRTY)) t.N = false;
+    }
     if (!(n & REACTIVE_IN_HEAP_HEIGHT)) actualInsertIntoHeap(e, t);
 }
 
@@ -3174,6 +3189,16 @@ function getLatestValueComputed(e) {
     const r = e.A !== undefined && e.A !== NOT_PENDING ? unwrapOverride(e.A) : e.Me;
     let i;
     try {
+        // An untracked latest() read has no reading context, so read() never
+        // performs its mid-tick pull — a plain write queued between two latest()
+        // calls left a still-subscribed shadow at its previous speculative value
+        // until the flush (#2922). Mirror the tracked-read pull here: mark the
+        // queued staleness through the graph, then bring the shadow up to date.
+        const e = queueFor(t);
+        if (t.nt >= e.P && !(t.Qe & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE))) {
+            markHeap(e);
+            prepareComputed(t, true);
+        }
         i = read(t);
     } catch (t) {
         if (t instanceof NotReadyError && (!context || !(e.$e & STATUS_UNINITIALIZED))) return r;
@@ -3189,6 +3214,11 @@ function getLatestValueComputed(e) {
             return r;
         }
     }
+    // A shadow recomputed by the pull above (not at creation) holds its fresh
+    // speculative value in _pendingValue; a contextless read() only surfaces
+    // _value. Overrides stay authoritative (A17), and stale readers keep the
+    // other transition's committed view, matching read()'s own selection.
+        if (t.V !== NOT_PENDING && !hasActiveOverride(t) && !(stale && t.T && activeTransition !== t.T)) return t.V;
     return i;
 }
 
@@ -3432,6 +3462,22 @@ function restoreTransition(e, t) {
 }
 
 /**
+ * The primitive for mutations: imperative async workflows whose *writes span
+ * an async gap* — optimistic write, server round-trip, reconciling write —
+ * where intermediate state must not leak and failure must revert cleanly
+ * (pair with `createOptimistic` / `createOptimisticStore`).
+ *
+ * Navigation-shaped updates do not need an action. A plain setter call is
+ * enough: reads pull the async, and downstream async computeds hold their
+ * previous values per-node until the new ones are ready (`isPending` /
+ * `latest` expose the in-flight state). Reach for `action` only when writes
+ * happen *after* async work, not merely upstream of it.
+ *
+ * Framework-level actions (router form actions, server actions) are
+ * specializations of this primitive: they are actions in exactly this sense —
+ * the same transactional semantics — with form binding, serialization, and
+ * submission tracking layered on top. The shared name is deliberate.
+ *
  * Wraps a generator function so each invocation runs as a single transaction
  * (a "transition") that batches every signal/store write between yields. The
  * surrounding UI sees one atomic update per yielded step; nothing is committed
@@ -3506,7 +3552,29 @@ function restoreTransition(e, t) {
         };
         const run = e => {
             if (e.done) return done(e.value);
-            if (isThenable(e.value)) return void e.value.then(e => restoreTransition(o, () => step(e)), e => restoreTransition(o, () => step(e, true)));
+            // Thenable assimilation can itself throw synchronously (a `then`
+            // getter, or a `then()` method that throws — #2918). Match `await`
+            // semantics: the failure is thrown back into the generator at the
+            // yield point (catchable there); if uncaught, step()'s guard settles
+            // the action so its iterator never leaks in the transition. The
+            // settled flag implements A+ 2.3.3.3.4.1: a throw after the thenable
+            // already called a callback is ignored.
+                        let t = false;
+            try {
+                if (isThenable(e.value)) return void e.value.then(e => {
+                    if (t) return;
+                    t = true;
+                    restoreTransition(o, () => step(e));
+                }, e => {
+                    if (t) return;
+                    t = true;
+                    restoreTransition(o, () => step(e, true));
+                });
+            } catch (e) {
+                if (t) return;
+                t = true;
+                return void restoreTransition(o, () => step(e, true));
+            }
             restoreTransition(o, () => step(e.value));
         };
         step();

package/dist/prod/core/action.js

@@ -4,14 +4,30 @@ import { isThenable } from "./async.js";
 
 import "./core.js";
 
-function restoreTransition(e, n) {
+function restoreTransition(e, r) {
     globalQueue.initTransition(e);
-    const t = n();
+    const t = r();
     flush();
     return t;
 }
 
 /**
+ * The primitive for mutations: imperative async workflows whose *writes span
+ * an async gap* — optimistic write, server round-trip, reconciling write —
+ * where intermediate state must not leak and failure must revert cleanly
+ * (pair with `createOptimistic` / `createOptimisticStore`).
+ *
+ * Navigation-shaped updates do not need an action. A plain setter call is
+ * enough: reads pull the async, and downstream async computeds hold their
+ * previous values per-node until the new ones are ready (`isPending` /
+ * `latest` expose the in-flight state). Reach for `action` only when writes
+ * happen *after* async work, not merely upstream of it.
+ *
+ * Framework-level actions (router form actions, server actions) are
+ * specializations of this primitive: they are actions in exactly this sense —
+ * the same transactional semantics — with form binding, serialization, and
+ * submission tracking layered on top. The shared name is deliberate.
+ *
  * Wraps a generator function so each invocation runs as a single transaction
  * (a "transition") that batches every signal/store write between yields. The
  * surrounding UI sees one atomic update per yielded step; nothing is committed
@@ -58,23 +74,23 @@ function restoreTransition(e, n) {
  * await addTodo("buy milk");
  * ```
  */ function action(e) {
-    return (...n) => new Promise((t, r) => {
-        const i = e(...n);
+    return (...r) => new Promise((t, n) => {
+        const i = e(...r);
         globalQueue.initTransition();
         let o = activeTransition;
         o.Te.push(i);
-        const done = (e, n, s = false) => {
+        const done = (e, r, s = false) => {
             o = currentTransition(o);
             const u = o.Te.indexOf(i);
             if (u >= 0) o.Te.splice(u, 1);
             setActiveTransition(o);
             schedule();
-            s ? r(n) : t(e);
+            s ? n(r) : t(e);
         };
-        const step = (e, n) => {
+        const step = (e, r) => {
             let t;
             try {
-                t = n ? i.throw(e) : i.next(e);
+                t = r ? i.throw(e) : i.next(e);
             } catch (e) {
                 return done(undefined, e, true);
             }
@@ -86,7 +102,29 @@ function restoreTransition(e, n) {
         };
         const run = e => {
             if (e.done) return done(e.value);
-            if (isThenable(e.value)) return void e.value.then(e => restoreTransition(o, () => step(e)), e => restoreTransition(o, () => step(e, true)));
+            // Thenable assimilation can itself throw synchronously (a `then`
+            // getter, or a `then()` method that throws — #2918). Match `await`
+            // semantics: the failure is thrown back into the generator at the
+            // yield point (catchable there); if uncaught, step()'s guard settles
+            // the action so its iterator never leaks in the transition. The
+            // settled flag implements A+ 2.3.3.3.4.1: a throw after the thenable
+            // already called a callback is ignored.
+                        let r = false;
+            try {
+                if (isThenable(e.value)) return void e.value.then(e => {
+                    if (r) return;
+                    r = true;
+                    restoreTransition(o, () => step(e));
+                }, e => {
+                    if (r) return;
+                    r = true;
+                    restoreTransition(o, () => step(e, true));
+                });
+            } catch (e) {
+                if (r) return;
+                r = true;
+                return void restoreTransition(o, () => step(e, true));
+            }
             restoreTransition(o, () => step(e.value));
         };
         step();

package/dist/prod/core/core.js

@@ -1,6 +1,6 @@
 import { handleAsync, clearStatus, notifyStatus } from "./async.js";
 
-import { EFFECT_TRACKED, REACTIVE_OPTIMISTIC_DIRTY, NOT_PENDING, STATUS_UNINITIALIZED, REACTIVE_REASK, REACTIVE_RECOMPUTING_DEPS, CONFIG_SYNC, STATUS_PENDING, STATUS_ERROR, REACTIVE_NONE, REACTIVE_SNAPSHOT_STALE, unwrapOverride, OVERRIDE_UNDEFINED, CONFIG_AUTO_DISPOSE, REACTIVE_LAZY, REACTIVE_DISPOSED, REACTIVE_CHECK, REACTIVE_DIRTY, REACTIVE_IN_HEAP, REACTIVE_IN_HEAP_HEIGHT, defaultContext, CONFIG_IN_SNAPSHOT_SCOPE, CONFIG_TRANSPARENT, CONFIG_OWNED_WRITE, CONFIG_NO_SNAPSHOT, $REFRESH, REACTIVE_MANUAL_WRITE, NO_SNAPSHOT, STORE_SNAPSHOT_PROPS, EFFECT_USER } from "./constants.js";
+import { EFFECT_TRACKED, REACTIVE_OPTIMISTIC_DIRTY, NOT_PENDING, STATUS_UNINITIALIZED, REACTIVE_REASK, REACTIVE_RECOMPUTING_DEPS, CONFIG_SYNC, STATUS_PENDING, STATUS_ERROR, REACTIVE_NONE, REACTIVE_SNAPSHOT_STALE, unwrapOverride, OVERRIDE_UNDEFINED, REACTIVE_LAZY, REACTIVE_DISPOSED, CONFIG_AUTO_DISPOSE, REACTIVE_CHECK, REACTIVE_DIRTY, REACTIVE_IN_HEAP, REACTIVE_IN_HEAP_HEIGHT, defaultContext, CONFIG_IN_SNAPSHOT_SCOPE, CONFIG_TRANSPARENT, CONFIG_OWNED_WRITE, CONFIG_NO_SNAPSHOT, $REFRESH, REACTIVE_MANUAL_WRITE, NO_SNAPSHOT, STORE_SNAPSHOT_PROPS, EFFECT_USER } from "./constants.js";
 
 import { NotReadyError } from "./error.js";
 

package/dist/prod/core/heap.js

@@ -43,7 +43,15 @@ function insertIntoHeap(e, E) {
     if (t & (REACTIVE_IN_HEAP | REACTIVE_RECOMPUTING_DEPS | REACTIVE_MANUAL_WRITE)) return;
     if (t & REACTIVE_CHECK) {
         e.u = t & -4 | REACTIVE_DIRTY | REACTIVE_IN_HEAP;
-    } else e.u = t | REACTIVE_IN_HEAP;
+    } else {
+        e.u = t | REACTIVE_IN_HEAP;
+        // An unmarked node entering a marked heap invalidates the markHeap memo:
+        // `_marked` is only reset by runHeap, so a write between two mid-tick
+        // pulls (read-time markHeap + updateIfNecessary) would otherwise leave
+        // this node unmarked and every downstream pull stale until the next
+        // flush (#2922: the second `latest()` returned the first write's value).
+                if (E.tE && !(t & REACTIVE_DIRTY)) E.tE = false;
+    }
     if (!(t & REACTIVE_IN_HEAP_HEIGHT)) actualInsertIntoHeap(e, E);
 }
 

package/dist/prod/core/scheduler.js

@@ -323,8 +323,12 @@ class GlobalQueue extends Queue {
                     const e = activeTransition;
                     runHeap(zombieQueue, GlobalQueue.Ce);
                     // Detach: the stashed transition keeps its batch; ambient work that
-                    // follows lands in a fresh one.
-                                        currentBatch = this.N = createBatch();
+                    // follows lands in a fresh one. If the batch is already a separate
+                    // ambient one — action done() restored activeTransition without
+                    // adopting the batch, and an ordinary write landed there before
+                    // the scheduled flush (#2916) — keep it: replacing it would strand
+                    // its queued pending nodes with held _pendingValues forever.
+                                        if (this.N === e) currentBatch = this.N = createBatch();
                     // Run lane effects immediately (before stashing) - lanes with no pending async
                                         if (activeLanes.size) {
                         GlobalQueue.On(EFFECT_RENDER);
@@ -332,7 +336,10 @@ class GlobalQueue extends Queue {
                     }
                     this.stashQueues(e.Bt);
                     clock++;
-                    scheduled = dirtyQueue.EE >= dirtyQueue.Le;
+                    // A kept ambient batch may hold pending nodes (#2916): stay
+                    // scheduled so the outer drain loop commits them via the plain
+                    // flush path instead of leaving them until the next natural flush.
+                                        scheduled = dirtyQueue.EE >= dirtyQueue.Le || this.N.yt.length > 0;
                     reassignPendingTransition(e.yt);
                     activeTransition = null;
                     // The stash pass (committed-view rerun of plain optimistic signals)

package/dist/prod/core/verdict.js

@@ -1,12 +1,12 @@
-import { NOT_PENDING, REACTIVE_DISPOSED, REACTIVE_DIRTY, REACTIVE_CHECK, unwrapOverride, STATUS_UNINITIALIZED, STATUS_PENDING, REACTIVE_MANUAL_WRITE } from "./constants.js";
+import { NOT_PENDING, REACTIVE_DISPOSED, REACTIVE_DIRTY, REACTIVE_CHECK, unwrapOverride, REACTIVE_ZOMBIE, STATUS_UNINITIALIZED, STATUS_PENDING, REACTIVE_MANUAL_WRITE } from "./constants.js";
 
-import { setSignal, read, context, stale, currentOptimisticLane, prepareComputed, tracking, setLatestReadActive, setContextInternal, optimisticComputed, setPendingCheckActive, latestReadActive, optimisticSignal, pendingCheckActive } from "./core.js";
+import { setSignal, prepareComputed, read, context, stale, currentOptimisticLane, tracking, setLatestReadActive, setContextInternal, optimisticComputed, setPendingCheckActive, latestReadActive, optimisticSignal, pendingCheckActive } from "./core.js";
 
 import { NotReadyError } from "./error.js";
 
 import { link } from "./graph.js";
 
-import { insertIntoHeap, queueFor } from "./heap.js";
+import { insertIntoHeap, queueFor, markHeap } from "./heap.js";
 
 import "./invariants.js";
 
@@ -14,7 +14,7 @@ import { findLane, hasActiveOverride } from "./lanes.js";
 
 import { installOptimisticEngine } from "./optimistic.js";
 
-import { GlobalQueue, clock, insertSubs, schedule } from "./scheduler.js";
+import { GlobalQueue, clock, insertSubs, schedule, activeTransition } from "./scheduler.js";
 
 /**
  * The isPending()/latest() verdict layer, moved out of core.ts. Importing this
@@ -175,6 +175,16 @@ function getLatestValueComputed(e) {
     const i = e.be !== undefined && e.be !== NOT_PENDING ? unwrapOverride(e.be) : e.Ue;
     let r;
     try {
+        // An untracked latest() read has no reading context, so read() never
+        // performs its mid-tick pull — a plain write queued between two latest()
+        // calls left a still-subscribed shadow at its previous speculative value
+        // until the flush (#2922). Mirror the tracked-read pull here: mark the
+        // queued staleness through the graph, then bring the shadow up to date.
+        const e = queueFor(t);
+        if (t.qe >= e.Le && !(t.u & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE))) {
+            markHeap(e);
+            prepareComputed(t, true);
+        }
         r = read(t);
     } catch (t) {
         if (t instanceof NotReadyError && (!context || !(e.i & STATUS_UNINITIALIZED))) return i;
@@ -190,6 +200,11 @@ function getLatestValueComputed(e) {
             return i;
         }
     }
+    // A shadow recomputed by the pull above (not at creation) holds its fresh
+    // speculative value in _pendingValue; a contextless read() only surfaces
+    // _value. Overrides stay authoritative (A17), and stale readers keep the
+    // other transition's committed view, matching read()'s own selection.
+        if (t.ge !== NOT_PENDING && !hasActiveOverride(t) && !(stale && t.ve && activeTransition !== t.ve)) return t.ge;
     return r;
 }
 

package/dist/types/core/action.d.ts

@@ -1,4 +1,20 @@
 /**
+ * The primitive for mutations: imperative async workflows whose *writes span
+ * an async gap* — optimistic write, server round-trip, reconciling write —
+ * where intermediate state must not leak and failure must revert cleanly
+ * (pair with `createOptimistic` / `createOptimisticStore`).
+ *
+ * Navigation-shaped updates do not need an action. A plain setter call is
+ * enough: reads pull the async, and downstream async computeds hold their
+ * previous values per-node until the new ones are ready (`isPending` /
+ * `latest` expose the in-flight state). Reach for `action` only when writes
+ * happen *after* async work, not merely upstream of it.
+ *
+ * Framework-level actions (router form actions, server actions) are
+ * specializations of this primitive: they are actions in exactly this sense —
+ * the same transactional semantics — with form binding, serialization, and
+ * submission tracking layered on top. The shared name is deliberate.
+ *
  * Wraps a generator function so each invocation runs as a single transaction
  * (a "transition") that batches every signal/store write between yields. The
  * surrounding UI sees one atomic update per yielded step; nothing is committed

package/dist/types-cjs/core/action.d.cts

@@ -1,4 +1,20 @@
 /**
+ * The primitive for mutations: imperative async workflows whose *writes span
+ * an async gap* — optimistic write, server round-trip, reconciling write —
+ * where intermediate state must not leak and failure must revert cleanly
+ * (pair with `createOptimistic` / `createOptimisticStore`).
+ *
+ * Navigation-shaped updates do not need an action. A plain setter call is
+ * enough: reads pull the async, and downstream async computeds hold their
+ * previous values per-node until the new ones are ready (`isPending` /
+ * `latest` expose the in-flight state). Reach for `action` only when writes
+ * happen *after* async work, not merely upstream of it.
+ *
+ * Framework-level actions (router form actions, server actions) are
+ * specializations of this primitive: they are actions in exactly this sense —
+ * the same transactional semantics — with form binding, serialization, and
+ * submission tracking layered on top. The shared name is deliberate.
+ *
  * Wraps a generator function so each invocation runs as a single transaction
  * (a "transition") that batches every signal/store write between yields. The
  * surrounding UI sees one atomic update per yielded step; nothing is committed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solidjs/signals",
-  "version": "2.0.0-beta.20",
+  "version": "2.0.0-beta.21",
   "description": "Solid's reactive primitives: signals, memos, effects, stores, and async-aware computations.",
   "author": "Ryan Carniato",
   "license": "MIT",