@solidjs/signals 2.0.0-beta.25 → 2.0.0-beta.27

package/dist/node.cjs

@@ -234,7 +234,7 @@ const activeLanes = new Set;
     // the owner's write merges the companion's subscribers into this lane and
     // their effects wait on its async instead of flushing immediately.
         adoptCompanionLane(e._, t);
-    adoptCompanionLane(e.p, t);
+    adoptCompanionLane(e.R, t);
     return t;
 }
 
@@ -291,10 +291,10 @@ function resolveTransition(e) {
     // transactions (#2912) — the merged root's _transition would hand this
     // node's override to whichever action wrote last through the shared
     // reader. Chase merge chains; a dead owner settled through another path.
-    if (hasActiveOverride(e) && e.R) {
-        const t = e.R = currentTransition(e.R);
+    if (hasActiveOverride(e) && e.p) {
+        const t = e.p = currentTransition(e.p);
         if (t.I !== true) return t;
-        e.R = null;
+        e.p = null;
     }
     return resolveLane(e)?.T ?? e.T;
 }
@@ -376,13 +376,13 @@ function registerTransientStoreNode(e) {
 
 function canUseSimpleSyncFlush(e) {
     const t = e.D;
-    return transitions.size === 0 && activeLanes.size === 0 && e.m.length === 0 && t.v.length === 0 && t.L.length === 0 && t.V.size === 0 && transientStoreNodes.size === 0;
+    return transitions.size === 0 && activeLanes.size === 0 && e.m.length === 0 && t.v.length === 0 && t.L.length === 0 && t.G.size === 0 && transientStoreNodes.size === 0;
 }
 
 function sweepTransientStoreNodes() {
     if (transientStoreNodes.size === 0) return;
     for (const e of transientStoreNodes) {
-        if (e.G !== null) {
+        if (e.V !== null) {
             transientStoreNodes.delete(e);
             continue;
         }
@@ -425,7 +425,7 @@ function setProjectionWriteActive(e) {
         M: new Map,
         v: [],
         L: [],
-        V: new Set,
+        G: new Set,
         $: [],
         j: {
             K: [ [], [] ],
@@ -454,7 +454,7 @@ function mergeTransitionState(e, t) {
         e.L.push(...t.L);
         t.L.length = 0;
     }
-    for (const n of t.V) e.V.add(n);
+    for (const n of t.G) e.G.add(n);
     for (const [n, r] of t.M) {
         let t = e.M.get(n);
         if (!t) e.M.set(n, t = new Set);
@@ -499,10 +499,15 @@ function notifyHalted() {
     haltNotified = false;
 }
 
+// Identifies one child-traversal pass in `Queue.run` so a rescan after the
+// child list shifts can tell "already run this pass" from "still pending".
+let queueRunToken = 0;
+
 class Queue {
     B=null;
     K=[ [], [] ];
     m=[];
+    Z=0;
     created=clock;
     addChild(e) {
         this.m.push(e);
@@ -525,7 +530,27 @@ class Queue {
             this.K[e - 1] = [];
             runQueue$1(t, e);
         }
-        for (let t = 0; t < this.m.length; t++) this.m[t].run?.(e);
+        // Effects run here can dispose owners, and disposal removes queues from
+        // this list — the running child itself, an earlier sibling, or several at
+        // once. A plain index walk then skips whatever shifted into the cursor.
+        // Stamping each child before it runs makes the pass idempotent, so a shift
+        // can be recovered by rescanning from the front and every child still runs
+        // exactly once. Children appended mid-pass carry a stale stamp and run,
+        // matching the previous live-array behaviour.
+                const t = this.m;
+        const n = ++queueRunToken;
+        for (let r = 0; r < t.length; ) {
+            const i = t[r];
+            if (i.Z !== n) {
+                i.Z = n;
+                i.run?.(e);
+                if (t[r] !== i) {
+                    r = 0;
+                    continue;
+                }
+            }
+            r++;
+        }
     }
     enqueue(e, t) {
         if (e) {
@@ -572,32 +597,31 @@ class GlobalQueue extends Queue {
     // The current transaction-shaped batch: a plain ambient batch while no
     // transition is active, the active transition itself after initTransition.
     D=createBatch();
-    static Z;
     static X;
     static J;
-    static ee=null;
+    static ee;
+    static te=null;
     // Store-side hook: drops a keyless affects() mark's identity scope when the
     // carrier node's last registration releases (wired by store.ts, mirroring
     // _clearOptimisticStore).
-    static te=null;
+    static ne=null;
     // affects()-side hooks (wired by affects.ts, mirroring _update): the mark
     // 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 ne=null;
     static re=null;
     static ie=null;
+    static oe=null;
     // External-source bridge (wired by enableExternalSource(); null while no
     // config is active — including after _resetExternalSourceConfig()).
-    static oe=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 ue=null;
     static le=null;
     static ae=null;
     static ce=null;
@@ -607,6 +631,7 @@ class GlobalQueue extends Queue {
     static Se=null;
     static Te=null;
     static Oe=null;
+    static _e=null;
     // Optimistic-engine hooks (wired by core/optimistic.ts via
     // installOptimisticEngine(), called from verdict.ts / createOptimistic /
     // createOptimisticStore — every module that can create optimistic state).
@@ -614,9 +639,8 @@ 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 _e=null;
-    static pe=null;
     static Re=null;
+    static pe=null;
     static Ie=null;
     static Ae=null;
     static he=null;
@@ -626,17 +650,18 @@ class GlobalQueue extends Queue {
     static Ce=null;
     static ge=null;
     static be=null;
+    static De=null;
     flush() {
         if (this.q) return;
         this.q = true;
         try {
             if (false) ;
-            runHeap(dirtyQueue, GlobalQueue.Z);
+            runHeap(dirtyQueue, GlobalQueue.X);
             if (activeTransition) {
                 const e = transitionComplete(activeTransition);
                 if (!e) {
                     const e = activeTransition;
-                    runHeap(zombieQueue, GlobalQueue.Z);
+                    runHeap(zombieQueue, GlobalQueue.X);
                     // Detach: the stashed transition keeps its batch; ambient work that
                     // follows lands in a fresh one. If the batch is already a separate
                     // ambient one — action done() restored activeTransition without
@@ -646,8 +671,8 @@ class GlobalQueue extends Queue {
                                         if (this.D === e) currentBatch = this.D = createBatch();
                     // Run lane effects immediately (before stashing) - lanes with no pending async
                                         if (activeLanes.size) {
-                        GlobalQueue.Ae(EFFECT_RENDER);
-                        GlobalQueue.Ae(EFFECT_USER);
+                        GlobalQueue.he(EFFECT_RENDER);
+                        GlobalQueue.he(EFFECT_USER);
                     }
                     this.stashQueues(e.j);
                     clock++;
@@ -676,18 +701,18 @@ class GlobalQueue extends Queue {
                     e.H = n.H;
                     e.v = n.v;
                     e.L = n.L;
-                    e.V = n.V;
+                    e.G = n.G;
                     currentBatch = this.D = e;
                 }
             } else {
                 if (canUseSimpleSyncFlush(this)) {
                     commitPendingNodes();
                     if (dirtyQueue.C >= dirtyQueue.P) {
-                        runHeap(dirtyQueue, GlobalQueue.Z);
+                        runHeap(dirtyQueue, GlobalQueue.X);
                         commitPendingNodes();
                     }
                 } else {
-                    if (transitions.size) runHeap(zombieQueue, GlobalQueue.Z);
+                    if (transitions.size) runHeap(zombieQueue, GlobalQueue.X);
                     finalizePureQueue();
                 }
             }
@@ -695,9 +720,9 @@ class GlobalQueue extends Queue {
             // Check if finalization added items to the heap (from optimistic reversion)
                         scheduled = dirtyQueue.C >= dirtyQueue.P;
             // Run lane effects first (for ready lanes), then regular effects
-                        activeLanes.size && GlobalQueue.Ae(EFFECT_RENDER);
+                        activeLanes.size && GlobalQueue.he(EFFECT_RENDER);
             this.run(EFFECT_RENDER);
-            activeLanes.size && GlobalQueue.Ae(EFFECT_USER);
+            activeLanes.size && GlobalQueue.he(EFFECT_USER);
             this.run(EFFECT_USER);
             if (false) ;
             if (false && !scheduled && !activeTransition && transitions.size === 0 && activeLanes.size === 0) ;
@@ -710,12 +735,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.De;
+                const t = r !== undefined ? r : e.we;
                 // 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?.we) return true;
+                                if (t?.me) return true;
                 if (activeTransition && t) {
                     const n = t.source;
                     let r = activeTransition.M.get(n);
@@ -763,7 +788,7 @@ class GlobalQueue extends Queue {
                 activeTransition.v.push(n);
             }
             if (t.L.length) activeTransition.L.push(...t.L);
-            for (const e of t.V) activeTransition.V.add(e);
+            for (const e of t.G) activeTransition.G.add(e);
             currentBatch = this.D = activeTransition;
         }
         for (const e of activeLanes) {
@@ -789,21 +814,21 @@ 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.me !== undefined;
+    const r = e.ve !== undefined;
     const i = reaskArmed;
-    for (let o = e.G; o !== null; o = o.ve) {
+    for (let o = e.V; o !== null; o = o.Le) {
         // A value-change notification is a new question for the subscriber: any
         // pending re-ask mark (refresh) it carried is superseded.
-        if (i) o.Ve.Le &= ~REACTIVE_REASK;
-        if (r && o.Ve.Ge & CONFIG_IN_SNAPSHOT_SCOPE) {
-            o.Ve.Le |= REACTIVE_SNAPSHOT_STALE;
+        if (i) o.Ve.Ge &= ~REACTIVE_REASK;
+        if (r && o.Ve.Ue & CONFIG_IN_SNAPSHOT_SCOPE) {
+            o.Ve.Ge |= REACTIVE_SNAPSHOT_STALE;
             continue;
         }
         if (t && n) {
-            o.Ve.Le |= REACTIVE_OPTIMISTIC_DIRTY;
+            o.Ve.Ge |= REACTIVE_OPTIMISTIC_DIRTY;
             assignOrMergeLane(o.Ve, n);
         } else if (t) {
-            o.Ve.Le |= REACTIVE_OPTIMISTIC_DIRTY;
+            o.Ve.Ge |= REACTIVE_OPTIMISTIC_DIRTY;
             // No source lane means reversion - clear subscriber's lane so effects go to regular queue
                         o.Ve.i = undefined;
         }
@@ -813,24 +838,24 @@ function insertSubs(e, t = false) {
 
 function commitPendingNode(e) {
     const t = e;
-    if (!t.Ue) {
+    if (!t.ke) {
         if (e.U !== NOT_PENDING) {
-            e.ke = e.U;
+            e.We = e.U;
             e.U = NOT_PENDING;
         }
-        if (e._ || e.p) GlobalQueue.ce(e);
+        if (e._ || e.R) GlobalQueue.fe(e);
         return;
     }
     if (e.U !== NOT_PENDING) {
-        e.ke = e.U;
+        e.We = e.U;
         e.U = NOT_PENDING;
         // Set _modified for effects, but not for tracked effects (they handle their own scheduling)
-                if (e.We && e.We !== EFFECT_TRACKED) e.Fe = true;
+                if (e.Fe && e.Fe !== EFFECT_TRACKED) e.xe = true;
     }
-    t.Le &= ~REACTIVE_MANUAL_WRITE;
-    if (!(t.xe & STATUS_PENDING)) t.xe &= ~STATUS_UNINITIALIZED;
-    if (t.Qe !== null || t.He !== null) GlobalQueue.X(t, false, true);
-    if (e._ || e.p) GlobalQueue.ce(e);
+    t.Ge &= ~REACTIVE_MANUAL_WRITE;
+    if (!(t.Qe & STATUS_PENDING)) t.Qe &= ~STATUS_UNINITIALIZED;
+    if (t.He !== null || t.Me !== null) GlobalQueue.J(t, false, true);
+    if (e._ || e.R) GlobalQueue.fe(e);
 }
 
 function commitPendingNodes() {
@@ -848,7 +873,7 @@ function finalizePureQueue(e = null, t = false) {
     if (n) commitPendingNodes();
     if (!t && globalQueue.m.length) checkBoundaryChildren(globalQueue);
     const r = dirtyQueue.C >= dirtyQueue.P;
-    if (r) runHeap(dirtyQueue, GlobalQueue.Z);
+    if (r) runHeap(dirtyQueue, GlobalQueue.X);
     if (n) {
         if (r) commitPendingNodes();
         // The settling batch: the completing transaction's, or the ambient one.
@@ -860,7 +885,7 @@ function finalizePureQueue(e = null, t = false) {
         // so they re-run with the now-committed values visible.
                 if (e && e.Y.size) {
             for (const t of e.Y) {
-                if (t.Le & REACTIVE_DISPOSED) continue;
+                if (t.Ge & REACTIVE_DISPOSED) continue;
                 enqueueSub(t);
             }
             e.Y.clear();
@@ -872,23 +897,23 @@ function finalizePureQueue(e = null, t = false) {
         // 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.ne(t.L);
+            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
         // completing transition scopes the clear to its own layer keys (#2899).
-                if (t.V.size) GlobalQueue.ee(t.V, e);
+                if (t.G.size) GlobalQueue.te(t.G, e);
         sweepTransientStoreNodes();
         // Lanes only enter activeLanes through the engine's getOrCreateLane.
-                if (activeLanes.size) GlobalQueue.Ie(e);
+                if (activeLanes.size) GlobalQueue.Ae(e);
     }
 }
 
 function checkBoundaryChildren(e) {
     for (const t of e.m) {
-        t.Me?.();
+        t.$e?.();
         checkBoundaryChildren(t);
     }
 }
@@ -955,16 +980,16 @@ function runQueue$1(e, t) {
 }
 
 function reporterBlocksSource(e, t) {
-    if (e.Le & (REACTIVE_ZOMBIE | REACTIVE_DISPOSED)) return false;
-    if (e.$e?.has(t)) return true;
-    for (let n = e.je; n; n = n.Ke) {
-        let e = n.Ye;
+    if (e.Ge & (REACTIVE_ZOMBIE | REACTIVE_DISPOSED)) return false;
+    if (e.je?.has(t)) return true;
+    for (let n = e.Ke; n; n = n.Ye) {
+        let e = n.qe;
         while (e) {
-            if (e === t || e.qe === t) return true;
+            if (e === t || e.Be === t) return true;
             e = e.t;
         }
     }
-    return !!(e.xe & STATUS_PENDING && e.De instanceof NotReadyError && e.De.source === t);
+    return !!(e.Qe & STATUS_PENDING && e.we instanceof NotReadyError && e.we.source === t);
 }
 
 function transitionComplete(e) {
@@ -980,15 +1005,15 @@ function transitionComplete(e) {
             }
             r.delete(e);
         }
-        if (!i) e.M.delete(n); else if (n.xe & STATUS_PENDING && n.De?.source === n) {
+        if (!i) e.M.delete(n); else if (n.Qe & STATUS_PENDING && n.we?.source === n) {
             t = false;
             break;
         }
     }
-    // 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.v.length && GlobalQueue.Re(e)) t = false;
+    // Override blockage lives with the engine (absent hook = "no optimistic
+    // blockage"); the hook's loops over _optimisticNodes/_optimisticStores are
+    // no-ops when the transition holds neither, so no pre-check is needed.
+        if (t && GlobalQueue.Ie?.(e)) t = false;
     t && (e.I = true);
     return t;
 }
@@ -998,10 +1023,6 @@ function currentTransition(e) {
     return e;
 }
 
-function setActiveTransition(e) {
-    activeTransition = e;
-}
-
 function runInTransition(e, t) {
     const n = activeTransition;
     try {
@@ -1013,7 +1034,7 @@ function runInTransition(e, t) {
 }
 
 /** The queue a node belongs to, picked from its own zombie flag. */ function queueFor(e) {
-    return e.Le & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
+    return e.Ge & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
 }
 
 /**
@@ -1021,40 +1042,40 @@ 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.We === EFFECT_TRACKED) {
+    if (e.Fe === EFFECT_TRACKED) {
         const t = e;
-        if (!t.Fe) {
-            t.Fe = true;
-            t.Be.enqueue(EFFECT_USER, t.Ze);
+        if (!t.xe) {
+            t.xe = true;
+            t.Ze.enqueue(EFFECT_USER, t.Xe);
         }
         return;
     }
     const t = queueFor(e);
-    if (t.P > e.Xe) t.P = e.Xe;
+    if (t.P > e.ze) t.P = e.ze;
     insertIntoHeap(e, t);
 }
 
 function actualInsertIntoHeap(e, t) {
-    const n = (e.B?.ze ? e.B.Je?.Xe : e.B?.Xe) ?? -1;
-    if (n >= e.Xe) e.Xe = n + 1;
-    const r = e.Xe;
+    const n = (e.B?.Je ? e.B.et?.ze : e.B?.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.et;
-        t.tt = e;
-        e.et = t;
-        i.et = e;
+        const t = i.tt;
+        t.nt = e;
+        e.tt = t;
+        i.tt = e;
     }
     if (r > t.C) t.C = r;
 }
 
 function insertIntoHeap(e, t) {
-    let n = e.Le;
+    let n = e.Ge;
     if (n & (REACTIVE_IN_HEAP | REACTIVE_RECOMPUTING_DEPS | REACTIVE_MANUAL_WRITE)) return;
     if (n & REACTIVE_CHECK) {
-        e.Le = n & -4 | REACTIVE_DIRTY | REACTIVE_IN_HEAP;
+        e.Ge = n & -4 | REACTIVE_DIRTY | REACTIVE_IN_HEAP;
     } else {
-        e.Le = n | REACTIVE_IN_HEAP;
+        e.Ge = 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
@@ -1066,48 +1087,48 @@ function insertIntoHeap(e, t) {
 }
 
 function insertIntoHeapHeight(e, t) {
-    let n = e.Le;
+    let n = e.Ge;
     if (n & (REACTIVE_IN_HEAP | REACTIVE_RECOMPUTING_DEPS | REACTIVE_IN_HEAP_HEIGHT | REACTIVE_MANUAL_WRITE)) return;
-    e.Le = n | REACTIVE_IN_HEAP_HEIGHT;
+    e.Ge = n | REACTIVE_IN_HEAP_HEIGHT;
     actualInsertIntoHeap(e, t);
 }
 
 function deleteFromHeap(e, t) {
-    const n = e.Le;
+    const n = e.Ge;
     if (!(n & (REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT))) return;
-    e.Le = n & -25;
-    const r = e.Xe;
-    if (e.et === e) t.h[r] = undefined; else {
-        const n = e.tt;
+    e.Ge = 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.et.tt = n;
-        o.et = e.et;
+        if (e === i) t.h[r] = n; else e.tt.nt = n;
+        o.tt = e.tt;
     }
-    e.et = e;
-    e.tt = 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.tt) {
-            if (n.Le & REACTIVE_IN_HEAP) markNode(n);
+        for (let n = e.h[t]; n !== undefined; n = n.nt) {
+            if (n.Ge & REACTIVE_IN_HEAP) markNode(n);
         }
     }
 }
 
 function markNode(e, t = REACTIVE_DIRTY) {
-    const n = e.Le;
+    const n = e.Ge;
     if ((n & (REACTIVE_CHECK | REACTIVE_DIRTY)) >= t) return;
-    e.Le = n & -4 | t;
-    for (let t = e.G; t !== null; t = t.ve) {
+    e.Ge = n & -4 | t;
+    for (let t = e.V; t !== null; t = t.Le) {
         markNode(t.Ve, REACTIVE_CHECK);
     }
-    if (e.nt !== null) {
-        for (let t = e.nt; t !== null; t = t.rt) {
-            for (let e = t.G; e !== null; e = e.ve) {
+    if (e.rt !== null) {
+        for (let t = e.rt; t !== null; t = t.it) {
+            for (let e = t.V; e !== null; e = e.Le) {
                 markNode(e.Ve, REACTIVE_CHECK);
             }
         }
@@ -1119,7 +1140,7 @@ function runHeap(e, t) {
     for (e.P = 0; e.P <= e.C; e.P++) {
         let n = e.h[e.P];
         while (n !== undefined) {
-            if (n.Le & REACTIVE_IN_HEAP) t(n); else adjustHeight(n, e);
+            if (n.Ge & REACTIVE_IN_HEAP) t(n); else adjustHeight(n, e);
             n = e.h[e.P];
         }
     }
@@ -1128,15 +1149,15 @@ function runHeap(e, t) {
 
 function adjustHeight(e, t) {
     deleteFromHeap(e, t);
-    let n = e.Xe;
-    for (let t = e.je; t; t = t.Ke) {
-        const e = t.Ye;
-        const r = e.qe || e;
-        if (r.Ue && r.Xe >= n) n = r.Xe + 1;
-    }
-    if (e.Xe !== n) {
-        e.Xe = n;
-        for (let t = e.G; 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.ke && r.ze >= n) n = r.ze + 1;
+    }
+    if (e.ze !== n) {
+        e.ze = n;
+        for (let t = e.V; t !== null; t = t.Le) {
             // 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
@@ -1151,10 +1172,10 @@ const PENDING_OWNER = {};
 
  // Dummy owner to trigger store's read() path
 function markDisposal(e) {
-    let t = e.it;
+    let t = e.ot;
     while (t) {
-        const e = t.Le;
-        t.Le = e | REACTIVE_ZOMBIE;
+        const e = t.Ge;
+        t.Ge = 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
@@ -1165,79 +1186,79 @@ function markDisposal(e) {
             if (e & REACTIVE_IN_HEAP) insertIntoHeap(t, zombieQueue); else insertIntoHeapHeight(t, zombieQueue);
         }
         markDisposal(t);
-        t = t.ot;
+        t = t.st;
     }
 }
 
 function dispose(e) {
-    let t = e.je;
+    let t = e.Ke;
     while (t !== null) {
         t = unlinkSubs(t);
     }
-    e.je = null;
-    e.st = null;
+    e.Ke = null;
+    e.ut = null;
     disposeChildren(e, true);
 }
 
 function disposeChildren(e, t = false, n) {
-    const r = e.Le;
+    const r = e.Ge;
     if (r & REACTIVE_DISPOSED) return;
     if (t) {
-        e.Le = r | REACTIVE_DISPOSED;
+        e.Ge = 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.p) GlobalQueue.ce(t);
+        if (t._ || t.R) GlobalQueue.fe(t);
     }
-    if (t && e.Ue) e.ut = null;
-    let i = n ? e.Qe : e.it;
+    if (t && e.ke) e.lt = null;
+    let i = n ? e.He : e.ot;
     while (i) {
-        const e = i.ot;
-        if (i.je) {
+        const e = i.st;
+        if (i.Ke) {
             const e = i;
             deleteFromHeap(e, queueFor(e));
-            let t = e.je;
+            let t = e.Ke;
             do {
                 t = unlinkSubs(t);
             } while (t !== null);
-            e.je = null;
-            e.st = null;
+            e.Ke = null;
+            e.ut = null;
         }
         disposeChildren(i, true);
         i = e;
     }
     if (n) {
-        e.Qe = null;
+        e.He = null;
     } else {
-        e.it = null;
-        e.lt = 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.B !== null && !(e.B.Le & REACTIVE_DISPOSED)) {
-        const t = e.ct;
-        const n = e.ot;
-        if (t !== null) t.ot = n; else e.B.it = n;
-        if (n !== null) n.ct = t;
-        e.ct = null;
+        if (t && !n && !(r & REACTIVE_ZOMBIE) && e.B !== null && !(e.B.Ge & REACTIVE_DISPOSED)) {
+        const t = e.ft;
+        const n = e.st;
+        if (t !== null) t.st = n; else e.B.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.ft) {
-        const t = e.ft;
-        e.ft = undefined;
+        if (t && e.Et) {
+        const t = e.Et;
+        e.Et = undefined;
         t();
     }
 }
 
 function runDisposal(e, t) {
-    let n = t ? e.He : e.Et;
+    let n = t ? e.Me : e.dt;
     if (!n) return;
     if (Array.isArray(n)) {
         for (let e = 0; e < n.length; e++) {
@@ -1247,13 +1268,13 @@ function runDisposal(e, t) {
     } else {
         n.call(n);
     }
-    t ? e.He = null : e.Et = null;
+    t ? e.Me = null : e.dt = null;
 }
 
 function childId(e, t) {
     let n = e;
-    while (n.Ge & CONFIG_TRANSPARENT && n.B) n = n.B;
-    if (n.id != null) return formatId(n.id, t ? n.lt++ : n.lt);
+    while (n.Ue & CONFIG_TRANSPARENT && n.B) n = n.B;
+    if (n.id != null) return formatId(n.id, t ? n.ct++ : n.ct);
     throw new Error("");
 }
 
@@ -1334,7 +1355,7 @@ function formatId(e, t) {
  * checks. `cleanup()` is the unchecked primitive used by internals.
  */ function cleanup(e) {
     if (!context) return e;
-    if (!context.Et) context.Et = e; else if (Array.isArray(context.Et)) context.Et.push(e); else context.Et = [ context.Et, e ];
+    if (!context.dt) context.dt = e; else if (Array.isArray(context.dt)) context.dt.push(e); else context.dt = [ context.dt, e ];
     return e;
 }
 
@@ -1354,7 +1375,7 @@ function formatId(e, t) {
  * }
  * ```
  */ function isDisposed(e) {
-    return !!(e.Le & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE));
+    return !!(e.Ge & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE));
 }
 
 function disposeRootSelf(e = true) {
@@ -1373,29 +1394,29 @@ function disposeRootSelf(e = true) {
     const n = e?.transparent ?? false;
     const r = {
         id: inheritId(e, n, t),
-        Ge: n ? CONFIG_TRANSPARENT : 0,
-        ze: true,
-        Je: t?.ze ? t.Je : t,
-        it: null,
+        Ue: n ? CONFIG_TRANSPARENT : 0,
+        Je: true,
+        et: t?.Je ? t.et : t,
         ot: null,
-        ct: null,
-        Et: null,
-        Be: t?.Be ?? globalQueue,
-        dt: t?.dt || defaultContext,
-        lt: 0,
+        st: null,
+        ft: null,
+        dt: null,
+        Ze: t?.Ze ?? globalQueue,
+        St: t?.St || defaultContext,
+        ct: 0,
+        Me: null,
         He: null,
-        Qe: null,
         B: t,
         dispose: disposeRootSelf
     };
     if (t) {
-        const e = t.it;
+        const e = t.ot;
         if (e === null) {
-            t.it = r;
+            t.ot = r;
         } else {
-            r.ot = e;
-            e.ct = r;
-            t.it = r;
+            r.st = e;
+            e.ft = r;
+            t.ot = r;
         }
     }
     return r;
@@ -1431,13 +1452,13 @@ function disposeRootSelf(e = true) {
 
 // https://github.com/stackblitz/alien-signals/blob/v2.0.3/src/system.ts#L100
 function unlinkSubs(e) {
-    const t = e.Ye;
-    const n = e.Ke;
-    const r = e.ve;
-    const i = e.St;
-    if (r !== null) r.St = i; else t.Tt = i;
-    if (i !== null) i.ve = r; else {
-        t.G = r;
+    const t = e.qe;
+    const n = e.Ye;
+    const r = e.Le;
+    const i = e.Tt;
+    if (r !== null) r.Tt = i; else t.Ot = i;
+    if (i !== null) i.Le = r; else {
+        t.V = r;
         if (r === null) {
             t.W?.();
             // No more subscribers; only tear down if CONFIG_AUTO_DISPOSE is set.
@@ -1447,31 +1468,31 @@ function unlinkSubs(e) {
             // this same last-one-out check when that observer releases (the
             // untracked-read dispose in core.ts guards on pending identically).
                         const e = t;
-            e.Ue && e.Ge & CONFIG_AUTO_DISPOSE && !(e.Le & REACTIVE_ZOMBIE) && !(e.xe & STATUS_PENDING) && unobserved(e);
+            e.ke && e.Ue & CONFIG_AUTO_DISPOSE && !(e.Ge & REACTIVE_ZOMBIE) && !(e.Qe & STATUS_PENDING) && unobserved(e);
         }
     }
     return n;
 }
 
 function trimStaleDeps(e) {
-    const t = e.st;
-    let n = t !== null ? t.Ke : e.je;
+    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.Ke = null; else e.je = null;
+        if (t !== null) t.Ye = null; else e.Ke = null;
     }
 }
 
 function unobserved(e) {
     deleteFromHeap(e, queueFor(e));
-    let t = e.je;
+    let t = e.Ke;
     while (t !== null) {
         t = unlinkSubs(t);
     }
-    e.je = null;
-    e.st = null;
+    e.Ke = null;
+    e.ut = null;
     disposeChildren(e, true);
 }
 
@@ -1482,20 +1503,20 @@ function link(e, t, n = false) {
     // 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.st;
-    if (r !== null && r.Ye === e) {
-        r.Ot &&= n;
+    const r = t.ut;
+    if (r !== null && r.qe === e) {
+        r._t &&= n;
         return;
     }
     let i = null;
-    const o = t.Le & REACTIVE_RECOMPUTING_DEPS;
+    const o = t.Ge & REACTIVE_RECOMPUTING_DEPS;
     if (o) {
-        i = r !== null ? r.Ke : t.je;
-        if (i !== null && i.Ye === e) {
-            i._t = t.Rt;
-            t.st = i;
+        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;
+                        i._t = n;
             return;
         }
     }
@@ -1504,24 +1525,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.Tt;
-    if (s !== null && s.Ve === t && (!o || s._t === t.Rt)) {
+        const s = e.Ot;
+    if (s !== null && s.Ve === 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;
+        if (o) s._t &&= n; else s._t = n;
         return;
     }
-    const u = t.st = e.Tt = {
-        Ye: e,
+    const u = t.ut = e.Ot = {
+        qe: e,
         Ve: t,
-        Ke: i,
-        St: s,
-        ve: null,
-        _t: t.Rt,
-        Ot: n
+        Ye: i,
+        Tt: s,
+        Le: null,
+        Rt: t.It,
+        _t: n
     };
-    if (r !== null) r.Ke = u; else t.je = u;
-    if (s !== null) s.ve = u; else e.G = u;
+    if (r !== null) r.Ye = u; else t.Ke = u;
+    if (s !== null) s.Le = u; else e.V = u;
 }
 
 // The lazily-created Set is the ONE container for pending sources. Its
@@ -1530,74 +1551,141 @@ 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.$e?.has(t)) return false;
-    (e.$e ??= new Set).add(t);
+    if (e.je?.has(t)) return false;
+    (e.je ??= new Set).add(t);
     return true;
 }
 
 function removePendingSource(e, t) {
-    if (!e.$e?.delete(t)) return false;
-    if (e.$e.size === 0) e.$e = undefined;
+    if (!e.je?.delete(t)) return false;
+    if (e.je.size === 0) e.je = undefined;
     return true;
 }
 
 function clearPendingSources(e) {
-    e.$e?.clear();
-    e.$e = undefined;
+    e.je?.clear();
+    e.je = undefined;
 }
 
 function setPendingError(e, t, n) {
     if (!t) {
-        e.De = null;
+        e.we = null;
         return;
     }
     if (n instanceof NotReadyError && n.source === t) {
-        e.De = n;
+        e.we = n;
         return;
     }
-    const r = e.De;
+    const r = e.we;
     if (!(r instanceof NotReadyError) || r.source !== t) {
-        e.De = new NotReadyError(t);
+        e.we = new NotReadyError(t);
     }
 }
 
 function forEachDependent(e, t) {
-    for (let n = e.G; n !== null; n = n.ve) t(n.Ve, n);
+    for (let n = e.V; n !== null; n = n.Le) t(n.Ve, n);
     // `?? null`: affects() marks route plain signals (no `_child` slot) through here.
-        for (let n = e.nt ?? null; n !== null; n = n.rt) {
-        for (let e = n.G; e !== null; e = e.ve) t(e.Ve, e);
+        for (let n = e.rt ?? null; n !== null; n = n.it) {
+        for (let e = n.V; e !== null; e = e.Le) t(e.Ve, 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).
+// Settle-time counterpart of unlinkSubs' last-one-out check. A lazy node that
+// loses its last subscriber while STATUS_PENDING is exempt from autodispose
+// (the in-flight work is an observer), so whatever CLEARS that pending state
+// must run the release — otherwise the node stays linked and recomputes
+// forever with zero subscribers (#2934). The node's own promise/iterator
+// callbacks handle their own release (settleAutodispose in handleAsync); this
+// covers derivatively-pending dependents, which have no callbacks of their own.
+function releaseIfSettledUnobserved(e) {
+    e.ke && e.Ue & CONFIG_AUTO_DISPOSE && !e.V && !(e.Ge & REACTIVE_ZOMBIE) && !(e.Qe & STATUS_PENDING) && unobserved(e);
+}
+
+// Error-path sweep: notifyStatus(STATUS_ERROR) clears dependents' pending
+// sources through its own recursion (no per-node settle callback), so after
+// the propagation completes, walk the same graph for stranded lazy nodes.
+// Collect-then-release so unobserved() never unlinks under the walk.
+function releaseSettledDependents(e) {
+    let t;
+    const n = new Set;
+    const visit = e => {
+        if (n.has(e)) return;
+        n.add(e);
+        if (!e.V && e.Ue & CONFIG_AUTO_DISPOSE) (t ??= []).push(e);
+        forEachDependent(e, visit);
+    };
+    forEachDependent(e, visit);
+    if (t) for (const e of t) releaseIfSettledUnobserved(e);
+}
+
+// Error-dimension twin of settlePendingSource's blocked re-enqueue (#2949):
+// a node in STATUS_ERROR that recovers by recomputing to an UNCHANGED value
+// fires no value notification — the recovery is completely silent. But a
+// dependent that re-ran during the error window consumed its dirty flag and
+// committed nothing (the fresh sibling values it read were absorbed into an
+// errored run), so its committed value is stale. The propagated error is one
+// object identity down the whole dependent tree, and holding it is exactly
+// the "blocked on this error" marker — re-enqueue those holders so they
+// re-run: fresh values commit and flow, and a dependent with another
+// still-broken source simply re-errors. The async dimension needs no twin of
+// its own: recovery there passes through a pending window whose re-runners
+// set _blocked and ride settlePendingSource. Walks the full dependent graph
+// (releaseSettledDependents shape): identity holders can sit below an
+// intermediate whose own error state has since been scrubbed or replaced
+// (e.g. an error boundary's tree node).
+function settleErroredDependents(e, t) {
+    let n = false;
+    const r = new Set;
+    const visit = e => {
+        if (r.has(e)) return;
+        r.add(e);
+        if (e.we === t) {
+            enqueueSub(e);
+            n = true;
+        }
+        forEachDependent(e, visit);
+    };
+    forEachDependent(e, visit);
+    if (n) schedule();
+}
+
 function settlePendingSource(e) {
     let t = false;
-    const n = new Set;
+    let n;
+    const r = new Set;
     // Companion updates no-op without the verdict layer (null hook).
-        const r = GlobalQueue.le;
-    const settle = i => {
-        if (n.has(i) || !removePendingSource(i, e)) return;
-        n.add(i);
-        i.F = clock;
-        const o = i.$e?.values().next().value;
-        if (o) {
-            setPendingError(i, o);
-            r !== null && r(i);
+        const i = GlobalQueue.ae;
+    const settle = o => {
+        if (r.has(o) || !removePendingSource(o, e)) return;
+        r.add(o);
+        o.F = clock;
+        const s = o.je?.values().next().value;
+        if (s) {
+            setPendingError(o, s);
+            i !== null && i(o);
         } else {
-            i.xe &= ~STATUS_PENDING;
-            setPendingError(i);
-            r !== null && r(i);
-            if (i.It) {
-                enqueueSub(i);
+            o.Qe &= ~STATUS_PENDING;
+            setPendingError(o);
+            i !== null && i(o);
+            if (o.At) {
+                enqueueSub(o);
                 t = true;
             }
-            i.It = false;
+            o.At = false;
+            // Fully settled with nobody watching: release candidate (#2934). Checked
+            // again at release time — deferred so unobserved() can't unlink subs
+            // lists this walk is still iterating.
+                        if (!o.V && o.Ue & CONFIG_AUTO_DISPOSE) (n ??= []).push(o);
         }
-        forEachDependent(i, settle);
+        forEachDependent(o, settle);
     };
     forEachDependent(e, settle);
+    // Release before the flush schedule below: unobserved() pulls the node back
+    // out of the heap, so the enqueueSub above never recomputes a released node.
+        if (n) for (const e of n) releaseIfSettledUnobserved(e);
     if (t) schedule();
 }
 
@@ -1616,26 +1704,51 @@ function handleAsync(e, t, n) {
         });
     }
     if (!i && !r) {
-        e.ut = null;
+        e.lt = null;
         return t;
     }
-    e.ut = t;
+    e.lt = t;
     let o;
+    // Settle-time transition re-entry. The loading rail is invisible to
+    // transactions (#2933): a boundary-caught first load never registers as an
+    // async reporter, so its settle — the boundary's fallback -> content
+    // reveal — must flow ambiently. The node can still carry a `_transition`
+    // stamp (pending-node bookkeeping rides through the stamping sites), and
+    // blindly re-entering that stamped, still-incomplete transaction stashed
+    // the reveal with it — a deadlock when the transaction's completion
+    // depended on the reveal (#2937). An ESCAPED first load did register and
+    // keeps transition scheduling; initialized (value-holding) pending settles
+    // are the transaction's reveal machinery and always re-enter.
+        const settleTransition = () => {
+        const t = resolveTransition(e);
+        if (t && e.Qe & STATUS_UNINITIALIZED && !currentTransition(t).M.has(e)) {
+            // Drop the stale stamp too: the plain settle write (setSignal) and the
+            // stash-path restamp both re-enter the transaction through it.
+            e.T = null;
+            return;
+        }
+        globalQueue.initTransition(t);
+    };
     const handleError = n => {
-        if (e.ut !== t) return;
-        globalQueue.initTransition(resolveTransition(e));
+        if (e.lt !== t) return;
+        settleTransition();
         // NotReadyError from rejected promises should be treated as pending, not error
-                notifyStatus(e, n instanceof NotReadyError ? STATUS_PENDING : STATUS_ERROR, n);
+                const r = n instanceof NotReadyError;
+        notifyStatus(e, r ? STATUS_PENDING : STATUS_ERROR, n);
         e.F = clock;
+        // A real error settles derivatively-pending dependents (notifyStatus
+        // cleared their pending sources), so stranded lazy ones release here —
+        // the error twin of settlePendingSource's release (#2934).
+                if (!r) releaseSettledDependents(e);
     };
     const asyncWrite = (r, i) => {
-        if (e.ut !== 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.Le & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY)) return;
-        globalQueue.initTransition(resolveTransition(e));
-        const o = !!(e.xe & STATUS_UNINITIALIZED);
+                if (e.Ge & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY)) return;
+        settleTransition();
+        const o = !!(e.Qe & STATUS_UNINITIALIZED);
         trimStaleDeps(e);
         clearStatus(e);
         const s = resolveLane(e);
@@ -1662,22 +1775,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.ue !== null && GlobalQueue.ue(e, r);
+                        GlobalQueue.le !== null && GlobalQueue.le(e, r);
             if (!hasActiveOverride(e)) insertSubs(e);
             e.F = clock;
         } else if (s) {
             // Route through lane's effect queue for independent flushing
-            const t = e.We;
-            const n = e.ke;
-            const i = e.At;
+            const t = e.Fe;
+            const n = e.We;
+            const i = e.ht;
             try {
                 if (!t && o || !i || !i(r, n)) {
-                    e.ke = r;
+                    e.We = r;
                     e.F = 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.ue !== null && GlobalQueue.ue(e, r);
+                                        GlobalQueue.le !== null && GlobalQueue.le(e, r);
                     insertSubs(e, true);
                 }
             } catch (t) {
@@ -1706,10 +1819,14 @@ function handleAsync(e, t, n) {
     // work (a lazy async memo would otherwise tear down and re-execute — one
     // fetch per suspended re-read). Settling is that observer's release, so
     // it runs the same last-one-out check the other release sites run.
+    // Returns whether the node released, so the iterator branch can stop
+    // pulling values instead of pumping an unobserved stream forever (#2935).
         const settleAutodispose = () => {
-        if (e.Ge & CONFIG_AUTO_DISPOSE && !e.G && !(e.xe & STATUS_PENDING)) {
+        if (e.Ue & CONFIG_AUTO_DISPOSE && !e.V && !(e.Qe & STATUS_PENDING)) {
             unobserved(e);
+            return true;
         }
+        return false;
     };
     if (i) {
         let n = false, r = false, i, s = true;
@@ -1755,6 +1872,12 @@ function handleAsync(e, t, n) {
                 if (isThenable(e)) e.then(undefined, () => {});
             } catch {}
         });
+        // Release check before each next pull: an unobserved lazy node must tear
+        // down (its cleanup above closes the iterator) instead of pumping the
+        // stream forever with zero subscribers (#2935).
+                const iterateOrRelease = () => {
+            if (!settleAutodispose()) iterate();
+        };
         const iterate = () => {
             let u, l, a = false, c = false, f = true;
             n.next().then(n => {
@@ -1762,11 +1885,11 @@ function handleAsync(e, t, n) {
                     u = n;
                     a = true;
                     if (n.done) i = true;
-                } else if (e.ut !== t) {
+                } else if (e.lt !== t) {
                     return;
                 } else if (!n.done) {
                     r = true;
-                    asyncWrite(n.value, iterate);
+                    asyncWrite(n.value, iterateOrRelease);
                 } else {
                     i = true;
                     if (r) {
@@ -1776,14 +1899,16 @@ function handleAsync(e, t, n) {
                         // Empty completion settles like the immediately-done sync path.
                         asyncWrite(undefined);
                     }
+                    settleAutodispose();
                 }
             }, n => {
                 if (f) {
                     l = n;
                     c = true;
-                } else if (e.ut === t) {
+                } else if (e.lt === t) {
                     i = true;
                     handleError(n);
+                    settleAutodispose();
                 }
             });
             f = false;
@@ -1813,19 +1938,19 @@ function handleAsync(e, t, n) {
 }
 
 function clearStatus(e, t = false) {
-    if (e.$e) clearPendingSources(e);
-    if (e.It) e.It = false;
+    if (e.je) 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.ht = false;
-    e.xe = t ? 0 : e.xe & STATUS_UNINITIALIZED;
-    if (e.De) setPendingError(e);
+        e.Nt = false;
+    e.Qe = t ? 0 : e.Qe & STATUS_UNINITIALIZED;
+    if (e.we) setPendingError(e);
     // Update pending signal for isPending() reactivity (companions only exist
     // once the verdict layer created them, which installs the hooks).
-        if (e._ || e.p) GlobalQueue.le(e);
-    if (e.nt && GlobalQueue.ae !== null) GlobalQueue.ae(e);
-    if (e.Nt) e.Nt();
+        if (e._ || e.R) GlobalQueue.ae(e);
+    if (e.rt && GlobalQueue.ce !== null) GlobalQueue.ce(e);
+    if (e.yt) e.yt();
 }
 
 function notifyStatus(e, t, n, r, i) {
@@ -1838,43 +1963,43 @@ function notifyStatus(e, t, n, r, i) {
     if (!r) {
         if (t === STATUS_PENDING && o) {
             addPendingSource(e, o);
-            e.xe = STATUS_PENDING | e.xe & STATUS_UNINITIALIZED;
+            e.Qe = STATUS_PENDING | e.Qe & 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.xe = t | (t !== STATUS_ERROR ? e.xe & STATUS_UNINITIALIZED : 0);
-            e.De = n;
+            e.Qe = t | (t !== STATUS_ERROR ? e.Qe & STATUS_UNINITIALIZED : 0);
+            e.we = n;
         }
-        GlobalQueue.le !== null && GlobalQueue.le(e);
-        if (e.nt && GlobalQueue.ae !== null) GlobalQueue.ae(e);
+        GlobalQueue.ae !== null && GlobalQueue.ae(e);
+        if (e.rt && GlobalQueue.ce !== null) GlobalQueue.ce(e);
     }
     if (i && !r) {
         assignOrMergeLane(e, i);
     }
     const a = r || l;
     const c = r || u ? undefined : i;
-    if (e.Nt) {
+    if (e.yt) {
         if (r && t === STATUS_PENDING) {
             return;
         }
         if (a) {
-            e.Nt(t, n);
+            e.yt(t, n);
         } else {
-            e.Nt();
+            e.yt();
         }
         return;
     }
     forEachDependent(e, (e, r) => {
         e.F = clock;
-        if (t === STATUS_PENDING && o && !e.$e?.has(o) || t !== STATUS_PENDING && (e.De !== n || e.$e)) {
+        if (t === STATUS_PENDING && o && !e.je?.has(o) || t !== STATUS_PENDING && (e.we !== n || e.je)) {
             // 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.Ot && t !== STATUS_PENDING && !(n instanceof NotReadyError)) {
+            if (r._t && t !== STATUS_PENDING && !(n instanceof NotReadyError)) {
                 enqueueSub(e);
                 schedule();
                 return;
@@ -1885,9 +2010,9 @@ function notifyStatus(e, t, n, r, i) {
     });
 }
 
-GlobalQueue.Z = recompute;
+GlobalQueue.X = recompute;
 
-GlobalQueue.X = disposeChildren;
+GlobalQueue.J = disposeChildren;
 
 let tracking = false;
 
@@ -1919,7 +2044,7 @@ let snapshotSources = null;
 
 function ownerInSnapshotScope(e) {
     while (e) {
-        if (e.yt) return true;
+        if (e.Pt) return true;
         e = e.B;
     }
     return false;
@@ -1931,41 +2056,41 @@ function setSnapshotCapture(e) {
 }
 
 function markSnapshotScope(e) {
-    e.yt = true;
+    e.Pt = true;
 }
 
 function releaseSnapshotScope(e) {
-    e.yt = false;
+    e.Pt = false;
     releaseSubtree(e);
     schedule();
 }
 
 function releaseSubtree(e) {
-    let t = e.it;
+    let t = e.ot;
     while (t) {
-        if (t.yt) {
-            t = t.ot;
+        if (t.Pt) {
+            t = t.st;
             continue;
         }
-        if (t.Ue) {
+        if (t.ke) {
             const e = t;
-            e.Ge &= ~CONFIG_IN_SNAPSHOT_SCOPE;
-            if (e.Le & REACTIVE_SNAPSHOT_STALE) {
-                e.Le &= ~REACTIVE_SNAPSHOT_STALE;
-                e.Le |= REACTIVE_DIRTY;
-                if (dirtyQueue.P > e.Xe) dirtyQueue.P = e.Xe;
+            e.Ue &= ~CONFIG_IN_SNAPSHOT_SCOPE;
+            if (e.Ge & REACTIVE_SNAPSHOT_STALE) {
+                e.Ge &= ~REACTIVE_SNAPSHOT_STALE;
+                e.Ge |= REACTIVE_DIRTY;
+                if (dirtyQueue.P > e.ze) dirtyQueue.P = e.ze;
                 insertIntoHeap(e, dirtyQueue);
             }
         }
         releaseSubtree(t);
-        t = t.ot;
+        t = t.st;
     }
 }
 
 function clearSnapshots() {
     if (snapshotSources) {
         for (const e of snapshotSources) {
-            delete e.me;
+            delete e.ve;
             // StoreNode targets share one pre-initialized hidden class (see
             // createStoreProxy) — assign undefined instead of deleting, and only
             // when present so signal-node sources don't grow the field.
@@ -1977,37 +2102,41 @@ function clearSnapshots() {
 }
 
 function recompute(e, t = false) {
-    const n = e.We;
+    const n = e.Fe;
     if (!t) {
         if (e.T && (!n || activeTransition) && activeTransition !== e.T) globalQueue.initTransition(e.T);
         deleteFromHeap(e, queueFor(e));
-        e.ut = 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.it !== null || e.Et !== null) {
+                if (e.T || n === EFFECT_TRACKED) disposeChildren(e); else if (e.ot !== null || e.dt !== null) {
             markDisposal(e);
-            e.He = e.Et;
-            e.Qe = e.it;
-            e.Et = null;
-            e.it = null;
-            e.lt = 0;
+            e.Me = e.dt;
+            e.He = e.ot;
+            e.dt = null;
+            e.ot = null;
+            e.ct = 0;
         } else ;
     }
-    let r = !!(e.Le & REACTIVE_OPTIMISTIC_DIRTY);
+    let r = !!(e.Ge & REACTIVE_OPTIMISTIC_DIRTY);
     const i = e.A !== undefined && e.A !== NOT_PENDING;
-    const o = !!(e.xe & STATUS_UNINITIALIZED);
+    const o = !!(e.Qe & STATUS_UNINITIALIZED);
+    // Outgoing error, captured before the compute clears status: if this run
+    // recovers to an unchanged value, dependents still holding this object must
+    // be swept (settleErroredDependents, #2949).
+        const s = e.Qe & STATUS_ERROR ? e.we : undefined;
     // Re-ask classification lives in the verdict module; capture the flag before
     // the recompute wipes _flags below.
-        const s = (e.Le & REACTIVE_REASK) !== 0;
-    const u = context;
+        const u = (e.Ge & REACTIVE_REASK) !== 0;
+    const l = context;
     context = e;
-    e.st = null;
-    e.Rt++;
-    e.Le = REACTIVE_RECOMPUTING_DEPS;
+    e.ut = null;
+    e.It++;
+    e.Ge = REACTIVE_RECOMPUTING_DEPS;
     e.F = clock;
-    let l = e.U === NOT_PENDING ? e.ke : e.U;
-    let a = e.Xe;
-    let c = tracking;
-    let f = currentOptimisticLane;
+    let a = e.U === NOT_PENDING ? e.We : e.U;
+    let c = e.ze;
+    let f = tracking;
+    let E = 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
@@ -2015,74 +2144,74 @@ function recompute(e, t = false) {
     // 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;
+        const d = 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.Pe(e, true);
+        const t = GlobalQueue.Ce(e, true);
         if (t) currentOptimisticLane = t;
     } else if (activeTransition && !t && activeTransition.v.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.Pe(e, false);
+        const t = GlobalQueue.Ce(e, false);
         if (t) {
             r = true;
             currentOptimisticLane = t;
         }
     }
-    const d = n && n !== EFFECT_USER;
-    const S = stale;
-    if (d) stale = true;
+    const S = n && n !== EFFECT_USER;
+    const T = stale;
+    if (S) stale = true;
     try {
-        if (!false && e.Ge & CONFIG_SYNC) {
-            l = e.Ue(l);
-            e.ut = null;
+        if (!false && e.Ue & CONFIG_SYNC) {
+            a = e.ke(a);
+            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.ut;
-            const n = e.Ue(l);
+            const t = e.lt;
+            const n = e.ke(a);
             const r = typeof n === "object" && n !== null;
-            const i = e.ut !== t;
-            l = i || !r ? n : handleAsync(e, n);
-            if (!i && !r) e.ut = null;
+            const i = e.lt !== t;
+            a = i || !r ? n : handleAsync(e, n);
+            if (!i && !r) e.lt = null;
         }
         // On a status-free node clearStatus is a guaranteed no-op: every branch
         // in its body is gated on one of these fields, and with _statusFlags === 0
         // the flags write (create or not) stores the 0 already there.
-                if (e.xe !== 0 || e.Nt !== undefined || e.De || e.ht || e.It || e.$e !== undefined || e._ !== undefined || e.p !== undefined || e.nt !== null) clearStatus(e, t);
+                if (e.Qe !== 0 || e.yt !== undefined || e.we || e.Nt || e.At || e.je !== undefined || e._ !== undefined || e.R !== undefined || e.rt !== 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.Ce(e);
+        if (t instanceof NotReadyError && currentOptimisticLane) GlobalQueue.ge(e);
         let n = false;
         if (t instanceof NotReadyError) {
-            e.It = true;
-            if (GlobalQueue.Se !== null) n = GlobalQueue.Se(e, s);
+            e.At = true;
+            if (GlobalQueue.Te !== null) n = GlobalQueue.Te(e, u);
         }
         notifyStatus(e, t instanceof NotReadyError ? STATUS_PENDING : STATUS_ERROR, t, undefined, t instanceof NotReadyError ? e.i : undefined);
-        if (n) GlobalQueue.Te(e);
+        if (n) GlobalQueue.Oe(e);
     } finally {
-        tracking = c;
-        latestReadActive = E;
-        if (d) stale = S;
-        e.Le = REACTIVE_NONE | (t ? e.Le & REACTIVE_SNAPSHOT_STALE : 0);
-        context = u;
+        tracking = f;
+        latestReadActive = d;
+        if (S) stale = T;
+        e.Ge = REACTIVE_NONE | (t ? e.Ge & REACTIVE_SNAPSHOT_STALE : 0);
+        context = l;
     }
-    if (!e.De) {
+    if (!e.we) {
         trimStaleDeps(e);
-        const s = i ? unwrapOverride(e.A) : e.U === NOT_PENDING ? e.ke : e.U;
-        let u = false;
+        const u = i ? unwrapOverride(e.A) : e.U === NOT_PENDING ? e.We : e.U;
+        let l = false;
         try {
-            u = !n && o || !e.At || !e.At(s, l);
+            l = !n && o || !e.ht || !e.ht(u, a);
         } 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
@@ -2095,13 +2224,13 @@ function recompute(e, t = false) {
         // its runner — happen here instead. `!create` matches the previous `initialized`
         // 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.Fe = !e.De;
+                if (n && l) {
+            e.xe = !e.we;
             // Reuse one bound runner per effect — runEffect no-ops on a stale
             // `_modified`, so re-enqueueing the same function is harmless.
-                        if (!t) e.Be.enqueue(n, e.Pt ??= GlobalQueue.J.bind(null, e));
+                        if (!t) e.Ze.enqueue(n, e.Ct ??= GlobalQueue.ee.bind(null, e));
         }
-        if (e.De) ; else if (u) {
+        if (e.we) ; else if (l) {
             const o = i ? e.A : undefined;
             if (t || 
             // Plain sync flush (no transition on either side) commits effect
@@ -2109,104 +2238,110 @@ function recompute(e, t = false) {
             // commitPendingNodes) exists to sequence transition reveals, and
             // paying it per effect on the plain path is pure overhead.
             n && (activeTransition !== e.T || activeTransition === null) || r) {
-                e.ke = l;
+                e.We = a;
                 // 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
                 // commit can't clobber the fresh value.
                                 if (i && r) {
-                    e.A = l === undefined ? OVERRIDE_UNDEFINED : l;
+                    e.A = a === undefined ? OVERRIDE_UNDEFINED : a;
                     e.U = NOT_PENDING;
                 }
             } else {
-                e.U = l;
+                e.U = a;
                 // Transition-held sync recompute is a write path like setSignal/asyncWrite,
                 // so sync derivations of held sources stay visible to isPending()/latest()
                 // (#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.ue !== null) GlobalQueue.ue(e, l);
+                                if ((activeTransition || e.T) && GlobalQueue.le !== null) GlobalQueue.le(e, a);
             }
             // insertSubs only walks _subs (no scheduling of its own), so a
             // subscriber-less node has nothing to notify.
-                        if (e.G !== null && (!i || r || e.A !== o)) insertSubs(e, r || i);
+                        if (e.V !== null && (!i || r || e.A !== o)) insertSubs(e, r || i);
         } else if (i) {
             // Unchanged value (equals the override) recomputed while the override
             // is active: _value may still be stale, so hold the authoritative value
             // for commit on its own transition's schedule — invisibly (A17/A18).
             if (e.U === NOT_PENDING) queuePendingNode(e);
-            e.U = l;
-        } else if (e.Xe != a) {
-            for (let t = e.G; t !== null; t = t.ve) {
+            e.U = a;
+        } else if (e.ze != c) {
+            for (let t = e.V; t !== null; t = t.Le) {
                 insertIntoHeapHeight(t.Ve, queueFor(t.Ve));
             }
         }
+        // Silent recovery: errored → unchanged value fires no notification, but
+        // dependents still holding the propagated error consumed their dirty flag
+        // in an errored run and may sit on stale commits (#2949). Changed-value
+        // recoveries ride insertSubs above; a comparator throw re-errored the node
+        // (el._error re-set), so this only runs on a genuinely clean recovery.
+                if (s !== undefined && !l && !e.we) settleErroredDependents(e, s);
     }
-    currentOptimisticLane = f;
-    const T = e.U !== NOT_PENDING || e.Qe !== null || e.He !== null || (e.xe & (STATUS_PENDING | STATUS_UNINITIALIZED)) !== 0;
+    currentOptimisticLane = E;
+    const O = e.U !== NOT_PENDING || e.He !== null || e.Me !== null || (e.Qe & (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 && (!t || e.xe & STATUS_PENDING) && (!e.T || i) && queuePendingNode(e);
+        O && (!t || e.Qe & STATUS_PENDING) && (!e.T || i) && queuePendingNode(e);
     e.T && n && activeTransition !== e.T && runInTransition(e.T, () => recompute(e));
 }
 
 function updateIfNecessary(e) {
-    if (e.Le & REACTIVE_CHECK) {
-        for (let t = e.je; t; t = t.Ke) {
-            const n = t.Ye;
-            const r = n.qe || n;
-            if (r.Ue) {
+    if (e.Ge & REACTIVE_CHECK) {
+        for (let t = e.Ke; t; t = t.Ye) {
+            const n = t.qe;
+            const r = n.Be || n;
+            if (r.ke) {
                 updateIfNecessary(r);
             }
-            if (e.Le & REACTIVE_DIRTY) {
+            if (e.Ge & REACTIVE_DIRTY) {
                 break;
             }
         }
     }
-    if (e.Le & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY) || e.De && e.F < clock && !e.ut) {
+    if (e.Ge & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY) || e.we && e.F < clock && !e.lt) {
         recompute(e);
     }
-    e.Le = e.Le & (REACTIVE_SNAPSHOT_STALE | REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT);
+    e.Ge = e.Ge & (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),
-        Ge: (n ? CONFIG_TRANSPARENT : 0) | (t?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (!context || t?.lazy ? CONFIG_AUTO_DISPOSE : 0) | (t?.sync ? CONFIG_SYNC : 0) | (t?.Ct ? CONFIG_NO_SNAPSHOT : 0) | (snapshotCaptureActive && ownerInSnapshotScope(context) ? CONFIG_IN_SNAPSHOT_SCOPE : 0),
-        At: t?.equals != null ? t.equals : isEqual,
+        Ue: (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,
-        Et: null,
-        Be: context?.Be ?? globalQueue,
-        dt: context?.dt ?? defaultContext,
-        lt: 0,
-        Ue: e,
-        ke: undefined,
-        Xe: 0,
-        nt: null,
-        tt: undefined,
-        et: null,
-        je: null,
-        st: null,
-        Rt: 0,
-        G: null,
-        Tt: null,
+        dt: null,
+        Ze: context?.Ze ?? globalQueue,
+        St: context?.St ?? defaultContext,
+        ct: 0,
+        ke: e,
+        We: undefined,
+        ze: 0,
+        rt: null,
+        nt: undefined,
+        tt: null,
+        Ke: null,
+        ut: null,
+        It: 0,
+        V: null,
+        Ot: null,
         B: context,
+        st: null,
+        ft: null,
         ot: null,
-        ct: null,
-        it: null,
-        Le: t?.lazy ? REACTIVE_LAZY : REACTIVE_NONE,
-        xe: STATUS_UNINITIALIZED,
+        Ge: t?.lazy ? REACTIVE_LAZY : REACTIVE_NONE,
+        Qe: STATUS_UNINITIALIZED,
         F: clock,
         U: NOT_PENDING,
+        Me: null,
         He: null,
-        Qe: null,
-        ut: null,
+        lt: null,
         T: null,
-        ht: false
+        Nt: false
     };
     setupComputedNode(r, t);
     return r;
@@ -2221,44 +2356,44 @@ function computed(e, t) {
     const s = o?.transparent ?? false;
     const u = {
         id: inheritId(o, s, context),
-        Ge: (s ? CONFIG_TRANSPARENT : 0) | (o?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (o?.sync ? CONFIG_SYNC : 0) | (snapshotCaptureActive && ownerInSnapshotScope(context) ? CONFIG_IN_SNAPSHOT_SCOPE : 0),
-        At: false,
+        Ue: (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,
-        Et: null,
-        Be: context?.Be ?? globalQueue,
-        dt: context?.dt ?? defaultContext,
-        lt: 0,
-        Ue: e,
-        ke: undefined,
-        Xe: 0,
-        nt: null,
-        tt: undefined,
-        et: null,
-        je: null,
-        st: null,
-        Rt: 0,
-        G: null,
-        Tt: null,
+        dt: null,
+        Ze: context?.Ze ?? globalQueue,
+        St: context?.St ?? defaultContext,
+        ct: 0,
+        ke: e,
+        We: undefined,
+        ze: 0,
+        rt: null,
+        nt: undefined,
+        tt: null,
+        Ke: null,
+        ut: null,
+        It: 0,
+        V: null,
+        Ot: null,
         B: context,
+        st: null,
+        ft: null,
         ot: null,
-        ct: null,
-        it: null,
-        Le: REACTIVE_LAZY,
-        xe: STATUS_UNINITIALIZED,
+        Ge: REACTIVE_LAZY,
+        Qe: STATUS_UNINITIALIZED,
         F: clock,
         U: NOT_PENDING,
+        Me: null,
         He: null,
-        Qe: null,
-        ut: null,
+        lt: null,
         T: null,
-        ht: false,
-        Fe: false,
-        gt: undefined,
-        bt: t,
-        Dt: n,
-        ft: undefined,
-        We: r,
-        Nt: i
+        Nt: false,
+        xe: false,
+        bt: undefined,
+        Dt: t,
+        wt: n,
+        Et: undefined,
+        Fe: r,
+        yt: i
     };
     setupComputedNode(u, lazyOptions);
     return u;
@@ -2269,24 +2404,24 @@ const lazyOptions = {
 };
 
 function setupComputedNode(e, t) {
-    e.et = e;
-    const n = context?.ze ? context.Je : context;
+    e.tt = e;
+    const n = context?.Je ? context.et : context;
     if (context) {
-        const t = context.it;
+        const t = context.ot;
         if (t === null) {
-            context.it = e;
+            context.ot = e;
         } else {
-            e.ot = t;
-            t.ct = e;
-            context.it = e;
+            e.st = t;
+            t.ft = e;
+            context.ot = e;
         }
     }
-    if (n) e.Xe = n.Xe + 1;
-    if (GlobalQueue.oe !== null) GlobalQueue.oe(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.xe & STATUS_PENDING) && !(e.Ge & CONFIG_NO_SNAPSHOT)) {
-            e.me = e.ke === undefined ? NO_SNAPSHOT : e.ke;
+        if (!(e.Qe & STATUS_PENDING) && !(e.Ue & CONFIG_NO_SNAPSHOT)) {
+            e.ve = e.We === undefined ? NO_SNAPSHOT : e.We;
             snapshotSources.add(e);
         }
     }
@@ -2294,20 +2429,20 @@ function setupComputedNode(e, t) {
 
 function signal(e, t, n = null) {
     const r = {
-        At: t?.equals != null ? t.equals : isEqual,
-        Ge: (t?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (t?.Ct ? CONFIG_NO_SNAPSHOT : 0),
+        ht: t?.equals != null ? t.equals : isEqual,
+        Ue: (t?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (t?.gt ? CONFIG_NO_SNAPSHOT : 0),
         W: t?.unobserved,
-        ke: e,
-        G: null,
-        Tt: null,
+        We: e,
+        V: null,
+        Ot: null,
         F: clock,
-        qe: n,
-        rt: n?.nt || null,
+        Be: n,
+        it: n?.rt || null,
         U: NOT_PENDING
     };
-    n && (n.nt = r);
-    if (snapshotCaptureActive && !(r.Ge & CONFIG_NO_SNAPSHOT) && !((n?.xe ?? 0) & STATUS_PENDING)) {
-        r.me = e === undefined ? NO_SNAPSHOT : e;
+    n && (n.rt = r);
+    if (snapshotCaptureActive && !(r.Ue & CONFIG_NO_SNAPSHOT) && !((n?.Qe ?? 0) & STATUS_PENDING)) {
+        r.ve = e === undefined ? NO_SNAPSHOT : e;
         snapshotSources.add(r);
     }
     return r;
@@ -2351,11 +2486,11 @@ function isEqual(e, t) {
  * );
  * ```
  */ function untrack(e, t) {
-    if (GlobalQueue.se === null && !tracking && true) return e();
+    if (GlobalQueue.ue === null && !tracking && true) return e();
     const n = tracking;
     tracking = false;
     try {
-        if (GlobalQueue.se !== null) return GlobalQueue.se(e);
+        if (GlobalQueue.ue !== null) return GlobalQueue.ue(e);
         return e();
     } finally {
         tracking = n;
@@ -2367,10 +2502,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.Le & REACTIVE_LAZY) {
-        e.Le &= ~REACTIVE_LAZY;
+    if (e.Ge & REACTIVE_LAZY) {
+        e.Ge &= ~REACTIVE_LAZY;
         recompute(e, true);
-    } else if (e.Le & REACTIVE_DISPOSED) {
+    } else if (e.Ge & REACTIVE_DISPOSED) {
         recompute(e, true);
     } else if (t) {
         updateIfNecessary(e);
@@ -2391,11 +2526,11 @@ function isEqual(e, t) {
  * snapshot / transition / lane / dev-strictRead state all take the full
  * resolution. Anything slow returns READ_SLOW; the caller then calls read().
  */ function readNodeFast(e) {
-    if (latestReadActive || pendingCheckActive || e.Ue || e.qe || e.A !== undefined || e.me !== undefined || activeTransition !== null || currentOptimisticLane !== null || snapshotCaptureActive || false) return READ_SLOW;
+    if (latestReadActive || pendingCheckActive || e.ke || e.Be || e.A !== undefined || e.ve !== undefined || activeTransition !== null || currentOptimisticLane !== null || snapshotCaptureActive || false) return READ_SLOW;
     let t = context;
-    if (t?.ze) t = t.Je;
+    if (t?.Je) t = t.et;
     if (t && tracking) link(e, t);
-    return !t || e.U === NOT_PENDING ? e.ke : e.U;
+    return !t || e.U === NOT_PENDING ? e.We : e.U;
 }
 
 function read(e) {
@@ -2403,72 +2538,76 @@ 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.fe(e);
+    if (latestReadActive) return GlobalQueue.Ee(e);
     let t = context;
-    if (t?.ze) t = t.Je;
+    if (t?.Je) t = t.et;
     const n = e;
-    const r = e.qe;
+    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.Ee(e, t, i, r);
-    } else if (typeof n.Ue === "function") {
+        GlobalQueue.de(e, t, i, r);
+    } else if (typeof n.ke === "function") {
         prepareComputed(e, false);
     }
-    if (!n.Ue && i === e && e.A === undefined && e.me === undefined && activeTransition === null && currentOptimisticLane === null && !snapshotCaptureActive && true) {
+    if (!n.ke && i === e && e.A === undefined && e.ve === undefined && activeTransition === null && currentOptimisticLane === null && !snapshotCaptureActive && true) {
         if (t && tracking) link(e, t);
-        return !t || e.U === NOT_PENDING ? e.ke : e.U;
+        return !t || e.U === NOT_PENDING ? e.We : e.U;
     }
     if (t && tracking) {
         link(e, t, pendingCheckActive);
-        if (i.Ue) {
+        if (i.ke) {
             const n = queueFor(e);
-            if (i.Xe >= n.P) {
+            if (i.ze >= n.P) {
                 markNode(t);
                 markHeap(n);
                 updateIfNecessary(i);
             }
-            const r = i.Xe;
+            const r = i.ze;
             // parent check is shallow, might need to be recursive
-                        if (r >= t.Xe && e.B !== t) {
-                t.Xe = r + 1;
+                        if (r >= t.ze && e.B !== t) {
+                t.ze = r + 1;
             }
         }
     }
-    if (i.xe & STATUS_PENDING) {
+    if (i.Qe & 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.Ne(i)) {
+            if (currentOptimisticLane === null || GlobalQueue.ye(i)) {
                 if (!tracking && e !== t) link(e, t);
-                throw i.De;
+                throw i.we;
             }
-        } else if (t && i !== e && i.xe & STATUS_UNINITIALIZED) {
+        } else if (t && i !== e && i.Qe & STATUS_UNINITIALIZED) {
             if (!tracking && e !== t) link(e, t);
-            throw i.De;
-        } else if (!t && i.xe & STATUS_UNINITIALIZED) {
-            throw i.De;
+            throw i.we;
+        } else if (!t && i.Qe & STATUS_UNINITIALIZED) {
+            throw i.we;
         }
     }
-    if (e.Ue && e.xe & STATUS_ERROR) {
+    // `owner` is the computed itself, or the firewall behind a store node —
+    // firewall-backed reads follow the same rules (memo parity, #2897 ruling):
+    // an errored derive throws for every late reader instead of silently
+    // serving node values (the seed, or last-good data after a failed refetch).
+        if (i.ke && i.Qe & 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
-        // - el._time < clock: only on a later cycle than the one the error was found
-        if (tracking && !pendingCheckActive && e.F < clock) {
-            recompute(e);
+        // - owner._time < clock: only on a later cycle than the one the error was found
+        if (tracking && !pendingCheckActive && i.F < clock) {
+            recompute(i);
             return read(e);
-        } else throw e.De;
+        } else throw i.we;
     }
-    if (snapshotCaptureActive && t && t.Ge & CONFIG_IN_SNAPSHOT_SCOPE) {
-        const n = e.me;
+    if (snapshotCaptureActive && t && t.Ue & CONFIG_IN_SNAPSHOT_SCOPE) {
+        const n = e.ve;
         if (n !== undefined) {
             const r = n === NO_SNAPSHOT ? undefined : n;
-            const i = e.U !== NOT_PENDING ? e.U : e.ke;
-            if (i !== r) t.Le |= REACTIVE_SNAPSHOT_STALE;
+            const i = e.U !== NOT_PENDING ? e.U : e.We;
+            if (i !== r) t.Ge |= REACTIVE_SNAPSHOT_STALE;
             return r;
         }
     }
@@ -2483,18 +2622,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.he(e, i, t)) {
-        return e.ke;
+        if (currentOptimisticLane !== null && activeTransition !== null && t !== null && GlobalQueue.Ne(e, i, t)) {
+        return e.We;
     }
     // 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.ye(e, i, t) || e.U === NOT_PENDING || stale && e.T && activeTransition !== e.T ? e.ke : e.U;
+        const o = !t || currentOptimisticLane !== null && GlobalQueue.Pe(e, i, t) || e.U === NOT_PENDING || stale && e.T && activeTransition !== e.T ? e.We : e.U;
     // 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.de(e, o);
-    if (!t && i === e && typeof n.Ue === "function" && e.Ge & CONFIG_AUTO_DISPOSE && !(i.xe & STATUS_PENDING) && !e.G) {
+        if (pendingCheckActive) GlobalQueue.Se(e, o);
+    if (!t && i === e && typeof n.ke === "function" && e.Ue & CONFIG_AUTO_DISPOSE && !(i.Qe & STATUS_PENDING) && !e.V) {
         unobserved(e);
     }
     return o;
@@ -2506,19 +2645,19 @@ 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._e(e, t);
-    const n = e.U === NOT_PENDING ? e.ke : e.U;
+        if (e.A !== undefined && !projectionWriteActive) return GlobalQueue.Re(e, t);
+    const n = e.U === NOT_PENDING ? e.We : e.U;
     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.xe & STATUS_UNINITIALIZED) || !e.At || !e.At(n, t);
+        const r = !!(e.Qe & STATUS_UNINITIALIZED) || !e.ht || !e.ht(n, t);
     if (!r) return t;
     if (e.U === NOT_PENDING) queuePendingNode(e);
     e.U = t;
     // syncCompanions only pokes _pendingSignal/_latestValueComputed — with
     // neither companion present the call is a guaranteed no-op (companions are
     // only ever created, never removed, and creating one installs the hook).
-        (e._ !== undefined || e.p !== undefined) && GlobalQueue.ue !== null && GlobalQueue.ue(e, t);
+        (e._ !== undefined || e.R !== undefined) && GlobalQueue.le !== null && GlobalQueue.le(e, t);
     e.F = clock;
     insertSubs(e);
     schedule();
@@ -2533,11 +2672,11 @@ function setSignal(e, t) {
  * cleanup point.
  */ function suppressComputedRecompute(e) {
     deleteFromHeap(e, queueFor(e));
-    if (!(e.Le & REACTIVE_MANUAL_WRITE) && e.U === NOT_PENDING) {
+    if (!(e.Ge & REACTIVE_MANUAL_WRITE) && e.U === NOT_PENDING) {
         queuePendingNode(e);
         schedule();
     }
-    e.Le = e.Le & -4 | REACTIVE_MANUAL_WRITE;
+    e.Ge = e.Ge & -4 | REACTIVE_MANUAL_WRITE;
 }
 
 /**
@@ -2616,7 +2755,7 @@ function staleValues(e, t = true) {
     if (!t) {
         return;
     }
-    if (typeof t.Ue === "function" && !(t.Le & (REACTIVE_DISPOSED | REACTIVE_MANUAL_WRITE))) {
+    if (typeof t.ke === "function" && !(t.Ge & (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
@@ -2624,11 +2763,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.Le & (REACTIVE_DIRTY | REACTIVE_CHECK | REACTIVE_IN_HEAP))) {
-            t.Le |= REACTIVE_REASK;
+        if (!(t.Ge & (REACTIVE_DIRTY | REACTIVE_CHECK | REACTIVE_IN_HEAP))) {
+            t.Ge |= REACTIVE_REASK;
             armReaskClear();
         }
-        t.Le = t.Le & ~REACTIVE_CHECK | REACTIVE_DIRTY;
+        t.Ge = t.Ge & ~REACTIVE_CHECK | REACTIVE_DIRTY;
         insertIntoHeap(t, queueFor(t));
         schedule();
     }
@@ -2676,11 +2815,11 @@ function wireExternalSource(e) {
         equals: false,
         ownedWrite: true
     });
-    const n = externalSourceConfig.factory(e.Ue, () => {
+    const n = externalSourceConfig.factory(e.ke, () => {
         setSignal(t, undefined);
     });
     cleanup(() => n.dispose());
-    e.Ue = e => {
+    e.ke = e => {
         read(t);
         return n.track(e);
     };
@@ -2694,8 +2833,8 @@ function externalUntrack(e) {
 // removed on reset) so core's null checks stay equivalent to the old
 // `externalSourceConfig` truthiness checks.
 function syncExternalHooks() {
-    GlobalQueue.oe = externalSourceConfig ? wireExternalSource : null;
-    GlobalQueue.se = externalSourceConfig ? externalUntrack : null;
+    GlobalQueue.se = externalSourceConfig ? wireExternalSource : null;
+    GlobalQueue.ue = externalSourceConfig ? externalUntrack : null;
 }
 
 function enableExternalSource(e) {
@@ -2752,7 +2891,7 @@ function enableExternalSource(e) {
     if (!t) {
         throw new NoOwnerError;
     }
-    const n = hasContext(e, t) ? t.dt[e.id] : e.defaultValue;
+    const n = hasContext(e, t) ? t.St[e.id] : e.defaultValue;
     if (isUndefined(n)) {
         throw new ContextNotFoundError;
     }
@@ -2773,14 +2912,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.dt = {
-        ...n.dt,
+        n.St = {
+        ...n.St,
         [e.id]: isUndefined(t) ? e.defaultValue : t
     };
 }
 
 function hasContext(e, t) {
-    return !isUndefined(t?.dt[e.id]);
+    return !isUndefined(t?.St[e.id]);
 }
 
 function isUndefined(e) {
@@ -2802,9 +2941,9 @@ function isUndefined(e) {
  */
 /** 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.ke;
+    const r = n ? unwrapOverride(e.A) : e.We;
     if (typeof t === "function") t = t(r);
-    const i = !!(e.xe & STATUS_UNINITIALIZED) || !e.At || !e.At(r, t);
+    const i = !!(e.Qe & 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.
@@ -2822,7 +2961,7 @@ function isUndefined(e) {
     // Stamp ownership on the node (post-merge, so entangled writers share the
     // joint root). resolveTransition prefers this over the lane's _transition,
     // which a shared subscriber can merge across transactions (#2912).
-        e.R = activeTransition;
+        e.p = activeTransition;
     const o = getOrCreateLane(e);
     e.i = o;
     // Literal undefined must not land raw: the slot doubles as the optimistic
@@ -2831,7 +2970,7 @@ function isUndefined(e) {
         e.A = t === undefined ? OVERRIDE_UNDEFINED : t;
     // syncCompanions only pokes _pendingSignal/_latestValueComputed — with
     // neither companion present the call is a guaranteed no-op.
-        (e._ !== undefined || e.p !== undefined) && GlobalQueue.ue !== null && GlobalQueue.ue(e, t);
+        (e._ !== undefined || e.R !== undefined) && GlobalQueue.le !== null && GlobalQueue.le(e, t);
     e.F = clock;
     insertSubs(e, true);
     schedule();
@@ -2845,7 +2984,7 @@ function isUndefined(e) {
  */ function transitionBlocked(e) {
     for (let t = 0; t < e.v.length; t++) {
         const n = e.v[t];
-        if (hasActiveOverride(n) && "xe" in n && n.xe & STATUS_PENDING && n.De instanceof NotReadyError) {
+        if (hasActiveOverride(n) && "Qe" in n && n.Qe & STATUS_PENDING && n.we instanceof NotReadyError) {
             return true;
         }
     }
@@ -2863,21 +3002,21 @@ 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.xe & STATUS_PENDING)) t.xe &= ~STATUS_UNINITIALIZED;
+                if (!(t.Qe & STATUS_PENDING)) t.Qe &= ~STATUS_UNINITIALIZED;
         const r = t.A;
         t.A = NOT_PENDING;
-        if (r !== NOT_PENDING && t.ke !== unwrapOverride(r)) insertSubs(t, true);
+        if (r !== NOT_PENDING && t.We !== unwrapOverride(r)) insertSubs(t, true);
         t.T = null;
-        t.R = null;
+        t.p = null;
     }
     // Settlement checkpoint (#2838): companions caught in this batch (or owned
     // by a node in it) re-derive from committed state, so verdicts survive the
     // 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.p) GlobalQueue.ce(t);
+        if (t._ || t.R) GlobalQueue.fe(t);
         const r = t.t;
-        if (r && (r._ === t || r.p === t)) GlobalQueue.ce(r);
+        if (r && (r._ === t || r.R === t)) GlobalQueue.fe(r);
     }
     e.splice(0, t);
 }
@@ -2930,7 +3069,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.U === NOT_PENDING || e.Ue || t !== e && !(t.Le & REACTIVE_MANUAL_WRITE)) {
+    if (latestReadActive || e.U === NOT_PENDING || e.ke || t !== e && !(t.Ge & REACTIVE_MANUAL_WRITE)) {
         return false;
     }
     activeTransition.Y.add(n);
@@ -2941,7 +3080,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.xe & STATUS_PENDING);
+    return e.A !== undefined || !!e.i || t === e && stale && n.t !== e || !!(t.Qe & STATUS_PENDING);
 }
 
 /**
@@ -2950,12 +3089,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.je; t; t = t.Ke) {
-        const n = t.Ye;
-        if (n.Le & REACTIVE_OPTIMISTIC_DIRTY) {
+    for (let t = e.Ke; t; t = t.Ye) {
+        const n = t.qe;
+        if (n.Ge & REACTIVE_OPTIMISTIC_DIRTY) {
             const t = resolveLane(n);
             if (t) {
-                e.Le |= REACTIVE_OPTIMISTIC_DIRTY;
+                e.Ge |= REACTIVE_OPTIMISTIC_DIRTY;
                 assignOrMergeLane(e, t);
                 return t;
             }
@@ -2969,7 +3108,7 @@ function cleanupCompletedLanes(e) {
     if (t.o !== e) {
         t.u.add(e);
         e.i = t;
-        GlobalQueue.le !== null && GlobalQueue.le(t.o);
+        GlobalQueue.ae !== null && GlobalQueue.ae(t.o);
     }
 }
 
@@ -2977,13 +3116,13 @@ function cleanupCompletedLanes(e) {
     const t = resolveLane(e);
     if (t) {
         t.u.delete(e);
-        GlobalQueue.le !== null && GlobalQueue.le(t.o);
+        GlobalQueue.ae !== null && GlobalQueue.ae(t.o);
     }
 }
 
 function trackOptimisticStore(e) {
     // After initTransition, globalQueue._batch IS activeTransition (same reference)
-    globalQueue.D.V.add(e);
+    globalQueue.D.G.add(e);
     schedule();
 }
 
@@ -2992,19 +3131,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._e !== null) return;
-    GlobalQueue._e = optimisticWrite;
+    if (GlobalQueue.Re !== null) return;
+    GlobalQueue.Re = optimisticWrite;
     GlobalQueue.pe = resolveOptimisticNodes;
-    GlobalQueue.Re = transitionBlocked;
-    GlobalQueue.Ie = cleanupCompletedLanes;
-    GlobalQueue.Ae = runLaneEffects;
-    GlobalQueue.he = gatedRead;
-    GlobalQueue.Ne = laneSuspends;
-    GlobalQueue.ye = laneReadsCommitted;
-    GlobalQueue.Pe = recomputeLane;
-    GlobalQueue.Ce = laneAsyncPending;
-    GlobalQueue.ge = laneAsyncSettled;
-    GlobalQueue.be = trackOptimisticStore;
+    GlobalQueue.Ie = transitionBlocked;
+    GlobalQueue.Ae = cleanupCompletedLanes;
+    GlobalQueue.he = runLaneEffects;
+    GlobalQueue.Ne = gatedRead;
+    GlobalQueue.ye = laneSuspends;
+    GlobalQueue.Pe = laneReadsCommitted;
+    GlobalQueue.Ce = recomputeLane;
+    GlobalQueue.ge = laneAsyncPending;
+    GlobalQueue.be = laneAsyncSettled;
+    GlobalQueue.De = trackOptimisticStore;
 }
 
 /**
@@ -3037,7 +3176,7 @@ let pendingProbe = null;
 function collectPendingSources(e) {
     if (!pendingProbe) return;
     pendingProbe.sources.add(e);
-    const t = e.qe || e;
+    const t = e.Be || e;
     if (t !== e) pendingProbe.sources.add(t);
 }
 
@@ -3067,20 +3206,20 @@ function collectPendingSources(e) {
     // 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.xe & STATUS_ERROR) return false;
+        if (e.Qe & STATUS_ERROR) return false;
     if (t.has(e)) return false;
     t.add(e);
-    const n = e.qe;
+    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.st : undefined;
+    const i = r.Ge & REACTIVE_RECOMPUTING_DEPS ? r.ut : undefined;
     if (i !== null) {
-        for (let e = r.je ?? null; e !== null; e = e.Ke) {
-            if (!e.Ot && markWalk(e.Ye, t)) return true;
+        for (let e = r.Ke ?? null; e !== null; e = e.Ye) {
+            if (!e._t && markWalk(e.qe, t)) return true;
             if (e === i) break;
         }
     }
@@ -3092,35 +3231,35 @@ function collectPendingSources(e) {
 }
 
 function quietPending(e) {
-    if (e.$e) {
-        for (const t of e.$e) if (!t.ht) return false;
+    if (e.je) {
+        for (const t of e.je) if (!t.Nt) return false;
         return true;
     }
-    return e.ht;
+    return e.Nt;
 }
 
 function newQuestionInFlight(e) {
-    return !!(e.xe & STATUS_PENDING) && !(e.xe & STATUS_UNINITIALIZED) && !quietPending(e);
+    return !!(e.Qe & STATUS_PENDING) && !(e.Qe & STATUS_UNINITIALIZED) && !quietPending(e);
 }
 
 function computePendingState(e) {
     const t = e;
-    if (t.Le & REACTIVE_DISPOSED) return false;
+    if (t.Ge & 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.qe;
+    const n = e.Be;
     if (e.t) {
         const t = e.t;
-        const n = t.qe || t;
+        const n = t.Be || t;
         return newQuestionInFlight(n);
     }
     if (n && e.U !== NOT_PENDING && !hasActiveOverride(e)) {
-        return !!(n.Le & REACTIVE_MANUAL_WRITE) || !n.ut && !(n.xe & STATUS_PENDING) || !!(n.xe & STATUS_PENDING) && quietPending(n);
+        return !!(n.Ge & REACTIVE_MANUAL_WRITE) || !n.lt && !(n.Qe & STATUS_PENDING) || !!(n.Qe & STATUS_PENDING) && quietPending(n);
     }
-    if (e.U !== NOT_PENDING && !(t.xe & STATUS_UNINITIALIZED)) {
-        if (hasActiveOverride(e)) return !e.At || !e.At(e.U, unwrapOverride(e.A));
+    if (e.U !== NOT_PENDING && !(t.Qe & STATUS_UNINITIALIZED)) {
+        if (hasActiveOverride(e)) return !e.ht || !e.ht(e.U, unwrapOverride(e.A));
         return true;
     }
     return newQuestionInFlight(t);
@@ -3128,19 +3267,19 @@ function computePendingState(e) {
 
 function syncCompanions(e, t) {
     if (e._) updatePendingSignal(e);
-    if (e.p) setSignal(e.p, t);
+    if (e.R) setSignal(e.R, t);
 }
 
 function updatePendingSignal(e) {
     if (e._) {
         setSignal(e._, computePendingState(e));
     }
-    if (e.p) updatePendingSignal(e.p);
+    if (e.R) updatePendingSignal(e.R);
 }
 
 function updateChildCompanions(e) {
-    for (let t = e.nt; t !== null; t = t.rt) {
-        if (t._ || t.p) updatePendingSignal(t);
+    for (let t = e.rt; t !== null; t = t.it) {
+        if (t._ || t.R) updatePendingSignal(t);
     }
 }
 
@@ -3158,9 +3297,9 @@ function updateChildCompanions(e) {
     const visit = e => {
         if (r.has(e)) return;
         r.add(e);
-        if (e._ || e.p) n(e);
-        for (let t = e.G; t !== null; t = t.ve) visit(t.Ve);
-        for (let t = e.nt ?? null; t !== null; t = t.rt) {
+        if (e._ || e.R) n(e);
+        for (let t = e.V; t !== null; t = t.Le) visit(t.Ve);
+        for (let t = e.rt ?? null; t !== null; t = t.it) {
             visit(t);
         }
     };
@@ -3171,18 +3310,18 @@ function snapCompanionsToState(e) {
     const t = e._;
     if (t && (t.A === undefined || t.A === NOT_PENDING)) {
         const n = computePendingState(e);
-        if (t.ke !== n || t.U !== NOT_PENDING) {
-            t.ke = n;
+        if (t.We !== n || t.U !== NOT_PENDING) {
+            t.We = n;
             t.U = NOT_PENDING;
             t.F = clock;
             insertSubs(t);
             schedule();
         }
     }
-    const n = e.p;
-    if (n && !(n.Le & REACTIVE_DISPOSED)) {
-        if ((n.A === undefined || n.A === NOT_PENDING) && n.U === NOT_PENDING && !Object.is(n.ke, e.ke) && !(n.Le & (REACTIVE_DIRTY | REACTIVE_CHECK))) {
-            n.Le |= REACTIVE_DIRTY;
+    const n = e.R;
+    if (n && !(n.Ge & REACTIVE_DISPOSED)) {
+        if ((n.A === undefined || n.A === NOT_PENDING) && n.U === NOT_PENDING && !Object.is(n.We, e.We) && !(n.Ge & (REACTIVE_DIRTY | REACTIVE_CHECK))) {
+            n.Ge |= REACTIVE_DIRTY;
             insertIntoHeap(n, queueFor(n));
             insertSubs(n);
             schedule();
@@ -3192,7 +3331,7 @@ function snapCompanionsToState(e) {
 }
 
 function getLatestValueComputed(e) {
-    if (!e.p) {
+    if (!e.R) {
         const t = latestReadActive;
         setLatestReadActive(false);
         const n = pendingCheckActive;
@@ -3200,21 +3339,21 @@ function getLatestValueComputed(e) {
         const r = context;
         setContextInternal(null);
  // Detach from owner so it isn't disposed with effects
-                e.p = optimisticComputed(() => read(e));
-        e.p.t = e;
+                e.R = optimisticComputed(() => read(e));
+        e.R.t = e;
  // Parent-child lane relationship
                 setContextInternal(r);
         setPendingCheckActive(n);
         setLatestReadActive(t);
     }
-    return e.p;
+    return e.R;
 }
 
 /** The latest()-mode read path, installed as GlobalQueue._latestRead. */ function latestRead(e) {
     const t = getLatestValueComputed(e);
     const n = latestReadActive;
     setLatestReadActive(false);
-    const r = e.A !== undefined && e.A !== NOT_PENDING ? unwrapOverride(e.A) : e.ke;
+    const r = e.A !== undefined && e.A !== NOT_PENDING ? unwrapOverride(e.A) : e.We;
     let i;
     try {
         // An untracked latest() read has no reading context, so read() never
@@ -3223,18 +3362,18 @@ function getLatestValueComputed(e) {
         // 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.Xe >= e.P && !(t.Le & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE))) {
+        if (t.ze >= e.P && !(t.Ge & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE))) {
             markHeap(e);
             prepareComputed(t, true);
         }
         i = read(t);
     } catch (t) {
-        if (t instanceof NotReadyError && (!context || !(e.xe & STATUS_UNINITIALIZED))) return r;
+        if (t instanceof NotReadyError && (!context || !(e.Qe & STATUS_UNINITIALIZED))) return r;
         throw t;
     } finally {
         setLatestReadActive(n);
     }
-    if (t.xe & STATUS_PENDING) return r;
+    if (t.Qe & STATUS_PENDING) return r;
     if (stale && currentOptimisticLane && t.i) {
         const e = findLane(t.i);
         const n = findLane(currentOptimisticLane);
@@ -3252,12 +3391,12 @@ function getLatestValueComputed(e) {
 
 /** The isPending()-probe read path, installed as GlobalQueue._pendingCheck. */ function pendingCheckRead(e, t, n, r) {
     setPendingCheckActive(false);
-    if (typeof e.Ue === "function") prepareComputed(e, true);
-    const i = n.xe;
+    if (typeof e.ke === "function") prepareComputed(e, true);
+    const i = n.Qe;
     if (t && i & STATUS_PENDING && i & STATUS_UNINITIALIZED) {
         if (tracking && e !== t) link(e, t);
         setPendingCheckActive(true);
-        throw n.De;
+        throw n.we;
     }
     collectPendingSources(e);
     if (r) collectPendingSources(r);
@@ -3269,10 +3408,10 @@ function recordFreshRead(e, t) {
 }
 
 function applyReask(e, t) {
-    const n = !!(e.xe & STATUS_PENDING);
-    const r = t && !(n && !e.ht);
-    const i = n && e.ht !== r;
-    e.ht = r;
+    const n = !!(e.Qe & STATUS_PENDING);
+    const r = t && !(n && !e.Nt);
+    const i = n && e.Nt !== r;
+    e.Nt = r;
     return i;
 }
 
@@ -3312,7 +3451,7 @@ function isPending(e) {
     } catch (e) {
         collectPending();
         if (e instanceof NotReadyError) {
-            const t = !!(e.source?.xe & STATUS_UNINITIALIZED);
+            const t = !!(e.source?.Qe & STATUS_UNINITIALIZED);
             if (r.found && !t) return true;
             if (context && t) throw e;
         }
@@ -3326,25 +3465,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.ue = syncCompanions;
+GlobalQueue.le = syncCompanions;
 
-GlobalQueue.le = updatePendingSignal;
+GlobalQueue.ae = updatePendingSignal;
 
-GlobalQueue.ae = updateChildCompanions;
+GlobalQueue.ce = updateChildCompanions;
 
-GlobalQueue.ce = snapCompanionsToState;
+GlobalQueue.fe = snapCompanionsToState;
 
-GlobalQueue.fe = latestRead;
+GlobalQueue.Ee = latestRead;
 
-GlobalQueue.Ee = pendingCheckRead;
+GlobalQueue.de = pendingCheckRead;
 
-GlobalQueue.de = recordFreshRead;
+GlobalQueue.Se = recordFreshRead;
 
-GlobalQueue.Se = applyReask;
+GlobalQueue.Te = applyReask;
 
-GlobalQueue.Te = repollDownstreamVerdicts;
+GlobalQueue.Oe = repollDownstreamVerdicts;
 
-GlobalQueue.Oe = witnessAffects;
+GlobalQueue._e = witnessAffects;
 
 /**
  * Effects are the leaf nodes of our reactive graph. When their sources change, they are
@@ -3354,16 +3493,16 @@ GlobalQueue.Oe = witnessAffects;
     const i = !!r?.user;
     const o = createEffectNode(e, t, n, i ? EFFECT_USER : EFFECT_RENDER, notifyEffectStatus, r);
     recompute(o, true);
-    !r?.defer && (o.We === EFFECT_USER || r?.schedule ? o.Be.enqueue(o.We, runEffect.bind(null, o)) : runEffect(o));
+    !r?.defer && (o.Fe === EFFECT_USER || r?.schedule ? o.Ze.enqueue(o.Fe, 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.xe;
-    const r = t !== undefined ? t : this.De;
+    const n = e !== undefined ? e : this.Qe;
+    const r = t !== undefined ? t : this.we;
     if (n & STATUS_ERROR) {
-        this.Be.notify(this, STATUS_PENDING, 0);
-        if (this.We === EFFECT_USER) {
+        this.Ze.notify(this, STATUS_PENDING, 0);
+        if (this.Fe === 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
@@ -3373,23 +3512,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.xe & STATUS_ERROR) {
-                this.Fe = true;
-                this.Be.enqueue(this.We, this.Pt ??= runEffect.bind(null, this));
+            if (this.Qe & STATUS_ERROR) {
+                this.xe = true;
+                this.Ze.enqueue(this.Fe, this.Ct ??= runEffect.bind(null, this));
             }
             return;
         }
-        if (!this.Be.notify(this, STATUS_ERROR, STATUS_ERROR)) {
+        if (!this.Ze.notify(this, STATUS_ERROR, STATUS_ERROR)) {
             haltReactivity(unwrapStatusError(r));
             throw r;
         }
-    } else if (this.We === EFFECT_RENDER) {
-        this.Be.notify(this, STATUS_PENDING | STATUS_ERROR, n, r);
+    } else if (this.Fe === EFFECT_RENDER) {
+        this.Ze.notify(this, STATUS_PENDING | STATUS_ERROR, n, r);
     }
 }
 
 function runEffect(e) {
-    if (!e.Fe || e.Le & REACTIVE_DISPOSED) return;
+    if (!e.xe || e.Ge & 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
@@ -3400,46 +3539,46 @@ 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.xe & STATUS_ERROR && e.We === EFFECT_USER) {
-        const t = unwrapStatusError(e.De);
-        e.gt = e.ke;
-        e.Fe = false;
+        if (e.Qe & STATUS_ERROR && e.Fe === EFFECT_USER) {
+        const t = unwrapStatusError(e.we);
+        e.bt = e.We;
+        e.xe = false;
         try {
-            e.Dt ? e.Dt(t, () => {
-                const t = e.ft;
-                e.ft = undefined;
+            e.wt ? e.wt(t, () => {
+                const t = e.Et;
+                e.Et = undefined;
                 t?.();
             }) : console.error(t);
         } catch (t) {
-            if (!e.Be.notify(e, STATUS_ERROR, STATUS_ERROR)) {
+            if (!e.Ze.notify(e, STATUS_ERROR, STATUS_ERROR)) {
                 haltReactivity(t);
                 throw t;
             }
         }
         return;
     }
-    const t = e.ft;
-    e.ft = undefined;
+    const t = e.Et;
+    e.Et = undefined;
     try {
         t?.();
-        const n = e.bt(e.ke, e.gt);
+        const n = e.Dt(e.We, e.bt);
         if (false && n !== undefined && typeof n !== "function") ;
         // The final cleanup is invoked by disposeChildren at true disposal.
-                e.ft = n;
+                e.Et = n;
     } catch (t) {
-        e.De = new StatusError(e, t);
-        e.xe |= STATUS_ERROR;
-        if (!e.Be.notify(e, STATUS_ERROR, STATUS_ERROR)) {
+        e.we = new StatusError(e, t);
+        e.Qe |= STATUS_ERROR;
+        if (!e.Ze.notify(e, STATUS_ERROR, STATUS_ERROR)) {
             haltReactivity(t);
             throw t;
         }
     } finally {
-        e.gt = e.ke;
-        e.Fe = false;
+        e.bt = e.We;
+        e.xe = false;
     }
 }
 
-GlobalQueue.J = runEffect;
+GlobalQueue.ee = runEffect;
 
 /**
  * Internal tracked effect - bypasses heap, goes directly to effect queue.
@@ -3447,39 +3586,39 @@ GlobalQueue.J = runEffect;
  * Uses stale reads.
  */ function trackedEffect(e, t) {
     const run = () => {
-        if (!n.Fe || n.Le & REACTIVE_DISPOSED) return;
+        if (!n.xe || n.Ge & REACTIVE_DISPOSED) return;
         try {
-            n.Fe = false;
+            n.xe = false;
             recompute(n);
         } finally {}
     };
     const n = computed(() => {
-        const t = n.ft;
-        n.ft = undefined;
+        const t = n.Et;
+        n.Et = undefined;
         t?.();
         const r = staleValues(e);
-        n.ft = r;
+        n.Et = r;
     }, {
         ...t,
         lazy: true
     });
-    n.ft = undefined;
-    n.Ge = n.Ge & ~CONFIG_AUTO_DISPOSE | CONFIG_CHILDREN_FORBIDDEN;
-    n.Fe = true;
-    n.We = EFFECT_TRACKED;
-    n.Nt = (e, t) => {
-        const r = e !== undefined ? e : n.xe;
+    n.Et = undefined;
+    n.Ue = n.Ue & ~CONFIG_AUTO_DISPOSE | CONFIG_CHILDREN_FORBIDDEN;
+    n.xe = true;
+    n.Fe = EFFECT_TRACKED;
+    n.yt = (e, t) => {
+        const r = e !== undefined ? e : n.Qe;
         if (r & STATUS_ERROR) {
-            n.Be.notify(n, STATUS_PENDING, 0);
-            const e = t !== undefined ? t : n.De;
-            if (!n.Be.notify(n, STATUS_ERROR, STATUS_ERROR)) {
+            n.Ze.notify(n, STATUS_PENDING, 0);
+            const e = t !== undefined ? t : n.we;
+            if (!n.Ze.notify(n, STATUS_ERROR, STATUS_ERROR)) {
                 haltReactivity(unwrapStatusError(e));
                 throw e;
             }
         }
     };
-    n.Ze = run;
-    n.Be.enqueue(EFFECT_USER, run);
+    n.Xe = run;
+    n.Ze.enqueue(EFFECT_USER, run);
 }
 
 function restoreTransition(e, t) {
@@ -3561,7 +3700,12 @@ function restoreTransition(e, t) {
             o = currentTransition(o);
             const u = o.$.indexOf(i);
             if (u >= 0) o.$.splice(u, 1);
-            setActiveTransition(o);
+            // Re-adopt through initTransition like every other resumption site:
+            // a bare setActiveTransition leaves globalQueue._batch as a detached
+            // ambient batch, and anything registered before the scheduled flush
+            // (held writes on a merging transition, optimistic overrides,
+            // affects() marks) lands there with nothing to ever finalize it.
+                        globalQueue.initTransition(o);
             schedule();
             s ? r(t) : n(e);
         };
@@ -3660,7 +3804,7 @@ function accessor(e) {
 function createSignal(e, t) {
     if (typeof e === "function") {
         const n = computed(e, t);
-        n.Ge &= ~CONFIG_AUTO_DISPOSE;
+        n.Ue &= ~CONFIG_AUTO_DISPOSE;
         return [ accessor(n), setMemo.bind(null, n) ];
     }
     const n = signal(e, t);
@@ -3872,9 +4016,9 @@ function createEffect(e, t, n) {
             // route through the inherited queue.
             const i = getOwner();
             const o = new MicrotaskQueue;
-            o.B = i.Be;
+            o.B = i.Ze;
  // notify() forwards up the normal chain
-                        i.Be = o;
+                        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
@@ -3901,7 +4045,7 @@ function createOptimistic(e, t) {
     installOptimisticEngine();
     if (typeof e === "function") {
         const n = optimisticComputed(e, t);
-        n.Ge &= ~CONFIG_AUTO_DISPOSE;
+        n.Ue &= ~CONFIG_AUTO_DISPOSE;
         return [ accessor(n), setSignal.bind(null, n) ];
     }
     const n = optimisticSignal(e, t);
@@ -3990,7 +4134,7 @@ function createOptimistic(e, t) {
  *   on owner disposal
  */ function onSettled(e) {
     const t = getOwner();
-    t && !(t.Ge & CONFIG_CHILDREN_FORBIDDEN) ? createTrackedEffect(() => untrack(e), undefined) : globalQueue.enqueue(EFFECT_USER, () => {
+    t && !(t.Ue & 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
@@ -4089,6 +4233,17 @@ function keyedMatch(e, t, n) {
     return e === t || isWrappable(e) && isWrappable(t) && n(e) === n(t);
 }
 
+// A pair of array slots may only be merged into when both sides are real store
+// children of the SAME container kind. An array and an object are different
+// shapes, and merging one into the other leaves the slot's proxy permanently
+// mismatched with its value (an array target holding an object, so
+// `Array.isArray`/spread/`map` lie). The object diff has always applied this
+// rule; the array paths reach the same recursion through `keyedMatch` /
+// positional pairing, where two keyless wrappables "match" regardless of kind.
+function recursablePair(e, t) {
+    return isWrappable(e) && isWrappable(t) && !(rawValuesUsed && (isRawValue(e) || isRawValue(t))) && Array.isArray(e) === Array.isArray(t);
+}
+
 // Array reconciliation updates the slots it visits, then swaps STORE_VALUE.
 // Previously tracked keys that are absent from `next` still need invalidating,
 // and `in` dependencies should follow the new value's membership. Use
@@ -4155,7 +4310,7 @@ function applyStateChild(e, t, n, r) {
 // Reconcile a single array slot: recurse into a wrappable pair, otherwise replace
 // the node's value outright (covers object→primitive and primitive→object).
 function applyArrayItem(e, t, n, r, i) {
-    if (isWrappable(e) && isWrappable(t) && !(rawValuesUsed && (isRawValue(t) || isRawValue(e)))) {
+    if (recursablePair(t, e)) {
         const o = wrap(t, n);
         r && setSignal(r, o);
         applyState(e, o, i);
@@ -4345,7 +4500,7 @@ function applyStateFast(e, t, n) {
                 // the recursion dispatch entirely. Raw-marked values are leaves:
                 // replace the slot node instead of recursing.
                 if (E !== e[a]) {
-                    if (rawValuesUsed && (isRawValue(E) || isRawValue(e[a]))) {
+                    if (!recursablePair(E, e[a])) {
                         i?.[a] && setSignal(i[a], wrapValue(e[a], t));
                     } else applyStateChild(e[a], E, t, n);
                 }
@@ -4401,7 +4556,7 @@ function applyStateFast(e, t, n) {
         } else if (e.length) {
             for (let s = 0, u = e.length; s < u; s++) {
                 const u = r[s];
-                if (isWrappable(u) && isWrappable(e[s]) && !(rawValuesUsed && (isRawValue(u) || isRawValue(e[s])))) {
+                if (recursablePair(u, e[s])) {
                     if (u !== e[s]) applyStateChild(e[s], u, t, n);
                 } else {
                     if (u !== e[s]) o = true;
@@ -4491,13 +4646,13 @@ function applyStateSlow(e, t, n) {
         if (e.length && l && isWrappable(e[0]) && n(e[0]) != null) {
             let a, c, f, E, d, S, T, O;
             for (f = 0, E = Math.min(l, e.length); f < E && keyedMatch(S = getOverrideValue(r, i, f, o), e[f], n); f++) {
-                if (isWrappable(S) && isWrappable(e[f]) && S !== e[f]) {
-                    if (rawValuesUsed && (isRawValue(S) || isRawValue(e[f]))) {
+                if (S !== e[f] && isWrappable(S) && isWrappable(e[f])) {
+                    if (!recursablePair(S, e[f])) {
                         s?.[f] && setSignal(s[f], wrapValue(e[f], t));
                     } else applyState(e[f], wrap(S, t), n);
                 }
             }
-            const _ = new Array(e.length), p = new Map;
+            const _ = new Array(e.length), R = 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;
@@ -4521,18 +4676,18 @@ function applyStateSlow(e, t, n) {
             for (c = d; c >= f; c--) {
                 S = e[c];
                 O = itemKey(S, n);
-                a = p.get(O);
+                a = R.get(O);
                 T[c] = a === undefined ? -1 : a;
-                p.set(O, c);
+                R.set(O, c);
             }
             for (a = f; a <= E; a++) {
                 S = getOverrideValue(r, i, a, o);
                 O = itemKey(S, n);
-                c = p.get(O);
+                c = R.get(O);
                 if (c !== undefined && c !== -1) {
                     _[c] = S;
                     c = T[c];
-                    p.set(O, c);
+                    R.set(O, c);
                 }
             }
             for (c = f; c < e.length; c++) {
@@ -4544,7 +4699,7 @@ function applyStateSlow(e, t, n) {
         } else if (e.length) {
             for (let l = 0, a = e.length; l < a; l++) {
                 const a = getOverrideValue(r, i, l, o);
-                if (isWrappable(a) && isWrappable(e[l]) && !(rawValuesUsed && (isRawValue(a) || isRawValue(e[l])))) {
+                if (recursablePair(a, e[l])) {
                     if (a !== e[l]) applyState(e[l], wrap(a, t), n);
                 } else {
                     if (a !== e[l]) u = true;
@@ -4593,6 +4748,58 @@ function applyStateSlow(e, t, n) {
 // the positional branch and object descent to plain per-property merging.
 const NOKEY = () => null;
 
+// Identity-as-key: distinct objects never match, so every slot takes the diff's
+// "not the same entity" branch and is replaced by reference rather than merged
+// into. Slots holding the same raw on both sides still keep their proxy.
+const IDENTITY = e => e;
+
+/**
+ * Shared body of `reconcile()` and the projection commit. `replace` is the
+ * only difference: a projection commit is a value swap, not a merge — its root
+ * proxy is a cell handed out by `createProjection` that can never change
+ * reference, so a derive returning a different entity is not the slot mistake
+ * `reconcile()` throws on. Nothing below the root survives that swap, which is
+ * the rule the keyed diff already applies at a nested slot on a key mismatch.
+ *
+ * @internal
+ */ function reconcileState(e, t, n, r) {
+    if (t == null) throw new Error("");
+    // A projection commit whose derive returns a foreign store adopts it as the
+    // live backing (store-in-store chain — the same shape as a store-proxy
+    // seed): reads route through the inner store's own graph, so its updates
+    // flow with no re-derive, and a derive with no dependencies never recomputes
+    // (#2941). The diff below still runs against raw values so THIS store's
+    // existing subscribers see the swap; the live proxy is installed after.
+    // Shallow projections keep their raw-ingest contract and never chain.
+        let i;
+    const o = r ? t[$TARGET] : undefined;
+    if (o !== undefined) {
+        if (e?.[$TARGET] !== undefined && e[$TARGET] !== o && !o[STORE_SHALLOW]) {
+            if (o[STORE_VALUE] === e) return;
+ // already chained to this store
+                        i = e;
+        }
+        // Re-diffing a previously chained backing goes through its raw — reads
+        // off the outgoing proxy would subscribe this computed to a store it is
+        // about to drop.
+                while (o[STORE_VALUE]?.[$TARGET] !== undefined) o[STORE_VALUE] = unwrap(o[STORE_VALUE]);
+    }
+    if (n === null) applyState(e, t, NOKEY); else {
+        let i = typeof n === "string" ? e => e[n] : n;
+        const o = i(t);
+        if (o !== undefined && i(e) !== o) {
+            if (!r) throw new Error("");
+            // Or the outgoing raw keeps resolving to this proxy and surfaces the
+            // incoming entity wherever it reappears in this family.
+                        const n = t[$TARGET];
+            if (n && n[STORE_VALUE] !== unwrap(e)) n[STORE_LOOKUP]?.delete(n[STORE_VALUE]);
+            i = IDENTITY;
+        }
+        applyState(e, t, i);
+    }
+    if (i !== undefined) o[STORE_VALUE] = i;
+}
+
 /**
  * Returns a draft-mutating function that smart-merges `value` into a store,
  * preserving fine-grained reactivity: only changed leaves trigger updates.
@@ -4607,6 +4814,9 @@ const NOKEY = () => null;
  * the classic pattern for fixed-shape data that churns in place (dashboards,
  * monitors), where no keyed diff pass is needed or wanted.
  *
+ * Merging into a slot that holds a *different* entity throws — the caller
+ * picked the slot, so a key mismatch there is a bug.
+ *
  * @param value the next state to merge in
  * @param key property name (string) or extractor function for stable
  * identity (default `"id"`); pass `null` for positional merging
@@ -4624,17 +4834,7 @@ const NOKEY = () => null;
  * setStats(reconcile(nextStats, null));
  * ```
  */ function reconcile(e, t = "id") {
-    return n => {
-        if (n == null) throw new Error("");
-        if (t === null) {
-            applyState(e, n, NOKEY);
-            return;
-        }
-        const r = typeof t === "string" ? e => e[t] : t;
-        const i = r(n);
-        if (i !== undefined && r(e) !== i) throw new Error("");
-        applyState(e, n, r);
-    };
+    return n => reconcileState(e, n, t, false);
 }
 
 function createProjectionInternal(e, t, n) {
@@ -4667,9 +4867,9 @@ function createProjectionInternal(e, t, n) {
     const s = wrapProjection(t);
     r = computed(() => {
         if (!r) r = getOwner();
-        runProjectionComputed(s, e, n?.key || "id");
+        runProjectionComputed(s, e, n?.key === undefined ? "id" : n.key);
     }, undefined);
-    r.Ge &= ~CONFIG_AUTO_DISPOSE;
+    r.Ue &= ~CONFIG_AUTO_DISPOSE;
     return {
         store: s,
         node: r
@@ -4684,6 +4884,10 @@ function createProjectionInternal(e, t, n) {
  * items keep their proxy identity — only added/removed items are
  * created/disposed.
  *
+ * If the derive returns a different entity than the one currently held (the
+ * `/users/1` → `/users/2` shape), the store swaps to it rather than merging,
+ * and nothing below it is treated as surviving.
+ *
  * Returns the projected store directly (no setter — reads only).
  *
  * Use this when you want the structural-sharing / per-property tracking
@@ -4696,7 +4900,8 @@ function createProjectionInternal(e, t, n) {
  * @param seed the backing store value to wrap and reconcile into
  * @param options `ProjectionOptions` — `name`, `key`. `key` defaults to
  *   `"id"`; specify it only when your data uses a different identity field
- *   (e.g. `{ key: "uuid" }` or `{ key: u => u.slug }`).
+ *   (e.g. `{ key: "uuid" }` or `{ key: u => u.slug }`), or `null` to merge
+ *   positionally with no keyed pass.
  *
  * @example
  * ```ts
@@ -4738,13 +4943,13 @@ function createProjectionInternal(e, t, n) {
     const o = getOwner();
     let s = false;
     let u;
-    const l = new Proxy(e, createWriteTraps(() => !s || o.ut === u, i));
+    const l = new Proxy(e, createWriteTraps(() => !s || o.lt === u, i));
     storeSetter(l, i => {
         u = t(i);
         s = true;
         const commit = t => {
             if (t === i || t === undefined) return;
-            const write = () => storeSetter(e, reconcile(t, n));
+            const write = () => storeSetter(e, e => reconcileState(t, e, n, true));
             r ? r(write) : write();
         };
         commit(handleAsync(o, u, commit));
@@ -4913,6 +5118,14 @@ function isRawValue(e) {
 
 function markRawOne(e) {
     if (isWrappable(e)) {
+        // A store proxy is already tracked elsewhere: the shallow boundary passes
+        // it through by reference (replaced, never edited — same slot semantics
+        // as a raw) instead of claiming it raw. The sticky mark is global, so
+        // marking a live proxy would make wrap() serve it verbatim through every
+        // OTHER store too — downstream deep stores then captured it instead of
+        // wrapping it in their own family, and their writes landed in the
+        // upstream store's override layer (#2932).
+        if (e[$TARGET] !== undefined) return;
         rawValuesUsed = true;
         rawValues.add(e);
     }
@@ -4964,11 +5177,39 @@ function wrapShallow(e) {
     return n;
 }
 
+const OBJECT_PROTO = Object.prototype;
+
+// Per-prototype memo for the custom-proto branch of isWrappable: the verdict
+// is fully determined by the prototype (tag and Node lineage both live on
+// the chain), so each class pays the tag call once — not per read.
+const wrappableProtos = new WeakMap;
+
 function isWrappable(e) {
     if (e == null || typeof e !== "object" || Object.isFrozen(e)) return false;
-    // Dynamic Node check (kept dynamic so test/SSR overrides of `globalThis.Node`
-    // are observed at call time).
-        return typeof Node === "undefined" || !(e instanceof Node);
+    // Plain data and user class instances wrap; platform objects never do
+    // (#2952). Native code brand-checks internal slots and throws through a
+    // proxy (`Map.prototype.size`, `Date.prototype.getTime`, ...), so
+    // collections and other built-ins can't honestly be stores — they get the
+    // markRaw-children contract automatically: served raw, mutations land raw,
+    // the property holding them still tracks (reassignment notifies). The tag
+    // check separates them structurally: user classes stringify as
+    // `[object Object]` while every native/host object carries its own brand
+    // (`[object Map]`, `[object Date]`, `[object Headers]`, ...), including
+    // subclasses, which inherit the tag. getPrototypeOf keeps the hot path
+    // (plain and null-proto objects) intrinsic-only — no property lookup.
+        const t = Object.getPrototypeOf(e);
+    if (t === OBJECT_PROTO || t === null) return true;
+    if (Array.isArray(e)) return true;
+    let n = wrappableProtos.get(t);
+    if (n === undefined) {
+        n = Object.prototype.toString.call(e) === "[object Object]" && (
+        // Dynamic Node check (kept dynamic so test/SSR overrides of
+        // `globalThis.Node` are observed at call time): shimmed DOMs implement
+        // nodes as plain user classes, which pass the tag check.
+        typeof Node === "undefined" || !(e instanceof Node));
+        wrappableProtos.set(t, n);
+    }
+    return n;
 }
 
 let writeOverride = false;
@@ -5046,7 +5287,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.U !== NOT_PENDING ? e.U : e.ke;
+    return e.A !== undefined && e.A !== NOT_PENDING ? unwrapOverride(e.A) : e.U !== NOT_PENDING ? e.U : e.We;
 }
 
 function hasOwnStoreProperty(e, t) {
@@ -5101,7 +5342,7 @@ function getNode(e, t, n, r, i = isEqual, o) {
     }
     if (o && n in o) {
         const e = o[n];
-        s.me = e === undefined ? NO_SNAPSHOT : e;
+        s.ve = e === undefined ? NO_SNAPSHOT : e;
         snapshotSources?.add(s);
     }
     if (typeof n === "symbol" && n !== $TRACK && n !== $AFFECTS) symbolKeyedRecords.add(t);
@@ -5131,7 +5372,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.k && i.scope.has(t) && (i.key === undefined || i.key === n)) {
-            GlobalQueue.re(e);
+            GlobalQueue.ie(e);
             i.inherited.push(e);
         }
     }
@@ -5219,11 +5460,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?.k) GlobalQueue.Oe(n);
+    if (n?.k) GlobalQueue._e(n);
     if (affectsScopes.size) {
         const r = e[STORE_VALUE];
         for (const [e, i] of affectsScopes) {
-            if (e !== n && e.k && i.scope.has(r) && (i.key === undefined || i.key === t)) GlobalQueue.Oe(e);
+            if (e !== n && e.k && i.scope.has(r) && (i.key === undefined || i.key === t)) GlobalQueue._e(e);
         }
     }
 }
@@ -5240,11 +5481,11 @@ i) {
  * @internal
  */ function getStoreAffectsNodes(e, t) {
     const n = getNodes(e, STORE_NODE);
-    GlobalQueue.te ||= e => {
+    GlobalQueue.ne ||= e => {
         const t = affectsScopes.get(e);
         if (!t) return;
         affectsScopes.delete(e);
-        for (let e = 0; e < t.inherited.length; e++) GlobalQueue.ie(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);
@@ -5371,7 +5612,7 @@ function prepareStoreWrite(e, t, n) {
     }
     const r = e[STORE_VALUE];
     const i = r[n];
-    if (snapshotCaptureActive && typeof n !== "symbol" && !((e[STORE_FIREWALL]?.xe ?? 0) & STATUS_PENDING)) {
+    if (snapshotCaptureActive && typeof n !== "symbol" && !((e[STORE_FIREWALL]?.Qe ?? 0) & STATUS_PENDING)) {
         if (!e[STORE_SNAPSHOT_PROPS]) {
             e[STORE_SNAPSHOT_PROPS] = Object.create(null);
             snapshotSources?.add(e);
@@ -5399,7 +5640,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.be(t);
+        GlobalQueue.De(t);
     }
 }
 
@@ -5409,8 +5650,11 @@ function prepareStoreWrite(e, t, n) {
  * concurrent actions writing disjoint keys must revert independently, exactly
  * like optimistic signal nodes do via the transition's _optimisticNodes.
  * `activeTransition` is the write's transaction (action() opens it before the
- * body runs); null marks an ambient write that clears at plain flush end.
- * Same-key writes across actions keep last-write-wins layer semantics.
+ * body runs); null marks an ambient write, which clears at plain flush end —
+ * unless its flush's transition is blocked on the store's own in-flight truth
+ * (pending firewall, #2951), in which case it rides that transaction to
+ * settle. Same-key writes across actions keep last-write-wins layer
+ * semantics.
  */ function stampOptimisticOwner(e, t, n) {
     if (t === STORE_OPTIMISTIC_OVERRIDE) (e[STORE_OPTIMISTIC_OWNERS] ??= Object.create(null))[n] = activeTransition;
 }
@@ -5463,16 +5707,36 @@ function notifyStoreProperty(e, t, n, r, i, o) {
 let Writing = null;
 
 /**
- * A derived store's seed is a draft for the derive function, never an
- * observable value (#2897): until the firewall first resolves there is
- * nothing to read, so every consumer path throws NotReady — tracked reads
- * through their node (core read()), and the untracked fall-throughs in the
- * traps through this guard. Returning the seed leaked it; returning
- * `undefined` would break non-nullable types. Callers exempt the firewall
- * itself (the derive function works its own draft while uninitialized).
- */ function throwIfUninitialized(e) {
+ * A derived store follows async memo rules (#2897 ruling): its seed is a
+ * draft for the derive function, never an observable value, and an errored
+ * derive is an error state, never a silent stale/seed serve. Until the
+ * firewall first resolves there is nothing to read, so every consumer path
+ * throws NotReady — tracked reads through their node (core read()), and the
+ * untracked fall-throughs in the traps through this guard. Returning the
+ * seed leaked it; returning `undefined` would break non-nullable types.
+ * Callers exempt the firewall itself (the derive function works its own
+ * draft while uninitialized).
+ *
+ * Error rail: a firewall carrying STATUS_ERROR throws its error for every
+ * late reader — memo parity, where read()'s error branch does the same for
+ * plain computeds. Rejection clears STATUS_UNINITIALIZED at commit, so
+ * without this check late readers silently got the seed while settle-time
+ * subscribers saw the error.
+ *
+ * Loading rail: the veto requires the firewall to still be in flight, not
+ * just flagged: STATUS_UNINITIALIZED's clear is deferred to batch commit,
+ * so during the settle flush a firewall that has already recomputed — and
+ * reconciled real values into STORE_VALUE — still carries the stale flag.
+ * STATUS_PENDING is the live bit (it clears eagerly at settle, mirroring
+ * core read()'s verdict), so gating on it stops the guard from throwing a
+ * fresh NotReadyError that nothing would ever sweep. #2944: mapArray's
+ * keyed diff reads items inside its internal owner (untracked by design)
+ * in exactly this window, and the stale throw wedged <For> permanently.
+ */ function throwIfUnreadable(e) {
     const t = e[STORE_FIREWALL];
-    if (t && t.xe & STATUS_UNINITIALIZED) throw t.De ?? new NotReadyError(t);
+    if (!t) return;
+    const n = t.Qe;
+    if (n & STATUS_ERROR || n & STATUS_UNINITIALIZED && n & STATUS_PENDING) throw t.we ?? new NotReadyError(t);
 }
 
 const storeTraps = {
@@ -5559,7 +5823,14 @@ const storeTraps = {
         }
         // Untracked fall-through (tracked reads already threw via their node in
         // read(); the dev strictRead error above wins first for memo parity).
-                if (!r) throwIfUninitialized(e);
+        // Observer-present reads must NOT re-consult the flag here: during the
+        // settle flush the firewall has recomputed (first values live on the
+        // pending rail, served by read() above) but its UNINITIALIZED clear is
+        // deferred to batch commit — vetoing read()'s verdict with the stale flag
+        // threw a fresh NotReadyError for an already-settled source, which no
+        // sweep would ever release (#2938: projection over an async store wedged
+        // its Loading boundary on `undefined`).
+                if (!r && !getObserver()) throwIfUnreadable(e);
         return isWrappable(f) ? wrap(f, e) : f;
     },
     has(e, t) {
@@ -5579,7 +5850,7 @@ const storeTraps = {
                 if (getObserver()) {
             return read(getNode(e, i, t, r));
         }
-        throwIfUninitialized(e);
+        throwIfUnreadable(e);
         return r;
     },
     set(e, t, n) {
@@ -5591,37 +5862,48 @@ const storeTraps = {
                 const u = getOverlayLayer(e, t);
                 const l = u ? u[t] : i;
                 const a = u ? u[t] !== $DELETED : t in e[STORE_VALUE];
-                const c = unwrapStoreValue(n);
-                if (e[STORE_SHALLOW] && isWrappable(c)) rawValues.add(c);
+                // Shallow slots hold store proxies verbatim (pass-through reference,
+                // never raw-marked — see markRawOne/#2932); everything else unwraps
+                // and marks as usual.
+                                const c = !!e[STORE_SHALLOW] && n?.[$TARGET] !== undefined;
+                const f = c ? n : unwrapStoreValue(n);
+                if (e[STORE_SHALLOW] && !c && isWrappable(f)) {
+                    // Flip the live gate too: a bare add was inert unless something else
+                    // had already marked a raw somewhere (wrap() checks rawValuesUsed
+                    // first), so the documented set-trap ingest mark silently no-oped in
+                    // apps whose only shallow data arrived through writes.
+                    rawValuesUsed = true;
+                    rawValues.add(f);
+                }
                 // Symbol-keyed writes on arrays are metadata, not index writes — never run
                 // them through the numeric index/length machinery (`parseInt` on a symbol
                 // 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;
-                if (l === c && T === undefined) return true;
+                                const E = typeof t === "string" ? Number(t) : -1;
+                const d = Array.isArray(s) && Number.isInteger(E) && E >= 0 && E < 4294967295 && String(E) === t;
+                const S = d ? E + 1 : 0;
+                const T = d && (getOverlayLayer(e, "length") ?? s).length;
+                const O = d && S > T ? S : undefined;
+                if (l === f && O === undefined) return true;
                 armOptimisticStoreWrite(e, r);
-                if (c !== undefined && c === i && T === undefined) {
+                if (f !== undefined && f === i && O === undefined) {
                     delete e[o]?.[t];
                     if (o === STORE_OPTIMISTIC_OVERRIDE) delete e[STORE_OPTIMISTIC_OWNERS]?.[t];
                 } else {
                     const n = e[o] || (e[o] = Object.create(null));
-                    n[t] = c;
+                    n[t] = f;
                     stampOptimisticOwner(e, o, t);
-                    if (T !== undefined) {
-                        n.length = T;
+                    if (O !== undefined) {
+                        n.length = O;
                         stampOptimisticOwner(e, o, "length");
                     }
                 }
-                notifyStoreProperty(e, t, "set", c, l, a);
+                notifyStoreProperty(e, t, "set", f, l, a);
                 // Shrinking an array's length must remove the truncated indices, otherwise
                 // they leak through `has`, `ownKeys`, and (tracked) index reads from the
                 // underlying value. Mark each as deleted and notify so reactive reads update. #2768
-                                if (Array.isArray(s) && t === "length" && typeof c === "number" && typeof l === "number" && c < l) {
+                                if (Array.isArray(s) && t === "length" && typeof f === "number" && typeof l === "number" && f < l) {
                     const t = e[o] || (e[o] = Object.create(null));
-                    for (let n = c; n < l; n++) {
+                    for (let n = f; n < l; n++) {
                         if (t[n] === $DELETED) continue;
                         const r = n in t ? t[n] : s[n];
                         if (!(n in t) && !(n in s)) continue;
@@ -5631,13 +5913,13 @@ const storeTraps = {
                     }
                 }
                 // notify length change
-                                if (Array.isArray(s) && t !== "length" && T !== undefined) {
+                                if (Array.isArray(s) && t !== "length" && O !== undefined) {
                     const t = getNodes(e, STORE_NODE);
                     if (t.length) {
-                        setSignal(t.length, T);
+                        setSignal(t.length, O);
                     } else if (!projectionWriteActive && !e[STORE_OPTIMISTIC]) {
-                        const n = upsertStoreNode(e, t, "length", S, e[STORE_SNAPSHOT_PROPS]);
-                        setSignal(n, T);
+                        const n = upsertStoreNode(e, t, "length", T, e[STORE_SNAPSHOT_PROPS]);
+                        setSignal(n, O);
                     }
                 }
                 if (false) ;
@@ -5698,7 +5980,7 @@ const storeTraps = {
             // path is exempt (like the get/has traps' writeOnly early returns):
             // the first landing's reconcile enumerates the store while
             // STATUS_UNINITIALIZED is still set — it IS the initialization.
-                        if (!getObserver() && !writeOnly(e[$PROXY])) throwIfUninitialized(e);
+                        if (!getObserver() && !writeOnly(e[$PROXY])) throwIfUnreadable(e);
         }
         // Merge optimistic override with regular override for key enumeration
                 let t = getKeys(e[STORE_VALUE], e[STORE_OVERRIDE], false);
@@ -5816,17 +6098,17 @@ function createStore(e, t, n) {
  * flush that would surface them, before effects run — verdict-only, netting
  * no visual change.
  */ function notifyMarkBoundaries(e) {
-    if (!e.G && !e.nt) return;
+    if (!e.V && !e.rt) return;
     const t = new NotReadyError(e);
-    t.we = true;
+    t.me = 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.Nt) {
-            e.Nt(STATUS_PENDING, t);
+                if (e.yt) {
+            e.yt(STATUS_PENDING, t);
             return;
         }
         forEachDependent(e, visit);
@@ -5847,7 +6129,7 @@ function createStore(e, t, n) {
     globalQueue.D.L.push(e);
     // Companions only exist once the verdict layer (isPending/latest) loaded;
     // without them there is no materialized verdict to poke.
-        GlobalQueue.Te !== null && GlobalQueue.Te(e);
+        GlobalQueue.Oe !== null && GlobalQueue.Oe(e);
     notifyMarkBoundaries(e);
     schedule();
 }
@@ -5861,8 +6143,8 @@ function createStore(e, t, n) {
     shiftAffectsMarks(-1);
     e.k--;
     if (!e.k) {
-        GlobalQueue.Te !== null && GlobalQueue.Te(e, true);
-        GlobalQueue.te?.(e);
+        GlobalQueue.Oe !== null && GlobalQueue.Oe(e, true);
+        GlobalQueue.ne?.(e);
     }
 }
 
@@ -5879,11 +6161,11 @@ function createStore(e, t, n) {
 // 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.ne = releaseAffectsMarks;
+GlobalQueue.re = releaseAffectsMarks;
 
-GlobalQueue.re = markAffects;
+GlobalQueue.ie = markAffects;
 
-GlobalQueue.ie = releaseAffectsMark;
+GlobalQueue.oe = releaseAffectsMark;
 
 function affects(e, t) {
     const n = e?.[$TARGET];
@@ -5904,7 +6186,26 @@ function createOptimisticStore(e, t, n) {
     // STORE_OPTIMISTIC take the engine's write path, so install it before any
     // node can be created.
     installOptimisticEngine();
-    GlobalQueue.ee ||= clearOptimisticStores;
+    if (!GlobalQueue.te) {
+        GlobalQueue.te = clearOptimisticStores;
+        // Store half of the engine's override blockage (#2951): signal-form
+        // createOptimistic carries the pending async and the override on ONE node,
+        // so transitionBlocked sees both; a derived optimistic STORE splits them —
+        // the layer sits on store targets while the in-flight truth lives on the
+        // firewall computed. Without this, the transition adopting a bare store
+        // write settled in the same flush that started the refetch and its settle
+        // consumed the layer mid-flight (follow-up writes then drafted from base,
+        // clobbering instead of composing). Optimistic state clears when truth
+        // lands or its transaction ends — never mid-refetch. Wrapped here (engine
+        // is already installed above) so store-free apps never carry the check.
+                const e = GlobalQueue.Ie;
+        GlobalQueue.Ie = t => {
+            for (const e of t.G) {
+                if ((e[$TARGET]?.[STORE_FIREWALL]?.Qe ?? 0) & STATUS_PENDING) return true;
+            }
+            return e(t);
+        };
+    }
     const r = typeof e === "function";
     // Plain form: the second slot carries options.
         if (!r && n === undefined) n = t;
@@ -5983,10 +6284,10 @@ function clearOptimisticStores(e, t) {
                 const i = isWrappable(r) ? wrap(r, e) : r;
                 const o = visibleNodeValue(a);
                 a.A = NOT_PENDING;
-                a.R = null;
+                a.p = null;
                 a.U = NOT_PENDING;
-                a.ke = i;
-                if (!a.At || !a.At(o, i)) {
+                a.We = i;
+                if (!a.ht || !a.ht(o, i)) {
                     insertSubs(a, true);
                     schedule();
                 }
@@ -6060,12 +6361,12 @@ function createOptimisticProjectionInternal(e, t, n) {
         r = computed(() => {
             setProjectionWriteActive(true);
             try {
-                runProjectionComputed(s, e, n?.key || "id", wrapCommit, clearProjectionOverride);
+                runProjectionComputed(s, e, n?.key === undefined ? "id" : n.key, wrapCommit, clearProjectionOverride);
             } finally {
                 setProjectionWriteActive(false);
             }
         }, undefined);
-        r.Ge &= ~CONFIG_AUTO_DISPOSE;
+        r.Ue &= ~CONFIG_AUTO_DISPOSE;
     }
     return {
         store: s,
@@ -6489,24 +6790,24 @@ function mapArray(e, t, n) {
     const i = t.length > 1;
     const o = t;
     const s = {
-        wt: createOwner(),
-        vt: 0,
-        Lt: e,
+        vt: createOwner(),
+        Lt: 0,
+        Gt: e,
         Vt: [],
-        Gt: o,
-        Ut: [],
+        Ut: o,
         kt: [],
-        Wt: r,
-        Ft: r || n?.keyed === false ? [] : undefined,
-        xt: i && n?.keyed !== false ? [] : undefined,
-        Qt: n?.keyed === false,
-        Ht: n?.fallback
+        Wt: [],
+        Ft: r,
+        xt: r || n?.keyed === false ? [] : undefined,
+        Qt: i && n?.keyed !== false ? [] : undefined,
+        Ht: n?.keyed === false,
+        Mt: 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.wt.Je = u;
-    u.Ge &= ~CONFIG_AUTO_DISPOSE;
+        s.vt.et = u;
+    u.Ue &= ~CONFIG_AUTO_DISPOSE;
     return accessor(u);
 }
 
@@ -6524,52 +6825,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.Lt() || [], t = e.length;
+    const e = this.Gt() || [], t = e.length;
     e[$TRACK];
  // top level tracking
-        runWithOwner(this.wt, () => {
+        runWithOwner(this.vt, () => {
         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.Ft ? this.Qt ? () => {
+        s = this.xt ? this.Ht ? () => {
             i[r] = signal(e[r], pureOptions);
-            return this.Gt(accessor(i[r]), r);
+            return this.Ut(accessor(i[r]), r);
         } : () => {
             i[r] = signal(e[r], pureOptions);
             o && (o[r] = signal(r, pureOptions));
-            return this.Gt(accessor(i[r]), o ? accessor(o[r]) : undefined);
-        } : this.xt ? () => {
+            return this.Ut(accessor(i[r]), o ? accessor(o[r]) : undefined);
+        } : this.Qt ? () => {
             const t = e[r];
             o[r] = signal(r, pureOptions);
-            return this.Gt(t, accessor(o[r]));
+            return this.Ut(t, accessor(o[r]));
         } : () => {
             const t = e[r];
-            return this.Gt(t);
+            return this.Ut(t);
         };
         // fast path for empty arrays
                 if (t === 0) {
-            if (this.vt !== 0) {
-                this.wt.dispose(false);
-                this.kt = [];
+            if (this.Lt !== 0) {
+                this.vt.dispose(false);
+                this.Wt = [];
                 this.Vt = [];
-                this.Ut = [];
-                this.vt = 0;
-                this.Ft && (this.Ft = []);
+                this.kt = [];
+                this.Lt = 0;
                 this.xt && (this.xt = []);
+                this.Qt && (this.Qt = []);
             }
-            if (this.Ht && !this.Ut[0]) {
+            if (this.Mt && !this.kt[0]) {
                 // an aborted fallback attempt leaves an owner without a mapping;
                 // dispose it before re-creating
-                this.kt[0]?.dispose();
-                this.Ut[0] = runWithOwner(this.kt[0] = createOwner(), this.Ht);
+                this.Wt[0]?.dispose();
+                this.kt[0] = runWithOwner(this.Wt[0] = createOwner(), this.Mt);
             }
         }
         // fast path for new create
-         else if (this.vt === 0) {
+         else if (this.Lt === 0) {
             const u = new Array(t);
             const l = new Array(t);
-            i = this.Ft && new Array(t);
-            o = this.xt && new Array(t);
+            i = this.xt && new Array(t);
+            o = this.Qt && new Array(t);
             try {
                 for (r = 0; r < t; r++) u[r] = runWithOwner(l[r] = createOwner(), s);
             } catch (e) {
@@ -6577,43 +6878,43 @@ function updateKeyedMap() {
                 throw e;
             }
             // commit
-                        if (this.kt[0]) this.kt[0].dispose();
+                        if (this.Wt[0]) this.Wt[0].dispose();
  // previous fallback
-                        this.Ut = u;
-            this.kt = l;
-            i && (this.Ft = i);
-            o && (this.xt = o);
+                        this.kt = u;
+            this.Wt = l;
+            i && (this.xt = i);
+            o && (this.Qt = o);
             this.Vt = e.slice(0);
-            this.vt = t;
+            this.Lt = t;
         } else {
             let u, l, a, c, f, E, d, S, T;
             // skip common prefix
-                        for (u = 0, l = Math.min(this.vt, t); u < l && (this.Vt[u] === e[u] || this.Ft && compare(this.Wt, this.Vt[u], e[u])); u++) {
-                if (this.Ft) setSignal(this.Ft[u], e[u]);
+                        for (u = 0, l = Math.min(this.Lt, t); u < l && (this.Vt[u] === e[u] || this.xt && compare(this.Ft, this.Vt[u], e[u])); u++) {
+                if (this.xt) setSignal(this.xt[u], e[u]);
             }
             // skip common suffix — counted only; retained entries land in one pass
             // at commit instead of being staged and copied twice
-                        for (l = this.vt - 1, a = t - 1; l >= u && a >= u && (this.Vt[l] === e[a] || this.Ft && compare(this.Wt, this.Vt[l], e[a])); l--, 
+                        for (l = this.Lt - 1, a = t - 1; l >= u && a >= u && (this.Vt[l] === e[a] || this.xt && compare(this.Ft, this.Vt[l], e[a])); l--, 
             a--) ;
             // no structural change (every position matched in place at equal
             // length — the common post-reconcile shape): keep the same mapped
             // array identity so downstream consumers don't re-run at all
-                        if (u === t && this.vt === t) {
+                        if (u === t && this.Lt === t) {
                 this.Vt = e.slice(0);
                 return;
             }
-            const O = t - this.vt;
+            const O = t - this.Lt;
             const _ = new Array(t);
-            const p = new Array(t);
-            i = this.Ft ? new Array(t) : undefined;
-            o = this.xt ? new Array(t) : undefined;
+            const R = new Array(t);
+            i = this.xt ? new Array(t) : undefined;
+            o = this.Qt ? new Array(t) : undefined;
             // 0) prepare a map of all indices in the changed window of newItems,
             // scanning backwards so we encounter them in natural order
                         E = new Map;
             d = new Array(a + 1);
             for (r = a; r >= u; r--) {
                 c = e[r];
-                f = this.Wt ? this.Wt(c) : c;
+                f = this.Ft ? this.Ft(c) : c;
                 n = E.get(f);
                 d[r] = n === undefined ? -1 : n;
                 E.set(f, r);
@@ -6623,23 +6924,23 @@ function updateKeyedMap() {
             // queue them for disposal at commit
                         for (n = u; n <= l; n++) {
                 c = this.Vt[n];
-                f = this.Wt ? this.Wt(c) : c;
+                f = this.Ft ? this.Ft(c) : c;
                 r = E.get(f);
                 if (r !== undefined && r !== -1) {
-                    _[r] = this.Ut[n];
-                    p[r] = this.kt[n];
-                    i && (i[r] = this.Ft[n]);
-                    o && (o[r] = this.xt[n]);
+                    _[r] = this.kt[n];
+                    R[r] = this.Wt[n];
+                    i && (i[r] = this.xt[n]);
+                    o && (o[r] = this.Qt[n]);
                     r = d[r];
                     E.set(f, r);
-                } else (S ??= []).push(this.kt[n]);
+                } else (S ??= []).push(this.Wt[n]);
             }
             // 2) create new rows into the temp arrays; an abort disposes only these
                         try {
                 for (r = u; r <= a; r++) {
-                    if (p[r] !== undefined) continue;
-                    (T ??= []).push(p[r] = createOwner());
-                    _[r] = runWithOwner(p[r], s);
+                    if (R[r] !== undefined) continue;
+                    (T ??= []).push(R[r] = createOwner());
+                    _[r] = runWithOwner(R[r], s);
                 }
             } catch (e) {
                 if (T) for (n = 0; n < T.length; n++) T[n].dispose();
@@ -6649,38 +6950,38 @@ function updateKeyedMap() {
             // into the fresh arrays, swap them in (new identity for downstream
             // change propagation), then dispose exited rows
                         for (n = 0; n < u; n++) {
-                _[n] = this.Ut[n];
-                p[n] = this.kt[n];
-                i && (i[n] = this.Ft[n]);
-                o && (o[n] = this.xt[n]);
+                _[n] = this.kt[n];
+                R[n] = this.Wt[n];
+                i && (i[n] = this.xt[n]);
+                o && (o[n] = this.Qt[n]);
             }
             for (r = u; r <= a; r++) {
                 if (i) setSignal(i[r], e[r]);
                 if (o) setSignal(o[r], r);
             }
             for (r = a + 1; r < t; r++) {
-                _[r] = this.Ut[r - O];
-                p[r] = this.kt[r - O];
+                _[r] = this.kt[r - O];
+                R[r] = this.Wt[r - O];
                 if (i) {
-                    i[r] = this.Ft[r - O];
+                    i[r] = this.xt[r - O];
                     setSignal(i[r], e[r]);
                 }
                 if (o) {
-                    o[r] = this.xt[r - O];
+                    o[r] = this.Qt[r - O];
                     if (O !== 0) setSignal(o[r], r);
                 }
             }
-            this.Ut = _;
-            this.kt = p;
-            i && (this.Ft = i);
-            o && (this.xt = o);
-            this.vt = t;
+            this.kt = _;
+            this.Wt = R;
+            i && (this.xt = i);
+            o && (this.Qt = o);
+            this.Lt = t;
             // save a copy of the mapped items for the next update
                         this.Vt = e.slice(0);
             if (S) for (n = 0; n < S.length; n++) S[n].dispose();
         }
     });
-    return this.Ut;
+    return this.kt;
 }
 
 /**
@@ -6700,22 +7001,22 @@ function updateKeyedMap() {
  */ function repeat(e, t, n) {
     const r = t;
     const i = {
-        wt: createOwner(),
-        vt: 0,
-        Mt: 0,
-        $t: e,
-        Gt: r,
+        vt: createOwner(),
+        Lt: 0,
+        $t: 0,
+        jt: e,
+        Ut: r,
+        Wt: [],
         kt: [],
-        Ut: [],
-        jt: n?.from,
-        Ht: n?.fallback
+        Kt: n?.from,
+        Mt: 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.wt.Je = o;
-    o.Ge &= ~CONFIG_AUTO_DISPOSE;
+        i.vt.et = o;
+    o.Ue &= ~CONFIG_AUTO_DISPOSE;
     return accessor(o);
 }
 
@@ -6727,55 +7028,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.$t();
-    const t = this.jt?.() || 0;
-    runWithOwner(this.wt, () => {
+    const e = this.jt();
+    const t = this.Kt?.() || 0;
+    runWithOwner(this.vt, () => {
         if (e === 0) {
-            if (this.vt !== 0) {
-                this.wt.dispose(false);
+            if (this.Lt !== 0) {
+                this.vt.dispose(false);
+                this.Wt = [];
                 this.kt = [];
-                this.Ut = [];
-                this.vt = 0;
+                this.Lt = 0;
                 // Reset offset to match the cleared data (#2767, repro 2).
-                                this.Mt = 0;
+                                this.$t = 0;
             }
-            if (this.Ht && !this.Ut[0]) {
+            if (this.Mt && !this.kt[0]) {
                 // an aborted fallback attempt leaves an owner without a mapping;
                 // dispose it before re-creating
-                this.kt[0]?.dispose();
-                this.Ut[0] = runWithOwner(this.kt[0] = createOwner(), this.Ht);
+                this.Wt[0]?.dispose();
+                this.kt[0] = runWithOwner(this.Wt[0] = createOwner(), this.Mt);
             }
             return;
         }
         const n = t + e;
-        const r = this.Mt + this.vt;
+        const r = this.$t + this.Lt;
         // 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.Mt);
+                const i = Math.max(t, this.$t);
         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.kt[e - this.Mt];
-            s[e - t] = this.Ut[e - this.Mt];
+            u[e - t] = this.Wt[e - this.$t];
+            s[e - t] = this.kt[e - this.$t];
         }
         try {
             for (let e = t; e < n; e++) {
                 if (e >= i && e < o) continue;
-                s[e - t] = runWithOwner(u[e - t] = createOwner(), () => this.Gt(e));
+                s[e - t] = runWithOwner(u[e - t] = createOwner(), () => this.Ut(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.vt === 0) this.kt[0]?.dispose(); else for (let e = this.Mt; e < r; e++) if (e < t || e >= n) this.kt[e - this.Mt].dispose();
-        this.Ut = s;
-        this.kt = u;
-        this.Mt = t;
-        this.vt = e;
+                if (this.Lt === 0) this.Wt[0]?.dispose(); else for (let e = this.$t; e < r; e++) if (e < t || e >= n) this.Wt[e - this.$t].dispose();
+        this.kt = s;
+        this.Wt = u;
+        this.$t = t;
+        this.Lt = e;
     });
-    return this.Ut;
+    return this.kt;
 }
 
 function compare(e, t, n) {
@@ -6786,23 +7087,23 @@ function boundaryComputed(e, t) {
     const n = computed(e, {
         lazy: true
     });
-    n.Nt = (e, t) => {
+    n.yt = (e, t) => {
         // Use passed values if provided, otherwise read from node
-        const r = e !== undefined ? e : n.xe;
-        const i = t !== undefined ? t : n.De;
+        const r = e !== undefined ? e : n.Qe;
+        const i = t !== undefined ? t : n.we;
         // 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.xe &= ~n.Kt;
-        const o = n.Be.notify(n, STATUS_PENDING | STATUS_ERROR, r, i);
+                n.Qe &= ~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.Kt & (STATUS_PENDING | STATUS_ERROR);
+                const s = r & ~n.Yt & (STATUS_PENDING | STATUS_ERROR);
         if (s) {
-            n.xe &= ~s;
-            if (n.De === i && !(n.xe & (STATUS_PENDING | STATUS_ERROR))) n.De = undefined;
+            n.Qe &= ~s;
+            if (n.we === i && !(n.Qe & (STATUS_PENDING | STATUS_ERROR))) n.we = 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
@@ -6813,16 +7114,16 @@ function boundaryComputed(e, t) {
             throw i;
         }
     };
-    n.Kt = t;
-    n.Ge &= ~CONFIG_AUTO_DISPOSE;
+    n.Yt = t;
+    n.Ue &= ~CONFIG_AUTO_DISPOSE;
     recompute(n, true);
     return n;
 }
 
 function createBoundChildren(e, t, n, r) {
-    const i = e.Be;
-    i.addChild(e.Be = n);
-    cleanup(() => i.removeChild(e.Be));
+    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);
@@ -6844,53 +7145,53 @@ function isRevealController(e) {
 }
 
 function isSlotReady(e) {
-    return isRevealController(e) ? e.Yt() : e.qt.size === 0 && !e.Bt;
+    return isRevealController(e) ? e.qt() : e.Bt.size === 0 && !e.Zt;
 }
 
 function isSlotMinimallyReady(e) {
-    return isRevealController(e) ? e.Zt() : isSlotReady(e);
+    return isRevealController(e) ? e.Xt() : isSlotReady(e);
 }
 
 function setSlotState(e, t, n, r) {
-    setSignal(e.Xt, n);
-    setSignal(e.zt, r);
+    setSignal(e.zt, n);
+    setSignal(e.Jt, r);
     if (isRevealController(e)) {
-        if (!n && e.Jt === t) e.Jt = undefined;
-        return e.en(n, r);
+        if (!n && e.en === t) e.en = undefined;
+        return e.tn(n, r);
     }
-    if (!n && e.tn === t && e.nn) e.tn = undefined;
+    if (!n && e.nn === t && e.rn) e.nn = undefined;
 }
 
 class RevealController {
-    rn;
     sn;
-    un=[];
-    Jt;
-    Xt=signal(false, {
+    un;
+    ln=[];
+    en;
+    zt=signal(false, {
         ownedWrite: true,
-        Ct: true
+        gt: true
     });
-    zt=signal(false, {
+    Jt=signal(false, {
         ownedWrite: true,
-        Ct: true
+        gt: true
     });
-    ln=true;
     an=true;
-    cn=false;
+    cn=true;
+    fn=false;
     constructor(e, t) {
-        this.rn = e;
-        this.sn = t;
+        this.sn = e;
+        this.un = t;
     }
-    fn(e) {
-        for (let t = 0; t < this.un.length; t++) {
-            const n = this.un[t];
-            if ((isRevealController(n) ? n.Jt : n.tn) !== 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;
     }
-    Yt() {
-        return this.fn(isSlotReady);
+    qt() {
+        return this.En(isSlotReady);
     }
     /**
    * "Minimally ready" = this group has something visible to show under its own policy.
@@ -6898,13 +7199,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.
-   */    Zt() {
-        const e = untrack(this.rn);
-        if (e === "together") return this.fn(isSlotMinimallyReady);
+   */    Xt() {
+        const e = untrack(this.sn);
+        if (e === "together") return this.En(isSlotMinimallyReady);
         if (e === "natural") {
             let e = false;
             let t = false;
-            this.fn(n => {
+            this.En(n => {
                 e = true;
                 if (isSlotMinimallyReady(n)) {
                     t = true;
@@ -6915,45 +7216,45 @@ class RevealController {
         }
         // sequential: only the first owned slot matters.
                 let t = true;
-        this.fn(e => {
+        this.En(e => {
             t = isSlotMinimallyReady(e);
             return false;
         });
         return t;
     }
-    En(e) {
-        if (this.un.includes(e)) return;
-        this.un.push(e);
-        const t = untrack(this.rn);
-        setSignal(e.Xt, true), setSignal(e.zt, t === "sequential" ? !!untrack(this.sn) : false);
-        untrack(() => this.en());
-    }
     dn(e) {
-        const t = this.un.indexOf(e);
-        if (t >= 0) this.un.splice(t, 1);
-        untrack(() => this.en());
-    }
-    en(e, t) {
-        if (this.cn) return;
-        this.cn = true;
-        const n = this.ln;
-        const r = this.an;
+        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());
+    }
+    Sn(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.an;
+        const r = this.cn;
         try {
-            const n = e ?? read(this.Xt), r = untrack(this.rn), 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.fn(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.fn(e => {
+                this.En(e => {
                     if (isRevealController(e)) {
+                        setSignal(e.Jt, false);
                         setSignal(e.zt, false);
-                        setSignal(e.Xt, false);
-                        e.en(false, false);
+                        e.tn(false, false);
                     } else {
                         setSlotState(e, this, !isSlotReady(e), false);
                     }
@@ -6964,11 +7265,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.fn(isSlotMinimallyReady);
-                this.fn(t => setSlotState(t, this, !e, false));
+                const e = this.En(isSlotMinimallyReady);
+                this.En(t => setSlotState(t, this, !e, false));
             } else {
                 let e = false;
-                this.fn(t => {
+                this.En(t => {
                     if (e) return setSlotState(t, this, true, i);
                     if (isSlotReady(t)) return setSlotState(t, this, false, false);
                     e = true;
@@ -6979,63 +7280,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.Jt, false);
                         setSignal(t.zt, false);
-                        setSignal(t.Xt, false);
-                        t.en(false, false);
+                        t.tn(false, false);
                     } else {
                         setSlotState(t, this, true, false);
                     }
                 });
             }
         } finally {
-            this.ln = this.Yt();
-            this.an = this.Zt();
-            this.cn = false;
+            this.an = this.qt();
+            this.cn = this.Xt();
+            this.fn = false;
         }
-        if (this.Jt && (n !== this.ln || r !== this.an)) this.Jt.en();
+        if (this.en && (n !== this.an || r !== this.cn)) this.en.tn();
     }
 }
 
 class CollectionQueue extends Queue {
-    Sn;
-    qt=new Set;
     Tn;
-    Bt=true;
-    Xt=signal(false, {
+    Bt=new Set;
+    On;
+    Zt=true;
+    zt=signal(false, {
         ownedWrite: true,
-        Ct: true
+        gt: true
     });
-    De;
-    zt=signal(false, {
+    we;
+    Jt=signal(false, {
         ownedWrite: true,
-        Ct: true
+        gt: true
     });
-    tn;
-    nn=false;
-    On;
-    _n=ON_INIT;
+    nn;
+    rn=false;
+    _n;
+    Rn=ON_INIT;
     constructor(e) {
         super();
-        this.Sn = e;
+        this.Tn = e;
     }
     run(e) {
-        if (!e || read(this.Xt) && (!_revealUsed || read(this.zt))) return;
+        if (!e || read(this.zt) && (!_revealUsed || read(this.Jt))) return;
         return super.run(e);
     }
     notify(e, t, n, r) {
-        if (!(t & this.Sn)) return super.notify(e, t, n, r);
-        if (this.nn && this.On) {
+        if (!(t & this.Tn)) return super.notify(e, t, n, r);
+        if (this.rn && this._n) {
             const e = untrack(() => {
                 try {
-                    return this.On();
+                    return this._n();
                 } catch {
                     return ON_INIT;
                 }
             });
-            if (e !== this._n) {
-                this._n = e;
-                this.nn = false;
-                this.qt.clear();
+            if (e !== this.Rn) {
+                this.Rn = e;
+                this.rn = false;
+                this.Bt.clear();
             }
         }
         // Routing is dimension-independent: each boundary consumes only its own
@@ -7048,47 +7349,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.Sn & STATUS_PENDING && this.nn) return super.notify(e, t, n, r);
-        if (n & this.Sn) {
-            this.Bt = true;
-            const t = r?.source || e.De?.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.we?.source;
             if (t) {
-                const e = this.qt.size === 0;
-                this.qt.add(t);
-                if (e) setSignal(this.Xt, true);
-                if (this.Sn & STATUS_ERROR) {
-                    setSignal(this.De, unwrapStatusError(t.De));
+                const e = this.Bt.size === 0;
+                this.Bt.add(t);
+                if (e) setSignal(this.zt, true);
+                if (this.Tn & STATUS_ERROR) {
+                    setSignal(this.we, unwrapStatusError(t.we));
                 }
             }
         }
-        t &= ~this.Sn;
+        t &= ~this.Tn;
         return t ? super.notify(e, t, n, r) : true;
     }
-    Me() {
-        for (const e of this.qt) {
+    $e() {
+        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.k && !(e.xe & this.Sn) && !(this.Sn & STATUS_ERROR && e.xe & STATUS_PENDING)) this.qt.delete(e);
+            if (e.Ge & REACTIVE_DISPOSED || !e.k && !(e.Qe & this.Tn) && !(this.Tn & STATUS_ERROR && e.Qe & STATUS_PENDING)) this.Bt.delete(e);
         }
-        if (!this.qt.size) {
-            if (this.Sn & STATUS_PENDING && this.Bt && !this.nn && this.Tn) {
-                this.Bt = !!(this.Tn.xe & this.Sn);
+        if (!this.Bt.size) {
+            if (this.Tn & STATUS_PENDING && this.Zt && !this.rn && this.On) {
+                this.Zt = !!(this.On.Qe & this.Tn);
             } else {
-                this.Bt = false;
+                this.Zt = false;
             }
-            if (!this.Bt) {
-                setSignal(this.Xt, false);
-                if (this.On) {
+            if (!this.Zt) {
+                setSignal(this.zt, false);
+                if (this._n) {
                     try {
-                        this._n = untrack(() => this.On());
+                        this.Rn = untrack(() => this._n());
                     } catch {
                         /* value not yet committed — _prevOn stays stale, next notify will reset */}
                 }
             }
         }
-        if (_revealUsed) this.tn?.en();
+        if (_revealUsed) this.nn?.tn();
     }
 }
 
@@ -7096,12 +7397,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.De = signal(undefined, {
+    if (e === STATUS_ERROR) o.we = signal(undefined, {
         ownedWrite: true,
-        Ct: true
+        gt: true
     });
-    if (r) o.On = r;
-    const s = o.Tn = createBoundChildren(i, t, o, e);
+    if (r) o._n = r;
+    const s = o.On = createBoundChildren(i, t, o, e);
     // Prime source tracking so reveal registration sees pending sources.
         untrack(() => {
         let t = false;
@@ -7110,23 +7411,23 @@ function createCollectionBoundary(e, t, n, r) {
         } catch (e) {
             if (e instanceof NotReadyError) t = true; else throw e;
         }
-        o.Bt = t || !!(s.xe & e) || s.De instanceof NotReadyError;
+        o.Zt = t || !!(s.Qe & e) || s.we instanceof NotReadyError;
     });
     const u = _revealUsed && e === STATUS_PENDING ? getContext(RevealControllerContext) : null;
     if (u) {
-        o.tn = u;
-        u.En(o);
-        cleanup(() => u.dn(o));
+        o.nn = u;
+        u.dn(o);
+        cleanup(() => u.Sn(o));
     }
     return accessor(computed(() => {
-        if (!read(o.Xt)) {
+        if (!read(o.zt)) {
             const e = read(s);
-            if (!untrack(() => read(o.Xt))) return o.nn = 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.zt)) 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
@@ -7134,7 +7435,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.
     {
-        Ct: true
+        gt: true
     }));
 }
 
@@ -7187,8 +7488,8 @@ function createCollectionBoundary(e, t, n, r) {
  * }
  * ```
  */ function createErrorBoundary(e, t) {
-    return createCollectionBoundary(STATUS_ERROR, e, e => t(accessor(e.De), () => {
-        for (const t of e.qt) recompute(t);
+    return createCollectionBoundary(STATUS_ERROR, e, e => t(accessor(e.we), () => {
+        for (const t of e.Bt) recompute(t);
         schedule();
     }));
 }
@@ -7245,12 +7546,12 @@ function createCollectionBoundary(e, t, n, r) {
         computed(() => {
             i();
             o();
-            s.en();
+            s.tn();
         });
         if (r) {
-            s.Jt = r;
-            r.En(s);
-            cleanup(() => r.dn(s));
+            s.en = r;
+            r.dn(s);
+            cleanup(() => r.Sn(s));
         }
         return t;
     });