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

package/dist/node.cjs

@@ -330,15 +330,15 @@ const transitions = new Set;
 const dirtyQueue = {
     h: new Array(2e3).fill(undefined),
     N: false,
-    P: 0,
-    C: 0
+    C: 0,
+    P: 0
 };
 
 const zombieQueue = {
     h: new Array(2e3).fill(undefined),
     N: false,
-    P: 0,
-    C: 0
+    C: 0,
+    P: 0
 };
 
 let clock = 0;
@@ -572,35 +572,32 @@ class GlobalQueue extends Queue {
     // _clearOptimisticStore).
     static ne=null;
     // affects()-side hooks (wired by affects.ts, mirroring _update): the mark
-    // engine — count/register/release plus the post-commit re-application of
-    // marked reads — lives with the feature. Every call site is gated by state
-    // only that module creates, so `!` invocations are safe once the gate holds.
+    // engine — count/register/release — lives with the feature. Every call site
+    // is gated by state only that module creates, so `!` invocations are safe
+    // once the gate holds.
     static re=null;
     static ie=null;
     static oe=null;
-    static se=null;
-    static ue=null;
-    static le=null;
     // External-source bridge (wired by enableExternalSource(); null while no
     // config is active — including after _resetExternalSourceConfig()).
-    static ce=null;
-    static ae=null;
+    static se=null;
+    static ue=null;
     // Verdict-layer hooks (wired by verdict.ts when isPending()/latest() are
     // imported; null in apps that never use them). Call sites either guard for
     // null or sit behind state only the verdict layer can create (`!` is safe
     // there: `_pendingSignal`/`_latestValueComputed` are only ever assigned by
     // verdict.ts, and `pendingCheckActive`/`latestReadActive` only flip inside
     // isPending()/latest()).
+    static le=null;
+    static ce=null;
+    static ae=null;
     static fe=null;
     static Ee=null;
-    static de=null;
     static Se=null;
+    static de=null;
     static Te=null;
     static pe=null;
     static _e=null;
-    static Oe=null;
-    static Re=null;
-    static Ie=null;
     // Optimistic-engine hooks (wired by core/optimistic.ts via
     // installOptimisticEngine(), called from verdict.ts / createOptimistic /
     // createOptimisticStore — every module that can create optimistic state).
@@ -608,20 +605,18 @@ class GlobalQueue extends Queue {
     // `_overrideValue` slot, a lane in `activeLanes`, an `_optimisticNodes`
     // entry, or a non-null `currentOptimisticLane`, so `!` invocations are safe
     // once the gate holds.
+    static Oe=null;
+    static Re=null;
+    static Ie=null;
     static Ae=null;
     static he=null;
     static Ne=null;
     static ye=null;
-    static Pe=null;
     static Ce=null;
+    static Pe=null;
     static ge=null;
     static be=null;
     static De=null;
-    static me=null;
-    static ve=null;
-    static we=null;
-    static Ge=null;
-    static Le=null;
     flush() {
         if (this.B) return;
         this.B = true;
@@ -634,26 +629,26 @@ 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);
-                        GlobalQueue.Ce(EFFECT_USER);
+                        GlobalQueue.he(EFFECT_RENDER);
+                        GlobalQueue.he(EFFECT_USER);
                     }
                     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.P >= dirtyQueue.C || this.D.H.length > 0;
                     reassignPendingTransition(e.H);
                     activeTransition = null;
-                    // The stash pass (committed-view rerun of plain optimistic signals)
-                    // wraps finalizePureQueue in the engine; a non-empty _optimisticNodes
-                    // means _optimisticWrite ran, which installed the hook.
-                                        if (!e.$.length && !e.j.size && e.G.length) {
-                        GlobalQueue.Ne(e);
-                    } else {
-                        finalizePureQueue(null, true);
-                    }
+                    finalizePureQueue(null, true);
                     return;
                 }
                 const t = activeTransition;
@@ -678,7 +673,7 @@ class GlobalQueue extends Queue {
             } else {
                 if (canUseSimpleSyncFlush(this)) {
                     commitPendingNodes();
-                    if (dirtyQueue.C >= dirtyQueue.P) {
+                    if (dirtyQueue.P >= dirtyQueue.C) {
                         runHeap(dirtyQueue, GlobalQueue.X);
                         commitPendingNodes();
                     }
@@ -689,11 +684,11 @@ class GlobalQueue extends Queue {
             }
             clock++;
             // Check if finalization added items to the heap (from optimistic reversion)
-                        scheduled = dirtyQueue.C >= dirtyQueue.P;
+                        scheduled = dirtyQueue.P >= dirtyQueue.C;
             // Run lane effects first (for ready lanes), then regular effects
-                        activeLanes.size && GlobalQueue.Ce(EFFECT_RENDER);
+                        activeLanes.size && GlobalQueue.he(EFFECT_RENDER);
             this.run(EFFECT_RENDER);
-            activeLanes.size && GlobalQueue.Ce(EFFECT_USER);
+            activeLanes.size && GlobalQueue.he(EFFECT_USER);
             this.run(EFFECT_USER);
             if (false) ;
             if (false && !scheduled && !activeTransition && transitions.size === 0 && activeLanes.size === 0) ;
@@ -706,7 +701,12 @@ class GlobalQueue extends Queue {
         // Only track async if the boundary is propagating STATUS_PENDING (not caught by boundary)
         if (t & STATUS_PENDING) {
             if (n & STATUS_PENDING) {
-                const t = r !== undefined ? r : e.Ue;
+                const t = r !== undefined ? r : e.me;
+                // A visibility-only mark notification (the affects() boundary
+                // channel) updates display state on its way up but must be invisible
+                // to completion accounting BY CONSTRUCTION: it never registers a
+                // reporter and never counts toward the loading-boundary diagnostic.
+                                if (t?.ve) return true;
                 if (activeTransition && t) {
                     const n = t.source;
                     let r = activeTransition.j.get(n);
@@ -780,48 +780,48 @@ function insertSubs(e, t = false) {
     // Get source lane: prefer node's own lane over current context
     // This is important for isPending signals which need their own lane to flush immediately
     const n = e.i || currentOptimisticLane;
-    const r = e.ke !== undefined;
+    const r = e.we !== undefined;
     const i = reaskArmed;
-    for (let o = e.k; o !== null; o = o.Ve) {
+    for (let o = e.k; o !== null; o = o.Ge) {
         // A value-change notification is a new question for the subscriber: any
         // pending re-ask mark (refresh) it carried is superseded.
-        if (i) o.xe.Qe &= ~REACTIVE_REASK;
-        if (r && o.xe.Fe & CONFIG_IN_SNAPSHOT_SCOPE) {
-            o.xe.Qe |= REACTIVE_SNAPSHOT_STALE;
+        if (i) o.Ue.Le &= ~REACTIVE_REASK;
+        if (r && o.Ue.ke & CONFIG_IN_SNAPSHOT_SCOPE) {
+            o.Ue.Le |= REACTIVE_SNAPSHOT_STALE;
             continue;
         }
         if (t && n) {
-            o.xe.Qe |= REACTIVE_OPTIMISTIC_DIRTY;
-            assignOrMergeLane(o.xe, n);
+            o.Ue.Le |= REACTIVE_OPTIMISTIC_DIRTY;
+            assignOrMergeLane(o.Ue, n);
         } else if (t) {
-            o.xe.Qe |= REACTIVE_OPTIMISTIC_DIRTY;
+            o.Ue.Le |= REACTIVE_OPTIMISTIC_DIRTY;
             // No source lane means reversion - clear subscriber's lane so effects go to regular queue
-                        o.xe.i = undefined;
+                        o.Ue.i = undefined;
         }
-        enqueueSub(o.xe);
+        enqueueSub(o.Ue);
     }
 }
 
 function commitPendingNode(e) {
     const t = e;
-    if (!t.We) {
+    if (!t.Ve) {
         if (e.V !== NOT_PENDING) {
-            e.Me = e.V;
+            e.xe = e.V;
             e.V = NOT_PENDING;
         }
-        if (e._ || e.O) GlobalQueue.Se(e);
+        if (e._ || e.O) GlobalQueue.fe(e);
         return;
     }
     if (e.V !== NOT_PENDING) {
-        e.Me = e.V;
+        e.xe = e.V;
         e.V = NOT_PENDING;
         // Set _modified for effects, but not for tracked effects (they handle their own scheduling)
-                if (e.He && e.He !== EFFECT_TRACKED) e.je = true;
+                if (e.Qe && e.Qe !== EFFECT_TRACKED) e.Fe = true;
     }
-    t.Qe &= ~REACTIVE_MANUAL_WRITE;
-    if (!(t.$e & STATUS_PENDING)) t.$e &= ~STATUS_UNINITIALIZED;
-    if (t.Ke !== null || t.Ye !== null) GlobalQueue.J(t, false, true);
-    if (e._ || e.O) GlobalQueue.Se(e);
+    t.Le &= ~REACTIVE_MANUAL_WRITE;
+    if (!(t.We & STATUS_PENDING)) t.We &= ~STATUS_UNINITIALIZED;
+    if (t.Me !== null || t.He !== null) GlobalQueue.J(t, false, true);
+    if (e._ || e.O) GlobalQueue.fe(e);
 }
 
 function commitPendingNodes() {
@@ -838,7 +838,7 @@ function finalizePureQueue(e = null, t = false) {
     const n = !t;
     if (n) commitPendingNodes();
     if (!t && globalQueue.m.length) checkBoundaryChildren(globalQueue);
-    const r = dirtyQueue.C >= dirtyQueue.P;
+    const r = dirtyQueue.P >= dirtyQueue.C;
     if (r) runHeap(dirtyQueue, GlobalQueue.X);
     if (n) {
         if (r) commitPendingNodes();
@@ -846,20 +846,26 @@ function finalizePureQueue(e = null, t = false) {
                 const t = e ?? globalQueue.D;
         // Optimistic reversion: a non-empty batch means _optimisticWrite ran,
         // which installed the engine's hooks.
-                if (t.G.length) GlobalQueue.he(t.G);
+                if (t.G.length) GlobalQueue.Re(t.G);
         // Replay entanglement: subs recorded by the read-time gate get rescheduled
         // so they re-run with the now-committed values visible.
                 if (e && e.q.size) {
             for (const t of e.q) {
-                if (t.Qe & REACTIVE_DISPOSED) continue;
+                if (t.Le & REACTIVE_DISPOSED) continue;
                 enqueueSub(t);
             }
             e.q.clear();
         }
         // Declared motion ends with the transaction: settle (or plain flush end
         // for ambient marks) releases each registration's refcount. A non-empty
-        // batch means registerAffectsMark ran, which installed the hook.
-                if (t.L.length) GlobalQueue.ie(t.L);
+        // batch means registerAffectsMark ran, which installed the hook. Marks
+        // held boundary display state through the visual channel, and their
+        // release is the display-state update point — re-run the boundary sweep
+        // (the earlier sweep above ran while the marks were still live).
+                if (t.L.length) {
+            GlobalQueue.re(t.L);
+            if (globalQueue.m.length) checkBoundaryChildren(globalQueue);
+        }
         // A non-empty set means trackOptimisticStore ran, which installed the
         // hook; the hook iterates, clears, and schedules (keeping the loop out of
         // core lets esbuild shake it — rollup already folds the null guard). The
@@ -867,13 +873,13 @@ function finalizePureQueue(e = null, t = false) {
                 if (t.U.size) GlobalQueue.te(t.U, e);
         sweepTransientStoreNodes();
         // Lanes only enter activeLanes through the engine's getOrCreateLane.
-                if (activeLanes.size) GlobalQueue.Pe(e);
+                if (activeLanes.size) GlobalQueue.Ae(e);
     }
 }
 
 function checkBoundaryChildren(e) {
     for (const t of e.m) {
-        t.qe?.();
+        t.je?.();
         checkBoundaryChildren(t);
     }
 }
@@ -940,16 +946,16 @@ function runQueue$1(e, t) {
 }
 
 function reporterBlocksSource(e, t) {
-    if (e.Qe & (REACTIVE_ZOMBIE | REACTIVE_DISPOSED)) return false;
-    if (e.Be?.has(t)) return true;
-    for (let n = e.Ze; n; n = n.Xe) {
-        let e = n.ze;
+    if (e.Le & (REACTIVE_ZOMBIE | REACTIVE_DISPOSED)) return false;
+    if (e.$e?.has(t)) return true;
+    for (let n = e.Ke; n; n = n.Ye) {
+        let e = n.qe;
         while (e) {
-            if (e === t || e.Je === t) return true;
+            if (e === t || e.Be === t) return true;
             e = e.t;
         }
     }
-    return !!(e.$e & STATUS_PENDING && e.Ue instanceof NotReadyError && e.Ue.source === t);
+    return !!(e.We & STATUS_PENDING && e.me instanceof NotReadyError && e.me.source === t);
 }
 
 function transitionComplete(e) {
@@ -965,7 +971,7 @@ function transitionComplete(e) {
             }
             r.delete(e);
         }
-        if (!i) e.j.delete(n); else if (n.$e & STATUS_PENDING && n.Ue?.source === n) {
+        if (!i) e.j.delete(n); else if (n.We & STATUS_PENDING && n.me?.source === n) {
             t = false;
             break;
         }
@@ -973,7 +979,7 @@ function transitionComplete(e) {
     // Override blockage lives with the engine. Absent hook = "no optimistic
     // blockage", which is exact: only _optimisticWrite (engine) pushes to
     // _optimisticNodes, so without the engine the loop was vacuous anyway.
-        if (t && e.G.length && GlobalQueue.ye(e)) t = false;
+        if (t && e.G.length && GlobalQueue.Ie(e)) t = false;
     t && (e.I = true);
     return t;
 }
@@ -998,7 +1004,7 @@ function runInTransition(e, t) {
 }
 
 /** The queue a node belongs to, picked from its own zombie flag. */ function queueFor(e) {
-    return e.Qe & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
+    return e.Le & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
 }
 
 /**
@@ -1006,86 +1012,94 @@ function runInTransition(e, t) {
  * the heap and go directly to their effect queue; everything else is inserted
  * into its own (zombie-flag-routed) heap with the `_min` cursor pulled down.
  */ function enqueueSub(e) {
-    if (e.He === EFFECT_TRACKED) {
+    if (e.Qe === EFFECT_TRACKED) {
         const t = e;
-        if (!t.je) {
-            t.je = true;
-            t.et.enqueue(EFFECT_USER, t.tt);
+        if (!t.Fe) {
+            t.Fe = true;
+            t.Ze.enqueue(EFFECT_USER, t.Xe);
         }
         return;
     }
     const t = queueFor(e);
-    if (t.P > e.nt) t.P = e.nt;
+    if (t.C > e.ze) t.C = e.ze;
     insertIntoHeap(e, t);
 }
 
 function actualInsertIntoHeap(e, t) {
-    const n = (e.Z?.rt ? e.Z.it?.nt : e.Z?.nt) ?? -1;
-    if (n >= e.nt) e.nt = n + 1;
-    const r = e.nt;
+    const n = (e.Z?.Je ? e.Z.et?.ze : e.Z?.ze) ?? -1;
+    if (n >= e.ze) e.ze = n + 1;
+    const r = e.ze;
     const i = t.h[r];
     if (i === undefined) t.h[r] = e; else {
-        const t = i.ot;
-        t.st = e;
-        e.ot = t;
-        i.ot = e;
+        const t = i.tt;
+        t.nt = e;
+        e.tt = t;
+        i.tt = e;
     }
-    if (r > t.C) t.C = r;
+    if (r > t.P) t.P = r;
 }
 
 function insertIntoHeap(e, t) {
-    let n = e.Qe;
+    let n = e.Le;
     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;
+        e.Le = n & -4 | REACTIVE_DIRTY | REACTIVE_IN_HEAP;
+    } else {
+        e.Le = 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);
 }
 
 function insertIntoHeapHeight(e, t) {
-    let n = e.Qe;
+    let n = e.Le;
     if (n & (REACTIVE_IN_HEAP | REACTIVE_RECOMPUTING_DEPS | REACTIVE_IN_HEAP_HEIGHT | REACTIVE_MANUAL_WRITE)) return;
-    e.Qe = n | REACTIVE_IN_HEAP_HEIGHT;
+    e.Le = n | REACTIVE_IN_HEAP_HEIGHT;
     actualInsertIntoHeap(e, t);
 }
 
 function deleteFromHeap(e, t) {
-    const n = e.Qe;
+    const n = e.Le;
     if (!(n & (REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT))) return;
-    e.Qe = n & -25;
-    const r = e.nt;
-    if (e.ot === e) t.h[r] = undefined; else {
-        const n = e.st;
+    e.Le = n & -25;
+    const r = e.ze;
+    if (e.tt === e) t.h[r] = undefined; else {
+        const n = e.nt;
         const i = t.h[r];
         const o = n ?? i;
-        if (e === i) t.h[r] = n; else e.ot.st = n;
-        o.ot = e.ot;
+        if (e === i) t.h[r] = n; else e.tt.nt = n;
+        o.tt = e.tt;
     }
-    e.ot = e;
-    e.st = undefined;
+    e.tt = e;
+    e.nt = undefined;
 }
 
 function markHeap(e) {
     if (e.N) return;
     e.N = true;
-    for (let t = 0; t <= e.C; t++) {
-        for (let n = e.h[t]; n !== undefined; n = n.st) {
-            if (n.Qe & REACTIVE_IN_HEAP) markNode(n);
+    for (let t = 0; t <= e.P; t++) {
+        for (let n = e.h[t]; n !== undefined; n = n.nt) {
+            if (n.Le & REACTIVE_IN_HEAP) markNode(n);
         }
     }
 }
 
 function markNode(e, t = REACTIVE_DIRTY) {
-    const n = e.Qe;
+    const n = e.Le;
     if ((n & (REACTIVE_CHECK | REACTIVE_DIRTY)) >= t) return;
-    e.Qe = n & -4 | t;
-    for (let t = e.k; t !== null; t = t.Ve) {
-        markNode(t.xe, REACTIVE_CHECK);
-    }
-    if (e.ut !== null) {
-        for (let t = e.ut; t !== null; t = t.lt) {
-            for (let e = t.k; e !== null; e = e.Ve) {
-                markNode(e.xe, REACTIVE_CHECK);
+    e.Le = n & -4 | t;
+    for (let t = e.k; t !== null; t = t.Ge) {
+        markNode(t.Ue, REACTIVE_CHECK);
+    }
+    if (e.rt !== null) {
+        for (let t = e.rt; t !== null; t = t.it) {
+            for (let e = t.k; e !== null; e = e.Ge) {
+                markNode(e.Ue, REACTIVE_CHECK);
             }
         }
     }
@@ -1093,33 +1107,33 @@ function markNode(e, t = REACTIVE_DIRTY) {
 
 function runHeap(e, t) {
     e.N = false;
-    for (e.P = 0; e.P <= e.C; e.P++) {
-        let n = e.h[e.P];
+    for (e.C = 0; e.C <= e.P; e.C++) {
+        let n = e.h[e.C];
         while (n !== undefined) {
-            if (n.Qe & REACTIVE_IN_HEAP) t(n); else adjustHeight(n, e);
-            n = e.h[e.P];
+            if (n.Le & REACTIVE_IN_HEAP) t(n); else adjustHeight(n, e);
+            n = e.h[e.C];
         }
     }
-    e.C = 0;
+    e.P = 0;
 }
 
 function adjustHeight(e, t) {
     deleteFromHeap(e, t);
-    let n = e.nt;
-    for (let t = e.Ze; t; t = t.Xe) {
-        const e = t.ze;
-        const r = e.Je || e;
-        if (r.We && r.nt >= n) n = r.nt + 1;
-    }
-    if (e.nt !== n) {
-        e.nt = n;
-        for (let t = e.k; t !== null; t = t.Ve) {
+    let n = e.ze;
+    for (let t = e.Ke; t; t = t.Ye) {
+        const e = t.qe;
+        const r = e.Be || e;
+        if (r.Ve && r.ze >= n) n = r.ze + 1;
+    }
+    if (e.ze !== n) {
+        e.ze = n;
+        for (let t = e.k; t !== null; t = t.Ge) {
             // Route each subscriber by its own zombie flag, mirroring the
             // post-recompute height-adjust path. Inserting into the running `heap`
             // unconditionally can park a zombie in `dirtyQueue` (or a live node in
             // `zombieQueue`), breaking the flag/queue invariant `deleteFromHeap`
             // relies on — the same corruption class as #2759.
-            insertIntoHeapHeight(t.xe, queueFor(t.xe));
+            insertIntoHeapHeight(t.Ue, queueFor(t.Ue));
         }
     }
 }
@@ -1128,10 +1142,10 @@ const PENDING_OWNER = {};
 
  // Dummy owner to trigger store's read() path
 function markDisposal(e) {
-    let t = e.ct;
+    let t = e.ot;
     while (t) {
-        const e = t.Qe;
-        t.Qe = e | REACTIVE_ZOMBIE;
+        const e = t.Le;
+        t.Le = e | REACTIVE_ZOMBIE;
         // migrate height-adjust entries too, not just recompute entries: every
         // `deleteFromHeap` call site picks the queue from the zombie flag, so a
         // node left physically linked in `dirtyQueue` after being zombified gets
@@ -1142,79 +1156,79 @@ function markDisposal(e) {
             if (e & REACTIVE_IN_HEAP) insertIntoHeap(t, zombieQueue); else insertIntoHeapHeight(t, zombieQueue);
         }
         markDisposal(t);
-        t = t.ft;
+        t = t.st;
     }
 }
 
 function dispose(e) {
-    let t = e.Ze;
+    let t = e.Ke;
     while (t !== null) {
         t = unlinkSubs(t);
     }
-    e.Ze = null;
-    e.Et = null;
+    e.Ke = null;
+    e.ut = null;
     disposeChildren(e, true);
 }
 
 function disposeChildren(e, t = false, n) {
-    const r = e.Qe;
+    const r = e.Le;
     if (r & REACTIVE_DISPOSED) return;
     if (t) {
-        e.Qe = r | REACTIVE_DISPOSED;
+        e.Le = r | REACTIVE_DISPOSED;
         // Companions are created detached and outlive their owner, but a verdict
         // must not: a disposed source can never settle, so an isPending companion
         // latched `true` here would hold a spinner forever (INV-9, the PR #2845
         // edge). Snap runs after the DISPOSED flag is set so the oracle reads
         // false, and notifies subscribers still watching the companion.
                 const t = e;
-        if (t._ || t.O) GlobalQueue.Se(t);
+        if (t._ || t.O) GlobalQueue.fe(t);
     }
-    if (t && e.We) e.dt = null;
-    let i = n ? e.Ke : e.ct;
+    if (t && e.Ve) e.lt = null;
+    let i = n ? e.Me : e.ot;
     while (i) {
-        const e = i.ft;
-        if (i.Ze) {
+        const e = i.st;
+        if (i.Ke) {
             const e = i;
             deleteFromHeap(e, queueFor(e));
-            let t = e.Ze;
+            let t = e.Ke;
             do {
                 t = unlinkSubs(t);
             } while (t !== null);
-            e.Ze = null;
-            e.Et = null;
+            e.Ke = null;
+            e.ut = null;
         }
         disposeChildren(i, true);
         i = e;
     }
     if (n) {
-        e.Ke = null;
+        e.Me = null;
     } else {
-        e.ct = null;
-        e.St = 0;
+        e.ot = null;
+        e.ct = 0;
     }
     // O(1) splice out of parent's chain on individual dispose. Skipped during
     // batch dispose (parent already disposed) and zombie disposal (node sits on
     // parent's _pendingFirstChild). We leave node._nextSibling intact so outer
     // walks that already advanced past us still reach later siblings.
-        if (t && !n && !(r & REACTIVE_ZOMBIE) && e.Z !== null && !(e.Z.Qe & REACTIVE_DISPOSED)) {
-        const t = e.Tt;
-        const n = e.ft;
-        if (t !== null) t.ft = n; else e.Z.ct = n;
-        if (n !== null) n.Tt = t;
-        e.Tt = null;
+        if (t && !n && !(r & REACTIVE_ZOMBIE) && e.Z !== null && !(e.Z.Le & REACTIVE_DISPOSED)) {
+        const t = e.ft;
+        const n = e.st;
+        if (t !== null) t.st = n; else e.Z.ot = n;
+        if (n !== null) n.ft = t;
+        e.ft = null;
     }
     runDisposal(e, n);
     // Final effect-returned cleanup fires at true disposal, after `_disposal`
     // to mirror rerun ordering (compute-phase teardown first, cleanup last).
-        if (t && e._t) {
-        const t = e._t;
-        e._t = undefined;
+        if (t && e.Et) {
+        const t = e.Et;
+        e.Et = undefined;
         t();
     }
 }
 
 function runDisposal(e, t) {
-    let n = t ? e.Ye : e.Ot;
+    let n = t ? e.He : e.St;
     if (!n) return;
     if (Array.isArray(n)) {
         for (let e = 0; e < n.length; e++) {
@@ -1224,13 +1238,13 @@ function runDisposal(e, t) {
     } else {
         n.call(n);
     }
-    t ? e.Ye = null : e.Ot = null;
+    t ? e.He = null : e.St = null;
 }
 
 function childId(e, t) {
     let n = e;
-    while (n.Fe & CONFIG_TRANSPARENT && n.Z) n = n.Z;
-    if (n.id != null) return formatId(n.id, t ? n.St++ : n.St);
+    while (n.ke & CONFIG_TRANSPARENT && n.Z) n = n.Z;
+    if (n.id != null) return formatId(n.id, t ? n.ct++ : n.ct);
     throw new Error("");
 }
 
@@ -1311,7 +1325,7 @@ function formatId(e, t) {
  * checks. `cleanup()` is the unchecked primitive used by internals.
  */ function cleanup(e) {
     if (!context) return e;
-    if (!context.Ot) context.Ot = e; else if (Array.isArray(context.Ot)) context.Ot.push(e); else context.Ot = [ context.Ot, e ];
+    if (!context.St) context.St = e; else if (Array.isArray(context.St)) context.St.push(e); else context.St = [ context.St, e ];
     return e;
 }
 
@@ -1331,7 +1345,7 @@ function formatId(e, t) {
  * }
  * ```
  */ function isDisposed(e) {
-    return !!(e.Qe & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE));
+    return !!(e.Le & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE));
 }
 
 function disposeRootSelf(e = true) {
@@ -1350,29 +1364,29 @@ function disposeRootSelf(e = true) {
     const n = e?.transparent ?? false;
     const r = {
         id: inheritId(e, n, t),
-        Fe: n ? CONFIG_TRANSPARENT : 0,
-        rt: true,
-        it: t?.rt ? t.it : t,
-        ct: null,
+        ke: n ? CONFIG_TRANSPARENT : 0,
+        Je: true,
+        et: t?.Je ? t.et : t,
+        ot: null,
+        st: null,
         ft: null,
-        Tt: null,
-        Ot: null,
-        et: t?.et ?? globalQueue,
-        Rt: t?.Rt || defaultContext,
-        St: 0,
-        Ye: null,
-        Ke: null,
+        St: null,
+        Ze: t?.Ze ?? globalQueue,
+        dt: t?.dt || defaultContext,
+        ct: 0,
+        He: null,
+        Me: null,
         Z: t,
         dispose: disposeRootSelf
     };
     if (t) {
-        const e = t.ct;
+        const e = t.ot;
         if (e === null) {
-            t.ct = r;
+            t.ot = r;
         } else {
-            r.ft = e;
-            e.Tt = r;
-            t.ct = r;
+            r.st = e;
+            e.ft = r;
+            t.ot = r;
         }
     }
     return r;
@@ -1408,60 +1422,66 @@ function disposeRootSelf(e = true) {
 
 // https://github.com/stackblitz/alien-signals/blob/v2.0.3/src/system.ts#L100
 function unlinkSubs(e) {
-    const t = e.ze;
-    const n = e.Xe;
-    const r = e.Ve;
-    const i = e.It;
-    if (r !== null) r.It = i; else t.At = i;
-    if (i !== null) i.Ve = r; else {
+    const t = e.qe;
+    const n = e.Ye;
+    const r = e.Ge;
+    const i = e.Tt;
+    if (r !== null) r.Tt = i; else t._t = i;
+    if (i !== null) i.Ge = r; else {
         t.k = r;
         if (r === null) {
             t.W?.();
             // No more subscribers; only tear down if CONFIG_AUTO_DISPOSE is set.
                         const e = t;
-            e.We && e.Fe & CONFIG_AUTO_DISPOSE && !(e.Qe & REACTIVE_ZOMBIE) && unobserved(e);
+            e.Ve && e.ke & CONFIG_AUTO_DISPOSE && !(e.Le & REACTIVE_ZOMBIE) && unobserved(e);
         }
     }
     return n;
 }
 
 function trimStaleDeps(e) {
-    const t = e.Et;
-    let n = t !== null ? t.Xe : e.Ze;
+    const t = e.ut;
+    let n = t !== null ? t.Ye : e.Ke;
     if (n !== null) {
         do {
             n = unlinkSubs(n);
         } while (n !== null);
-        if (t !== null) t.Xe = null; else e.Ze = null;
+        if (t !== null) t.Ye = null; else e.Ke = null;
     }
 }
 
 function unobserved(e) {
     deleteFromHeap(e, queueFor(e));
-    let t = e.Ze;
+    let t = e.Ke;
     while (t !== null) {
         t = unlinkSubs(t);
     }
-    e.Ze = null;
-    e.Et = null;
+    e.Ke = null;
+    e.ut = null;
     disposeChildren(e, true);
 }
 
 // https://github.com/stackblitz/alien-signals/blob/v2.0.3/src/system.ts#L52
 function link(e, t, n = false) {
-    const r = t.Et;
-    if (r !== null && r.ze === e) {
-        r.ht = n;
+    // Repeat touches within one pass AND-combine `_pendingObserver`: a probe
+    // read (`isPending(() => x())`) beside a value read of the same dep must
+    // not relabel the value dependency as probe-only — the value read is what
+    // real-error propagation and affects() coverage key off, regardless of
+    // read order within the computation.
+    const r = t.ut;
+    if (r !== null && r.qe === e) {
+        r.Ot &&= n;
         return;
     }
     let i = null;
-    const o = t.Qe & REACTIVE_RECOMPUTING_DEPS;
+    const o = t.Le & REACTIVE_RECOMPUTING_DEPS;
     if (o) {
-        i = r !== null ? r.Xe : t.Ze;
-        if (i !== null && i.ze === e) {
-            i.Nt = t.yt;
-            t.Et = i;
-            i.ht = n;
+        i = r !== null ? r.Ye : t.Ke;
+        if (i !== null && i.qe === e) {
+            i.Rt = t.It;
+            t.ut = i;
+            // First touch of this pass: the previous pass's label is stale.
+                        i.Ot = n;
             return;
         }
     }
@@ -1470,22 +1490,24 @@ function link(e, t, n = false) {
     // [deps.._depsTail] prefix — the O(1) equivalent of scanning the dep list
     // (the old alien-signals `isValidLink` walk, O(n²) when a computation
     // re-reads earlier deps non-consecutively, e.g. store leaf reads).
-        const s = e.At;
-    if (s !== null && s.xe === t && (!o || s.Nt === t.yt)) {
-        s.ht = n;
+        const s = e._t;
+    if (s !== null && s.Ue === t && (!o || s.Rt === t.It)) {
+        // Gen-matched during a recompute = repeat touch this pass (AND); outside
+        // a recompute there is no pass boundary, so the latest read labels it.
+        if (o) s.Ot &&= n; else s.Ot = n;
         return;
     }
-    const u = t.Et = e.At = {
-        ze: e,
-        xe: t,
-        Xe: i,
-        It: s,
-        Ve: null,
-        Nt: t.yt,
-        ht: n
+    const u = t.ut = e._t = {
+        qe: e,
+        Ue: t,
+        Ye: i,
+        Tt: s,
+        Ge: null,
+        Rt: t.It,
+        Ot: n
     };
-    if (r !== null) r.Xe = u; else t.Ze = u;
-    if (s !== null) s.Ve = u; else e.k = u;
+    if (r !== null) r.Ye = u; else t.Ke = u;
+    if (s !== null) s.Ge = u; else e.k = u;
 }
 
 // The lazily-created Set is the ONE container for pending sources. Its
@@ -1494,79 +1516,75 @@ function link(e, t, n = false) {
 // overlapping source landed beside the Set and removePendingSource refused
 // to clear it, stranding the Set members' pending forever (#2893).
 function addPendingSource(e, t) {
-    if (e.Be?.has(t)) return false;
-    (e.Be ??= new Set).add(t);
+    if (e.$e?.has(t)) return false;
+    (e.$e ??= new Set).add(t);
     return true;
 }
 
 function removePendingSource(e, t) {
-    if (!e.Be?.delete(t)) return false;
-    if (e.Be.size === 0) e.Be = undefined;
+    if (!e.$e?.delete(t)) return false;
+    if (e.$e.size === 0) e.$e = undefined;
     return true;
 }
 
 function clearPendingSources(e) {
-    e.Be?.clear();
-    e.Be = undefined;
+    e.$e?.clear();
+    e.$e = undefined;
 }
 
 function setPendingError(e, t, n) {
     if (!t) {
-        e.Ue = null;
+        e.me = null;
         return;
     }
     if (n instanceof NotReadyError && n.source === t) {
-        e.Ue = n;
+        e.me = n;
         return;
     }
-    const r = e.Ue;
+    const r = e.me;
     if (!(r instanceof NotReadyError) || r.source !== t) {
-        e.Ue = new NotReadyError(t);
+        e.me = new NotReadyError(t);
     }
 }
 
 function forEachDependent(e, t) {
-    for (let n = e.k; n !== null; n = n.Ve) t(n.xe, n);
+    for (let n = e.k; n !== null; n = n.Ge) t(n.Ue, n);
     // `?? null`: affects() marks route plain signals (no `_child` slot) through here.
-        for (let n = e.ut ?? null; n !== null; n = n.lt) {
-        for (let e = n.k; e !== null; e = e.Ve) t(e.xe, e);
+        for (let n = e.rt ?? null; n !== null; n = n.it) {
+        for (let e = n.k; e !== null; e = e.Ge) t(e.Ue, e);
     }
 }
 
 // Queue a node to re-run on the next flush (used both when a pending source
 // settles and when an `isPending` observer must re-evaluate after a real error):
 // shared scheduling helper in heap.ts (tracked effects bypass the heap).
-function settlePendingSource(e, t = e, 
-// Mark release runs inside queue finalization: companion writes must go
-// through the settlement snap (committed), because a setSignal here would
-// open a fresh transition-scoped override window that nothing reverts.
-n = false) {
-    let r = false;
-    const i = new Set;
-    // Companion updates no-op without the verdict layer (null hooks).
-        const o = n ? GlobalQueue.Se : GlobalQueue.Ee;
-    const settle = e => {
-        if (i.has(e) || !removePendingSource(e, t)) return;
-        i.add(e);
-        e.M = clock;
-        const n = e.Be?.values().next().value;
-        if (n) {
-            setPendingError(e, n);
-            o !== null && o(e);
+function settlePendingSource(e) {
+    let t = false;
+    const n = new Set;
+    // Companion updates no-op without the verdict layer (null hook).
+        const r = GlobalQueue.ce;
+    const settle = i => {
+        if (n.has(i) || !removePendingSource(i, e)) return;
+        n.add(i);
+        i.M = clock;
+        const o = i.$e?.values().next().value;
+        if (o) {
+            setPendingError(i, o);
+            r !== null && r(i);
         } else {
-            e.$e &= ~STATUS_PENDING;
-            setPendingError(e);
-            o !== null && o(e);
-            if (e.Pt) {
-                enqueueSub(e);
-                r = true;
+            i.We &= ~STATUS_PENDING;
+            setPendingError(i);
+            r !== null && r(i);
+            if (i.At) {
+                enqueueSub(i);
+                t = true;
             }
-            e.Pt = false;
+            i.At = false;
         }
-        forEachDependent(e, settle);
+        forEachDependent(i, settle);
     };
     forEachDependent(e, settle);
-    if (r) schedule();
+    if (t) schedule();
 }
 
 // Object-thenable detection (Promises/A+ shape).
@@ -1584,26 +1602,26 @@ function handleAsync(e, t, n) {
         });
     }
     if (!i && !r) {
-        e.dt = null;
+        e.lt = null;
         return t;
     }
-    e.dt = t;
+    e.lt = t;
     let o;
     const handleError = n => {
-        if (e.dt !== t) return;
+        if (e.lt !== t) return;
         globalQueue.initTransition(resolveTransition(e));
         // NotReadyError from rejected promises should be treated as pending, not error
                 notifyStatus(e, n instanceof NotReadyError ? STATUS_PENDING : STATUS_ERROR, n);
         e.M = clock;
     };
     const asyncWrite = (r, i) => {
-        if (e.dt !== t) return;
+        if (e.lt !== t) return;
         // If the node was dirtied by a newer write (optimistic override or regular),
         // skip this stale async result — the upcoming flush will recompute the node
         // with the new value, creating a fresh Promise that supersedes this one.
-                if (e.Qe & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY)) return;
+                if (e.Le & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY)) return;
         globalQueue.initTransition(resolveTransition(e));
-        const o = !!(e.$e & STATUS_UNINITIALIZED);
+        const o = !!(e.We & STATUS_UNINITIALIZED);
         trimStaleDeps(e);
         clearStatus(e);
         const s = resolveLane(e);
@@ -1630,22 +1648,22 @@ function handleAsync(e, t, n) {
             // only notified when the hold is visible to them: under an active
             // override every reader sees the override (A17), so waking subs would
             // re-show an unchanged view — the revert is the notification point.
-                        GlobalQueue.fe !== null && GlobalQueue.fe(e, r);
+                        GlobalQueue.le !== null && GlobalQueue.le(e, r);
             if (!hasActiveOverride(e)) insertSubs(e);
             e.M = clock;
         } else if (s) {
             // Route through lane's effect queue for independent flushing
-            const t = e.He;
-            const n = e.Me;
-            const i = e.Ct;
+            const t = e.Qe;
+            const n = e.xe;
+            const i = e.ht;
             try {
                 if (!t && o || !i || !i(r, n)) {
-                    e.Me = r;
+                    e.xe = r;
                     e.M = clock;
                     // The latest() shadow write gives latest() effects independent lanes; the
                     // _pendingSignal update is a no-op repeat of the clearStatus() call above
                     // (computePendingState doesn't read _value).
-                                        GlobalQueue.fe !== null && GlobalQueue.fe(e, r);
+                                        GlobalQueue.le !== null && GlobalQueue.le(e, r);
                     insertSubs(e, true);
                 }
             } catch (t) {
@@ -1714,7 +1732,7 @@ function handleAsync(e, t, n) {
                     u = n;
                     c = true;
                     if (n.done) i = true;
-                } else if (e.dt !== t) {
+                } else if (e.lt !== t) {
                     return;
                 } else if (!n.done) {
                     r = true;
@@ -1733,7 +1751,7 @@ function handleAsync(e, t, n) {
                 if (f) {
                     l = n;
                     a = true;
-                } else if (e.dt === t) {
+                } else if (e.lt === t) {
                     i = true;
                     handleError(n);
                 }
@@ -1765,86 +1783,74 @@ function handleAsync(e, t, n) {
 }
 
 function clearStatus(e, t = false) {
-    if (e.Be) clearPendingSources(e);
-    if (e.Pt) e.Pt = false;
+    if (e.$e) clearPendingSources(e);
+    if (e.At) e.At = false;
     // The pending window is over; its quiet classification dies with it.
     // (Unconditional: _reask is baked into the node literals, so this is a
     // plain store to an existing slot — no shape change.)
-        e.gt = false;
-    e.$e = t ? 0 : e.$e & STATUS_UNINITIALIZED;
-    if (e.Ue) setPendingError(e);
+        e.Nt = false;
+    e.We = t ? 0 : e.We & STATUS_UNINITIALIZED;
+    if (e.me) setPendingError(e);
     // Update pending signal for isPending() reactivity (companions only exist
     // once the verdict layer created them, which installs the hooks).
-        if (e._ || e.O) GlobalQueue.Ee(e);
-    if (e.ut && GlobalQueue.de !== null) GlobalQueue.de(e);
-    if (e.bt) e.bt();
+        if (e._ || e.O) GlobalQueue.ce(e);
+    if (e.rt && GlobalQueue.ae !== null) GlobalQueue.ae(e);
+    if (e.yt) e.yt();
 }
 
 function notifyStatus(e, t, n, r, i) {
     // Wrap regular errors to track source node
     if (t === STATUS_ERROR && !(n instanceof StatusError) && !(n instanceof NotReadyError)) n = new StatusError(e, n);
     const o = t === STATUS_PENDING && n instanceof NotReadyError ? n.source : undefined;
-    // Mark-sourced propagation must not capture subscribers into the marking
-    // action's transaction (#2893): they carry no held value needing a
-    // transition-scheduled commit, and stamping `_transition` on them would
-    // freeze unrelated writes that share a downstream memo until the action
-    // settles. Real async keeps queuing (its commits ride the transition).
-        const s = o?.Dt !== undefined;
-    // A real error is a settled verdict a mark must not erase (#2893): landing
-    // STATUS_PENDING here would clobber `_error` with the sentinel's
-    // NotReadyError, and unlike real async there is no arriving value whose
-    // recompute would surface the error again. Descent stops too — everything
-    // downstream holds the propagated error for the same reason.
-        if (s && e.$e & STATUS_ERROR) return;
-    const u = o === e;
-    const l = t === STATUS_PENDING && e.A !== undefined && !u;
-    const c = l && hasActiveOverride(e);
+    const s = o === e;
+    const u = t === STATUS_PENDING && e.A !== undefined && !s;
+    const l = u && hasActiveOverride(e);
     if (!r) {
         if (t === STATUS_PENDING && o) {
             addPendingSource(e, o);
-            e.$e = STATUS_PENDING | e.$e & STATUS_UNINITIALIZED;
+            e.We = STATUS_PENDING | e.We & STATUS_UNINITIALIZED;
             // Preserve the current source on this propagation so render-effect notification
             // can register every distinct pending source with the transition.
                         setPendingError(e, o, n);
         } else {
             clearPendingSources(e);
-            e.$e = t | (t !== STATUS_ERROR ? e.$e & STATUS_UNINITIALIZED : 0);
-            e.Ue = n;
+            e.We = t | (t !== STATUS_ERROR ? e.We & STATUS_UNINITIALIZED : 0);
+            e.me = n;
         }
-        GlobalQueue.Ee !== null && GlobalQueue.Ee(e);
-        if (e.ut && GlobalQueue.de !== null) GlobalQueue.de(e);
+        GlobalQueue.ce !== null && GlobalQueue.ce(e);
+        if (e.rt && GlobalQueue.ae !== null) GlobalQueue.ae(e);
     }
     if (i && !r) {
         assignOrMergeLane(e, i);
     }
-    const a = r || c;
-    const f = r || l ? undefined : i;
-    if (e.bt) {
+    const c = r || l;
+    const a = r || u ? undefined : i;
+    if (e.yt) {
         if (r && t === STATUS_PENDING) {
             return;
         }
-        if (a) {
-            e.bt(t, n);
+        if (c) {
+            e.yt(t, n);
         } else {
-            e.bt();
+            e.yt();
         }
         return;
     }
     forEachDependent(e, (e, r) => {
         e.M = clock;
-        if (t === STATUS_PENDING && o && !e.Be?.has(o) || t !== STATUS_PENDING && (e.Ue !== n || e.Be)) {
+        if (t === STATUS_PENDING && o && !e.$e?.has(o) || t !== STATUS_PENDING && (e.me !== n || e.$e)) {
             // A pending-observer link is the subscription an `isPending` read created.
             // It exists so the observer re-runs when the source settles, but it must
             // not carry a real (non-NotReadyError) error — the synchronous `isPending`
             // read swallows those, and the async path must match. Re-run the observer
             // so `isPending` re-evaluates (to not-pending) instead of forwarding.
-            if (r.ht && t !== STATUS_PENDING && !(n instanceof NotReadyError)) {
+            if (r.Ot && t !== STATUS_PENDING && !(n instanceof NotReadyError)) {
                 enqueueSub(e);
                 schedule();
                 return;
             }
-            if (!a && !s && !e.T) queuePendingNode(e);
-            notifyStatus(e, t, n, a, f);
+            if (!c && !e.T) queuePendingNode(e);
+            notifyStatus(e, t, n, c, a);
         }
     });
 }
@@ -1877,24 +1883,13 @@ let context = null;
 
 let currentOptimisticLane = null;
 
-/**
- * Marked sources read by the recompute currently on the stack (saved/restored
- * per recompute, like `context`). A computed that reads a node with a live
- * `affects()` mark inherits the mark's pendingness — `recompute` applies the
- * collected sources through `applyAffectsReads` after its commit, because the
- * `clearStatus` at the top of the commit path wipes whatever sentinel entries
- * the node held from the registration-time push. This is the pull half of
- * mark propagation (real async re-establishes itself by re-throwing on read;
- * marks are value-transparent, so they re-establish here instead).
- */ let affectsReads = null;
-
 let snapshotCaptureActive = false;
 
 let snapshotSources = null;
 
 function ownerInSnapshotScope(e) {
     while (e) {
-        if (e.vt) return true;
+        if (e.Ct) return true;
         e = e.Z;
     }
     return false;
@@ -1906,41 +1901,41 @@ function setSnapshotCapture(e) {
 }
 
 function markSnapshotScope(e) {
-    e.vt = true;
+    e.Ct = true;
 }
 
 function releaseSnapshotScope(e) {
-    e.vt = false;
+    e.Ct = false;
     releaseSubtree(e);
     schedule();
 }
 
 function releaseSubtree(e) {
-    let t = e.ct;
+    let t = e.ot;
     while (t) {
-        if (t.vt) {
-            t = t.ft;
+        if (t.Ct) {
+            t = t.st;
             continue;
         }
-        if (t.We) {
+        if (t.Ve) {
             const e = t;
-            e.Fe &= ~CONFIG_IN_SNAPSHOT_SCOPE;
-            if (e.Qe & REACTIVE_SNAPSHOT_STALE) {
-                e.Qe &= ~REACTIVE_SNAPSHOT_STALE;
-                e.Qe |= REACTIVE_DIRTY;
-                if (dirtyQueue.P > e.nt) dirtyQueue.P = e.nt;
+            e.ke &= ~CONFIG_IN_SNAPSHOT_SCOPE;
+            if (e.Le & REACTIVE_SNAPSHOT_STALE) {
+                e.Le &= ~REACTIVE_SNAPSHOT_STALE;
+                e.Le |= REACTIVE_DIRTY;
+                if (dirtyQueue.C > e.ze) dirtyQueue.C = e.ze;
                 insertIntoHeap(e, dirtyQueue);
             }
         }
         releaseSubtree(t);
-        t = t.ft;
+        t = t.st;
     }
 }
 
 function clearSnapshots() {
     if (snapshotSources) {
         for (const e of snapshotSources) {
-            delete e.ke;
+            delete e.we;
             delete e[STORE_SNAPSHOT_PROPS];
         }
         snapshotSources = null;
@@ -1949,105 +1944,109 @@ function clearSnapshots() {
 }
 
 function recompute(e, t = false) {
-    const n = e.He;
+    const n = e.Qe;
     if (!t) {
         if (e.T && (!n || activeTransition) && activeTransition !== e.T) globalQueue.initTransition(e.T);
         deleteFromHeap(e, queueFor(e));
-        e.dt = null;
+        e.lt = null;
         // Tracked effects run after finalizePureQueue, so dispose immediately instead of deferring
-                if (e.T || n === EFFECT_TRACKED) disposeChildren(e); else if (e.ct !== null || e.Ot !== null) {
+                if (e.T || n === EFFECT_TRACKED) disposeChildren(e); else if (e.ot !== null || e.St !== null) {
             markDisposal(e);
-            e.Ye = e.Ot;
-            e.Ke = e.ct;
-            e.Ot = null;
-            e.ct = null;
-            e.St = 0;
+            e.He = e.St;
+            e.Me = e.ot;
+            e.St = null;
+            e.ot = null;
+            e.ct = 0;
         } else ;
     }
-    let r = !!(e.Qe & REACTIVE_OPTIMISTIC_DIRTY);
+    let r = !!(e.Le & REACTIVE_OPTIMISTIC_DIRTY);
     const i = e.A !== undefined && e.A !== NOT_PENDING;
-    const o = !!(e.$e & STATUS_UNINITIALIZED);
+    const o = !!(e.We & STATUS_UNINITIALIZED);
     // Re-ask classification lives in the verdict module; capture the flag before
     // the recompute wipes _flags below.
-        const s = (e.Qe & REACTIVE_REASK) !== 0;
+        const s = (e.Le & REACTIVE_REASK) !== 0;
     const u = context;
     context = e;
-    e.Et = null;
-    e.yt++;
-    e.Qe = REACTIVE_RECOMPUTING_DEPS;
+    e.ut = null;
+    e.It++;
+    e.Le = REACTIVE_RECOMPUTING_DEPS;
     e.M = clock;
-    let l = e.V === NOT_PENDING ? e.Me : e.V;
-    let c = e.nt;
+    let l = e.V === NOT_PENDING ? e.xe : e.V;
+    let c = e.ze;
     let a = tracking;
-    const f = affectsReads;
-    affectsReads = null;
-    let E = null;
-    let d = currentOptimisticLane;
+    let f = currentOptimisticLane;
     tracking = true;
+    // A computed's fn establishes its OWN dependencies, so it must never run
+    // inside a latest() read window: read() short-circuits through the
+    // companion path before dependency linking, so a memo created (eagerly
+    // computed) inside latest(fn) came out permanently dependency-less (#2926).
+    // latestRead() already suspends the flag for its pull-recomputes; this
+    // covers creation-time computes and flushes that run inside the window.
+        const E = latestReadActive;
+    latestReadActive = false;
     // Lane posture lives with the engine: OPTIMISTIC_DIRTY is only ever set by
     // engine-driven paths, and _optimisticNodes is only pushed by
     // _optimisticWrite, so the hook is installed whenever either gate holds.
         if (r) {
-        const t = GlobalQueue.ve(e, true);
+        const t = GlobalQueue.Pe(e, true);
         if (t) currentOptimisticLane = t;
     } else if (activeTransition && !t && activeTransition.G.length) {
         // Lane adoption: parent-deeper-than-owned-child can run before its OPT-dirty
         // child propagates. Walk deps once and inherit the OPT lane so this node
         // recomputes under the right posture and propagates correctly.
-        const t = GlobalQueue.ve(e, false);
+        const t = GlobalQueue.Pe(e, false);
         if (t) {
             r = true;
             currentOptimisticLane = t;
         }
     }
     const S = n && n !== EFFECT_USER;
-    const T = stale;
+    const d = stale;
     if (S) stale = true;
     try {
-        if (!false && e.Fe & CONFIG_SYNC) {
-            l = e.We(l);
-            e.dt = null;
+        if (!false && e.ke & CONFIG_SYNC) {
+            l = e.Ve(l);
+            e.lt = null;
         } else {
             // Snapshot `_inFlight` so we can detect whether `_fn` self-registered an async
             // subscription (e.g. `createProjection` calls `handleAsync` from inside its body
             // with a setter callback). In that case, the outer `handleAsync` call below would
             // clobber the fresh subscription, so we skip it and let the internally-registered
             // iteration drive updates.
-            const t = e.dt;
-            const n = e.We(l);
+            const t = e.lt;
+            const n = e.Ve(l);
             const r = typeof n === "object" && n !== null;
-            const i = e.dt !== t;
+            const i = e.lt !== t;
             l = i || !r ? n : handleAsync(e, n);
-            if (!i && !r) e.dt = null;
+            if (!i && !r) e.lt = null;
         }
         clearStatus(e, t);
         // _optimisticLane is only ever assigned by engine paths.
-                if (e.i) GlobalQueue.Ge(e);
+                if (e.i) GlobalQueue.be(e);
     } catch (t) {
         // Track pending async in the lane (not the lane's source — it creates the lane
         // but doesn't belong to it). Set lane BEFORE notifyStatus for downstream propagation.
-        if (t instanceof NotReadyError && currentOptimisticLane) GlobalQueue.we(e);
+        if (t instanceof NotReadyError && currentOptimisticLane) GlobalQueue.ge(e);
         let n = false;
         if (t instanceof NotReadyError) {
-            e.Pt = true;
-            if (GlobalQueue.Oe !== null) n = GlobalQueue.Oe(e, s);
+            e.At = true;
+            if (GlobalQueue.Te !== null) n = GlobalQueue.Te(e, s);
         }
         notifyStatus(e, t instanceof NotReadyError ? STATUS_PENDING : STATUS_ERROR, t, undefined, t instanceof NotReadyError ? e.i : undefined);
-        if (n) GlobalQueue.Re(e);
+        if (n) GlobalQueue.pe(e);
     } finally {
         tracking = a;
-        if (S) stale = T;
-        e.Qe = REACTIVE_NONE | (t ? e.Qe & REACTIVE_SNAPSHOT_STALE : 0);
+        latestReadActive = E;
+        if (S) stale = d;
+        e.Le = REACTIVE_NONE | (t ? e.Le & REACTIVE_SNAPSHOT_STALE : 0);
         context = u;
-        E = affectsReads;
-        affectsReads = f;
     }
-    if (!e.Ue) {
+    if (!e.me) {
         trimStaleDeps(e);
-        const s = i ? unwrapOverride(e.A) : e.V === NOT_PENDING ? e.Me : e.V;
+        const s = i ? unwrapOverride(e.A) : e.V === NOT_PENDING ? e.xe : e.V;
         let u = false;
         try {
-            u = !n && o || !e.Ct || !e.Ct(s, l);
+            u = !n && o || !e.ht || !e.ht(s, l);
         } catch (t) {
             // A throwing user comparator is an error of this node's computation.
             // Route it through the same status path as a compute-phase throw so
@@ -2061,15 +2060,15 @@ function recompute(e, t = false) {
         // gate: the explicit recompute(node, true) inside effect() does not enqueue, so
         // effect() can call its runner synchronously for the first run.
                 if (n && u) {
-            e.je = !e.Ue;
+            e.Fe = !e.me;
             // Reuse one bound runner per effect — runEffect no-ops on a stale
             // `_modified`, so re-enqueueing the same function is harmless.
-                        if (!t) e.et.enqueue(n, e.wt ??= GlobalQueue.ee.bind(null, e));
+                        if (!t) e.Ze.enqueue(n, e.Pt ??= GlobalQueue.ee.bind(null, e));
         }
-        if (e.Ue) ; else if (u) {
+        if (e.me) ; else if (u) {
             const o = i ? e.A : undefined;
             if (t || n && activeTransition !== e.T || r) {
-                e.Me = l;
+                e.xe = l;
                 // Lane-propagated correction: upstream data is fresh, correct the
                 // override unconditionally. The direct _value commit is the lane's
                 // own reveal schedule; drop any superseded older hold so its queued
@@ -2085,7 +2084,7 @@ function recompute(e, t = false) {
                 // (#2831). Both companion writes are transition-scoped (optimistic) and
                 // auto-revert/re-derive at commit. Skipped for plain flushes where the
                 // pending value commits before effects run.
-                                if ((activeTransition || e.T) && GlobalQueue.fe !== null) GlobalQueue.fe(e, l);
+                                if ((activeTransition || e.T) && GlobalQueue.le !== null) GlobalQueue.le(e, l);
             }
             if (!i || r || e.A !== o) insertSubs(e, r || i);
         } else if (i) {
@@ -2094,90 +2093,77 @@ function recompute(e, t = false) {
             // for commit on its own transition's schedule — invisibly (A17/A18).
             if (e.V === NOT_PENDING) queuePendingNode(e);
             e.V = l;
-        } else if (e.nt != c) {
-            for (let t = e.k; t !== null; t = t.Ve) {
-                insertIntoHeapHeight(t.xe, queueFor(t.xe));
+        } else if (e.ze != c) {
+            for (let t = e.k; t !== null; t = t.Ge) {
+                insertIntoHeapHeight(t.Ue, queueFor(t.Ue));
             }
         }
     }
-    currentOptimisticLane = d;
-    // Marks read during this recompute re-attach after the commit above:
-    // earlier, the sentinel's NotReadyError in `_error` would have routed the
-    // fresh value into the error-skip branch instead of committing it. A real
-    // (non-NotReady) error wins over marks (#2893): applying the sentinel here
-    // would clobber the user's error with a NotReadyError from a node whose
-    // reads value-transparency promises can never throw NotReady.
-    // `markedReads` only collects under a live mark, so the hook is installed.
-        if (E && !(e.$e & STATUS_ERROR)) GlobalQueue.re(e, E);
-    // Mark-only pending doesn't queue (#2893): the node holds no value needing
-    // a transition-scheduled commit, and queueing would stamp the marking
-    // action's transaction onto it — freezing unrelated writes that share it.
-    // (Single mask test up front keeps the mark-free hot path at original cost.)
-        const p = e.$e & (STATUS_PENDING | STATUS_UNINITIALIZED);
-    const _ = e.V !== NOT_PENDING || e.Ke !== null || e.Ye !== null || p !== 0 && (p !== STATUS_PENDING || activeAffectsMarks === 0 || !GlobalQueue.ue(e));
+    currentOptimisticLane = f;
+    const T = e.V !== NOT_PENDING || e.Me !== null || e.He !== null || (e.We & (STATUS_PENDING | STATUS_UNINITIALIZED)) !== 0;
     // Override-covered holds (hasOverride) always queue: their commit belongs
     // to their own transition's schedule (A18 re-rule) and is unobservable
     // under the override (A17). Revert no longer commits anything, so an
     // unqueued covered hold would leak (INV-7) once the revert clears
     // _transition.
-        _ && (!t || e.$e & STATUS_PENDING) && (!e.T || i) && queuePendingNode(e);
+        T && (!t || e.We & STATUS_PENDING) && (!e.T || i) && queuePendingNode(e);
     e.T && n && activeTransition !== e.T && runInTransition(e.T, () => recompute(e));
 }
 
 function updateIfNecessary(e) {
-    if (e.Qe & REACTIVE_CHECK) {
-        for (let t = e.Ze; t; t = t.Xe) {
-            const n = t.ze;
-            const r = n.Je || n;
-            if (r.We) {
+    if (e.Le & REACTIVE_CHECK) {
+        for (let t = e.Ke; t; t = t.Ye) {
+            const n = t.qe;
+            const r = n.Be || n;
+            if (r.Ve) {
                 updateIfNecessary(r);
             }
-            if (e.Qe & REACTIVE_DIRTY) {
+            if (e.Le & REACTIVE_DIRTY) {
                 break;
             }
         }
     }
-    if (e.Qe & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY) || e.Ue && e.M < clock && !e.dt) {
+    if (e.Le & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY) || e.me && e.M < clock && !e.lt) {
         recompute(e);
     }
-    e.Qe = e.Qe & (REACTIVE_SNAPSHOT_STALE | REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT);
+    e.Le = e.Le & (REACTIVE_SNAPSHOT_STALE | REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT);
 }
 
 function computed(e, t) {
     const n = t?.transparent ?? false;
     const r = {
         id: inheritId(t, n, context),
-        Fe: (n ? CONFIG_TRANSPARENT : 0) | (t?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (!context || t?.lazy ? CONFIG_AUTO_DISPOSE : 0) | (t?.sync ? CONFIG_SYNC : 0) | (t?.Gt ? CONFIG_NO_SNAPSHOT : 0) | (snapshotCaptureActive && ownerInSnapshotScope(context) ? CONFIG_IN_SNAPSHOT_SCOPE : 0),
-        Ct: t?.equals != null ? t.equals : isEqual,
+        ke: (n ? CONFIG_TRANSPARENT : 0) | (t?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (!context || t?.lazy ? CONFIG_AUTO_DISPOSE : 0) | (t?.sync ? CONFIG_SYNC : 0) | (t?.gt ? CONFIG_NO_SNAPSHOT : 0) | (snapshotCaptureActive && ownerInSnapshotScope(context) ? CONFIG_IN_SNAPSHOT_SCOPE : 0),
+        ht: t?.equals != null ? t.equals : isEqual,
         W: t?.unobserved,
-        Ot: null,
-        et: context?.et ?? globalQueue,
-        Rt: context?.Rt ?? defaultContext,
-        St: 0,
-        We: e,
-        Me: undefined,
-        nt: 0,
+        St: null,
+        Ze: context?.Ze ?? globalQueue,
+        dt: context?.dt ?? defaultContext,
+        ct: 0,
+        Ve: e,
+        xe: undefined,
+        ze: 0,
+        rt: null,
+        nt: undefined,
+        tt: null,
+        Ke: null,
         ut: null,
-        st: undefined,
-        ot: null,
-        Ze: null,
-        Et: null,
-        yt: 0,
+        It: 0,
         k: null,
-        At: null,
+        _t: null,
         Z: context,
+        st: null,
         ft: null,
-        Tt: null,
-        ct: null,
-        Qe: t?.lazy ? REACTIVE_LAZY : REACTIVE_NONE,
-        $e: STATUS_UNINITIALIZED,
+        ot: null,
+        Le: t?.lazy ? REACTIVE_LAZY : REACTIVE_NONE,
+        We: STATUS_UNINITIALIZED,
         M: clock,
         V: NOT_PENDING,
-        Ye: null,
-        Ke: null,
-        dt: null,
+        He: null,
+        Me: null,
+        lt: null,
         T: null,
-        gt: false
+        Nt: false
     };
     setupComputedNode(r, t);
     return r;
@@ -2192,44 +2178,44 @@ function computed(e, t) {
     const s = o?.transparent ?? false;
     const u = {
         id: inheritId(o, s, context),
-        Fe: (s ? CONFIG_TRANSPARENT : 0) | (o?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (o?.sync ? CONFIG_SYNC : 0) | (snapshotCaptureActive && ownerInSnapshotScope(context) ? CONFIG_IN_SNAPSHOT_SCOPE : 0),
-        Ct: false,
+        ke: (s ? CONFIG_TRANSPARENT : 0) | (o?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (o?.sync ? CONFIG_SYNC : 0) | (snapshotCaptureActive && ownerInSnapshotScope(context) ? CONFIG_IN_SNAPSHOT_SCOPE : 0),
+        ht: false,
         W: o?.unobserved,
-        Ot: null,
-        et: context?.et ?? globalQueue,
-        Rt: context?.Rt ?? defaultContext,
-        St: 0,
-        We: e,
-        Me: undefined,
-        nt: 0,
+        St: null,
+        Ze: context?.Ze ?? globalQueue,
+        dt: context?.dt ?? defaultContext,
+        ct: 0,
+        Ve: e,
+        xe: undefined,
+        ze: 0,
+        rt: null,
+        nt: undefined,
+        tt: null,
+        Ke: null,
         ut: null,
-        st: undefined,
-        ot: null,
-        Ze: null,
-        Et: null,
-        yt: 0,
+        It: 0,
         k: null,
-        At: null,
+        _t: null,
         Z: context,
+        st: null,
         ft: null,
-        Tt: null,
-        ct: null,
-        Qe: REACTIVE_LAZY,
-        $e: STATUS_UNINITIALIZED,
+        ot: null,
+        Le: REACTIVE_LAZY,
+        We: STATUS_UNINITIALIZED,
         M: clock,
         V: NOT_PENDING,
-        Ye: null,
-        Ke: null,
-        dt: null,
+        He: null,
+        Me: null,
+        lt: null,
         T: null,
-        gt: false,
-        je: false,
-        Lt: undefined,
-        Ut: t,
-        kt: n,
-        _t: undefined,
-        He: r,
-        bt: i
+        Nt: false,
+        Fe: false,
+        bt: undefined,
+        Dt: t,
+        vt: n,
+        Et: undefined,
+        Qe: r,
+        yt: i
     };
     setupComputedNode(u, lazyOptions);
     return u;
@@ -2240,24 +2226,24 @@ const lazyOptions = {
 };
 
 function setupComputedNode(e, t) {
-    e.ot = e;
-    const n = context?.rt ? context.it : context;
+    e.tt = e;
+    const n = context?.Je ? context.et : context;
     if (context) {
-        const t = context.ct;
+        const t = context.ot;
         if (t === null) {
-            context.ct = e;
+            context.ot = e;
         } else {
-            e.ft = t;
-            t.Tt = e;
-            context.ct = e;
+            e.st = t;
+            t.ft = e;
+            context.ot = e;
         }
     }
-    if (n) e.nt = n.nt + 1;
-    if (GlobalQueue.ce !== null) GlobalQueue.ce(e);
+    if (n) e.ze = n.ze + 1;
+    if (GlobalQueue.se !== null) GlobalQueue.se(e);
     !t?.lazy && recompute(e, true);
     if (snapshotCaptureActive && !t?.lazy) {
-        if (!(e.$e & STATUS_PENDING) && !(e.Fe & CONFIG_NO_SNAPSHOT)) {
-            e.ke = e.Me === undefined ? NO_SNAPSHOT : e.Me;
+        if (!(e.We & STATUS_PENDING) && !(e.ke & CONFIG_NO_SNAPSHOT)) {
+            e.we = e.xe === undefined ? NO_SNAPSHOT : e.xe;
             snapshotSources.add(e);
         }
     }
@@ -2265,20 +2251,20 @@ function setupComputedNode(e, t) {
 
 function signal(e, t, n = null) {
     const r = {
-        Ct: t?.equals != null ? t.equals : isEqual,
-        Fe: (t?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (t?.Gt ? CONFIG_NO_SNAPSHOT : 0),
+        ht: t?.equals != null ? t.equals : isEqual,
+        ke: (t?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (t?.gt ? CONFIG_NO_SNAPSHOT : 0),
         W: t?.unobserved,
-        Me: e,
+        xe: e,
         k: null,
-        At: null,
+        _t: null,
         M: clock,
-        Je: n,
-        lt: n?.ut || null,
+        Be: n,
+        it: n?.rt || null,
         V: NOT_PENDING
     };
-    n && (n.ut = r);
-    if (snapshotCaptureActive && !(r.Fe & CONFIG_NO_SNAPSHOT) && !((n?.$e ?? 0) & STATUS_PENDING)) {
-        r.ke = e === undefined ? NO_SNAPSHOT : e;
+    n && (n.rt = r);
+    if (snapshotCaptureActive && !(r.ke & CONFIG_NO_SNAPSHOT) && !((n?.We ?? 0) & STATUS_PENDING)) {
+        r.we = e === undefined ? NO_SNAPSHOT : e;
         snapshotSources.add(r);
     }
     return r;
@@ -2322,11 +2308,11 @@ function isEqual(e, t) {
  * );
  * ```
  */ function untrack(e, t) {
-    if (GlobalQueue.ae === null && !tracking && true) return e();
+    if (GlobalQueue.ue === null && !tracking && true) return e();
     const n = tracking;
     tracking = false;
     try {
-        if (GlobalQueue.ae !== null) return GlobalQueue.ae(e);
+        if (GlobalQueue.ue !== null) return GlobalQueue.ue(e);
         return e();
     } finally {
         tracking = n;
@@ -2338,10 +2324,10 @@ function isEqual(e, t) {
  * an isPending() probe (`refresh`) additionally pulls the node fully up to
  * date so its status flags reflect the current graph.
  */ function prepareComputed(e, t) {
-    if (e.Qe & REACTIVE_LAZY) {
-        e.Qe &= ~REACTIVE_LAZY;
+    if (e.Le & REACTIVE_LAZY) {
+        e.Le &= ~REACTIVE_LAZY;
         recompute(e, true);
-    } else if (e.Qe & REACTIVE_DISPOSED) {
+    } else if (e.Le & REACTIVE_DISPOSED) {
         recompute(e, true);
     } else if (t) {
         updateIfNecessary(e);
@@ -2353,78 +2339,57 @@ function read(e) {
     // Checked before isPending so that isPending(() => latest(x)) checks
     // the _pendingSignal of _latestValueComputed (async in flight) rather
     // than the original node (which stays "pending" while held in a transition).
-    if (latestReadActive) return GlobalQueue.Te(e);
+    if (latestReadActive) return GlobalQueue.Ee(e);
     let t = context;
-    if (t?.rt) t = t.it;
+    if (t?.Je) t = t.et;
     const n = e;
-    const r = e.Je;
+    const r = e.Be;
     const i = r || e;
     // Handle isPending() mode: collect pending state while preserving normal read semantics.
     // Probe mode is suspended while preparing the node so nested reads during a
     // recompute don't collect into the probe.
         if (pendingCheckActive) {
-        GlobalQueue.pe(e, t, i, r);
-    } else if (typeof n.We === "function") {
+        GlobalQueue.Se(e, t, i, r);
+    } else if (typeof n.Ve === "function") {
         prepareComputed(e, false);
     }
-    if (!n.We && i === e && e.A === undefined && e.ke === undefined && activeTransition === null && currentOptimisticLane === null && !snapshotCaptureActive && true) {
-        if (t && tracking) {
-            link(e, t);
-            // A live mark on a read source flows to the reader (probe reads are
-            // excluded: the probe's own collection owns that verdict, and marking
-            // the enclosing memo would make an `isPending` wrapper itself pending).
-                        if (activeAffectsMarks !== 0 && e.F && !pendingCheckActive) (affectsReads ??= []).push(e);
-        }
-        return !t || e.V === NOT_PENDING ? e.Me : e.V;
+    if (!n.Ve && i === e && e.A === undefined && e.we === undefined && activeTransition === null && currentOptimisticLane === null && !snapshotCaptureActive && true) {
+        if (t && tracking) link(e, t);
+        return !t || e.V === NOT_PENDING ? e.xe : e.V;
     }
     if (t && tracking) {
         link(e, t, pendingCheckActive);
-        // Mark inheritance through derivation (see the fast path above), and its
-        // transitive half (#2893): a mark-pended owner's sentinel sources flow to
-        // the reader like a direct mark — value-transparent reads have no throw
-        // to re-establish through, so without this a mid-window recompute sheds
-        // pendingness permanently past one derivation level.
-                if (activeAffectsMarks !== 0 && !pendingCheckActive) {
-            if (e.F) (affectsReads ??= []).push(e);
-            if (i.$e & STATUS_PENDING) GlobalQueue.le(i, affectsReads ??= []);
-        }
-        if (i.We) {
+        if (i.Ve) {
             const n = queueFor(e);
-            if (i.nt >= n.P) {
+            if (i.ze >= n.C) {
                 markNode(t);
                 markHeap(n);
                 updateIfNecessary(i);
             }
-            const r = i.nt;
+            const r = i.ze;
             // parent check is shallow, might need to be recursive
-                        if (r >= t.nt && e.Z !== t) {
-                t.nt = r + 1;
+                        if (r >= t.ze && e.Z !== t) {
+                t.ze = r + 1;
             }
         }
     }
-    // Mark-only pending never suspends the reader (#2886): an affects() mark is
-    // a promise of change, not an absence of value, so a derived node whose only
-    // pending sources are mark sentinels keeps its real value readable —
-    // pendingness reaches readers through verdicts (isPending), not throws.
-    // (`activeAffectsMarks` gates the source scan off the mark-free hot path;
-    // sentinels can't survive in pending sources past their last release.)
-        if (i.$e & STATUS_PENDING && !(activeAffectsMarks !== 0 && GlobalQueue.ue(i))) {
+    if (i.We & STATUS_PENDING) {
         if (t && !(stale && i.T && activeTransition !== i.T)) {
             // Per-lane suspension lives with the engine (a non-null lane implies it
             // is installed): under a lane, only same-lane pending async without an
             // active override throws.
-            if (currentOptimisticLane === null || GlobalQueue.De(i)) {
+            if (currentOptimisticLane === null || GlobalQueue.ye(i)) {
                 if (!tracking && e !== t) link(e, t);
-                throw i.Ue;
+                throw i.me;
             }
-        } else if (t && i !== e && i.$e & STATUS_UNINITIALIZED) {
+        } else if (t && i !== e && i.We & STATUS_UNINITIALIZED) {
             if (!tracking && e !== t) link(e, t);
-            throw i.Ue;
-        } else if (!t && i.$e & STATUS_UNINITIALIZED) {
-            throw i.Ue;
+            throw i.me;
+        } else if (!t && i.We & STATUS_UNINITIALIZED) {
+            throw i.me;
         }
     }
-    if (e.We && e.$e & STATUS_ERROR) {
+    if (e.Ve && e.We & STATUS_ERROR) {
         // Only a genuine reactive re-read may retry an errored async source:
         // - tracking: owned/tracked scope only (never events / `untrack` / effect side-effect phase)
         // - !pendingCheckActive: an `isPending` probe observes the error, never refetches
@@ -2432,21 +2397,19 @@ function read(e) {
         if (tracking && !pendingCheckActive && e.M < clock) {
             recompute(e);
             return read(e);
-        } else throw e.Ue;
+        } else throw e.me;
     }
-    if (snapshotCaptureActive && t && t.Fe & CONFIG_IN_SNAPSHOT_SCOPE) {
-        const n = e.ke;
+    if (snapshotCaptureActive && t && t.ke & CONFIG_IN_SNAPSHOT_SCOPE) {
+        const n = e.we;
         if (n !== undefined) {
             const r = n === NO_SNAPSHOT ? undefined : n;
-            const i = e.V !== NOT_PENDING ? e.V : e.Me;
-            if (i !== r) t.Qe |= REACTIVE_SNAPSHOT_STALE;
+            const i = e.V !== NOT_PENDING ? e.V : e.xe;
+            if (i !== r) t.Le |= REACTIVE_SNAPSHOT_STALE;
             return r;
         }
     }
     if (e.A !== undefined && e.A !== NOT_PENDING) {
-        // An active override means the engine is installed (A17: the override IS
-        // the value for every reader — that check itself stays right here).
-        if (t && stale && GlobalQueue.ge(e)) return e.Me;
+        // A17: the override IS the value for every reader.
         return unwrapOverride(e.A);
     }
     // Entanglement gate: a reader recomputing under an optimistic lane that reads
@@ -2456,18 +2419,18 @@ function read(e) {
     // _pendingValue for correct fetching. The sub is recorded for replay at commit
     // so it re-runs with the new committed view. (Gate details live with the
     // engine — a non-null lane implies it is installed.)
-        if (currentOptimisticLane !== null && activeTransition !== null && t !== null && GlobalQueue.be(e, i, t)) {
-        return e.Me;
+        if (currentOptimisticLane !== null && activeTransition !== null && t !== null && GlobalQueue.Ne(e, i, t)) {
+        return e.xe;
     }
     // In optimistic lane context, return _value for optimistic/lane-assigned signals
     // and for regular signals in stale mode (render effects). Non-stale readers (user
     // effects) see _pendingValue so that latest() and direct reads stay consistent.
     // (The lane-context clause lives with the engine.)
-        const o = !t || currentOptimisticLane !== null && GlobalQueue.me(e, i, t) || e.V === NOT_PENDING || stale && e.T && activeTransition !== e.T ? e.Me : e.V;
+        const o = !t || currentOptimisticLane !== null && GlobalQueue.Ce(e, i, t) || e.V === NOT_PENDING || stale && e.T && activeTransition !== e.T ? e.xe : e.V;
     // Record that this isPending() probe observed the fresh pending value, so
     // the probe doesn't pair "pending" with the new value (#2831).
-        if (pendingCheckActive) GlobalQueue._e(e, o);
-    if (!t && i === e && typeof n.We === "function" && e.Fe & CONFIG_AUTO_DISPOSE && !(i.$e & STATUS_PENDING) && !e.k) {
+        if (pendingCheckActive) GlobalQueue.de(e, o);
+    if (!t && i === e && typeof n.Ve === "function" && e.ke & CONFIG_AUTO_DISPOSE && !(i.We & STATUS_PENDING) && !e.k) {
         unobserved(e);
     }
     return o;
@@ -2479,16 +2442,16 @@ function setSignal(e, t) {
     // optimisticComputed callers and optimistic store nodes carry an
     // _overrideValue slot, and every module that creates one installs the
     // engine first.
-        if (e.A !== undefined && !projectionWriteActive) return GlobalQueue.Ae(e, t);
-    const n = e.V === NOT_PENDING ? e.Me : e.V;
+        if (e.A !== undefined && !projectionWriteActive) return GlobalQueue.Oe(e, t);
+    const n = e.V === NOT_PENDING ? e.xe : e.V;
     if (typeof t === "function") t = t(n);
     // Uninitialized check first: the first commit has no previous value, so the
     // user comparator must not run against `undefined` (matches recompute).
-        const r = !!(e.$e & STATUS_UNINITIALIZED) || !e.Ct || !e.Ct(n, t);
+        const r = !!(e.We & STATUS_UNINITIALIZED) || !e.ht || !e.ht(n, t);
     if (!r) return t;
     if (e.V === NOT_PENDING) queuePendingNode(e);
     e.V = t;
-    GlobalQueue.fe !== null && GlobalQueue.fe(e, t);
+    GlobalQueue.le !== null && GlobalQueue.le(e, t);
     e.M = clock;
     insertSubs(e);
     schedule();
@@ -2503,11 +2466,11 @@ function setSignal(e, t) {
  * cleanup point.
  */ function suppressComputedRecompute(e) {
     deleteFromHeap(e, queueFor(e));
-    if (!(e.Qe & REACTIVE_MANUAL_WRITE) && e.V === NOT_PENDING) {
+    if (!(e.Le & REACTIVE_MANUAL_WRITE) && e.V === NOT_PENDING) {
         queuePendingNode(e);
         schedule();
     }
-    e.Qe = e.Qe & -4 | REACTIVE_MANUAL_WRITE;
+    e.Le = e.Le & -4 | REACTIVE_MANUAL_WRITE;
 }
 
 /**
@@ -2586,7 +2549,7 @@ function staleValues(e, t = true) {
     if (!t) {
         return;
     }
-    if (typeof t.We === "function" && !(t.Qe & (REACTIVE_DISPOSED | REACTIVE_MANUAL_WRITE))) {
+    if (typeof t.Ve === "function" && !(t.Le & (REACTIVE_DISPOSED | REACTIVE_MANUAL_WRITE))) {
         // A refresh with no value-change dirt already queued is a re-ask of the
         // same question: mark it so the recompute classifies any resulting
         // pending window as quiet (not pending). If the node is already dirty
@@ -2594,11 +2557,11 @@ function staleValues(e, t = true) {
         // REACTIVE_IN_HEAP counts as dirt: insertSubs schedules subscribers by
         // heap insertion alone (no DIRTY/CHECK flag), so a same-batch value
         // change followed by refresh() must not be laundered into a quiet re-ask.
-        if (!(t.Qe & (REACTIVE_DIRTY | REACTIVE_CHECK | REACTIVE_IN_HEAP))) {
-            t.Qe |= REACTIVE_REASK;
+        if (!(t.Le & (REACTIVE_DIRTY | REACTIVE_CHECK | REACTIVE_IN_HEAP))) {
+            t.Le |= REACTIVE_REASK;
             armReaskClear();
         }
-        t.Qe = t.Qe & ~REACTIVE_CHECK | REACTIVE_DIRTY;
+        t.Le = t.Le & ~REACTIVE_CHECK | REACTIVE_DIRTY;
         insertIntoHeap(t, queueFor(t));
         schedule();
     }
@@ -2646,11 +2609,11 @@ function wireExternalSource(e) {
         equals: false,
         ownedWrite: true
     });
-    const n = externalSourceConfig.factory(e.We, () => {
+    const n = externalSourceConfig.factory(e.Ve, () => {
         setSignal(t, undefined);
     });
     cleanup(() => n.dispose());
-    e.We = e => {
+    e.Ve = e => {
         read(t);
         return n.track(e);
     };
@@ -2664,8 +2627,8 @@ function externalUntrack(e) {
 // removed on reset) so core's null checks stay equivalent to the old
 // `externalSourceConfig` truthiness checks.
 function syncExternalHooks() {
-    GlobalQueue.ce = externalSourceConfig ? wireExternalSource : null;
-    GlobalQueue.ae = externalSourceConfig ? externalUntrack : null;
+    GlobalQueue.se = externalSourceConfig ? wireExternalSource : null;
+    GlobalQueue.ue = externalSourceConfig ? externalUntrack : null;
 }
 
 function enableExternalSource(e) {
@@ -2722,7 +2685,7 @@ function enableExternalSource(e) {
     if (!t) {
         throw new NoOwnerError;
     }
-    const n = hasContext(e, t) ? t.Rt[e.id] : e.defaultValue;
+    const n = hasContext(e, t) ? t.dt[e.id] : e.defaultValue;
     if (isUndefined(n)) {
         throw new ContextNotFoundError;
     }
@@ -2743,14 +2706,14 @@ function enableExternalSource(e) {
     }
     // We're creating a new object to avoid child context values being exposed to parent owners. If
     // we don't do this, everything will be a singleton and all hell will break lose.
-        n.Rt = {
-        ...n.Rt,
+        n.dt = {
+        ...n.dt,
         [e.id]: isUndefined(t) ? e.defaultValue : t
     };
 }
 
 function hasContext(e, t) {
-    return !isUndefined(t?.Rt[e.id]);
+    return !isUndefined(t?.dt[e.id]);
 }
 
 function isUndefined(e) {
@@ -2770,15 +2733,11 @@ function isUndefined(e) {
  * `_optimisticNodes.length`, `activeLanes.size`), so `!` invocations are safe
  * once the gate holds — the same late-binding contract as verdict.ts.
  */
-// When a background transition is stashed, plain optimistic signals need one
-// committed-view rerun. Keep that override local to the stash flush.
-let stashedOptimisticReads = null;
-
 /** The optimistic half of setSignal, fired when `_overrideValue !== undefined`. */ function optimisticWrite(e, t) {
     const n = e.A !== NOT_PENDING;
-    const r = n ? unwrapOverride(e.A) : e.Me;
+    const r = n ? unwrapOverride(e.A) : e.xe;
     if (typeof t === "function") t = t(r);
-    const i = !!(e.$e & STATUS_UNINITIALIZED) || !e.Ct || !e.Ct(r, t);
+    const i = !!(e.We & STATUS_UNINITIALIZED) || !e.ht || !e.ht(r, t);
     if (!i) {
         // Same-value write with an active override still entangles the current
         // action's transition — the hold must outlast all overlapping actions.
@@ -2803,43 +2762,13 @@ let stashedOptimisticReads = null;
     // brand, and erasing it makes the write invisible and routes follow-up
     // writes off the optimistic path into permanent commits (#2898).
         e.A = t === undefined ? OVERRIDE_UNDEFINED : t;
-    GlobalQueue.fe !== null && GlobalQueue.fe(e, t);
+    GlobalQueue.le !== null && GlobalQueue.le(e, t);
     e.M = clock;
     insertSubs(e, true);
     schedule();
     return t;
 }
 
-function readStashed(e) {
-    return !!stashedOptimisticReads?.has(e);
-}
-
-function queueStashedOptimisticEffects(e) {
-    for (let t = e.k; t !== null; t = t.Ve) {
-        const e = t.xe;
-        if (!e.He) continue;
-        enqueueSub(e);
-    }
-}
-
-/**
- * Incomplete-transition finalization when the stashed transition holds
- * optimistic nodes: give plain optimistic signals one committed-view rerun.
- */ function stashOptimistic(e) {
-    stashedOptimisticReads = new Set;
-    for (let t = 0; t < e.G.length; t++) {
-        const n = e.G[t];
-        if (n.We || n.Fe & CONFIG_OWNED_WRITE) continue;
-        stashedOptimisticReads.add(n);
-        queueStashedOptimisticEffects(n);
-    }
-    try {
-        finalizePureQueue(null, true);
-    } finally {
-        stashedOptimisticReads = null;
-    }
-}
-
 /**
  * transitionComplete's override blockage: a settling transition stays open
  * while one of its optimistic nodes holds an active override that is still
@@ -2847,11 +2776,7 @@ function queueStashedOptimisticEffects(e) {
  */ function transitionBlocked(e) {
     for (let t = 0; t < e.G.length; t++) {
         const n = e.G[t];
-        if (hasActiveOverride(n) && "$e" in n && n.$e & STATUS_PENDING && n.Ue instanceof NotReadyError && 
-        // Mark-sourced pending never blocks settlement: affects() releases AT
-        // settle, so counting its sentinel here would deadlock the window it
-        // is scoped to.
-        !n.Ue.source?.Dt) {
+        if (hasActiveOverride(n) && "We" in n && n.We & STATUS_PENDING && n.me instanceof NotReadyError) {
             return true;
         }
     }
@@ -2869,10 +2794,10 @@ function resolveOptimisticNodes(e) {
         // Revert is a pure drop: there is no revert target to commit —
         // override-covered authoritative values hold in _pendingValue and
         // elevate on their OWN transition's schedule (A18 as re-ruled 2026-07-07).
-                if (!(t.$e & STATUS_PENDING)) t.$e &= ~STATUS_UNINITIALIZED;
+                if (!(t.We & STATUS_PENDING)) t.We &= ~STATUS_UNINITIALIZED;
         const r = t.A;
         t.A = NOT_PENDING;
-        if (r !== NOT_PENDING && t.Me !== unwrapOverride(r)) insertSubs(t, true);
+        if (r !== NOT_PENDING && t.xe !== unwrapOverride(r)) insertSubs(t, true);
         t.T = null;
         t.R = null;
     }
@@ -2881,9 +2806,9 @@ function resolveOptimisticNodes(e) {
     // transition that produced them (A19 — pending is a property of the data).
         for (let n = 0; n < t; n++) {
         const t = e[n];
-        if (t._ || t.O) GlobalQueue.Se(t);
+        if (t._ || t.O) GlobalQueue.fe(t);
         const r = t.t;
-        if (r && (r._ === t || r.O === t)) GlobalQueue.Se(r);
+        if (r && (r._ === t || r.O === t)) GlobalQueue.fe(r);
     }
     e.splice(0, t);
 }
@@ -2936,7 +2861,7 @@ function cleanupCompletedLanes(e) {
  * that reads a pending mid-transition write sees the committed value; the sub
  * is recorded for replay at commit.
  */ function gatedRead(e, t, n) {
-    if (latestReadActive || e.V === NOT_PENDING || e.We || t !== e && !(t.Qe & REACTIVE_MANUAL_WRITE)) {
+    if (latestReadActive || e.V === NOT_PENDING || e.Ve || t !== e && !(t.Le & REACTIVE_MANUAL_WRITE)) {
         return false;
     }
     activeTransition.q.add(n);
@@ -2947,7 +2872,7 @@ function cleanupCompletedLanes(e) {
  * read()'s value selection under a lane: return the committed `_value` for
  * optimistic/lane-assigned signals, stale-mode reads, and pending owners.
  */ function laneReadsCommitted(e, t, n) {
-    return e.A !== undefined || !!e.i || t === e && stale && n.t !== e || !!(t.$e & STATUS_PENDING);
+    return e.A !== undefined || !!e.i || t === e && stale && n.t !== e || !!(t.We & STATUS_PENDING);
 }
 
 /**
@@ -2956,12 +2881,12 @@ function cleanupCompletedLanes(e) {
  * can run before its OPT-dirty child propagates).
  */ function recomputeLane(e, t) {
     if (t) return resolveLane(e) ?? null;
-    for (let t = e.Ze; t; t = t.Xe) {
-        const n = t.ze;
-        if (n.Qe & REACTIVE_OPTIMISTIC_DIRTY) {
+    for (let t = e.Ke; t; t = t.Ye) {
+        const n = t.qe;
+        if (n.Le & REACTIVE_OPTIMISTIC_DIRTY) {
             const t = resolveLane(n);
             if (t) {
-                e.Qe |= REACTIVE_OPTIMISTIC_DIRTY;
+                e.Le |= REACTIVE_OPTIMISTIC_DIRTY;
                 assignOrMergeLane(e, t);
                 return t;
             }
@@ -2975,7 +2900,7 @@ function cleanupCompletedLanes(e) {
     if (t.o !== e) {
         t.u.add(e);
         e.i = t;
-        GlobalQueue.Ee !== null && GlobalQueue.Ee(t.o);
+        GlobalQueue.ce !== null && GlobalQueue.ce(t.o);
     }
 }
 
@@ -2983,7 +2908,7 @@ function cleanupCompletedLanes(e) {
     const t = resolveLane(e);
     if (t) {
         t.u.delete(e);
-        GlobalQueue.Ee !== null && GlobalQueue.Ee(t.o);
+        GlobalQueue.ce !== null && GlobalQueue.ce(t.o);
     }
 }
 
@@ -2998,21 +2923,19 @@ function trackOptimisticStore(e) {
  * create optimistic state (verdict.ts at module top level, createOptimistic
  * and createOptimisticStore at first call) BEFORE any optimistic node exists.
  */ function installOptimisticEngine() {
-    if (GlobalQueue.Ae !== null) return;
-    GlobalQueue.Ae = optimisticWrite;
-    GlobalQueue.he = resolveOptimisticNodes;
-    GlobalQueue.Ne = stashOptimistic;
-    GlobalQueue.ye = transitionBlocked;
-    GlobalQueue.Pe = cleanupCompletedLanes;
-    GlobalQueue.Ce = runLaneEffects;
-    GlobalQueue.ge = readStashed;
-    GlobalQueue.be = gatedRead;
-    GlobalQueue.De = laneSuspends;
-    GlobalQueue.me = laneReadsCommitted;
-    GlobalQueue.ve = recomputeLane;
-    GlobalQueue.we = laneAsyncPending;
-    GlobalQueue.Ge = laneAsyncSettled;
-    GlobalQueue.Le = trackOptimisticStore;
+    if (GlobalQueue.Oe !== null) return;
+    GlobalQueue.Oe = optimisticWrite;
+    GlobalQueue.Re = resolveOptimisticNodes;
+    GlobalQueue.Ie = transitionBlocked;
+    GlobalQueue.Ae = cleanupCompletedLanes;
+    GlobalQueue.he = runLaneEffects;
+    GlobalQueue.Ne = gatedRead;
+    GlobalQueue.ye = laneSuspends;
+    GlobalQueue.Ce = laneReadsCommitted;
+    GlobalQueue.Pe = recomputeLane;
+    GlobalQueue.ge = laneAsyncPending;
+    GlobalQueue.be = laneAsyncSettled;
+    GlobalQueue.De = trackOptimisticStore;
 }
 
 /**
@@ -3045,7 +2968,7 @@ let pendingProbe = null;
 function collectPendingSources(e) {
     if (!pendingProbe) return;
     pendingProbe.sources.add(e);
-    const t = e.Je || e;
+    const t = e.Be || e;
     if (t !== e) pendingProbe.sources.add(t);
 }
 
@@ -3059,34 +2982,76 @@ function collectPendingSources(e) {
     pendingProbe?.sources.add(e);
 }
 
+/**
+ * The affects() coverage walk — the read half of the dedicated mark channel.
+ * A node is covered by a live mark iff it carries one (`_affectsCount`) or
+ * derives, through its CURRENT deps (hopping store firewalls), from a node
+ * that does. Pull-based coverage means graph rewires, mid-window recomputes,
+ * and probe-triggered recomputes can never strand or strip a mark — there is
+ * nothing stored downstream to corrupt. Probe-created links
+ * (`_pendingObserver`) are skipped so an `isPending` wrapper memo never
+ * inherits the coverage it reports on.
+ */ function markWalk(e, t) {
+    if (e.F) return true;
+    // A real error outranks an inherited mark (A16/A24c): an errored node
+    // answers probes with its error, not a coverage verdict, and coverage does
+    // not flow through it — matching the rails' behavior, where propagation
+    // stopped at errored nodes. A DIRECT mark on an errored node still reads
+    // pending (the count check above), also matching.
+        if (e.We & STATUS_ERROR) return false;
+    if (t.has(e)) return false;
+    t.add(e);
+    const n = e.Be;
+    if (n && markWalk(n, t)) return true;
+    // Mid-recompute (the clearStatus companion poke runs before
+    // trimStaleDeps), only the validated prefix [_deps.._depsTail] is this
+    // pass's dependency set — walking past it would read dropped deps and
+    // latch a stale verdict on the companion.
+        const r = e;
+    const i = r.Le & REACTIVE_RECOMPUTING_DEPS ? r.ut : undefined;
+    if (i !== null) {
+        for (let e = r.Ke ?? null; e !== null; e = e.Ye) {
+            if (!e.Ot && markWalk(e.qe, t)) return true;
+            if (e === i) break;
+        }
+    }
+    return false;
+}
+
+/** Gated entry: apps with no live mark pay one integer compare. */ function markCovered(e) {
+    return activeAffectsMarks !== 0 && markWalk(e, new Set);
+}
+
 function quietPending(e) {
-    if (e.Be) {
-        for (const t of e.Be) if (!t.gt) return false;
+    if (e.$e) {
+        for (const t of e.$e) if (!t.Nt) return false;
         return true;
     }
-    return e.gt;
+    return e.Nt;
 }
 
 function newQuestionInFlight(e) {
-    return !!(e.$e & STATUS_PENDING) && !(e.$e & STATUS_UNINITIALIZED) && !quietPending(e);
+    return !!(e.We & STATUS_PENDING) && !(e.We & STATUS_UNINITIALIZED) && !quietPending(e);
 }
 
 function computePendingState(e) {
     const t = e;
-    if (t.Qe & REACTIVE_DISPOSED) return false;
-    if (e.F) return true;
-    const n = e.Je;
+    if (t.Le & REACTIVE_DISPOSED) return false;
+    // Mark coverage is transitive by dep-graph reachability: a latest() shadow
+    // reaches its owner (and a store leaf its firewall) through its own deps,
+    // so the one walk covers direct marks, derivation, and companion chains.
+        if (markCovered(e)) return true;
+    const n = e.Be;
     if (e.t) {
         const t = e.t;
-        if (t.F) return true;
-        const n = t.Je || t;
+        const n = t.Be || t;
         return newQuestionInFlight(n);
     }
     if (n && e.V !== NOT_PENDING && !hasActiveOverride(e)) {
-        return !!(n.Qe & REACTIVE_MANUAL_WRITE) || !n.dt && !(n.$e & STATUS_PENDING) || !!(n.$e & STATUS_PENDING) && quietPending(n);
+        return !!(n.Le & REACTIVE_MANUAL_WRITE) || !n.lt && !(n.We & STATUS_PENDING) || !!(n.We & STATUS_PENDING) && quietPending(n);
     }
-    if (e.V !== NOT_PENDING && !(t.$e & STATUS_UNINITIALIZED)) {
-        if (hasActiveOverride(e)) return !e.Ct || !e.Ct(e.V, unwrapOverride(e.A));
+    if (e.V !== NOT_PENDING && !(t.We & STATUS_UNINITIALIZED)) {
+        if (hasActiveOverride(e)) return !e.ht || !e.ht(e.V, unwrapOverride(e.A));
         return true;
     }
     return newQuestionInFlight(t);
@@ -3105,19 +3070,28 @@ function updatePendingSignal(e) {
 }
 
 function updateChildCompanions(e) {
-    for (let t = e.ut; t !== null; t = t.lt) {
+    for (let t = e.rt; t !== null; t = t.it) {
         if (t._ || t.O) updatePendingSignal(t);
     }
 }
 
-function repollDownstreamVerdicts(e) {
-    const t = new Set;
+/**
+ * Re-derive every verdict companion downstream of `el` (subs + firewall
+ * children, dedup'd). The affects() channel's poke walk: registration and
+ * re-ask flips use the live write path (companion setSignal — its own lane
+ * lets the wake escape an incomplete transition's effect stash, #2887);
+ * mark release passes `snap` because it runs inside queue finalization,
+ * where companion writes must land committed (a setSignal there would open
+ * a fresh override window that nothing settles).
+ */ function repollDownstreamVerdicts(e, t = false) {
+    const n = t ? snapCompanionsToState : updatePendingSignal;
+    const r = new Set;
     const visit = e => {
-        if (t.has(e)) return;
-        t.add(e);
-        if (e._ || e.O) updatePendingSignal(e);
-        for (let t = e.k; t !== null; t = t.Ve) visit(t.xe);
-        for (let t = e.ut ?? null; t !== null; t = t.lt) {
+        if (r.has(e)) return;
+        r.add(e);
+        if (e._ || e.O) n(e);
+        for (let t = e.k; t !== null; t = t.Ge) visit(t.Ue);
+        for (let t = e.rt ?? null; t !== null; t = t.it) {
             visit(t);
         }
     };
@@ -3128,8 +3102,8 @@ function snapCompanionsToState(e) {
     const t = e._;
     if (t && (t.A === undefined || t.A === NOT_PENDING)) {
         const n = computePendingState(e);
-        if (t.Me !== n || t.V !== NOT_PENDING) {
-            t.Me = n;
+        if (t.xe !== n || t.V !== NOT_PENDING) {
+            t.xe = n;
             t.V = NOT_PENDING;
             t.M = clock;
             insertSubs(t);
@@ -3137,9 +3111,9 @@ function snapCompanionsToState(e) {
         }
     }
     const n = e.O;
-    if (n && !(n.Qe & REACTIVE_DISPOSED)) {
-        if ((n.A === undefined || n.A === NOT_PENDING) && n.V === NOT_PENDING && !Object.is(n.Me, e.Me) && !(n.Qe & (REACTIVE_DIRTY | REACTIVE_CHECK))) {
-            n.Qe |= REACTIVE_DIRTY;
+    if (n && !(n.Le & REACTIVE_DISPOSED)) {
+        if ((n.A === undefined || n.A === NOT_PENDING) && n.V === NOT_PENDING && !Object.is(n.xe, e.xe) && !(n.Le & (REACTIVE_DIRTY | REACTIVE_CHECK))) {
+            n.Le |= REACTIVE_DIRTY;
             insertIntoHeap(n, queueFor(n));
             insertSubs(n);
             schedule();
@@ -3171,17 +3145,27 @@ function getLatestValueComputed(e) {
     const t = getLatestValueComputed(e);
     const n = latestReadActive;
     setLatestReadActive(false);
-    const r = e.A !== undefined && e.A !== NOT_PENDING ? unwrapOverride(e.A) : e.Me;
+    const r = e.A !== undefined && e.A !== NOT_PENDING ? unwrapOverride(e.A) : e.xe;
     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.ze >= e.C && !(t.Le & (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;
+        if (t instanceof NotReadyError && (!context || !(e.We & STATUS_UNINITIALIZED))) return r;
         throw t;
     } finally {
         setLatestReadActive(n);
     }
-    if (t.$e & STATUS_PENDING) return r;
+    if (t.We & STATUS_PENDING) return r;
     if (stale && currentOptimisticLane && t.i) {
         const e = findLane(t.i);
         const n = findLane(currentOptimisticLane);
@@ -3189,17 +3173,22 @@ 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;
 }
 
 /** The isPending()-probe read path, installed as GlobalQueue._pendingCheck. */ function pendingCheckRead(e, t, n, r) {
     setPendingCheckActive(false);
-    if (typeof e.We === "function") prepareComputed(e, true);
-    const i = n.$e;
+    if (typeof e.Ve === "function") prepareComputed(e, true);
+    const i = n.We;
     if (t && i & STATUS_PENDING && i & STATUS_UNINITIALIZED) {
         if (tracking && e !== t) link(e, t);
         setPendingCheckActive(true);
-        throw n.Ue;
+        throw n.me;
     }
     collectPendingSources(e);
     if (r) collectPendingSources(r);
@@ -3211,10 +3200,10 @@ function recordFreshRead(e, t) {
 }
 
 function applyReask(e, t) {
-    const n = !!(e.$e & STATUS_PENDING);
-    const r = t && !(n && !e.gt);
-    const i = n && e.gt !== r;
-    e.gt = r;
+    const n = !!(e.We & STATUS_PENDING);
+    const r = t && !(n && !e.Nt);
+    const i = n && e.Nt !== r;
+    e.Nt = r;
     return i;
 }
 
@@ -3254,7 +3243,7 @@ function isPending(e) {
     } catch (e) {
         collectPending();
         if (e instanceof NotReadyError) {
-            const t = !!(e.source?.$e & STATUS_UNINITIALIZED);
+            const t = !!(e.source?.We & STATUS_UNINITIALIZED);
             if (r.found && !t) return true;
             if (context && t) throw e;
         }
@@ -3268,25 +3257,25 @@ function isPending(e) {
 // Hook installation (same late-binding pattern as GlobalQueue._update /
 // _propagateAffects): core call sites fire these behind the same guards the
 // direct calls used, so behavior is identical once this module loads.
-GlobalQueue.fe = syncCompanions;
+GlobalQueue.le = syncCompanions;
 
-GlobalQueue.Ee = updatePendingSignal;
+GlobalQueue.ce = updatePendingSignal;
 
-GlobalQueue.de = updateChildCompanions;
+GlobalQueue.ae = updateChildCompanions;
 
-GlobalQueue.Se = snapCompanionsToState;
+GlobalQueue.fe = snapCompanionsToState;
 
-GlobalQueue.Te = latestRead;
+GlobalQueue.Ee = latestRead;
 
-GlobalQueue.pe = pendingCheckRead;
+GlobalQueue.Se = pendingCheckRead;
 
-GlobalQueue._e = recordFreshRead;
+GlobalQueue.de = recordFreshRead;
 
-GlobalQueue.Oe = applyReask;
+GlobalQueue.Te = applyReask;
 
-GlobalQueue.Re = repollDownstreamVerdicts;
+GlobalQueue.pe = repollDownstreamVerdicts;
 
-GlobalQueue.Ie = witnessAffects;
+GlobalQueue._e = witnessAffects;
 
 /**
  * Effects are the leaf nodes of our reactive graph. When their sources change, they are
@@ -3296,16 +3285,16 @@ GlobalQueue.Ie = witnessAffects;
     const i = !!r?.user;
     const o = createEffectNode(e, t, n, i ? EFFECT_USER : EFFECT_RENDER, notifyEffectStatus, r);
     recompute(o, true);
-    !r?.defer && (o.He === EFFECT_USER || r?.schedule ? o.et.enqueue(o.He, runEffect.bind(null, o)) : runEffect(o));
+    !r?.defer && (o.Qe === EFFECT_USER || r?.schedule ? o.Ze.enqueue(o.Qe, runEffect.bind(null, o)) : runEffect(o));
 }
 
 function notifyEffectStatus(e, t) {
     // Use passed values if provided, otherwise read from node
-    const n = e !== undefined ? e : this.$e;
-    const r = t !== undefined ? t : this.Ue;
+    const n = e !== undefined ? e : this.We;
+    const r = t !== undefined ? t : this.me;
     if (n & STATUS_ERROR) {
-        this.et.notify(this, STATUS_PENDING, 0);
-        if (this.He === EFFECT_USER) {
+        this.Ze.notify(this, STATUS_PENDING, 0);
+        if (this.Qe === EFFECT_USER) {
             // The error handler is the error arm of the effect phase (#2840 ruling):
             // queue it like the effect function. It runs in the same imperative,
             // writable scope, throws escalate the same way, and a held transition
@@ -3315,23 +3304,23 @@ function notifyEffectStatus(e, t) {
             // phase takes the success arm instead. Blocked forwards (explicit
             // `status` arg without node-state writes) don't queue: the status
             // re-propagates unblocked at commit.
-            if (this.$e & STATUS_ERROR) {
-                this.je = true;
-                this.et.enqueue(this.He, this.wt ??= runEffect.bind(null, this));
+            if (this.We & STATUS_ERROR) {
+                this.Fe = true;
+                this.Ze.enqueue(this.Qe, this.Pt ??= runEffect.bind(null, this));
             }
             return;
         }
-        if (!this.et.notify(this, STATUS_ERROR, STATUS_ERROR)) {
+        if (!this.Ze.notify(this, STATUS_ERROR, STATUS_ERROR)) {
             haltReactivity(unwrapStatusError(r));
             throw r;
         }
-    } else if (this.He === EFFECT_RENDER) {
-        this.et.notify(this, STATUS_PENDING | STATUS_ERROR, n, r);
+    } else if (this.Qe === EFFECT_RENDER) {
+        this.Ze.notify(this, STATUS_PENDING | STATUS_ERROR, n, r);
     }
 }
 
 function runEffect(e) {
-    if (!e.je || e.Qe & REACTIVE_DISPOSED) return;
+    if (!e.Fe || e.Le & REACTIVE_DISPOSED) return;
     // Error arm (#2840), user effects only: a compute-phase error that is still
     // the node's settled state at effect time runs the bundle's error handler in
     // this same imperative, writable scope. Unwrap the StatusError used for
@@ -3342,42 +3331,42 @@ function runEffect(e) {
     // Render effects bypass: their errors route to boundaries synchronously in
     // notifyEffectStatus, and a runner queued by an earlier valueChanged in the
     // same flush must not be hijacked by a later-arriving error status.
-        if (e.$e & STATUS_ERROR && e.He === EFFECT_USER) {
-        const t = unwrapStatusError(e.Ue);
-        e.Lt = e.Me;
-        e.je = false;
+        if (e.We & STATUS_ERROR && e.Qe === EFFECT_USER) {
+        const t = unwrapStatusError(e.me);
+        e.bt = e.xe;
+        e.Fe = false;
         try {
-            e.kt ? e.kt(t, () => {
-                const t = e._t;
-                e._t = undefined;
+            e.vt ? e.vt(t, () => {
+                const t = e.Et;
+                e.Et = undefined;
                 t?.();
             }) : console.error(t);
         } catch (t) {
-            if (!e.et.notify(e, STATUS_ERROR, STATUS_ERROR)) {
+            if (!e.Ze.notify(e, STATUS_ERROR, STATUS_ERROR)) {
                 haltReactivity(t);
                 throw t;
             }
         }
         return;
     }
-    const t = e._t;
-    e._t = undefined;
+    const t = e.Et;
+    e.Et = undefined;
     try {
         t?.();
-        const n = e.Ut(e.Me, e.Lt);
+        const n = e.Dt(e.xe, e.bt);
         if (false && n !== undefined && typeof n !== "function") ;
         // The final cleanup is invoked by disposeChildren at true disposal.
-                e._t = n;
+                e.Et = n;
     } catch (t) {
-        e.Ue = new StatusError(e, t);
-        e.$e |= STATUS_ERROR;
-        if (!e.et.notify(e, STATUS_ERROR, STATUS_ERROR)) {
+        e.me = new StatusError(e, t);
+        e.We |= STATUS_ERROR;
+        if (!e.Ze.notify(e, STATUS_ERROR, STATUS_ERROR)) {
             haltReactivity(t);
             throw t;
         }
     } finally {
-        e.Lt = e.Me;
-        e.je = false;
+        e.bt = e.xe;
+        e.Fe = false;
     }
 }
 
@@ -3389,39 +3378,39 @@ GlobalQueue.ee = runEffect;
  * Uses stale reads.
  */ function trackedEffect(e, t) {
     const run = () => {
-        if (!n.je || n.Qe & REACTIVE_DISPOSED) return;
+        if (!n.Fe || n.Le & REACTIVE_DISPOSED) return;
         try {
-            n.je = false;
+            n.Fe = false;
             recompute(n);
         } finally {}
     };
     const n = computed(() => {
-        const t = n._t;
-        n._t = undefined;
+        const t = n.Et;
+        n.Et = undefined;
         t?.();
         const r = staleValues(e);
-        n._t = r;
+        n.Et = r;
     }, {
         ...t,
         lazy: true
     });
-    n._t = undefined;
-    n.Fe = n.Fe & ~CONFIG_AUTO_DISPOSE | CONFIG_CHILDREN_FORBIDDEN;
-    n.je = true;
-    n.He = EFFECT_TRACKED;
-    n.bt = (e, t) => {
-        const r = e !== undefined ? e : n.$e;
+    n.Et = undefined;
+    n.ke = n.ke & ~CONFIG_AUTO_DISPOSE | CONFIG_CHILDREN_FORBIDDEN;
+    n.Fe = true;
+    n.Qe = EFFECT_TRACKED;
+    n.yt = (e, t) => {
+        const r = e !== undefined ? e : n.We;
         if (r & STATUS_ERROR) {
-            n.et.notify(n, STATUS_PENDING, 0);
-            const e = t !== undefined ? t : n.Ue;
-            if (!n.et.notify(n, STATUS_ERROR, STATUS_ERROR)) {
+            n.Ze.notify(n, STATUS_PENDING, 0);
+            const e = t !== undefined ? t : n.me;
+            if (!n.Ze.notify(n, STATUS_ERROR, STATUS_ERROR)) {
                 haltReactivity(unwrapStatusError(e));
                 throw e;
             }
         }
     };
-    n.tt = run;
-    n.et.enqueue(EFFECT_USER, run);
+    n.Xe = run;
+    n.Ze.enqueue(EFFECT_USER, run);
 }
 
 function restoreTransition(e, t) {
@@ -3432,6 +3421,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 +3511,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();
@@ -3564,7 +3591,7 @@ function accessor(e) {
 function createSignal(e, t) {
     if (typeof e === "function") {
         const n = computed(e, t);
-        n.Fe &= ~CONFIG_AUTO_DISPOSE;
+        n.ke &= ~CONFIG_AUTO_DISPOSE;
         return [ accessor(n), setMemo.bind(null, n) ];
     }
     const n = signal(e, t);
@@ -3738,6 +3765,12 @@ function createEffect(e, t, n) {
     };
 }
 
+/** Delivers effect applies on a microtask instead of queueing them (#2930). */ class MicrotaskQueue extends Queue {
+    enqueue(e, t) {
+        queueMicrotask(() => t(e));
+    }
+}
+
 /**
  * Awaits a reactive expression and returns its first fully-settled value as a
  * `Promise`. Pending async reads (`createMemo` returning a promise, etc.) are
@@ -3761,11 +3794,23 @@ function createEffect(e, t, n) {
  */ function resolve(e) {
     return new Promise((t, n) => {
         createRoot(r => {
+            // Deliver effect applies on a microtask instead of the owner queue: an
+            // incomplete transition stashes its effect queues until it settles, but
+            // an action yielding this promise is itself what keeps the transition
+            // open — the stashed res() deadlocked the action (#2930). The compute
+            // still runs in place (under the transaction's view when created inside
+            // an action step), and status/boundary notifications keep their normal
+            // route through the inherited queue.
+            const i = getOwner();
+            const o = new MicrotaskQueue;
+            o.Z = i.Ze;
+ // notify() forwards up the normal chain
+                        i.Ze = o;
             // A user effect rather than a bare computed: computeds are pull-based and
             // are only re-enqueued when a pending source *resolves* — a rejection just
             // marks them errored, so nothing would re-run and the promise would never
             // settle (#2842). The effect's error channel is notified on rejection.
-            effect(e, e => {
+                        effect(e, e => {
                 t(e);
                 r();
             }, e => {
@@ -3787,7 +3832,7 @@ function createOptimistic(e, t) {
     installOptimisticEngine();
     if (typeof e === "function") {
         const n = optimisticComputed(e, t);
-        n.Fe &= ~CONFIG_AUTO_DISPOSE;
+        n.ke &= ~CONFIG_AUTO_DISPOSE;
         return [ accessor(n), setSignal.bind(null, n) ];
     }
     const n = optimisticSignal(e, t);
@@ -3876,7 +3921,7 @@ function createOptimistic(e, t) {
  *   on owner disposal
  */ function onSettled(e) {
     const t = getOwner();
-    t && !(t.Fe & CONFIG_CHILDREN_FORBIDDEN) ? createTrackedEffect(() => untrack(e), undefined) : globalQueue.enqueue(EFFECT_USER, () => {
+    t && !(t.ke & CONFIG_CHILDREN_FORBIDDEN) ? createTrackedEffect(() => untrack(e), undefined) : globalQueue.enqueue(EFFECT_USER, () => {
         // Unowned, out-of-band fire (no owner, or a children-forbidden one this
         // one-shot must not bind to): a returned cleanup has no lifecycle to
         // attach to. Reject it in dev; in production the return is simply
@@ -4030,9 +4075,9 @@ function applyArrayItem(e, t, n, r, i) {
         if (!isWrappable(f)) continue;
         const E = (u.get(f) ?? storeLookup.get(f))?.[$TARGET];
         if (!E?.[STORE_DESC]) continue;
-        const d = unwrap(t[a]);
-        if (f === d || !isWrappable(d) || Array.isArray(f) !== Array.isArray(d) || i(f) != null && i(f) !== i(d)) continue;
-        applyState(d, wrap(f, n), i);
+        const S = unwrap(t[a]);
+        if (f === S || !isWrappable(S) || Array.isArray(f) !== Array.isArray(S) || i(f) != null && i(f) !== i(S)) continue;
+        applyState(S, wrap(f, n), i);
     }
 }
 
@@ -4066,7 +4111,7 @@ function applyStateFast(e, t, n) {
         let o = false;
         const s = r.length;
         if (e.length && s && isWrappable(e[0]) && n(e[0]) != null) {
-            let u, l, c, a, f, E, d, S;
+            let u, l, c, a, f, E, S, d;
             for (c = 0, a = Math.min(s, e.length); c < a && keyedMatch(E = r[c], e[c], n); c++) {
                 isWrappable(E) && isWrappable(e[c]) && applyState(e[c], wrap(E, t), n);
             }
@@ -4089,22 +4134,22 @@ function applyStateFast(e, t, n) {
                 s !== e.length && i?.length && setSignal(i.length, e.length);
                 return;
             }
-            d = new Array(f + 1);
+            S = new Array(f + 1);
             for (l = f; l >= c; l--) {
                 E = e[l];
-                S = itemKey(E, n);
-                u = p.get(S);
-                d[l] = u === undefined ? -1 : u;
-                p.set(S, l);
+                d = itemKey(E, n);
+                u = p.get(d);
+                S[l] = u === undefined ? -1 : u;
+                p.set(d, l);
             }
             for (u = c; u <= a; u++) {
                 E = r[u];
-                S = itemKey(E, n);
-                l = p.get(S);
+                d = itemKey(E, n);
+                l = p.get(d);
                 if (l !== undefined && l !== -1) {
                     T[l] = E;
-                    l = d[l];
-                    p.set(S, l);
+                    l = S[l];
+                    p.set(d, l);
                 }
             }
             for (l = c; l < e.length; l++) {
@@ -4173,17 +4218,17 @@ function applyStateSlow(e, t, n) {
         let u = false;
         const l = getOverrideValue(r, i, "length", o);
         if (e.length && l && isWrappable(e[0]) && n(e[0]) != null) {
-            let c, a, f, E, d, S, T, p;
-            for (f = 0, E = Math.min(l, e.length); f < E && keyedMatch(S = getOverrideValue(r, i, f, o), e[f], n); f++) {
-                isWrappable(S) && isWrappable(e[f]) && applyState(e[f], wrap(S, t), n);
+            let c, a, f, E, S, d, T, p;
+            for (f = 0, E = Math.min(l, e.length); f < E && keyedMatch(d = getOverrideValue(r, i, f, o), e[f], n); f++) {
+                isWrappable(d) && isWrappable(e[f]) && applyState(e[f], wrap(d, t), n);
             }
             const _ = new Array(e.length), O = new Map;
-            for (E = l - 1, d = e.length - 1; E >= f && d >= f && keyedMatch(S = getOverrideValue(r, i, E, o), e[d], n); E--, 
-            d--) {
-                _[d] = S;
+            for (E = l - 1, S = e.length - 1; E >= f && S >= f && keyedMatch(d = getOverrideValue(r, i, E, o), e[S], n); E--, 
+            S--) {
+                _[S] = d;
             }
-            if (f > d || f > E) {
-                for (a = f; a <= d; a++) {
+            if (f > S || f > E) {
+                for (a = f; a <= S; a++) {
                     u = true;
                     s?.[a] && setSignal(s[a], wrapValue(e[a], t));
                 }
@@ -4197,20 +4242,20 @@ function applyStateSlow(e, t, n) {
                 l !== r && s?.length && setSignal(s.length, r);
                 return;
             }
-            T = new Array(d + 1);
-            for (a = d; a >= f; a--) {
-                S = e[a];
-                p = itemKey(S, n);
+            T = new Array(S + 1);
+            for (a = S; a >= f; a--) {
+                d = e[a];
+                p = itemKey(d, n);
                 c = O.get(p);
                 T[a] = c === undefined ? -1 : c;
                 O.set(p, a);
             }
             for (c = f; c <= E; c++) {
-                S = getOverrideValue(r, i, c, o);
-                p = itemKey(S, n);
+                d = getOverrideValue(r, i, c, o);
+                p = itemKey(d, n);
                 a = O.get(p);
                 if (a !== undefined && a !== -1) {
-                    _[a] = S;
+                    _[a] = d;
                     a = T[a];
                     O.set(p, a);
                 }
@@ -4248,12 +4293,12 @@ function applyStateSlow(e, t, n) {
             const a = l[c];
             const f = s[a];
             const E = unwrap(getOverrideValue(r, i, a, o));
-            let d = unwrap(e[a]);
-            if (E === d) continue;
-            if (!E || !isWrappable(E) || !isWrappable(d) || Array.isArray(E) !== Array.isArray(d) || n(E) != null && n(E) !== n(d)) {
+            let S = unwrap(e[a]);
+            if (E === S) continue;
+            if (!E || !isWrappable(E) || !isWrappable(S) || Array.isArray(E) !== Array.isArray(S) || n(E) != null && n(E) !== n(S)) {
                 u && setSignal(u, void 0);
-                f && setSignal(f, isWrappable(d) ? wrap(d, t) : d);
-            } else applyState(d, wrap(E, t), n);
+                f && setSignal(f, isWrappable(S) ? wrap(S, t) : S);
+            } else applyState(S, wrap(E, t), n);
         }
     }
     if (!u && t[STORE_DESC]) applyDescendants(r, e, t, s, n, i, o);
@@ -4323,7 +4368,7 @@ function createProjectionInternal(e, t, n) {
         if (!r) r = getOwner();
         runProjectionComputed(o, e, n?.key || "id");
     }, undefined);
-    r.Fe &= ~CONFIG_AUTO_DISPOSE;
+    r.ke &= ~CONFIG_AUTO_DISPOSE;
     return {
         store: o,
         node: r
@@ -4392,7 +4437,7 @@ function createProjectionInternal(e, t, n) {
     const o = getOwner();
     let s = false;
     let u;
-    const l = new Proxy(e, createWriteTraps(() => !s || o.dt === u, i));
+    const l = new Proxy(e, createWriteTraps(() => !s || o.lt === u, i));
     storeSetter(l, i => {
         u = t(i);
         s = true;
@@ -4599,7 +4644,7 @@ function ownEnumerableKeysPlain(e) {
  * The value a store leaf's backing signal currently shows to readers: active
  * override, else held pending value, else committed value.
  */ function visibleNodeValue(e) {
-    return e.A !== undefined && e.A !== NOT_PENDING ? unwrapOverride(e.A) : e.V !== NOT_PENDING ? e.V : e.Me;
+    return e.A !== undefined && e.A !== NOT_PENDING ? unwrapOverride(e.A) : e.V !== NOT_PENDING ? e.V : e.xe;
 }
 
 function hasOwnStoreProperty(e, t) {
@@ -4654,7 +4699,7 @@ function getNode(e, t, n, r, i = isEqual, o) {
     }
     if (o && n in o) {
         const e = o[n];
-        s.ke = e === undefined ? NO_SNAPSHOT : e;
+        s.we = e === undefined ? NO_SNAPSHOT : e;
         snapshotSources?.add(s);
     }
     if (typeof n === "symbol" && n !== $TRACK && n !== $AFFECTS) symbolKeyedRecords.add(t);
@@ -4684,7 +4729,7 @@ function getNode(e, t, n, r, i = isEqual, o) {
     // A live scope exists, so affects.ts already installed the mark engine.
     for (const [r, i] of affectsScopes) {
         if (r.F && i.scope.has(t) && (i.key === undefined || i.key === n)) {
-            GlobalQueue.oe(e);
+            GlobalQueue.ie(e);
             i.inherited.push(e);
         }
     }
@@ -4772,11 +4817,11 @@ i) {
     // Callers guard on `pendingCheckActive`, which only flips inside
     // isPending() — the verdict layer is loaded and its hook installed.
     const n = e[STORE_NODE]?.[$AFFECTS];
-    if (n?.F) GlobalQueue.Ie(n);
+    if (n?.F) GlobalQueue._e(n);
     if (affectsScopes.size) {
         const r = e[STORE_VALUE];
         for (const [e, i] of affectsScopes) {
-            if (e !== n && e.F && i.scope.has(r) && (i.key === undefined || i.key === t)) GlobalQueue.Ie(e);
+            if (e !== n && e.F && i.scope.has(r) && (i.key === undefined || i.key === t)) GlobalQueue._e(e);
         }
     }
 }
@@ -4797,7 +4842,7 @@ i) {
         const t = affectsScopes.get(e);
         if (!t) return;
         affectsScopes.delete(e);
-        for (let e = 0; e < t.inherited.length; e++) GlobalQueue.se(t.inherited[e]);
+        for (let e = 0; e < t.inherited.length; e++) GlobalQueue.oe(t.inherited[e]);
     };
     if (t === undefined) {
         const t = getNode(e, n, $AFFECTS, undefined, false);
@@ -4924,7 +4969,7 @@ function prepareStoreWrite(e, t, n) {
     }
     const r = e[STORE_VALUE];
     const i = r[n];
-    if (snapshotCaptureActive && typeof n !== "symbol" && !((e[STORE_FIREWALL]?.$e ?? 0) & STATUS_PENDING)) {
+    if (snapshotCaptureActive && typeof n !== "symbol" && !((e[STORE_FIREWALL]?.We ?? 0) & STATUS_PENDING)) {
         if (!e[STORE_SNAPSHOT_PROPS]) {
             e[STORE_SNAPSHOT_PROPS] = Object.create(null);
             snapshotSources?.add(e);
@@ -4952,7 +4997,7 @@ function prepareStoreWrite(e, t, n) {
     // STORE_OPTIMISTIC is only set by createOptimisticStore, which installs the
     // optimistic engine before wrapping.
     if (e[STORE_OPTIMISTIC] && !projectionWriteActive) {
-        GlobalQueue.Le(t);
+        GlobalQueue.De(t);
     }
 }
 
@@ -5025,7 +5070,7 @@ let Writing = null;
  * itself (the derive function works its own draft while uninitialized).
  */ function throwIfUninitialized(e) {
     const t = e[STORE_FIREWALL];
-    if (t && t.$e & STATUS_UNINITIALIZED) throw t.Ue ?? new NotReadyError(t);
+    if (t && t.We & STATUS_UNINITIALIZED) throw t.me ?? new NotReadyError(t);
 }
 
 const storeTraps = {
@@ -5118,9 +5163,9 @@ const storeTraps = {
                 // throws). #2769
                                 const f = typeof t === "string" ? Number(t) : -1;
                 const E = Array.isArray(s) && Number.isInteger(f) && f >= 0 && f < 4294967295 && String(f) === t;
-                const d = E ? f + 1 : 0;
-                const S = E && (getOverlayLayer(e, "length") ?? s).length;
-                const T = E && d > S ? d : undefined;
+                const S = E ? f + 1 : 0;
+                const d = E && (getOverlayLayer(e, "length") ?? s).length;
+                const T = E && S > d ? S : undefined;
                 if (l === a && T === undefined) return true;
                 armOptimisticStoreWrite(e, r);
                 if (a !== undefined && a === i && T === undefined) {
@@ -5156,7 +5201,7 @@ const storeTraps = {
                     if (t.length) {
                         setSignal(t.length, T);
                     } else if (!projectionWriteActive && !e[STORE_OPTIMISTIC]) {
-                        const n = upsertStoreNode(e, t, "length", S, e[STORE_SNAPSHOT_PROPS]);
+                        const n = upsertStoreNode(e, t, "length", d, e[STORE_SNAPSHOT_PROPS]);
                         setSignal(n, T);
                     }
                 }
@@ -5312,126 +5357,76 @@ function createStore(e, t, n) {
     } : e => storeSetter(i, e) ];
 }
 
-/**
- * The pending-source identity of a live `affects()` mark on `node` (lazy,
- * one per node, shared by overlapping registrations via the refcount).
- *
- * A mark rides the SAME status rails as real in-flight async — downstream
- * subscribers hold the sentinel in `_pendingSources` — but under its own
- * identity so the two channels can't clear each other:
- * - `_reask` is permanently `false`: a mark is by definition a declared
- *   value change, so `quietPending` never silences a window it participates
- *   in — even when the mark rides over an otherwise-quiet `refresh()`
- *   re-ask of the same node (the whole point of declaring one).
- * - A landing on the marked node settles only the node's OWN source entry;
- *   the sentinel entry survives until the mark's transaction releases it.
- * - The sentinel itself never carries `STATUS_PENDING`, so
- *   `transitionComplete` never counts a mark as a blocker of its own
- *   transaction (release happens AT settle — self-blocking would deadlock),
- *   and reads of the marked node never throw (marks are value-transparent
- *   at the source; pendingness is what propagates).
- */ function getAffectsSentinel(e) {
-    return e.Vt ??= {
-        Qt: undefined,
-        // Brand + backref: lets the scheduler's settlement checks recognize
-        // mark-sourced pending (which must never block its own transaction —
-        // release happens AT settle).
-        Dt: e,
-        Qe: 0,
-        $e: 0,
-        gt: false,
-        Ue: undefined,
-        k: null,
-        Ze: null
-    };
-}
-
-/**
- * Push a live mark's pendingness downstream from the marked node through the
- * normal status rails. Runs on every registration (dedup in `notifyStatus`
- * stops re-descent at already-covered subscribers). Subscribers that
- * recompute mid-window shed this via `clearStatus` and re-acquire it through
- * the read path (`applyAffectsReads` for direct readers of the marked node,
- * `collectMarkSources` transitively) — the mark analogue of real async's
- * re-throw-on-read. Subscribers are deliberately NOT queued as pending nodes
- * (#2893): they hold no value needing a transition-scheduled commit, and
- * queueing would stamp the marking action's transaction onto them — from then
- * on ANY write dirtying one of them (including writes to unmarked signals
- * that merely share a downstream memo) would be captured and frozen until the
- * action settles.
- */ function propagateAffectsMark(e) {
-    if (!e.k && !e.ut) return;
-    const t = getAffectsSentinel(e);
-    const n = new NotReadyError(t);
-    forEachDependent(e, e => {
-        if (!e.Be?.has(t)) {
-            notifyStatus(e, STATUS_PENDING, n);
-        }
-    });
-}
-
-/**
- * Re-establish mark pendingness on a computed that read marked sources
- * during its recompute (`clearStatus` at the top of the commit path wiped
- * any sentinel entries it held). Called by `recompute` after the commit —
- * not before, because setting `_error` earlier would make the commit path
- * treat the node as errored and skip the value write.
- */ function applyAffectsReads(e, t) {
-    let n = false;
-    for (let r = 0; r < t.length; r++) {
-        const i = t[r];
-        if (!i.F) continue;
-        const o = getAffectsSentinel(i);
-        if (addPendingSource(e, o)) {
-            e.$e |= STATUS_PENDING;
-            setPendingError(e, o);
-            n = true;
-        }
-    }
-    if (n && GlobalQueue.Ee !== null) GlobalQueue.Ee(e);
-}
-
 /**
  * The counting half of a mark, shared by direct registration and store-scope
- * inheritance (a node created inside a live keyless mark's identity scope):
- * bumps the refcount and pokes the node's verdict companions so an
- * already-materialized `false` flips reactively.
+ * inheritance (a node created inside a live keyless mark's identity scope).
+ * A mark is ONLY this count: coverage of everything derived from the node is
+ * pull-derived by the verdict layer's `markWalk` (dep-graph reachability), so
+ * nothing is stored downstream and nothing can be stranded or stripped by
+ * mid-window recomputes.
  */ function markAffects(e) {
     e.F = (e.F || 0) + 1;
     shiftAffectsMarks(1);
-    // Companions only exist once the verdict layer (isPending/latest) loaded;
-    // without them there is no materialized verdict to flip.
-        if (e.F === 1 && GlobalQueue.Ee !== null) GlobalQueue.Ee(e);
+}
+
+/**
+ * Boundary visual channel: within a transaction, a live mark holds Loading
+ * fallbacks / reveal ordering the way real in-flight async would — but the
+ * notification is tagged visibility-only at the source (`_markVisual`), so
+ * the root queue never registers reporters from it: marks are invisible to
+ * ALL completion and settlement accounting by construction. Boundaries hold
+ * the marked node in `_sources` while `_affectsCount` is live; the release
+ * sweep (finalizePureQueue re-checks boundary children after mark release)
+ * is the display-state update point. Ambient marks release inside the same
+ * flush that would surface them, before effects run — verdict-only, netting
+ * no visual change.
+ */ function notifyMarkBoundaries(e) {
+    if (!e.k && !e.rt) return;
+    const t = new NotReadyError(e);
+    t.ve = true;
+    const n = new Set;
+    const visit = e => {
+        if (n.has(e)) return;
+        n.add(e);
+        // Display consumers (render effects, boundary computeds) act on the
+        // notification; descent stops there, exactly like the status rails.
+                if (e.yt) {
+            e.yt(STATUS_PENDING, t);
+            return;
+        }
+        forEachDependent(e, visit);
+    };
+    forEachDependent(e, visit);
 }
 
 /**
  * Registers one `affects()` mark on a node: counts it, records the
  * registration with the current transaction (after initTransition the queue's
- * batch IS the active transition, mirroring `_optimisticNodes`), and
- * propagates STATUS_PENDING downstream on the status rails so everything
- * DERIVED from the marked data reads pending too. Propagation runs on every
- * registration (not just the first): subscribers gained since an earlier
- * overlapping registration get covered, and dedup stops re-descent early.
+ * batch IS the active transition, mirroring `_optimisticNodes`), re-derives
+ * every downstream verdict companion (the mark channel's only push — verdict
+ * pokes, not state), and notifies boundary display state. Both walks run on
+ * every registration (not just the first): subscribers gained since an
+ * earlier overlapping registration get covered, and dedup stops re-descent.
  */ function registerAffectsMark(e) {
     markAffects(e);
     globalQueue.D.L.push(e);
-    propagateAffectsMark(e);
+    // Companions only exist once the verdict layer (isPending/latest) loaded;
+    // without them there is no materialized verdict to poke.
+        GlobalQueue.pe !== null && GlobalQueue.pe(e);
+    notifyMarkBoundaries(e);
     schedule();
 }
 
 /**
- * Releases one registration. When the node's last mark drops, settles the
- * mark's sentinel out of every downstream `_pendingSources` (waking blocked
- * nodes and re-deriving verdicts along the walk). Companion writes go through
- * the settlement snap (committed, not transition-scoped) so releasing a mark
- * can't open a fresh override window that would itself need settlement.
+ * Releases one registration. When the node's last mark drops, re-derives
+ * every downstream verdict through the settlement snap (committed, not
+ * transition-scoped — release runs inside queue finalization, where a
+ * setSignal would open a fresh override window that nothing settles).
  */ function releaseAffectsMark(e) {
     shiftAffectsMarks(-1);
     e.F--;
     if (!e.F) {
-        const t = e.Vt;
-        if (t) settlePendingSource(e, t, true);
-        GlobalQueue.Se !== null && GlobalQueue.Se(e);
+        GlobalQueue.pe !== null && GlobalQueue.pe(e, true);
         GlobalQueue.ne?.(e);
     }
 }
@@ -5444,58 +5439,16 @@ function createStore(e, t, n) {
     e.length = 0;
 }
 
-/**
- * True when a node's pending status comes ONLY from affects() sentinels. A
- * mark is a promise of change, not an absence of value: reads of mark-pended
- * derived nodes stay value-transparent (verdicts report pending; the read
- * path must not suspend). Any real async source among the pending sources
- * keeps normal suspension semantics. Core's read path reaches this through
- * `GlobalQueue._onlyMarkPending`, gated on the `activeAffectsMarks` counter.
- */ function onlyMarkPending(e) {
-    const t = e.Be;
-    if (t) {
-        for (const e of t) if (!e.Dt) return false;
-        return true;
-    }
-    return false;
-}
-
-/**
- * Collect the still-live marked nodes behind a pended owner's sentinel
- * sources into a recompute's `affectsReads`. This is the transitive half of
- * read-path re-establishment (#2893): real async re-establishes at every
- * derivation level because its re-throw on read re-registers the source, but
- * mark-pended reads are value-transparent — without this, pendingness dies on
- * the first mid-window recompute past depth one, and the isPending() probe
- * itself (whose prepare step recomputes retryable NotReady holders) strips
- * the very status it reports on. Reached through
- * `GlobalQueue._collectMarkSources`, gated on `activeAffectsMarks`.
- */ function collectMarkSources(e, t) {
-    if (e.Be) {
-        for (const n of e.Be) {
-            const e = n.Dt;
-            if (e && e.F) t.push(e);
-        }
-    }
-}
-
 // Late installation (same pattern as `GlobalQueue._update`): the mark engine
 // lives with the feature so graphs that never declare a mark never ship it.
-// Each call site is gated by state only this module creates (`markedReads`
-// collection under `activeAffectsMarks`, a non-empty `_affectsNodes` batch,
-// a live scope in the store's `affectsScopes`), so the hooks are installed
-// before the first time any of them can fire.
-GlobalQueue.re = applyAffectsReads;
-
-GlobalQueue.ie = releaseAffectsMarks;
-
-GlobalQueue.oe = markAffects;
+// Each call site is gated by state only this module creates (a non-empty
+// `_affectsNodes` batch, a live scope in the store's `affectsScopes`), so the
+// hooks are installed before the first time any of them can fire.
+GlobalQueue.re = releaseAffectsMarks;
 
-GlobalQueue.se = releaseAffectsMark;
+GlobalQueue.ie = markAffects;
 
-GlobalQueue.ue = onlyMarkPending;
-
-GlobalQueue.le = collectMarkSources;
+GlobalQueue.oe = releaseAffectsMark;
 
 function affects(e, t) {
     const n = e?.[$TARGET];
@@ -5595,8 +5548,8 @@ function clearOptimisticStores(e, t) {
                 c.A = NOT_PENDING;
                 c.R = null;
                 c.V = NOT_PENDING;
-                c.Me = i;
-                if (!c.Ct || !c.Ct(o, i)) {
+                c.xe = i;
+                if (!c.ht || !c.ht(o, i)) {
                     insertSubs(c, true);
                     schedule();
                 }
@@ -5668,7 +5621,7 @@ function createOptimisticProjectionInternal(e, t, n) {
                 setProjectionWriteActive(false);
             }
         }, undefined);
-        r.Fe &= ~CONFIG_AUTO_DISPOSE;
+        r.ke &= ~CONFIG_AUTO_DISPOSE;
     }
     return {
         store: o,
@@ -6080,24 +6033,24 @@ function mapArray(e, t, n) {
     const i = t.length > 1;
     const o = t;
     const s = {
-        xt: createOwner(),
-        Ft: 0,
-        Wt: e,
-        Mt: [],
-        Ht: o,
-        jt: [],
-        $t: [],
-        Kt: r,
-        Yt: r || n?.keyed === false ? [] : undefined,
-        qt: i && n?.keyed !== false ? [] : undefined,
-        Bt: n?.keyed === false,
-        Zt: n?.fallback
+        wt: createOwner(),
+        Gt: 0,
+        Lt: e,
+        Ut: [],
+        kt: o,
+        Vt: [],
+        xt: [],
+        Qt: r,
+        Ft: r || n?.keyed === false ? [] : undefined,
+        Wt: i && n?.keyed !== false ? [] : undefined,
+        Mt: n?.keyed === false,
+        Ht: n?.fallback
     };
     const u = computed(updateKeyedMap.bind(s));
     // Untracked reads inside the internal owner resolve via _parentComputed; routing
     // them through node lets store-proxy lookups see pending writes (not stale _value).
-        s.xt.it = u;
-    u.Fe &= ~CONFIG_AUTO_DISPOSE;
+        s.wt.et = u;
+    u.ke &= ~CONFIG_AUTO_DISPOSE;
     return accessor(u);
 }
 
@@ -6115,52 +6068,52 @@ const pureOptions = {
 // strong-abort ordering: removed rows now dispose AFTER the pass's new rows
 // are created (you cannot destroy state before knowing the pass will land).
 function updateKeyedMap() {
-    const e = this.Wt() || [], t = e.length;
+    const e = this.Lt() || [], t = e.length;
     e[$TRACK];
  // top level tracking
-        runWithOwner(this.xt, () => {
+        runWithOwner(this.wt, () => {
         let n, r, i, o, 
         // Mappers write freshly-created row/index signals into the STAGE
         // arrays (`rows`/`indexes`), never into `this._rows`/`this._indexes`.
-        s = this.Yt ? this.Bt ? () => {
+        s = this.Ft ? this.Mt ? () => {
             i[r] = signal(e[r], pureOptions);
-            return this.Ht(accessor(i[r]), r);
+            return this.kt(accessor(i[r]), r);
         } : () => {
             i[r] = signal(e[r], pureOptions);
             o && (o[r] = signal(r, pureOptions));
-            return this.Ht(accessor(i[r]), o ? accessor(o[r]) : undefined);
-        } : this.qt ? () => {
+            return this.kt(accessor(i[r]), o ? accessor(o[r]) : undefined);
+        } : this.Wt ? () => {
             const t = e[r];
             o[r] = signal(r, pureOptions);
-            return this.Ht(t, accessor(o[r]));
+            return this.kt(t, accessor(o[r]));
         } : () => {
             const t = e[r];
-            return this.Ht(t);
+            return this.kt(t);
         };
         // fast path for empty arrays
                 if (t === 0) {
-            if (this.Ft !== 0) {
-                this.xt.dispose(false);
-                this.$t = [];
-                this.Mt = [];
-                this.jt = [];
-                this.Ft = 0;
-                this.Yt && (this.Yt = []);
-                this.qt && (this.qt = []);
+            if (this.Gt !== 0) {
+                this.wt.dispose(false);
+                this.xt = [];
+                this.Ut = [];
+                this.Vt = [];
+                this.Gt = 0;
+                this.Ft && (this.Ft = []);
+                this.Wt && (this.Wt = []);
             }
-            if (this.Zt && !this.jt[0]) {
+            if (this.Ht && !this.Vt[0]) {
                 // an aborted fallback attempt leaves an owner without a mapping;
                 // dispose it before re-creating
-                this.$t[0]?.dispose();
-                this.jt[0] = runWithOwner(this.$t[0] = createOwner(), this.Zt);
+                this.xt[0]?.dispose();
+                this.Vt[0] = runWithOwner(this.xt[0] = createOwner(), this.Ht);
             }
         }
         // fast path for new create
-         else if (this.Ft === 0) {
+         else if (this.Gt === 0) {
             const u = new Array(t);
             const l = new Array(t);
-            i = this.Yt && new Array(t);
-            o = this.qt && new Array(t);
+            i = this.Ft && new Array(t);
+            o = this.Wt && new Array(t);
             try {
                 for (r = 0; r < t; r++) u[r] = runWithOwner(l[r] = createOwner(), s);
             } catch (e) {
@@ -6168,53 +6121,53 @@ function updateKeyedMap() {
                 throw e;
             }
             // commit
-                        if (this.$t[0]) this.$t[0].dispose();
+                        if (this.xt[0]) this.xt[0].dispose();
  // previous fallback
-                        this.jt = u;
-            this.$t = l;
-            i && (this.Yt = i);
-            o && (this.qt = o);
-            this.Mt = e.slice(0);
-            this.Ft = t;
+                        this.Vt = u;
+            this.xt = l;
+            i && (this.Ft = i);
+            o && (this.Wt = o);
+            this.Ut = e.slice(0);
+            this.Gt = t;
         } else {
-            let u, l, c, a, f, E, d, S, T, p = new Array(t), _ = new Array(t);
-            i = this.Yt ? new Array(t) : undefined;
-            o = this.qt ? new Array(t) : undefined;
+            let u, l, c, a, f, E, S, d, T, p = new Array(t), _ = new Array(t);
+            i = this.Ft ? new Array(t) : undefined;
+            o = this.Wt ? new Array(t) : undefined;
             // skip common prefix
-                        for (u = 0, l = Math.min(this.Ft, t); u < l && (this.Mt[u] === e[u] || this.Yt && compare(this.Kt, this.Mt[u], e[u])); u++) {
-                if (this.Yt) setSignal(this.Yt[u], e[u]);
+                        for (u = 0, l = Math.min(this.Gt, t); u < l && (this.Ut[u] === e[u] || this.Ft && compare(this.Qt, this.Ut[u], e[u])); u++) {
+                if (this.Ft) setSignal(this.Ft[u], e[u]);
             }
             // common suffix
-                        for (l = this.Ft - 1, c = t - 1; l >= u && c >= u && (this.Mt[l] === e[c] || this.Yt && compare(this.Kt, this.Mt[l], e[c])); l--, 
+                        for (l = this.Gt - 1, c = t - 1; l >= u && c >= u && (this.Ut[l] === e[c] || this.Ft && compare(this.Qt, this.Ut[l], e[c])); l--, 
             c--) {
-                p[c] = this.jt[l];
-                _[c] = this.$t[l];
-                i && (i[c] = this.Yt[l]);
-                o && (o[c] = this.qt[l]);
+                p[c] = this.Vt[l];
+                _[c] = this.xt[l];
+                i && (i[c] = this.Ft[l]);
+                o && (o[c] = this.Wt[l]);
             }
             // 0) prepare a map of all indices in newItems, scanning backwards so we encounter them in natural order
                         E = new Map;
-            d = new Array(c + 1);
+            S = new Array(c + 1);
             for (r = c; r >= u; r--) {
                 a = e[r];
-                f = this.Kt ? this.Kt(a) : a;
+                f = this.Qt ? this.Qt(a) : a;
                 n = E.get(f);
-                d[r] = n === undefined ? -1 : n;
+                S[r] = n === undefined ? -1 : n;
                 E.set(f, r);
             }
             // 1) step through all old items and see if they can be found in the new set; if so, save them in a temp array and mark them moved; if not, queue them for disposal at commit
                         for (n = u; n <= l; n++) {
-                a = this.Mt[n];
-                f = this.Kt ? this.Kt(a) : a;
+                a = this.Ut[n];
+                f = this.Qt ? this.Qt(a) : a;
                 r = E.get(f);
                 if (r !== undefined && r !== -1) {
-                    p[r] = this.jt[n];
-                    _[r] = this.$t[n];
-                    i && (i[r] = this.Yt[n]);
-                    o && (o[r] = this.qt[n]);
-                    r = d[r];
+                    p[r] = this.Vt[n];
+                    _[r] = this.xt[n];
+                    i && (i[r] = this.Ft[n]);
+                    o && (o[r] = this.Wt[n]);
+                    r = S[r];
                     E.set(f, r);
-                } else (S ??= []).push(this.$t[n]);
+                } else (d ??= []).push(this.xt[n]);
             }
             // 2) create new rows into the temp arrays; an abort disposes only these
                         try {
@@ -6229,25 +6182,25 @@ function updateKeyedMap() {
             }
             // 3) commit: land positions, then dispose exited rows
                         for (r = u; r < t; r++) {
-                this.jt[r] = p[r];
-                this.$t[r] = _[r];
+                this.Vt[r] = p[r];
+                this.xt[r] = _[r];
                 if (i) {
-                    this.Yt[r] = i[r];
-                    setSignal(this.Yt[r], e[r]);
+                    this.Ft[r] = i[r];
+                    setSignal(this.Ft[r], e[r]);
                 }
                 if (o) {
-                    this.qt[r] = o[r];
-                    setSignal(this.qt[r], r);
+                    this.Wt[r] = o[r];
+                    setSignal(this.Wt[r], r);
                 }
             }
-            if (S) for (n = 0; n < S.length; n++) S[n].dispose();
+            if (d) for (n = 0; n < d.length; n++) d[n].dispose();
             // 4) in case the new set is shorter than the old, set the length of the mapped array
-                        this.jt = this.jt.slice(0, this.Ft = t);
+                        this.Vt = this.Vt.slice(0, this.Gt = t);
             // 5) save a copy of the mapped items for the next update
-                        this.Mt = e.slice(0);
+                        this.Ut = e.slice(0);
         }
     });
-    return this.jt;
+    return this.Vt;
 }
 
 /**
@@ -6267,22 +6220,22 @@ function updateKeyedMap() {
  */ function repeat(e, t, n) {
     const r = t;
     const i = {
-        xt: createOwner(),
-        Ft: 0,
-        Xt: 0,
-        zt: e,
-        Ht: r,
-        $t: [],
-        jt: [],
-        Jt: n?.from,
-        Zt: n?.fallback
+        wt: createOwner(),
+        Gt: 0,
+        jt: 0,
+        $t: e,
+        kt: r,
+        xt: [],
+        Vt: [],
+        Kt: n?.from,
+        Ht: n?.fallback
     };
     const o = computed(updateRepeat.bind(i));
     // Same as mapArray: untracked reads inside the internal owner resolve via
     // _parentComputed, so async reads in row callbacks register with the node
     // (pending tracking + post-settle retry) instead of vanishing.
-        i.xt.it = o;
-    o.Fe &= ~CONFIG_AUTO_DISPOSE;
+        i.wt.et = o;
+    o.ke &= ~CONFIG_AUTO_DISPOSE;
     return accessor(o);
 }
 
@@ -6294,55 +6247,55 @@ function updateKeyedMap() {
 // for the post-settle retry. The overlap math also subsumes the previous
 // disjoint-window/front-clear/end-clear/shift special cases.
 function updateRepeat() {
-    const e = this.zt();
-    const t = this.Jt?.() || 0;
-    runWithOwner(this.xt, () => {
+    const e = this.$t();
+    const t = this.Kt?.() || 0;
+    runWithOwner(this.wt, () => {
         if (e === 0) {
-            if (this.Ft !== 0) {
-                this.xt.dispose(false);
-                this.$t = [];
-                this.jt = [];
-                this.Ft = 0;
+            if (this.Gt !== 0) {
+                this.wt.dispose(false);
+                this.xt = [];
+                this.Vt = [];
+                this.Gt = 0;
                 // Reset offset to match the cleared data (#2767, repro 2).
-                                this.Xt = 0;
+                                this.jt = 0;
             }
-            if (this.Zt && !this.jt[0]) {
+            if (this.Ht && !this.Vt[0]) {
                 // an aborted fallback attempt leaves an owner without a mapping;
                 // dispose it before re-creating
-                this.$t[0]?.dispose();
-                this.jt[0] = runWithOwner(this.$t[0] = createOwner(), this.Zt);
+                this.xt[0]?.dispose();
+                this.Vt[0] = runWithOwner(this.xt[0] = createOwner(), this.Ht);
             }
             return;
         }
         const n = t + e;
-        const r = this.Xt + this.Ft;
+        const r = this.jt + this.Gt;
         // Retained overlap [keepStart, keepEnd) in global indexes; empty when the
         // windows are disjoint or when coming from empty/fallback.
-                const i = Math.max(t, this.Xt);
+                const i = Math.max(t, this.jt);
         const o = Math.min(n, r);
         const s = new Array(e);
         const u = new Array(e);
         for (let e = i; e < o; e++) {
-            u[e - t] = this.$t[e - this.Xt];
-            s[e - t] = this.jt[e - this.Xt];
+            u[e - t] = this.xt[e - this.jt];
+            s[e - t] = this.Vt[e - this.jt];
         }
         try {
             for (let e = t; e < n; e++) {
                 if (e >= i && e < o) continue;
-                s[e - t] = runWithOwner(u[e - t] = createOwner(), () => this.Ht(e));
+                s[e - t] = runWithOwner(u[e - t] = createOwner(), () => this.kt(e));
             }
         } catch (e) {
             for (let e = t; e < n; e++) if ((e < i || e >= o) && u[e - t]) u[e - t].dispose();
             throw e;
         }
         // commit: dispose the previous fallback or the rows leaving the window
-                if (this.Ft === 0) this.$t[0]?.dispose(); else for (let e = this.Xt; e < r; e++) if (e < t || e >= n) this.$t[e - this.Xt].dispose();
-        this.jt = s;
-        this.$t = u;
-        this.Xt = t;
-        this.Ft = e;
+                if (this.Gt === 0) this.xt[0]?.dispose(); else for (let e = this.jt; e < r; e++) if (e < t || e >= n) this.xt[e - this.jt].dispose();
+        this.Vt = s;
+        this.xt = u;
+        this.jt = t;
+        this.Gt = e;
     });
-    return this.jt;
+    return this.Vt;
 }
 
 function compare(e, t, n) {
@@ -6353,23 +6306,23 @@ function boundaryComputed(e, t) {
     const n = computed(e, {
         lazy: true
     });
-    n.bt = (e, t) => {
+    n.yt = (e, t) => {
         // Use passed values if provided, otherwise read from node
-        const r = e !== undefined ? e : n.$e;
-        const i = t !== undefined ? t : n.Ue;
+        const r = e !== undefined ? e : n.We;
+        const i = t !== undefined ? t : n.me;
         // Notify both status dimensions like a render effect does; the queue chain
         // consumes this boundary's own type and forwards the remainder upward until
         // a boundary that handles it is found.
-                n.$e &= ~n.en;
-        const o = n.et.notify(n, STATUS_PENDING | STATUS_ERROR, r, i);
+                n.We &= ~n.Yt;
+        const o = n.Ze.notify(n, STATUS_PENDING | STATUS_ERROR, r, i);
         // The queue is the only propagation channel: a foreign status must not stay
         // reader-visible on the tree, or reads re-throw it across the boundary and
         // link unrelated ambient contexts (the #2809 nested-boundary loop). Deps are
         // untouched, so the tree still recomputes when the foreign source settles.
-                const s = r & ~n.en & (STATUS_PENDING | STATUS_ERROR);
+                const s = r & ~n.Yt & (STATUS_PENDING | STATUS_ERROR);
         if (s) {
-            n.$e &= ~s;
-            if (n.Ue === i && !(n.$e & (STATUS_PENDING | STATUS_ERROR))) n.Ue = undefined;
+            n.We &= ~s;
+            if (n.me === i && !(n.We & (STATUS_PENDING | STATUS_ERROR))) n.me = undefined;
         }
         // An ERROR the chain could not deliver to any boundary is uncaught. The
         // scrub above already removed it from reader-visible state, so without
@@ -6380,16 +6333,16 @@ function boundaryComputed(e, t) {
             throw i;
         }
     };
-    n.en = t;
-    n.Fe &= ~CONFIG_AUTO_DISPOSE;
+    n.Yt = t;
+    n.ke &= ~CONFIG_AUTO_DISPOSE;
     recompute(n, true);
     return n;
 }
 
 function createBoundChildren(e, t, n, r) {
-    const i = e.et;
-    i.addChild(e.et = n);
-    cleanup(() => i.removeChild(e.et));
+    const i = e.Ze;
+    i.addChild(e.Ze = n);
+    cleanup(() => i.removeChild(e.Ze));
     return runWithOwner(e, () => {
         const e = computed(t);
         return boundaryComputed(() => flatten(read(e)), r);
@@ -6411,53 +6364,53 @@ function isRevealController(e) {
 }
 
 function isSlotReady(e) {
-    return isRevealController(e) ? e.tn() : e.nn.size === 0 && !e.rn;
+    return isRevealController(e) ? e.qt() : e.Bt.size === 0 && !e.Zt;
 }
 
 function isSlotMinimallyReady(e) {
-    return isRevealController(e) ? e.sn() : isSlotReady(e);
+    return isRevealController(e) ? e.Xt() : isSlotReady(e);
 }
 
 function setSlotState(e, t, n, r) {
-    setSignal(e.un, n);
-    setSignal(e.ln, r);
+    setSignal(e.zt, n);
+    setSignal(e.Jt, r);
     if (isRevealController(e)) {
-        if (!n && e.cn === t) e.cn = undefined;
-        return e.an(n, r);
+        if (!n && e.en === t) e.en = undefined;
+        return e.tn(n, r);
     }
-    if (!n && e.fn === t && e.En) e.fn = undefined;
+    if (!n && e.nn === t && e.rn) e.nn = undefined;
 }
 
 class RevealController {
-    dn;
-    Sn;
-    Tn=[];
-    cn;
-    un=signal(false, {
+    sn;
+    un;
+    ln=[];
+    en;
+    zt=signal(false, {
         ownedWrite: true,
-        Gt: true
+        gt: true
     });
-    ln=signal(false, {
+    Jt=signal(false, {
         ownedWrite: true,
-        Gt: true
+        gt: true
     });
-    pn=true;
-    _n=true;
-    On=false;
+    cn=true;
+    an=true;
+    fn=false;
     constructor(e, t) {
-        this.dn = e;
-        this.Sn = t;
+        this.sn = e;
+        this.un = t;
     }
-    Rn(e) {
-        for (let t = 0; t < this.Tn.length; t++) {
-            const n = this.Tn[t];
-            if ((isRevealController(n) ? n.cn : n.fn) !== this) continue;
+    En(e) {
+        for (let t = 0; t < this.ln.length; t++) {
+            const n = this.ln[t];
+            if ((isRevealController(n) ? n.en : n.nn) !== this) continue;
             if (e(n) === false) return false;
         }
         return true;
     }
-    tn() {
-        return this.Rn(isSlotReady);
+    qt() {
+        return this.En(isSlotReady);
     }
     /**
    * "Minimally ready" = this group has something visible to show under its own policy.
@@ -6465,13 +6418,13 @@ class RevealController {
    * - `together`: every direct slot is minimally ready.
    * - `sequential`: the first owned slot is minimally ready (frontier can advance).
    * - `natural`: any owned slot is minimally ready.
-   */    sn() {
-        const e = untrack(this.dn);
-        if (e === "together") return this.Rn(isSlotMinimallyReady);
+   */    Xt() {
+        const e = untrack(this.sn);
+        if (e === "together") return this.En(isSlotMinimallyReady);
         if (e === "natural") {
             let e = false;
             let t = false;
-            this.Rn(n => {
+            this.En(n => {
                 e = true;
                 if (isSlotMinimallyReady(n)) {
                     t = true;
@@ -6482,45 +6435,45 @@ class RevealController {
         }
         // sequential: only the first owned slot matters.
                 let t = true;
-        this.Rn(e => {
+        this.En(e => {
             t = isSlotMinimallyReady(e);
             return false;
         });
         return t;
     }
-    In(e) {
-        if (this.Tn.includes(e)) return;
-        this.Tn.push(e);
-        const t = untrack(this.dn);
-        setSignal(e.un, true), setSignal(e.ln, t === "sequential" ? !!untrack(this.Sn) : false);
-        untrack(() => this.an());
-    }
-    An(e) {
-        const t = this.Tn.indexOf(e);
-        if (t >= 0) this.Tn.splice(t, 1);
-        untrack(() => this.an());
-    }
-    an(e, t) {
-        if (this.On) return;
-        this.On = true;
-        const n = this.pn;
-        const r = this._n;
+    Sn(e) {
+        if (this.ln.includes(e)) return;
+        this.ln.push(e);
+        const t = untrack(this.sn);
+        setSignal(e.zt, true), setSignal(e.Jt, t === "sequential" ? !!untrack(this.un) : false);
+        untrack(() => this.tn());
+    }
+    dn(e) {
+        const t = this.ln.indexOf(e);
+        if (t >= 0) this.ln.splice(t, 1);
+        untrack(() => this.tn());
+    }
+    tn(e, t) {
+        if (this.fn) return;
+        this.fn = true;
+        const n = this.cn;
+        const r = this.an;
         try {
-            const n = e ?? read(this.un), r = untrack(this.dn), i = r === "sequential" && !!untrack(this.Sn), o = t ?? i;
+            const n = e ?? read(this.zt), r = untrack(this.sn), i = r === "sequential" && !!untrack(this.un), o = t ?? i;
             if (n) {
                 // Held by an outer group. Propagate the hold (and whatever collapsed policy
                 // the outer asked for) down the whole subtree. Inner order is ignored while
                 // held; it resumes once the outer releases us.
-                this.Rn(e => setSlotState(e, this, true, o));
+                this.En(e => setSlotState(e, this, true, o));
             } else if (r === "natural") {
                 // Each child reveals based on its own readiness. A nested controller slot
                 // is released to run its own order locally — we bypass setSlotState for it
                 // so the parent backpointer survives for upward readiness notifications.
-                this.Rn(e => {
+                this.En(e => {
                     if (isRevealController(e)) {
-                        setSignal(e.ln, false);
-                        setSignal(e.un, false);
-                        e.an(false, false);
+                        setSignal(e.Jt, false);
+                        setSignal(e.zt, false);
+                        e.tn(false, false);
                     } else {
                         setSlotState(e, this, !isSlotReady(e), false);
                     }
@@ -6531,11 +6484,11 @@ class RevealController {
                 // sequential's first slot being ready is minimally ready; natural having any
                 // ready child is minimally ready. This lets `together` guarantee a single
                 // cohesive reveal without waiting for every grandchild.
-                const e = this.Rn(isSlotMinimallyReady);
-                this.Rn(t => setSlotState(t, this, !e, false));
+                const e = this.En(isSlotMinimallyReady);
+                this.En(t => setSlotState(t, this, !e, false));
             } else {
                 let e = false;
-                this.Rn(t => {
+                this.En(t => {
                     if (e) return setSlotState(t, this, true, i);
                     if (isSlotReady(t)) return setSlotState(t, this, false, false);
                     e = true;
@@ -6546,63 +6499,63 @@ class RevealController {
                     // advancing past this slot, and we bypass setSlotState so the parent
                     // backpointer survives for upward readiness notifications.
                                         if (isRevealController(t)) {
-                        setSignal(t.ln, false);
-                        setSignal(t.un, false);
-                        t.an(false, false);
+                        setSignal(t.Jt, false);
+                        setSignal(t.zt, false);
+                        t.tn(false, false);
                     } else {
                         setSlotState(t, this, true, false);
                     }
                 });
             }
         } finally {
-            this.pn = this.tn();
-            this._n = this.sn();
-            this.On = false;
+            this.cn = this.qt();
+            this.an = this.Xt();
+            this.fn = false;
         }
-        if (this.cn && (n !== this.pn || r !== this._n)) this.cn.an();
+        if (this.en && (n !== this.cn || r !== this.an)) this.en.tn();
     }
 }
 
 class CollectionQueue extends Queue {
-    hn;
-    nn=new Set;
-    Nn;
-    rn=true;
-    un=signal(false, {
+    Tn;
+    Bt=new Set;
+    pn;
+    Zt=true;
+    zt=signal(false, {
         ownedWrite: true,
-        Gt: true
+        gt: true
     });
-    Ue;
-    ln=signal(false, {
+    me;
+    Jt=signal(false, {
         ownedWrite: true,
-        Gt: true
+        gt: true
     });
-    fn;
-    En=false;
-    yn;
-    Pn=ON_INIT;
+    nn;
+    rn=false;
+    _n;
+    On=ON_INIT;
     constructor(e) {
         super();
-        this.hn = e;
+        this.Tn = e;
     }
     run(e) {
-        if (!e || read(this.un) && (!_revealUsed || read(this.ln))) return;
+        if (!e || read(this.zt) && (!_revealUsed || read(this.Jt))) return;
         return super.run(e);
     }
     notify(e, t, n, r) {
-        if (!(t & this.hn)) return super.notify(e, t, n, r);
-        if (this.En && this.yn) {
+        if (!(t & this.Tn)) return super.notify(e, t, n, r);
+        if (this.rn && this._n) {
             const e = untrack(() => {
                 try {
-                    return this.yn();
+                    return this._n();
                 } catch {
                     return ON_INIT;
                 }
             });
-            if (e !== this.Pn) {
-                this.Pn = e;
-                this.En = false;
-                this.nn.clear();
+            if (e !== this.On) {
+                this.On = e;
+                this.rn = false;
+                this.Bt.clear();
             }
         }
         // Routing is dimension-independent: each boundary consumes only its own
@@ -6615,43 +6568,47 @@ class CollectionQueue extends Queue {
         // dimension, while a status already caught by an inner boundary arrives with
         // its dimension consumed from the mask and is correctly not re-routed
         // (the Loading > Errored > content composition escape, #2856).
-                if (this.hn & STATUS_PENDING && this.En) return super.notify(e, t, n, r);
-        if (n & this.hn) {
-            this.rn = true;
-            const t = r?.source || e.Ue?.source;
+                if (this.Tn & STATUS_PENDING && this.rn) return super.notify(e, t, n, r);
+        if (n & this.Tn) {
+            this.Zt = true;
+            const t = r?.source || e.me?.source;
             if (t) {
-                const e = this.nn.size === 0;
-                this.nn.add(t);
-                if (e) setSignal(this.un, true);
-                if (this.hn & STATUS_ERROR) {
-                    setSignal(this.Ue, unwrapStatusError(t.Ue));
+                const e = this.Bt.size === 0;
+                this.Bt.add(t);
+                if (e) setSignal(this.zt, true);
+                if (this.Tn & STATUS_ERROR) {
+                    setSignal(this.me, unwrapStatusError(t.me));
                 }
             }
         }
-        t &= ~this.hn;
+        t &= ~this.Tn;
         return t ? super.notify(e, t, n, r) : true;
     }
-    qe() {
-        for (const e of this.nn) {
-            if (e.Qe & REACTIVE_DISPOSED || !(e.$e & this.hn) && !(this.hn & STATUS_ERROR && e.$e & STATUS_PENDING)) this.nn.delete(e);
-        }
-        if (!this.nn.size) {
-            if (this.hn & STATUS_PENDING && this.rn && !this.En && this.Nn) {
-                this.rn = !!(this.Nn.$e & this.hn);
+    je() {
+        for (const e of this.Bt) {
+            // A source with a live affects() mark holds display state for the
+            // mark's lifetime (the visual channel): the marked node carries no
+            // status of its own, so the count is the liveness test. The release
+            // sweep (finalizePureQueue after mark release) re-runs this check.
+            if (e.Le & REACTIVE_DISPOSED || !e.F && !(e.We & this.Tn) && !(this.Tn & STATUS_ERROR && e.We & STATUS_PENDING)) this.Bt.delete(e);
+        }
+        if (!this.Bt.size) {
+            if (this.Tn & STATUS_PENDING && this.Zt && !this.rn && this.pn) {
+                this.Zt = !!(this.pn.We & this.Tn);
             } else {
-                this.rn = false;
+                this.Zt = false;
             }
-            if (!this.rn) {
-                setSignal(this.un, false);
-                if (this.yn) {
+            if (!this.Zt) {
+                setSignal(this.zt, false);
+                if (this._n) {
                     try {
-                        this.Pn = untrack(() => this.yn());
+                        this.On = untrack(() => this._n());
                     } catch {
                         /* value not yet committed — _prevOn stays stale, next notify will reset */}
                 }
             }
         }
-        if (_revealUsed) this.fn?.an();
+        if (_revealUsed) this.nn?.tn();
     }
 }
 
@@ -6659,12 +6616,12 @@ function createCollectionBoundary(e, t, n, r) {
     const i = createOwner();
     if (_revealUsed) setContext(RevealControllerContext, null, i);
     const o = new CollectionQueue(e);
-    if (e === STATUS_ERROR) o.Ue = signal(undefined, {
+    if (e === STATUS_ERROR) o.me = signal(undefined, {
         ownedWrite: true,
-        Gt: true
+        gt: true
     });
-    if (r) o.yn = r;
-    const s = o.Nn = createBoundChildren(i, t, o, e);
+    if (r) o._n = r;
+    const s = o.pn = createBoundChildren(i, t, o, e);
     // Prime source tracking so reveal registration sees pending sources.
         untrack(() => {
         let t = false;
@@ -6673,23 +6630,23 @@ function createCollectionBoundary(e, t, n, r) {
         } catch (e) {
             if (e instanceof NotReadyError) t = true; else throw e;
         }
-        o.rn = t || !!(s.$e & e) || s.Ue instanceof NotReadyError;
+        o.Zt = t || !!(s.We & e) || s.me instanceof NotReadyError;
     });
     const u = _revealUsed && e === STATUS_PENDING ? getContext(RevealControllerContext) : null;
     if (u) {
-        o.fn = u;
-        u.In(o);
-        cleanup(() => u.An(o));
+        o.nn = u;
+        u.Sn(o);
+        cleanup(() => u.dn(o));
     }
     return accessor(computed(() => {
-        if (!read(o.un)) {
+        if (!read(o.zt)) {
             const e = read(s);
-            if (!untrack(() => read(o.un))) return o.En = true, e;
+            if (!untrack(() => read(o.zt))) return o.rn = true, e;
         }
         // Collapsed reveal slots suppress their own output entirely; the
         // renderer treats the hole as empty, so the cast never leaks to users
         // outside a `createRevealOrder` scope.
-                if (_revealUsed && read(o.ln)) return undefined;
+                if (_revealUsed && read(o.Jt)) return undefined;
         return n(o);
     }, 
     // Boundary structure, not a user source: its value is fallback-or-content and
@@ -6697,7 +6654,7 @@ function createCollectionBoundary(e, t, n, r) {
     // by snapshot capture. The tree no longer carries foreign status flags, so
     // capture can't rely on PENDING to skip this node the way it used to.
     {
-        Gt: true
+        gt: true
     }));
 }
 
@@ -6750,8 +6707,8 @@ function createCollectionBoundary(e, t, n, r) {
  * }
  * ```
  */ function createErrorBoundary(e, t) {
-    return createCollectionBoundary(STATUS_ERROR, e, e => t(accessor(e.Ue), () => {
-        for (const t of e.nn) recompute(t);
+    return createCollectionBoundary(STATUS_ERROR, e, e => t(accessor(e.me), () => {
+        for (const t of e.Bt) recompute(t);
         schedule();
     }));
 }
@@ -6808,12 +6765,12 @@ function createCollectionBoundary(e, t, n, r) {
         computed(() => {
             i();
             o();
-            s.an();
+            s.tn();
         });
         if (r) {
-            s.cn = r;
-            r.In(s);
-            cleanup(() => r.An(s));
+            s.en = r;
+            r.Sn(s);
+            cleanup(() => r.dn(s));
         }
         return t;
     });