@solidjs/signals 2.0.0-rc.17 → 2.0.0-rc.19

package/dist/prod/core/lanes.js

@@ -1,4 +1,4 @@
-import { CONFIG_GUESS, NOT_PENDING, CONFIG_OVERRIDE, REACTIVE_DISPOSED, CONFIG_VERDICT, REACTIVE_PROBE_UNANSWERED, REACTIVE_LANE_DIRTY, CONFIG_HELD, REACTIVE_LANE_READ, STATUS_UNINITIALIZED, REACTIVE_RECOMPUTING_DEPS, CONFIG_AUTHORITATIVE, STATUS_ERROR, CONFIG_CHILDREN_FORBIDDEN, STATUS_PENDING, EFFECT_RENDER, REACTIVE_SCREEN_READ, REACTIVE_FRAME_READ, REACTIVE_IN_HEAP, REACTIVE_DIRTY, REACTIVE_CHECK, CONFIG_INPUTS_PUBLISHED, CONFIG_SLOT_NODE, CONFIG_STAGED, REACTIVE_JOINED, REACTIVE_STAGED_READ } from "./constants.js";
+import { CONFIG_GUESS, NOT_PENDING, CONFIG_OVERRIDE, REACTIVE_DISPOSED, CONFIG_VERDICT, REACTIVE_PROBE_UNANSWERED, REACTIVE_LANE_DIRTY, CONFIG_HELD, REACTIVE_LANE_READ, STATUS_UNINITIALIZED, REACTIVE_RECOMPUTING_DEPS, CONFIG_AUTHORITATIVE, STATUS_ERROR, CONFIG_CHILDREN_FORBIDDEN, EFFECT_RENDER, REACTIVE_SCREEN_READ, REACTIVE_FRAME_READ, REACTIVE_IN_HEAP, REACTIVE_DIRTY, REACTIVE_CHECK, STATUS_PENDING, CONFIG_INPUTS_PUBLISHED, CONFIG_SLOT_NODE, CONFIG_STAGED, REACTIVE_JOINED, REACTIVE_STAGED_READ } from "./constants.js";
 
 import { ext, tracking, stagedRead } from "./core.js";
 
@@ -8,7 +8,7 @@ import { laneValueOf } from "./truth.js";
 
 import { enqueueSub } from "./heap.js";
 
-import { schedule, question, nextQuestion, installLaneHooks, GlobalQueue, newTransaction, resolveTx, ownFlights, blocked, txOf, clock, insertSubs, laneDirty, queuePendingNode, list, passLane, sameLane, flushTransaction, commitPendingNode, releaseQueues, holdNode, joinFuture, reruns, merge, setPassLane } from "./scheduler.js";
+import { schedule, question, nextQuestion, installLaneHooks, GlobalQueue, newTransaction, resolveTx, ownFlights, blocked, txOf, clock, insertSubs, laneDirty, queuePendingNode, list, passLane, setPassLane, sameLane, flushTransaction, commitPendingNode, releaseQueues, holdNode, joinFuture, reruns, merge } from "./scheduler.js";
 
 // Lanes (plan sec. 28 replay, 2026-10-02; maintainer rulings 2026-10-01/02). A lane
 // is "a new base of a transition": the sub-frame an optimistic write opens
@@ -50,8 +50,8 @@ function newLane(e) {
 
 /** What the screen shows for a lane's node: the lane's value once the lane
  * has revealed, the committed truth before. */ function display(e) {
-    const n = e.T.v;
-    return e.T.Re.ke && n !== NOT_PENDING ? n : e.Ie;
+    const n = e.T.P;
+    return e.T.Re.ge && n !== NOT_PENDING ? n : e.le;
 }
 
 /** Guesses written since the last seam (`[node, value, question, …]`).
@@ -66,7 +66,7 @@ function newLane(e) {
  * on (a store setter's draft too, store/optimistic.ts). */ function guessedValueOf(e) {
     const n = pendingGuessOf(e);
     if (n !== NOT_PENDING) return n;
-    return e.l & CONFIG_OVERRIDE ? laneValueOf(e) : e.Ie;
+    return e.l & CONFIG_OVERRIDE ? laneValueOf(e) : e.le;
 }
 
 /** The unflushed guess to `n`, else NOT_PENDING. */ function pendingGuessOf(e) {
@@ -119,10 +119,10 @@ function applyGuesses(e) {
             // value re-asked renews the question; nothing to notify.
             u = !t.xe || !t.xe(laneValueOf(t), l);
             if (!(t.l & CONFIG_GUESS)) {
-                t.se = NOT_PENDING;
+                t.ie = NOT_PENDING;
                 t.l |= CONFIG_GUESS;
             }
-            t.T.v = l;
+            t.T.P = l;
             i = txOf(t)._parent;
         } else {
             let s;
@@ -141,12 +141,12 @@ function applyGuesses(e) {
             // screen's plus the guess (plan sec. 19) — a derivation reading a held write
             // beside the guess must not show it. Two flights for one input, when
             // the worlds coincide, is the price.)
-                        ext(t).v = l;
+                        ext(t).P = l;
             t.l |= CONFIG_OVERRIDE | CONFIG_GUESS;
             list(t, s);
         }
         if (e !== null && i !== null) merge(e, i);
-        ext(t).Ee = pendingGuesses[s + 2];
+        ext(t).Te = pendingGuesses[s + 2];
         if (u) {
             // The lane's members re-derive as its work (REACTIVE_LANE_DIRTY): a
             // blocked lane's re-guess does not re-run its render effects as stale
@@ -187,7 +187,7 @@ function applyGuesses(e) {
 }
 
 /** Is `l` nested under `a` (an ancestor lane)? */ function under(e, n) {
-    for (let s = e._parent; s !== null && s.v; s = s._parent) if (s === n) return true;
+    for (let s = e._parent; s !== null && s.P; s = s._parent) if (s === n) return true;
     return false;
 }
 
@@ -231,7 +231,7 @@ function unlink(e) {
  * lane under the holder, shown now, re-derived at the landing, ending with
  * it. Judged at the seam like any lane: blocked while a verdict reader's
  * own derivation is in flight (lane rule 3), shown otherwise. */ function verdictLane(e) {
-    return e.he ??= newLane(e);
+    return e.Pe ??= newLane(e);
 }
 
 /** A lane pass's node (core.ts `recompute`, before its staging; a pending
@@ -255,16 +255,16 @@ function unlink(e) {
             const s = n.Re;
             // Cleared before equality, so a return to the committed value notifies
             // nobody. The seam wakes it unless the frame is still held (#3892).
-                        if (s?.ke && !blocked(resolveTx(s._parent))) e.R |= LEFT_SHOWN;
-            if (s?.v) n.Re = null;
-            n.v = NOT_PENDING;
+                        if (s?.ge && !blocked(resolveTx(s._parent))) e.R |= LEFT_SHOWN;
+            if (s?.P) n.Re = null;
+            n.P = NOT_PENDING;
         }
         e.l &= -1050881;
         return false;
     }
     if (!e.i) {
         if (!(e.l & CONFIG_OVERRIDE)) {
-            e.se = NOT_PENDING;
+            e.ie = NOT_PENDING;
             e.l = e.l & -1048833 | CONFIG_OVERRIDE;
             ext(e);
         }
@@ -287,7 +287,7 @@ function unlink(e) {
     // for the commit sweep as mainline's (async.ts). A node born in the lane
     // has nothing on screen: its leaf waits as the lane's.
      else if (t) {
-        if (t !== true && !(t.m & STATUS_UNINITIALIZED) && (e.l & CONFIG_HELD || e.R & REACTIVE_RECOMPUTING_DEPS) && !e.T?.Re?.v) {
+        if (t !== true && !(t.m & STATUS_UNINITIALIZED) && (e.l & CONFIG_HELD || e.R & REACTIVE_RECOMPUTING_DEPS) && !e.T?.Re?.P) {
             queuePendingNode(e);
             return false;
         }
@@ -306,14 +306,14 @@ function supersede(e, n, s) {
     // A store row answered by a new object the store would reconcile into
     // the guessed one unchanged is an echo, not a correction (#3898): the
     // server's object never matches the guess by reference.
-        if (s && e.l & CONFIG_SLOT_NODE && GlobalQueue.nn?.(e.T.v, n)) s = false;
+        if (s && e.l & CONFIG_SLOT_NODE && GlobalQueue.nn?.(e.T.P, n)) s = false;
     if (s) {
         dissolveLane(t, l, e);
         // What the screen showed stays the screen until the parent lands (A18
         // (c): display and untracked reads keep the override until the commit).
-                if (t.ke) e.Ie = e.T.v;
+                if (t.ge) e.le = e.T.P;
         e.l &= -10241;
-        e.T.v = NOT_PENDING;
+        e.T.P = NOT_PENDING;
         holdNode(e, l);
         if (e.o !== null) insertSubs(e);
     } else {
@@ -321,7 +321,7 @@ function supersede(e, n, s) {
         // A confirmation is silent (A17); only truth readers are told.
                 GlobalQueue.sn?.(t);
     }
-    e.se = n;
+    e.ie = n;
     joinFuture(l);
 }
 
@@ -340,9 +340,9 @@ function supersede(e, n, s) {
     unlink(e);
     // Its verdicts end with it (a correction's dissolution reaches here before
     // `endLanes` would): the readers re-derive from the truth's notification.
-        const l = e.he;
+        const l = e.Pe;
     if (l !== null) {
-        e.he = null;
+        e.Pe = null;
         if (lanes.indexOf(l) !== -1) dissolveLane(l, null);
     }
     for (let t = 0; t < e.tn.length; t++) {
@@ -351,12 +351,12 @@ function supersede(e, n, s) {
         if (l === s || u.Re !== e) continue;
         const i = l.i;
         const r = l.l & CONFIG_GUESS;
-        const o = u.v;
+        const o = u.P;
         // What the screen shows of it (NOT_PENDING: nothing — a lane pass that
         // errored or pends staged no value), and the lane's latest.
-                const E = e.ke && !i ? o : l.Ie;
+                const E = e.ge && !i ? o : l.le;
         const f = laneValueOf(l);
-        u.v = NOT_PENDING;
+        u.P = NOT_PENDING;
         l.l &= -10241;
         if (n === null) {
             // A derivation the revert re-derives (dirtied by the guess's
@@ -365,19 +365,19 @@ function supersede(e, n, s) {
             // of its flight observes it (#3648, #3651; #3305's commit beneath a
             // flight).
             u.Re = null;
-            if (!i && !r) l.se = f;
+            if (!i && !r) l.ie = f;
             commitPendingNode(l);
             if (!i) {
                 if (l.R & (REACTIVE_IN_HEAP | REACTIVE_DIRTY | REACTIVE_CHECK) || l.m & STATUS_PENDING) l.l |= CONFIG_INPUTS_PUBLISHED;
-                if (E !== NOT_PENDING && (!l.xe || !l.xe(E, l.Ie))) insertSubs(l);
+                if (E !== NOT_PENDING && (!l.xe || !l.xe(E, l.le))) insertSubs(l);
             }
         } else if (r) {
             // A guess of a dissolving lane: its truth — a landing held beneath it,
             // else the value it covered — is the parent's to land, and its readers
             // re-derive from it there. What the screen showed stays the screen
             // until then (A18 (c)).
-            if (l.se === NOT_PENDING) l.se = covered(l);
-            if (e.ke) l.Ie = o;
+            if (l.ie === NOT_PENDING) l.ie = covered(l);
+            if (e.ge) l.le = o;
             holdNode(l, n);
             insertSubs(l);
         } else {
@@ -390,13 +390,13 @@ function supersede(e, n, s) {
             // it: an input's truth equal to its committed value is silent).
             u.Re = null;
             if (!i) {
-                if (E !== NOT_PENDING && e.ke) l.se = E;
+                if (E !== NOT_PENDING && e.ge) l.ie = E;
                 if (l.m & STATUS_PENDING) {
-                    u.Se = null;
+                    u.Ee = null;
                     enqueueSub(l);
                 }
             }
-            if (e.ke) {
+            if (e.ge) {
                 commitPendingNode(l);
                 if (!i) l.l |= CONFIG_INPUTS_PUBLISHED;
             } else {
@@ -416,7 +416,7 @@ function supersede(e, n, s) {
     // void: nothing of it reached the screen. So are the runs a blocked lane
     // parked: they show a re-guess the seam never revealed, beside derivations
     // that keep what the screen showed.
-        if (n === null || e.ke && !e.ln) releaseQueues(e); else e.un[0].length = e.un[1].length = 0;
+        if (n === null || e.ge && !e.ln) releaseQueues(e); else e.un[0].length = e.un[1].length = 0;
 }
 
 /** Lanes. A lane's node is read by its reader's kind: an authoritative
@@ -433,7 +433,11 @@ function supersede(e, n, s) {
  * has shown, or one the seam has not judged yet (its run waits on the
  * verdict: released if the lane shows, held if it blocks) — and sees the
  * lane's latest. NOT_PENDING falls through: lane work's read of a pending
- * member throws like any. */ function laneRead(e, n) {
+ * member throws like any. A verdict reader entering a lane the seam has
+ * not judged reads ahead of it like a staging read: if the seam holds the
+ * lane, the pass re-derives on the screen (`entered`, #4284) — `latest()`
+ * beside the lane's nodes tears ahead of the hold however the reads are
+ * grouped into effects. */ function laneRead(e, n) {
     const s = n.l & CONFIG_GUESS;
     const t = txOf(n);
     // A lane a correction folded under (D-34): store/optimistic.ts reads it.
@@ -450,6 +454,7 @@ function supersede(e, n, s) {
     // An errored member's lane value predates its error; the error is the answer (#4106).
         if (!s && u & STATUS_ERROR) return NOT_PENDING;
     if (e === null) return laneValueOf(n);
+    const i = !s && u & STATUS_PENDING;
     if (!tracking || e.l & CONFIG_CHILDREN_FORBIDDEN) {
         // An untracked read inside lane work derives from the lane like a
         // tracked one, minus the subscription — `untrack` is about
@@ -458,39 +463,45 @@ function supersede(e, n, s) {
         // lanes read by one pass link, as for tracked reads). Outside lane
         // work, the screen.
         if (passLane === null || e.l & CONFIG_CHILDREN_FORBIDDEN) return display(n);
-        enterLane(t, e);
-        if (!s && u & STATUS_PENDING) return NOT_PENDING;
-        return laneValueOf(n);
-    }
-    if (e.i === EFFECT_RENDER && (passLane === null || !sameLane(passLane, t))) {
-        if (!s) {
-            // A flight whose value has never shown: nothing to show — the leaf
-            // waits on it, and its own frame holds (A15, #3334), not the lane's
-            // parent. The landing lands the frame: its own pass (the flush
-            // joined its transaction) reads the answer it waited on — the lane's
-            // staging, revealed at this seam.
-            if (u & STATUS_PENDING && n.T.v === NOT_PENDING) return NOT_PENDING;
-            if (n.se !== NOT_PENDING && e.l & CONFIG_HELD && flushTransaction !== null && resolveTx(flushTransaction) === txOf(e)) return n.se;
-        }
-        if (t.ln || !s && u & STATUS_PENDING) {
-            if (!s && !t.ke && u & STATUS_UNINITIALIZED) throw new NotReadyError(null);
-            // Re-derived at the reveal; once per pass (the pass may also be a stale
-            // reader of a transaction, REACTIVE_FRAME_READ — both reruns apply).
-                        if (!(e.R & REACTIVE_SCREEN_READ)) {
-                e.R |= REACTIVE_FRAME_READ | REACTIVE_SCREEN_READ;
-                t.En.push(e);
+    } else if (e.i === EFFECT_RENDER) {
+        // A flight whose value has never shown: nothing to show — the leaf
+        // waits on it, and its own frame holds (A15, #3334), not the lane's
+        // parent. The landing lands the frame: its own pass (the flush joined
+        // its transaction) reads the answer it waited on — the lane's staging,
+        // revealed at this seam.
+        const l = i && n.T.P === NOT_PENDING;
+        // D-28: a leaf a verdict read moved into the lane still throws on such
+        // a flight — the pass leaves the lane, and its frame holds as if the
+        // read had come first (S-39, #4275). Nor does a verdict lane's seat carry
+        // the leaf into another lane (no link): it reads that lane as from the
+        // frame's seat (#4284).
+                if ((l || passLane !== t) && passLane?._parent.Pe === passLane) setPassLane(null);
+        if (passLane === null || !sameLane(passLane, t)) {
+            // (A lane that has never shown: the screen is the committed value.)
+            if (l && t.ge) return NOT_PENDING;
+            if (!s && n.ie !== NOT_PENDING && e.l & CONFIG_HELD && flushTransaction !== null && resolveTx(flushTransaction) === txOf(e)) return n.ie;
+            if (t.ln || i) {
+                if (!s && !t.ge && u & STATUS_UNINITIALIZED) throw new NotReadyError(null);
+                // Re-derived at the reveal; once per pass (the pass may also be a stale
+                // reader of a transaction, REACTIVE_FRAME_READ — both reruns apply).
+                                if (!(e.R & REACTIVE_SCREEN_READ)) {
+                    e.R |= REACTIVE_FRAME_READ | REACTIVE_SCREEN_READ;
+                    t.En.push(e);
+                }
+                return display(n);
             }
-            return display(n);
+            // A verdict reader reads ahead of the seam's verdict: re-derived on the
+            // screen if the lane holds (#4284).
+                        if (e.l & CONFIG_VERDICT && t._parent.Pe !== t) entered.push(e);
         }
     }
     enterLane(t, e);
-    if (!s && u & STATUS_PENDING) return NOT_PENDING;
-    return laneValueOf(n);
+    return i ? NOT_PENDING : laneValueOf(n);
 }
 
 /** The value a guess covered: the node's committed value — a store slot's
  * asked of the store (a chained link follows the inner store's commits). */ function covered(e) {
-    return e.l & CONFIG_SLOT_NODE && GlobalQueue.fn !== undefined ? GlobalQueue.fn(e) : e.Ie;
+    return e.l & CONFIG_SLOT_NODE && GlobalQueue.fn !== undefined ? GlobalQueue.fn(e) : e.le;
 }
 
 /** A guess in `l` whose own truth is in flight (its refetch — authoritative:
@@ -521,7 +532,7 @@ function supersede(e, n, s) {
         const t = n[s];
         if (lanes.indexOf(t) === -1) continue;
         const l = resolveTx(t._parent);
-        if (!l.nt || l.tt !== 0 || l.v || ownFlights(l) || guessFlights(t)) continue;
+        if (!l.nt || l.tt !== 0 || l.P || ownFlights(l) || guessFlights(t)) continue;
         e = true;
         // Each guess's truth: the one beneath it (a landing held there), else
         // the one it covered. (A correction dissolves the lane — the others are
@@ -529,8 +540,8 @@ function supersede(e, n, s) {
                 for (let e = 0; e < t.tn.length && lanes.indexOf(t) !== -1; e++) {
             const n = t.tn[e];
             if (n.l & CONFIG_GUESS && n.T.Re === t) {
-                const e = n.se !== NOT_PENDING ? n.se : covered(n);
-                supersede(n, e, !n.xe || !n.xe(n.T.v, e));
+                const e = n.ie !== NOT_PENDING ? n.ie : covered(n);
+                supersede(n, e, !n.xe || !n.xe(n.T.P, e));
             }
         }
     }
@@ -545,7 +556,7 @@ function laneSeam(e, n) {
         return;
     }
     e.ln = false;
-    e.ke = true;
+    e.ge = true;
     reruns(e);
     for (let n = 0; n < e.tn.length; n++) {
         const s = e.tn[n];
@@ -555,9 +566,9 @@ function laneSeam(e, n) {
         }
         const t = s.T;
         if (t.Re !== e) continue;
-        if (!(s.l & CONFIG_GUESS) && !s.i && s.se !== NOT_PENDING) {
-            t.v = s.se;
-            s.se = NOT_PENDING;
+        if (!(s.l & CONFIG_GUESS) && !s.i && s.ie !== NOT_PENDING) {
+            t.P = s.ie;
+            s.ie = NOT_PENDING;
         }
         // The frame this pass built is the screen's now; the one it replaced
         // goes (as `commitPendingNode` retires a committed pass's).
@@ -582,7 +593,7 @@ function laneSeam(e, n) {
  * frame is not complete without it (A15) — landing it would commit the write
  * beside a derivation still showing the old one. A guess whose own flight is
  * up likewise: the question was asked in this frame. */ function lanesBlocked(e) {
-    return e.v && linkBlocked(e) || nestedBlocked(e);
+    return e.P && linkBlocked(e) || nestedBlocked(e);
 }
 
 /** The lanes under `t` (its own; a link group's are each other's). */ function nestedBlocked(e) {
@@ -611,17 +622,17 @@ function laneSeam(e, n) {
         // folds a current one beneath it (D-34): true.
         const s = stale(e, question);
         if (GlobalQueue.an?.(e, n, s) || s) {
-            e.se = n;
+            e.ie = n;
             e.l |= CONFIG_HELD;
             schedule();
             return n;
         }
-        supersede(e, n, !e.xe || !e.xe(e.T.v, n));
+        supersede(e, n, !e.xe || !e.xe(e.T.P, n));
     } else {
         const s = txOf(e);
         if (e.xe && e.xe(laneValueOf(e), n)) return n;
-        if (s.ke) e.se = n; else e.T.v = n;
-        if (e.X !== undefined) e.ie = clock;
+        if (s.ge) e.ie = n; else e.T.P = n;
+        if (e.X !== undefined) e.Se = clock;
         insertSubs(e);
         laneDirty(e, s);
     }
@@ -643,18 +654,18 @@ function laneSeam(e, n) {
  * A24). The guess's own question answering supersedes as usual. */ function laneOutcome(e, n, s) {
     if (s) return true;
     if (stale(e, answered(e))) {
-        e.se = n;
+        e.ie = n;
         e.l |= CONFIG_HELD;
         return true;
     }
-    supersede(e, n, !e.xe || !e.xe(e.T.v, n));
+    supersede(e, n, !e.xe || !e.xe(e.T.P, n));
     return true;
 }
 
 /** THE provenance test, for a derivation's pass and a write alike: an
  * answer to question `q` landing on a guess is stale when `q` is older
  * than the guess's own; unstamped (0) and mainline are current. */ function stale(e, n) {
-    return n !== 0 && n < e.T.Ee;
+    return n !== 0 && n < e.T.Te;
 }
 
 /** The question a derivation's pass answered: the newest among the stamped
@@ -663,7 +674,7 @@ function laneSeam(e, n) {
     let n = 0;
     for (let s = e.C; s !== null; s = s.G) {
         const e = s.S;
-        if (e.T !== null && e.T.Ee > n && e.ie === clock) n = e.T.Ee;
+        if (e.T !== null && e.T.Te > n && e.Se === clock) n = e.T.Te;
     }
     return n;
 }
@@ -693,20 +704,29 @@ const laneSeams = e => {
         // now (one run — #3322, #3540). Other verdict-lane work re-derives only
         // if the frame stays parked: a transaction landing at this seam makes
         // what it read the screen (one run).
-                if (t.R & REACTIVE_DISPOSED || l != null && l._parent?.he === l && (t.l & CONFIG_VERDICT ? !(t.R & REACTIVE_PROBE_UNANSWERED) : !blocked(l._parent))) continue;
+                if (t.R & REACTIVE_DISPOSED || l != null && l._parent?.Pe === l && (t.l & CONFIG_VERDICT ? !(t.R & REACTIVE_PROBE_UNANSWERED) : !blocked(l._parent))) continue;
         // A leaked effect re-derives seated in its lane from its first read: it
         // carries no lane value (`laneStage`), so without this its pass starts
         // as mainline, joins the parked frame on its first held read and reads
         // the staging, then re-enters the lane at its guess read and leaks
         // again — every round (#4014). A computed is already seated by its
         // override, and a written guess's own pass stays the frame's.
-                if (l != null && l.v && t.i) t.R |= REACTIVE_LANE_DIRTY;
+                if (l != null && l.P && t.i) t.R |= REACTIVE_LANE_DIRTY;
         enqueueSub(t);
-        if (l != null && l.v && n.indexOf(l) === -1) n.push(l);
+        if (l != null && l.P && n.indexOf(l) === -1) n.push(l);
     }
     for (let e = Math.min(judged, lanes.length) - 1; e >= 0; e--) laneSeam(lanes[e], n.indexOf(lanes[e]) !== -1);
+    // A verdict reader that entered a lane this seam held: its run waits with
+    // the lane, and the verdict beside it would freeze — it re-derives next
+    // round from the frame's seat, a stale reader of the lane (#4284).
+        for (let e; e = entered.pop(); ) if (e.T.Re?.ln) {
+        e.R &= ~REACTIVE_LANE_DIRTY;
+        enqueueSub(e);
+    }
 };
 
+/** Render effects that read a verdict and entered a lane before its seam (#4284). */ const entered = [];
+
 installLaneHooks(laneRead, laneStage, laneOutcome, laneWrite, applyGuessesAt, laneSeams, () => lanes.length !== 0 && laneCorrections(), endLanes, lanesBlocked);
 
 GlobalQueue.J = verdictLane;

package/dist/prod/core/owner.js

@@ -6,7 +6,7 @@ import { unobserved, clearDeps } from "./graph.js";
 
 import { deleteFromHeap } from "./heap.js";
 
-import { globalQueue, schedule, dirtyQueue } from "./scheduler.js";
+import { globalQueue, pendingNodes, schedule, dirtyQueue } from "./scheduler.js";
 
 // L2 (step 2): the parked frame. A pass parks the previous frame's children
 // and `_disposal` list on `_x._pendingFirstChild` / `_x._pendingDisposal`
@@ -16,11 +16,11 @@ import { globalQueue, schedule, dirtyQueue } from "./scheduler.js";
 // key off it, and the heap defers a zombie's recompute past the seam (no
 // second heap — the deferral list in scheduler.ts).
 function markDisposal(e) {
-    let n = e.De;
+    let n = e.pe;
     while (n) {
         n.R |= REACTIVE_ZOMBIE;
         markDisposal(n);
-        n = n.pe;
+        n = n.Ge;
     }
 }
 
@@ -72,15 +72,16 @@ function disposeChildren(e, n = false, r) {
         e.R = t | REACTIVE_DISPOSED;
     }
     if (n && e.X) {
-        if (e.T !== null) e.T.Se = null;
+        if (e.T !== null) e.T.Ee = null;
         // A death that can unblock the future (L2, `futureBlocked`): a held
         // flight's — a transaction's or a lane's (its `_x._transaction`) — or a
         // stale reader's (REACTIVE_FRAME_READ — a frame that derived from one).
+        // An idle pending queue would also pin it until an unrelated flush.
         // Nothing else re-examines a dead node, so make sure a seam comes.
-                if (e.m & STATUS_PENDING && e.T?.Re != null || t & REACTIVE_FRAME_READ) schedule();
+                if (e.m & STATUS_PENDING && e.T?.Re != null || t & REACTIVE_FRAME_READ || pendingNodes.length) schedule();
     }
-    let l = r ? e.T.Ue : e.De;
-    if (r) e.T.Ue = null; else e.De = null;
+    let l = r ? e.T.Ue : e.pe;
+    if (r) e.T.Ue = null; else e.pe = null;
     while (l) {
         const e = l;
         // Owner teardown is death regardless of the child's own lifecycle
@@ -110,7 +111,7 @@ function disposeChildren(e, n = false, r) {
         // itself out of the detached chain, and a cleanup may then have linked
         // it at the fresh head, which rewrote the `_nextSibling` a pre-read
         // would still be holding.
-                l = l.pe;
+                l = l.Ge;
     }
     if (!r) e.ye = 0;
     // O(1) splice out of parent's chain on individual dispose. Skipped during
@@ -120,8 +121,8 @@ function disposeChildren(e, n = false, r) {
     // still reach later siblings.
         if (n && !r && !(t & REACTIVE_ZOMBIE) && e._parent !== null && !(e._parent.R & REACTIVE_DISPOSED)) {
         const n = e.Ze;
-        const r = e.pe;
-        if (n !== null) n.pe = r; else e._parent.De = r;
+        const r = e.Ge;
+        if (n !== null) n.Ge = r; else e._parent.pe = r;
         if (r !== null) r.Ze = n;
         e.Ze = null;
     }
@@ -136,11 +137,11 @@ function disposeChildren(e, n = false, r) {
 }
 
 function linkChild(e, n) {
-    const r = e.De;
+    const r = e.pe;
     n.Ze = null;
-    n.pe = r;
+    n.Ge = r;
     if (r !== null) r.Ze = n;
-    e.De = n;
+    e.pe = n;
 }
 
 function runDisposal(e, n) {
@@ -306,8 +307,8 @@ function disposeRootSelf(e = true) {
         R: REACTIVE_NONE,
         Qe: true,
         Ye: n?.Qe ? n.Ye : n,
-        De: null,
         pe: null,
+        Ge: null,
         Ze: null,
         He: null,
         A: n?.A || defaultContext,