@solidjs/signals 2.0.0-rc.14 → 2.0.0-rc.15

package/dist/observe/core/owner.js

@@ -18,11 +18,11 @@ import { 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.sn;
+    let n = e.nn;
     while (n) {
         n.R |= REACTIVE_ZOMBIE;
         markDisposal(n);
-        n = n.rn;
+        n = n.tn;
     }
 }
 
@@ -33,7 +33,7 @@ function dispose(e) {
     // left queued would be recomputed and resurrected by the next flush (#2983)
     // — dep unlinking, child disposal) is exactly unobserved()'s body; only
     // this flag distinguishes death from dormancy.
-    e.u &= ~CONFIG_AUTO_DISPOSE;
+    e.i &= ~CONFIG_AUTO_DISPOSE;
     unobserved(e);
 }
 
@@ -50,16 +50,16 @@ function disposeChildren(e, n = false, t) {
         e.R = i | REACTIVE_DISPOSED;
         if (e._parent === null && e.Ht) unregisterRoot(e);
     }
-    if (n && e.re) {
-        if (e.m !== null) e.m.De = null;
+    if (n && e.ee) {
+        if (e.m !== null) e.m.Te = 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).
         // Nothing else re-examines a dead node, so make sure a seam comes.
-                if (e.G & STATUS_PENDING && e.m?._t != null || i & REACTIVE_FRAME_READ) schedule();
+                if (e.S & STATUS_PENDING && e.m?._t != null || i & REACTIVE_FRAME_READ) schedule();
     }
-    let r = t ? e.m.St : e.sn;
-    if (t) e.m.St = null; else e.sn = null;
+    let r = t ? e.m.St : e.nn;
+    if (t) e.m.St = null; else e.nn = null;
     while (r) {
         const e = r;
         // Owner teardown is death regardless of the child's own lifecycle
@@ -69,7 +69,7 @@ function disposeChildren(e, n = false, t) {
         // disposeChildren call early-returns on REACTIVE_DISPOSED) die too.
         // Only unobserved()'s own node keeps its dormancy — it is never in
         // this loop; its children are rebuilt fresh on reawaken.
-                e.u &= ~CONFIG_AUTO_DISPOSE;
+                e.i &= ~CONFIG_AUTO_DISPOSE;
         // Heap removal must not be gated on `_deps`: a dependency-free
         // computation queued by refresh() has a null dep list but still sits in
         // the dirty heap, and left there the post-disposal flush recomputes it —
@@ -89,9 +89,9 @@ function disposeChildren(e, n = false, t) {
         // 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.
-                r = r.rn;
+                r = r.tn;
     }
-    if (!t) e.Ct = 0;
+    if (!t) e.dt = 0;
     // O(1) splice out of parent's chain on individual dispose. Skipped during
     // batch dispose (parent already disposed) and for a zombie (it sits on the
     // parent's parked frame, drained whole by the commit). We leave
@@ -99,8 +99,8 @@ function disposeChildren(e, n = false, t) {
     // still reach later siblings.
         if (n && !t && !(i & REACTIVE_ZOMBIE) && e._parent !== null && !(e._parent.R & REACTIVE_DISPOSED)) {
         const n = e.Gt;
-        const t = e.rn;
-        if (n !== null) n.rn = t; else e._parent.sn = t;
+        const t = e.tn;
+        if (n !== null) n.tn = t; else e._parent.nn = t;
         if (t !== null) t.Gt = n;
         e.Gt = null;
     }
@@ -115,11 +115,11 @@ function disposeChildren(e, n = false, t) {
 }
 
 function linkChild(e, n) {
-    const t = e.sn;
+    const t = e.nn;
     n.Gt = null;
-    n.rn = t;
+    n.tn = t;
     if (t !== null) t.Gt = n;
-    e.sn = n;
+    e.nn = n;
 }
 
 function runDisposal(e, n) {
@@ -129,9 +129,9 @@ function runDisposal(e, n) {
     // walk ran every entry a second time. Detached, the re-entrant drain finds
     // nothing. The same shape latched a throwing cleanup: the list survived the
     // throw and every later drain re-ran and re-threw it.
-    const t = n ? e.m.ct : e.Pe;
+    const t = n ? e.m.ct : e.Re;
     if (!t) return;
-    if (n) e.m.ct = null; else e.Pe = null;
+    if (n) e.m.ct = null; else e.Re = null;
     if (Array.isArray(t)) {
         // Unwind order (#3572, restores 1.x #1562): later registrations run
         // before earlier ones. Children have already been disposed by the caller,
@@ -148,8 +148,8 @@ function runDisposal(e, n) {
 
 function childId(e, n) {
     let t = e;
-    while (t.u & CONFIG_TRANSPARENT && t._parent) t = t._parent;
-    if (t.id != null) return formatId(t.id, n ? t.Ct++ : t.Ct);
+    while (t.i & CONFIG_TRANSPARENT && t._parent) t = t._parent;
+    if (t.id != null) return formatId(t.id, n ? t.dt++ : t.dt);
     throw new Error("");
 }
 
@@ -229,7 +229,7 @@ function formatId(e, n) {
  * checks. `cleanup()` is the unchecked primitive used by internals.
  */ function cleanup(e) {
     if (!context) return e;
-    if (!context.Pe) context.Pe = e; else if (Array.isArray(context.Pe)) context.Pe.push(e); else context.Pe = [ context.Pe, e ];
+    if (!context.Re) context.Re = e; else if (Array.isArray(context.Re)) context.Re.push(e); else context.Re = [ context.Re, e ];
     return e;
 }
 
@@ -272,15 +272,15 @@ function disposeRootSelf(e = true) {
     // is a plain store rather than a shape fork between labelled and plain roots.
         const i = {
         id: inheritId(e, t, n),
-        u: t ? CONFIG_TRANSPARENT : 0,
+        i: t ? CONFIG_TRANSPARENT : 0,
         Ht: true,
         gt: n?.Ht ? n.gt : n,
-        sn: null,
-        rn: null,
+        nn: null,
+        tn: null,
         Gt: null,
-        Pe: null,
-        U: n?.U || defaultContext,
-        Ct: 0,
+        Re: null,
+        D: n?.D || defaultContext,
+        dt: 0,
         m: null,
         _parent: n,
         dispose: disposeRootSelf,

package/dist/observe/core/scheduler.js

@@ -1,4 +1,4 @@
-import { EFFECT_RENDER, EFFECT_USER, CONFIG_HELD, CONFIG_OVERRIDE, NOT_PENDING, STATUS_UNINITIALIZED, STATUS_PENDING, CONFIG_STAGED, REACTIVE_DISPOSED, REACTIVE_ZOMBIE, CONFIG_VERDICT, CONFIG_HAS_SNAPSHOT, REACTIVE_RECOMPUTING_DEPS, REACTIVE_MISSED_WAKE, CONFIG_IN_SNAPSHOT_SCOPE, REACTIVE_SNAPSHOT_STALE, REACTIVE_LANE_DIRTY, CONFIG_INPUTS_PUBLISHED, EFFECT_TRACKED, REACTIVE_MANUAL_WRITE, CONFIG_GUESS, REACTIVE_FRAME_READ, CONFIG_REDERIVE } from "./constants.js";
+import { EFFECT_RENDER, EFFECT_USER, CONFIG_HELD, CONFIG_OVERRIDE, NOT_PENDING, STATUS_UNINITIALIZED, STATUS_PENDING, CONFIG_STAGED, REACTIVE_DISPOSED, REACTIVE_ZOMBIE, CONFIG_VERDICT, CONFIG_HAS_SNAPSHOT, REACTIVE_RECOMPUTING_DEPS, REACTIVE_MISSED_WAKE, CONFIG_IN_SNAPSHOT_SCOPE, REACTIVE_SNAPSHOT_STALE, CONFIG_HELD_FRAME, REACTIVE_LANE_DIRTY, CONFIG_INPUTS_PUBLISHED, EFFECT_TRACKED, REACTIVE_MANUAL_WRITE, CONFIG_GUESS, REACTIVE_FRAME_READ, CONFIG_REDERIVE, STATUS_ERROR } from "./constants.js";
 
 import { attrHooks } from "./attribution-hooks.js";
 
@@ -19,12 +19,12 @@ import { devCheckQuiescent } from "./invariants.js";
 
 /** A transaction (listed here) or a lane (lanes.ts lists its own). */ function newTransaction(e, n = null) {
     const t = {
-        nn: [],
+        Je: [],
         En: [ [], [] ],
         an: [],
-        dn: null,
+        Sn: null,
         _parent: n,
-        Z: e,
+        B: e,
         rt: null,
         tt: 0,
         nt: false,
@@ -78,7 +78,7 @@ function setPassLane(e) {
  * set it. */ let passTx = null;
 
 function joinPassTx(e, n) {
-    if (globalQueue.ee && !n || flushTransaction !== null) return joinFuture(e);
+    if (globalQueue.X && !n || flushTransaction !== null) return joinFuture(e);
     if (passTx === null) passTx = resolveTx(e); else merge(resolveTx(e), passTx);
     schedule();
 }
@@ -95,7 +95,7 @@ function joinPassTx(e, n) {
 }
 
 function resolveTx(e) {
-    while (e.dn !== null) e = e.dn;
+    while (e.Sn !== null) e = e.Sn;
     return e;
 }
 
@@ -106,7 +106,7 @@ function resolveTx(e) {
     if (n === null) {
         flushTransaction = e === null ? newTransaction(false) : resolveTx(e);
     } else if (e !== null) merge(resolveTx(e), n);
-    if (!globalQueue.ee) schedule();
+    if (!globalQueue.X) schedule();
 }
 
 /** `t` merges into `f`: the work that touched both entangles them (A15).
@@ -116,12 +116,12 @@ function resolveTx(e) {
     // into the other would close a cycle `resolveTx` never leaves.
     e = resolveTx(e);
     n = resolveTx(n);
-    if (e === n || e.Z || n.Z) return;
+    if (e === n || e.B || n.B) return;
     if (attrHooks !== null) attrHooks.transitionMerged(n, e);
-    e.dn = n;
+    e.Sn = n;
     n.tt += e.tt;
     n.nt ||= e.nt;
-    append(n.nn, e.nn);
+    append(n.Je, e.Je);
     append(n.En[0], e.En[0]);
     append(n.En[1], e.En[1]);
     append(n.an, e.an);
@@ -151,7 +151,7 @@ function resolveTx(e) {
     judge ??= e;
     // An action still running in it holds it open (action.ts). Its lanes
     // (lanes.ts): a lane under `t` blocks it while blocked itself.
-        const t = e.tt !== 0 || blockedBy(e.nn, e) || !!GlobalQueue.Tn && GlobalQueue.Tn(e);
+        const t = e.tt !== 0 || blockedBy(e.Je, e) || !!GlobalQueue.dn && GlobalQueue.dn(e);
     judge = n;
     return t;
 }
@@ -162,9 +162,9 @@ let judge = null;
  * frame reader observes (`blockedBy`'s predicate, collected; the readers
  * themselves are not sources). */ function blockersOf(e) {
     const n = [];
-    for (let t = 0; t < e.nn.length; t++) {
-        const l = e.nn[t];
-        if (!l.i && l.G & STATUS_PENDING && !(l.R & REACTIVE_DISPOSED) && (l.m._t === null || txOf(l) === e) && blockedBy([ l ], e)) n.push(l);
+    for (let t = 0; t < e.Je.length; t++) {
+        const l = e.Je[t];
+        if (!l.u && l.S & STATUS_PENDING && !(l.R & REACTIVE_DISPOSED) && (l.m._t === null || txOf(l) === e) && blockedBy([ l ], e)) n.push(l);
     }
     return n;
 }
@@ -174,7 +174,7 @@ let judge = null;
  * not (lanes.ts, the body-end corollary). A pending reader counts only if
  * one of the sources it waits on is `t`'s (a render effect marked pending
  * by a lane flight, never re-run, is the lane's wait, not the frame's). */ function ownFlights(e) {
-    return blockedBy(e.nn, e, true);
+    return blockedBy(e.Je, e, true);
 }
 
 /** A source the pending node waits on that is `t`'s (held by it, or by no
@@ -192,15 +192,15 @@ let judge = null;
 function blockedBy(e, n, t = false) {
     for (let l = 0; l < e.length; l++) {
         const o = e[l];
-        if (!(o.G & STATUS_PENDING) || o.R & REACTIVE_DISPOSED || o.u & CONFIG_GUESS || o.m._t !== null && txOf(o) !== n || t && !ownSource(o, n)) continue;
+        if (!(o.S & STATUS_PENDING) || o.R & REACTIVE_DISPOSED || o.i & CONFIG_GUESS || o.m._t !== null && txOf(o) !== n || t && !ownSource(o, n)) continue;
         // The frame's own pending observer (off screen: this one holds nothing;
         // the next listed node may).
-                if (o.i === EFFECT_RENDER) {
+                if (o.u === EFFECT_RENDER) {
             if (onScreen(o, judge ?? n)) return true;
             continue;
         }
-        for (let e = o.t; e !== null; e = e.l) {
-            const t = e.o;
+        for (let e = o.t; e !== null; e = e.o) {
+            const t = e.l;
             // A frame reader: a render effect, or a stale reader of the flight
             // (REACTIVE_FRAME_READ — a verdict reader, `observeFlight`; lane work,
             // `frameRead`): served committed instead of going pending, it derives
@@ -212,7 +212,7 @@ function blockedBy(e, n, t = false) {
             // lane-membership ruling, 2026-10-05). An output that never committed
             // shows nothing — a mount the frame has not revealed — and holds
             // nothing.
-                        if ((t.i === EFFECT_RENDER || t.R & REACTIVE_FRAME_READ || t.u & CONFIG_REDERIVE && t.G === STATUS_PENDING) && (e.Ue === t.he || t.m?.v != null) && !(t.R & REACTIVE_DISPOSED) && onScreen(t, judge ?? n)) return true;
+                        if ((t.u === EFFECT_RENDER && t.S & STATUS_PENDING || t.R & REACTIVE_FRAME_READ || t.i & CONFIG_REDERIVE && t.S === STATUS_PENDING) && (e.Pe === t.pe || t.m?.F != null) && !(t.R & REACTIVE_DISPOSED) && onScreen(t, judge ?? n)) return true;
         }
     }
     return false;
@@ -237,7 +237,7 @@ function blockedBy(e, n, t = false) {
  * the nearest non-zombie ancestor. */ function removalStagedBy(e, n) {
     let t = e;
     while (t !== null && t.R & REACTIVE_ZOMBIE) t = t._parent;
-    return t !== null && (t.u & CONFIG_HELD) !== 0 && t.m?._t != null && txOf(t) === resolveTx(n);
+    return t !== null && (t.i & CONFIG_HELD) !== 0 && t.m?._t != null && txOf(t) === resolveTx(n);
 }
 
 /** Unchanged passes this flush whose stale dependency tail awaits the
@@ -264,7 +264,7 @@ function deferZombie(e) {
 
 /** Put a staged node in a transaction: flagged, stamped, on its landing
  * list. */ function holdNode(e, n) {
-    e.u |= CONFIG_HELD;
+    e.i |= CONFIG_HELD;
     list(e, n);
 }
 
@@ -274,7 +274,7 @@ function deferZombie(e) {
     const t = ext(e);
     if (t._t === n) return;
     t._t = n;
-    n.nn.push(e);
+    n.Je.push(e);
 }
 
 /** Hold the (uncommitted) frame under a held pass: every computed in the
@@ -290,16 +290,19 @@ function deferZombie(e) {
  * next read of it trips over (`laneRead` → `txOf`). Its frame is the lane's
  * too (ruling A: a lane pass's children are the lane's), revealed and
  * retired at the lane's seam. */ function holdFrame(e, n) {
-    for (let t = e.sn; t !== null; t = t.rn) {
-        if (t.m?._t?.Z) continue;
-        if (t.re !== undefined && !(t.u & CONFIG_HELD)) holdNode(t, n);
+    for (let t = e.nn; t !== null; t = t.tn) {
+        if (t.m?._t?.B) continue;
+        if (t.ee !== undefined) {
+            if (!(t.i & CONFIG_HELD)) holdNode(t, n);
+            t.i |= CONFIG_HELD_FRAME;
+        }
         holdFrame(t, n);
     }
 }
 
 const dirtyQueue = {
     jt: new Array(2e3).fill(undefined),
-    C: false,
+    N: false,
     ut: 0,
     Kt: 0
 };
@@ -364,7 +367,7 @@ function schedule() {
     }
     if (scheduled) return;
     scheduled = true;
-    if (!syncDepth && !globalQueue.ee) {
+    if (!syncDepth && !globalQueue.X) {
         queueMicrotask(flush);
     }
 }
@@ -414,10 +417,10 @@ function notifyHalted() {
 
 class GlobalQueue {
     En=[ [], [] ];
-    ee=false;
+    X=false;
     flush() {
-        if (this.ee) return;
-        this.ee = true;
+        if (this.X) return;
+        this.X = true;
         // A28: companions of nodes written since the last flush mirror the
         // flushed world — re-synced inside the running window (the write is
         // "flushed" from here on).
@@ -445,7 +448,7 @@ class GlobalQueue {
             if (false && !scheduled) ;
             if (false) ;
         } finally {
-            this.ee = false;
+            this.X = false;
             passTx = null;
         }
     }
@@ -458,7 +461,7 @@ class GlobalQueue {
         // Lanes: an ended action body judges its guesses now that their passes
         // have run (lanes.ts); a correction's re-derivations run in one more
         // pure round — the parent's flights before the parent is judged below.
-        if (GlobalQueue.Gn?.()) runHeap(dirtyQueue, GlobalQueue.et);
+        if (GlobalQueue.On?.()) runHeap(dirtyQueue, GlobalQueue.et);
         const e = flushTransaction;
         flushTransaction = null;
         // The frame's verdict is in: the guesses written since the last seam
@@ -466,11 +469,11 @@ class GlobalQueue {
         // parents a nested lane to it), or are dropped — the frame commits, and
         // there is nothing to be optimistic over. Their passes run next round;
         // a parent landing at this very seam ends the lane before they do.
-                GlobalQueue.cn?.(e);
+                GlobalQueue.Gn?.(e);
         // A lane's own flush (its flight landing, its reveal) parks nothing: the
         // lane's work reached it per pass; the frame's plain writes commit.
         // (Resolved: a guess over another transaction's guess merged them.)
-                const n = e !== null && !e.Z ? resolveTx(e) : null;
+                const n = e !== null && !e.B ? resolveTx(e) : null;
         if (n !== null) {
             // `t._nodes` grows under the walk (holdFrame pushes); the bound is
             // this flush's list, which does not.
@@ -480,7 +483,7 @@ class GlobalQueue {
                 // Already held: the pass that re-staged it joined its transaction,
                 // which is `t` (or merged into it). Lane work is the lane's (a
                 // pending mark propagated onto it queued it here too).
-                                if (!(e.u & (CONFIG_HELD | CONFIG_OVERRIDE)) && (e.m === null || e.m._t === null || !e.m._t.Z)) {
+                                if (!(e.i & (CONFIG_HELD | CONFIG_OVERRIDE)) && (e.m === null || e.m._t === null || !e.m._t.B)) {
                     // A loading source — pending with nothing staged and no committed
                     // value (A16, A19 exc. 1: uninitialized is loading, not pending)
                     // that is not an observer — is nobody's frame: not held. Its
@@ -489,15 +492,15 @@ class GlobalQueue {
                     // stale stamp was the bridge that entangled unrelated updates
                     // with a never-resolving flight). Its observers are held and
                     // wait on its flight (`blocked`).
-                    if (e.Ae === NOT_PENDING && e.G & STATUS_UNINITIALIZED && e.i !== EFFECT_RENDER) continue;
+                    if (e.Oe === NOT_PENDING && e.S & STATUS_UNINITIALIZED && e.u !== EFFECT_RENDER) continue;
                     // A34 (2): a tick whose writes net to the committed value made no
                     // proposal (`setShow(false); setShow(true)` on a committed true) —
                     // not staged, not held, pends nothing; a later write to it is
                     // plain mainline. (A node already held stays held when written
                     // back: A34 (1).)
-                                        if (e.Ae !== NOT_PENDING && !(e.G & (STATUS_PENDING | STATUS_UNINITIALIZED)) && e.tn && e.tn(e.pe, e.Ae) && e.m?.St == null && e.m?.ct == null) {
-                        e.Ae = NOT_PENDING;
-                        e.u &= ~CONFIG_STAGED;
+                                        if (e.Oe !== NOT_PENDING && !(e.S & (STATUS_PENDING | STATUS_UNINITIALIZED)) && e.en && e.en(e.Ae, e.Oe) && e.m?.St == null && e.m?.ct == null) {
+                        e.Oe = NOT_PENDING;
+                        e.i &= ~CONFIG_STAGED;
                         continue;
                     }
                     holdNode(e, n);
@@ -505,10 +508,10 @@ class GlobalQueue {
                 // A held pass's frame is held with it (ruling A, O2): the children it
                 // created are the transaction's — they compute, and a pass over them
                 // or a write that reaches them joins; they effect at the landing.
-                                if (e.u & CONFIG_STAGED) holdFrame(e, n);
+                                if (e.i & CONFIG_STAGED) holdFrame(e, n);
             }
             pendingNodes.length = 0;
-            GlobalQueue.hn?.(n);
+            GlobalQueue.An?.(n);
             // (This flush's runs are stashed with `t` below — after the landings,
             // so a `t` that lands at this very seam runs them first, ahead of
             // the runs it held from earlier flushes.)
@@ -519,7 +522,7 @@ class GlobalQueue {
             // holder's verdict lane's work — before the lane seams, which reveal
             // it (nothing commits this seam that could dispose it).
                         const t = deferredZombies.splice(0).sort((e, n) => e.it - n.it);
-            for (let e = 0; e < t.length; e++) if ((t[e].R & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE)) === REACTIVE_ZOMBIE && t[e].u & CONFIG_VERDICT) recompute(t[e]);
+            for (let e = 0; e < t.length; e++) if ((t[e].R & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE)) === REACTIVE_ZOMBIE && t[e].i & CONFIG_VERDICT) recompute(t[e]);
             // The unchanged passes' tails stay linked (A30, #3469): their inputs
             // are held, and the committed frame still derives from them — no trim.
                 } else {
@@ -531,7 +534,7 @@ class GlobalQueue {
             // `recompute`'s own gates.
                         for (let e = 0; e < heldTrims.length; e++) {
                 const n = heldTrims[e];
-                if (n.m?.v == null && !n.lt) trimStaleDeps(n);
+                if (n.m?.F == null && !n.lt) trimStaleDeps(n);
             }
         }
         // The list is the flush's either way. Reset only when there is something
@@ -550,14 +553,14 @@ class GlobalQueue {
         // The passes that read this frame's stagings as the screen read held
         // writes if it parked: the lane seam re-derives them on the committed
         // world (a lane's runs wait this round).
-                GlobalQueue._n?.(n !== null ? stagedReaders : null);
+                GlobalQueue.cn?.(n !== null ? stagedReaders : null);
         if (stagedReaders.length) stagedReaders.length = 0;
         this.En = [ [], [] ];
         for (let e = transactions.length - 1; e >= 0; e--) {
             const n = transactions[e];
             if (blocked(n)) continue;
             transactions.splice(e, 1);
-            GlobalQueue.On?.(n);
+            GlobalQueue.Tn?.(n);
             land(n);
             // A landing's commits can dispose a zombie a transaction judged above
             // was blocked on (#3463: live "until the commit that disposes it") —
@@ -566,12 +569,13 @@ class GlobalQueue {
         }
         // The store folds the pending backings whose container nodes committed
         // — this flush's, or a landing's (store/store.ts installs it).
-                GlobalQueue.Sn?.();
+                GlobalQueue.Rn?.();
         // Marks declared outside a transaction: the flush that carried them
         // parked (something async below) — the window is the frame's, the marks
         // are its transaction's; else they release at the seam, verdict-only,
         // nothing to show (affects.ts).
-                GlobalQueue.D?.(n !== null && transactions.indexOf(n) !== -1 ? n : null);
+                const o = n && liveTx(n);
+        GlobalQueue.A?.(o);
         // The effect phase: lane work first (displayed ahead of the frame), then
         // this flush's runs, then the runs the landings held from earlier
         // flushes — as one pass would have queued them (#3540: a shell
@@ -579,8 +583,7 @@ class GlobalQueue {
         // write; #3528: a display-ahead swap before the count it is shown
         // beside). A parked frame's runs wait with its transaction instead: the
         // effect phase applies a committed frame.
-                const o = n && liveTx(n);
-        const u = o !== null;
+                const u = o !== null;
         // Attribution hook: this flush found its transaction incomplete — its
         // writes stay staged, its runs are stashed below. Before the effect
         // phase (the lanes' display-ahead runs are the visible acknowledgers);
@@ -607,7 +610,7 @@ class GlobalQueue {
         }
         // Boundaries: readers that settled, landed or died this flush are
         // dropped; a fallback with none left reveals next round.
-                GlobalQueue.Ee?.();
+                GlobalQueue.ce?.();
     }
     run(e) {
         const n = this.En[e - 1];
@@ -638,7 +641,7 @@ class GlobalQueue {
      * A boundary between the observer and the root (boundaries.ts) is asked
      * first: a fallback catches what is not ready under it, and the root
      * never hears of it. */    notify(e, n, t, l) {
-        if (GlobalQueue.fe && GlobalQueue.fe(e, t & n, l)) return true;
+        if (GlobalQueue.ie && GlobalQueue.ie(e, t & n, l)) return true;
         if (n & STATUS_PENDING) {
             if (t & STATUS_PENDING) {
                 // A pass that went pending holds its frame: the async's own
@@ -674,14 +677,17 @@ class GlobalQueue {
  * it. */ function reruns(e) {
     for (let n = 0; n < e.an.length; n++) {
         const t = e.an[n];
-        if (t.R & REACTIVE_DISPOSED) continue;
-        if (t.R & REACTIVE_FRAME_READ) {
+        // An errored reader's display is its error (D-39): the landing gives it
+        // nothing to re-derive, and a re-run would be a read that retries the
+        // errored source (#3945).
+                if (t.R & REACTIVE_DISPOSED || t.S & STATUS_ERROR) continue;
+        if (t.R & REACTIVE_FRAME_READ || t.i & CONFIG_VERDICT) {
             t.R &= ~REACTIVE_FRAME_READ;
             t.lt = false;
             // Its frame is replaced by the re-derivation: a run one of its
             // children queued this flush (re-run by the same landing) is for the
             // frame being replaced — void too (#3404).
-                        for (let e = t.sn; e !== null; e = e.rn) if (e.i) e.lt = false;
+                        for (let e = t.nn; e !== null; e = e.tn) if (e.u) e.lt = false;
             enqueueSub(t);
         }
     }
@@ -693,12 +699,12 @@ class GlobalQueue {
     // (`_nodes` still lists them).
     if (attrHooks !== null) attrHooks.transitionSettled(e);
     reruns(e);
-    if (e.T !== null) GlobalQueue.A(e.T);
+    if (e.T !== null) GlobalQueue.k(e.T);
     // Old children die in the commits (cleanups first), then the stashed
     // effects run ahead of this flush's own. A node a lane took over since
     // (a guess written over the staged truth) is the lane's to land.
-        for (let n = 0; n < e.nn.length; n++) {
-        const t = e.nn[n];
+        for (let n = 0; n < e.Je.length; n++) {
+        const t = e.Je[n];
         if (t.m._t === null || txOf(t) !== e) continue;
         t.m._t = null;
         commitPendingNode(t);
@@ -738,7 +744,7 @@ class GlobalQueue {
 
 function queuePendingNode(e) {
     pendingNodes.push(e);
-    if (!globalQueue.ee) markUnflushedStaged();
+    if (!globalQueue.X) markUnflushedStaged();
  // A28
 }
 
@@ -758,13 +764,13 @@ function insertSubs(e) {
     // Presence bits gate the optional-slot probes (see constants.ts): one
     // masked read of the always-present _config instead of missing-property
     // lookups in the hottest notify loop.
-        const n = e.u;
+        const n = e.i;
     const t = (n & CONFIG_HAS_SNAPSHOT) !== 0 && e.m?.ot !== undefined;
     // Observe-tier fan-out: this walk visits every subscriber edge anyway, so
     // the graph-size count is one local increment here and no field anywhere.
         let l = 0;
-    for (let n = e.t; n !== null; n = n.l) {
-        const e = n.o;
+    for (let n = e.t; n !== null; n = n.o) {
+        const e = n.l;
         l++;
         // Missed-wake latch (#3037): this write is landing while the subscriber
         // is mid-recompute (a nested pull committing beneath its reads), and the
@@ -774,8 +780,8 @@ function insertSubs(e) {
         // pass either re-reads them fresh or trims them), and neither does the
         // tail link: it is the read IN FLIGHT — read() links before it pulls, so
         // this very commit is what that read returns.
-                if (e.R & REACTIVE_RECOMPUTING_DEPS && n.Ue === e.he && n !== e.S) e.R |= REACTIVE_MISSED_WAKE;
-        if (t && e.u & CONFIG_IN_SNAPSHOT_SCOPE) {
+                if (e.R & REACTIVE_RECOMPUTING_DEPS && n.Pe === e.pe && n !== e.p) e.R |= REACTIVE_MISSED_WAKE;
+        if (t && e.i & CONFIG_IN_SNAPSHOT_SCOPE) {
             e.R |= REACTIVE_SNAPSHOT_STALE;
             continue;
         }
@@ -792,9 +798,9 @@ function insertSubs(e) {
  * is a live write if the effect becomes a zombie later this flush — an
  * on-screen reader whose removal an adopted write stages follows the lane
  * (the lane-membership ruling, 2026-10-05; `_update`). */ function laneDirty(e, n) {
-    for (let t = e.t; t !== null; t = t.l) {
-        const e = t.o.m?._t;
-        if (e?.Z ? sameLane(e, n) : t.o.i) t.o.R |= REACTIVE_LANE_DIRTY;
+    for (let t = e.t; t !== null; t = t.o) {
+        const e = t.l.m?._t;
+        if (e?.B ? sameLane(e, n) : t.l.u) t.l.R |= REACTIVE_LANE_DIRTY;
     }
 }
 
@@ -809,24 +815,24 @@ function commitPendingNode(e) {
     // staged) stays uncommitted: a re-pass disposes its children on the spot,
     // and the frame it parked stays the frame until a pass of this node
     // commits a value.
-        if (!n.re) {
-        e.u &= -385;
-        if (e.Ae !== NOT_PENDING) {
-            e.pe = e.Ae;
-            e.Ae = NOT_PENDING;
+        if (!n.ee) {
+        e.i &= -385;
+        if (e.Oe !== NOT_PENDING) {
+            e.Ae = e.Oe;
+            e.Oe = NOT_PENDING;
         }
         return;
     }
     // Computeds only from here (`_statusFlags` is not a signal field). A
     // commit beneath a flight publishes its inputs (A15 reveal corollary,
     // #3305): a reveal of it must observe, not show the pre-flight value.
-        const t = e.Ae === NOT_PENDING && (n.G & STATUS_PENDING) !== 0;
-    e.u = t ? e.u & ~CONFIG_HELD | CONFIG_INPUTS_PUBLISHED : e.u & -1409;
-    if (e.Ae !== NOT_PENDING) {
-        e.pe = e.Ae;
-        e.Ae = NOT_PENDING;
+        const t = e.Oe === NOT_PENDING && (n.S & STATUS_PENDING) !== 0;
+    e.i = t ? e.i & -1048833 | CONFIG_INPUTS_PUBLISHED : e.i & -1049985;
+    if (e.Oe !== NOT_PENDING) {
+        e.Ae = e.Oe;
+        e.Oe = NOT_PENDING;
         // A node born staged (recompute) initializes at this commit.
-                n.G &= ~STATUS_UNINITIALIZED;
+                n.S &= ~STATUS_UNINITIALIZED;
         // A quiet re-ask's classification survives its landing and dies with
         // the landed value's commit (A19 exc. 2, #3178): verdict-quiet through
         // the reveal. (The sweep of a node still in flight is not a landing.)
@@ -834,15 +840,15 @@ function commitPendingNode(e) {
                 if (n.m != null) n.m.It = false, n.m.ht = NOT_PENDING;
         // An effect with a staged value was born held (L2): its first run is
         // this commit's, not its creation's (A29) — queue it now.
-                if (e.i && e.i !== EFFECT_TRACKED) {
+                if (e.u && e.u !== EFFECT_TRACKED) {
             e.lt = true;
-            globalQueue.enqueue(e.i, e.J ??= GlobalQueue.X.bind(null, n));
+            globalQueue.enqueue(e.u, e.Y ??= GlobalQueue.q.bind(null, n));
         }
     }
     // The committed value is the first observable answer for a loading-window
     // node — the window closes here, not at compute time (#2990). Unconditional
     // store to an always-present computed slot.
-        n._e = false;
+        n.De = false;
     n.R &= ~REACTIVE_MANUAL_WRITE;
     // The dependencies of the pass that produced the value are the frame's now:
     // the previous frame's tail goes (A30, #3410; `recompute` left it for a
@@ -850,11 +856,11 @@ function commitPendingNode(e) {
     // pass or by the node's own landing (whose pass was clean), so a set
     // `_error` means the last pass threw, kept its full list, and `_depsTail`
     // marks where it stopped.
-        if (n.m?.v == null) trimStaleDeps(n);
-    if (!(n.G & STATUS_PENDING)) n.G &= ~STATUS_UNINITIALIZED;
+        if (n.m?.F == null) trimStaleDeps(n);
+    if (!(n.S & STATUS_PENDING)) n.S &= ~STATUS_UNINITIALIZED;
     // L2: the children this commit publishes are the frame's now — the frame
     // they replace, parked by the pass (`recompute`), goes.
-        if (!t && n.m != null && (n.m.St !== null || n.m.ct !== null)) GlobalQueue.st(n, false, true);
+        if (!t && n.m != null && (n.m.St !== null || n.m.ct !== null)) GlobalQueue.Et(n, false, true);
 }
 
 function commitPendingNodes() {
@@ -863,7 +869,7 @@ function commitPendingNodes() {
         // A node a lane pass re-staged this round is the lane's to reveal; one
         // a transaction holds (born held by a mainline pass, `passTx`) is that
         // transaction's to commit, at its landing.
-                if (!(n.u & (CONFIG_OVERRIDE | CONFIG_HELD))) commitPendingNode(n);
+                if (!(n.i & (CONFIG_OVERRIDE | CONFIG_HELD))) commitPendingNode(n);
     }
     pendingNodes.length = 0;
 }
@@ -888,7 +894,7 @@ function flush(e) {
             }
         }
     }
-    if (globalQueue.ee) {
+    if (globalQueue.X) {
         return;
     }
     if (halted) return;