@solidjs/signals 2.0.0-beta.24 → 2.0.0-beta.26

package/dist/node.cjs

@@ -223,7 +223,7 @@ const activeLanes = new Set;
         l: [ [], [] ],
         S: null,
         T: activeTransition,
-        _: r
+        O: r
     };
     signalLanes.set(e, t);
     activeLanes.add(t);
@@ -233,7 +233,7 @@ const activeLanes = new Set;
     // parent-child is a property of the nodes, not of write order — otherwise
     // 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.O, t);
+        adoptCompanionLane(e._, t);
     adoptCompanionLane(e.p, t);
     return t;
 }
@@ -245,7 +245,7 @@ function adoptCompanionLane(e, t) {
     const r = findLane(n);
     // Only the companion's own unmerged root is safely re-parentable: a root
     // that absorbed other lanes carries work that is not a child of this owner.
-        if (r !== t && r.o === e && !r._) r._ = t;
+        if (r !== t && r.o === e && !r.O) r.O = t;
 }
 
 /**
@@ -324,9 +324,9 @@ function resolveTransition(e) {
             if (i !== n && !hasActiveOverride(e)) {
                 // Parent-child lanes stay independent so isPending resolves without
                 // waiting for the parent's async. The child keeps ownership.
-                if (n._ && findLane(n._) === i) {
+                if (n.O && findLane(n.O) === i) {
                     e.i = t;
-                } else if (i._ && findLane(i._) === n) ; else mergeLanes(n, i);
+                } else if (i.O && findLane(i.O) === n) ; else mergeLanes(n, i);
             }
             return;
         }
@@ -376,24 +376,24 @@ 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.G.length === 0 && t.L.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.V.size === 0 && transientStoreNodes.size === 0;
 }
 
 function sweepTransientStoreNodes() {
     if (transientStoreNodes.size === 0) return;
     for (const e of transientStoreNodes) {
-        if (e.U !== null) {
+        if (e.G !== null) {
             transientStoreNodes.delete(e);
             continue;
         }
-        if (e.V !== NOT_PENDING) continue;
+        if (e.U !== NOT_PENDING) continue;
         if (e.A !== undefined && e.A !== NOT_PENDING) continue;
         // A live affects() mark keeps the node addressable: sweeping it would
         // detach the refcount from the slot (a fresh probe would upsert a new,
         // unmarked node for the same property).
                 if (e.k) continue;
         transientStoreNodes.delete(e);
-        e.F?.();
+        e.W?.();
     }
 }
 
@@ -420,12 +420,12 @@ function setProjectionWriteActive(e) {
  * land there directly — no per-field aliasing.
  */ function createBatch() {
     return {
-        W: clock,
-        M: [],
-        H: new Map,
+        F: clock,
+        H: [],
+        M: new Map,
         v: [],
-        G: [],
-        L: new Set,
+        L: [],
+        V: new Set,
         $: [],
         j: {
             K: [ [], [] ],
@@ -447,17 +447,17 @@ function mergeTransitionState(e, t) {
         e.v.push(...t.v);
         t.v.length = 0;
     }
-    if (t.G.length) {
+    if (t.L.length) {
         // Move (don't copy): the global queue's batch may still be the outgoing
         // transition, and the adoption pass in initTransition would re-push its
         // contents into the target — double-releasing every mark.
-        e.G.push(...t.G);
-        t.G.length = 0;
+        e.L.push(...t.L);
+        t.L.length = 0;
     }
-    for (const n of t.L) e.L.add(n);
-    for (const [n, r] of t.H) {
-        let t = e.H.get(n);
-        if (!t) e.H.set(n, t = new Set);
+    for (const n of t.V) e.V.add(n);
+    for (const [n, r] of t.M) {
+        let t = e.M.get(n);
+        if (!t) e.M.set(n, t = new Set);
         for (const e of r) t.add(e);
     }
     for (const n of t.Y) e.Y.add(n);
@@ -599,14 +599,14 @@ class GlobalQueue extends Queue {
     // isPending()/latest()).
     static ue=null;
     static le=null;
-    static ce=null;
     static ae=null;
+    static ce=null;
     static fe=null;
     static Ee=null;
     static de=null;
     static Se=null;
     static Te=null;
-    static _e=null;
+    static Oe=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,7 +614,7 @@ class GlobalQueue extends Queue {
     // `_overrideValue` slot, a lane in `activeLanes`, an `_optimisticNodes`
     // entry, or a non-null `currentOptimisticLane`, so `!` invocations are safe
     // once the gate holds.
-    static Oe=null;
+    static _e=null;
     static pe=null;
     static Re=null;
     static Ie=null;
@@ -654,29 +654,29 @@ class GlobalQueue extends Queue {
                     // A kept ambient batch may hold pending nodes (#2916): stay
                     // scheduled so the outer drain loop commits them via the plain
                     // flush path instead of leaving them until the next natural flush.
-                                        scheduled = dirtyQueue.C >= dirtyQueue.P || this.D.M.length > 0;
-                    reassignPendingTransition(e.M);
+                                        scheduled = dirtyQueue.C >= dirtyQueue.P || this.D.H.length > 0;
+                    reassignPendingTransition(e.H);
                     activeTransition = null;
                     finalizePureQueue(null, true);
                     return;
                 }
                 const t = activeTransition;
                 const n = this.D;
-                n !== t && n.M.push(...t.M);
+                n !== t && n.H.push(...t.H);
                 this.restoreQueues(t.j);
                 transitions.delete(t);
                 activeTransition = null;
-                reassignPendingTransition(n.M);
+                reassignPendingTransition(n.H);
                 finalizePureQueue(t);
                 if (n === t) {
                     // Drop the dead Transition wrapper but keep its (drained) containers
                     // as the ambient batch — late registrations during finalization live
                     // there and must survive to the next flush.
                     const e = createBatch();
-                    e.M = n.M;
+                    e.H = n.H;
                     e.v = n.v;
-                    e.G = n.G;
                     e.L = n.L;
+                    e.V = n.V;
                     currentBatch = this.D = e;
                 }
             } else {
@@ -715,11 +715,11 @@ class GlobalQueue extends Queue {
                 // 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?.me) return true;
+                                if (t?.we) return true;
                 if (activeTransition && t) {
                     const n = t.source;
-                    let r = activeTransition.H.get(n);
-                    if (!r) activeTransition.H.set(n, r = new Set);
+                    let r = activeTransition.M.get(n);
+                    if (!r) activeTransition.M.set(n, r = new Set);
                     const i = r.size;
                     r.add(e);
                     if (r.size !== i) schedule();
@@ -732,7 +732,7 @@ class GlobalQueue extends Queue {
     initTransition(e) {
         if (e) e = currentTransition(e);
         if (e && e === activeTransition) return;
-        if (!e && activeTransition && activeTransition.W === clock) return;
+        if (!e && activeTransition && activeTransition.F === clock) return;
         if (!activeTransition) {
             activeTransition = e ?? createBatch();
         } else if (e) {
@@ -742,7 +742,7 @@ class GlobalQueue extends Queue {
             activeTransition = e;
         }
         transitions.add(activeTransition);
-        activeTransition.W = clock;
+        activeTransition.F = clock;
         const t = this.D;
         if (t !== activeTransition) {
             // Adopt the ambient batch into the transaction, then make the
@@ -752,18 +752,18 @@ class GlobalQueue extends Queue {
             // must not entangle unrelated writes to it; the same rule holds one hop
             // downstream: propagation never queues pended subscribers as pending
             // nodes, see propagateAffectsMark, #2893.
-            for (let e = 0; e < t.M.length; e++) {
-                const n = t.M[e];
+            for (let e = 0; e < t.H.length; e++) {
+                const n = t.H[e];
                 n.T = activeTransition;
-                activeTransition.M.push(n);
+                activeTransition.H.push(n);
             }
             for (let e = 0; e < t.v.length; e++) {
                 const n = t.v[e];
                 n.T = activeTransition;
                 activeTransition.v.push(n);
             }
-            if (t.G.length) activeTransition.G.push(...t.G);
-            for (const e of t.L) activeTransition.L.add(e);
+            if (t.L.length) activeTransition.L.push(...t.L);
+            for (const e of t.V) activeTransition.V.add(e);
             currentBatch = this.D = activeTransition;
         }
         for (const e of activeLanes) {
@@ -773,7 +773,7 @@ class GlobalQueue extends Queue {
 }
 
 function queuePendingNode(e) {
-    currentBatch.M.push(e);
+    currentBatch.H.push(e);
 }
 
 // Sticky: flips true on the first refresh() ever (the only setter of
@@ -789,52 +789,52 @@ 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.ve !== undefined;
+    const r = e.me !== undefined;
     const i = reaskArmed;
-    for (let o = e.U; o !== null; o = o.we) {
+    for (let o = e.G; o !== null; o = o.ve) {
         // A value-change notification is a new question for the subscriber: any
         // pending re-ask mark (refresh) it carried is superseded.
-        if (i) o.Le.Ge &= ~REACTIVE_REASK;
-        if (r && o.Le.Ue & CONFIG_IN_SNAPSHOT_SCOPE) {
-            o.Le.Ge |= REACTIVE_SNAPSHOT_STALE;
+        if (i) o.Ve.Le &= ~REACTIVE_REASK;
+        if (r && o.Ve.Ge & CONFIG_IN_SNAPSHOT_SCOPE) {
+            o.Ve.Le |= REACTIVE_SNAPSHOT_STALE;
             continue;
         }
         if (t && n) {
-            o.Le.Ge |= REACTIVE_OPTIMISTIC_DIRTY;
-            assignOrMergeLane(o.Le, n);
+            o.Ve.Le |= REACTIVE_OPTIMISTIC_DIRTY;
+            assignOrMergeLane(o.Ve, n);
         } else if (t) {
-            o.Le.Ge |= REACTIVE_OPTIMISTIC_DIRTY;
+            o.Ve.Le |= REACTIVE_OPTIMISTIC_DIRTY;
             // No source lane means reversion - clear subscriber's lane so effects go to regular queue
-                        o.Le.i = undefined;
+                        o.Ve.i = undefined;
         }
-        enqueueSub(o.Le);
+        enqueueSub(o.Ve);
     }
 }
 
 function commitPendingNode(e) {
     const t = e;
-    if (!t.Ve) {
-        if (e.V !== NOT_PENDING) {
-            e.ke = e.V;
-            e.V = NOT_PENDING;
+    if (!t.Ue) {
+        if (e.U !== NOT_PENDING) {
+            e.ke = e.U;
+            e.U = NOT_PENDING;
         }
-        if (e.O || e.p) GlobalQueue.ae(e);
+        if (e._ || e.p) GlobalQueue.ce(e);
         return;
     }
-    if (e.V !== NOT_PENDING) {
-        e.ke = e.V;
-        e.V = NOT_PENDING;
+    if (e.U !== NOT_PENDING) {
+        e.ke = e.U;
+        e.U = NOT_PENDING;
         // Set _modified for effects, but not for tracked effects (they handle their own scheduling)
-                if (e.Fe && e.Fe !== EFFECT_TRACKED) e.xe = true;
+                if (e.We && e.We !== EFFECT_TRACKED) e.Fe = true;
     }
-    t.Ge &= ~REACTIVE_MANUAL_WRITE;
-    if (!(t.Qe & STATUS_PENDING)) t.Qe &= ~STATUS_UNINITIALIZED;
-    if (t.We !== null || t.Me !== null) GlobalQueue.X(t, false, true);
-    if (e.O || e.p) GlobalQueue.ae(e);
+    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);
 }
 
 function commitPendingNodes() {
-    const e = currentBatch.M;
+    const e = currentBatch.H;
     for (let t = 0; t < e.length; t++) {
         commitPendingNode(e[t]);
     }
@@ -860,7 +860,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.Ge & REACTIVE_DISPOSED) continue;
+                if (t.Le & REACTIVE_DISPOSED) continue;
                 enqueueSub(t);
             }
             e.Y.clear();
@@ -871,15 +871,15 @@ function finalizePureQueue(e = null, t = false) {
         // held boundary display state through the visual channel, and their
         // release is the display-state update point — re-run the boundary sweep
         // (the earlier sweep above ran while the marks were still live).
-                if (t.G.length) {
-            GlobalQueue.ne(t.G);
+                if (t.L.length) {
+            GlobalQueue.ne(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.L.size) GlobalQueue.ee(t.L, e);
+                if (t.V.size) GlobalQueue.ee(t.V, e);
         sweepTransientStoreNodes();
         // Lanes only enter activeLanes through the engine's getOrCreateLane.
                 if (activeLanes.size) GlobalQueue.Ie(e);
@@ -888,7 +888,7 @@ function finalizePureQueue(e = null, t = false) {
 
 function checkBoundaryChildren(e) {
     for (const t of e.m) {
-        t.He?.();
+        t.Me?.();
         checkBoundaryChildren(t);
     }
 }
@@ -955,7 +955,7 @@ function runQueue$1(e, t) {
 }
 
 function reporterBlocksSource(e, t) {
-    if (e.Ge & (REACTIVE_ZOMBIE | REACTIVE_DISPOSED)) return false;
+    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;
@@ -964,14 +964,14 @@ function reporterBlocksSource(e, t) {
             e = e.t;
         }
     }
-    return !!(e.Qe & STATUS_PENDING && e.De instanceof NotReadyError && e.De.source === t);
+    return !!(e.xe & STATUS_PENDING && e.De instanceof NotReadyError && e.De.source === t);
 }
 
 function transitionComplete(e) {
     if (e.I) return true;
     if (e.$.length) return false;
     let t = true;
-    for (const [n, r] of e.H) {
+    for (const [n, r] of e.M) {
         let i = false;
         for (const e of r) {
             if (reporterBlocksSource(e, n)) {
@@ -980,7 +980,7 @@ function transitionComplete(e) {
             }
             r.delete(e);
         }
-        if (!i) e.H.delete(n); else if (n.Qe & STATUS_PENDING && n.De?.source === n) {
+        if (!i) e.M.delete(n); else if (n.xe & STATUS_PENDING && n.De?.source === n) {
             t = false;
             break;
         }
@@ -1013,7 +1013,7 @@ function runInTransition(e, t) {
 }
 
 /** The queue a node belongs to, picked from its own zombie flag. */ function queueFor(e) {
-    return e.Ge & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
+    return e.Le & REACTIVE_ZOMBIE ? zombieQueue : dirtyQueue;
 }
 
 /**
@@ -1021,10 +1021,10 @@ 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.Fe === EFFECT_TRACKED) {
+    if (e.We === EFFECT_TRACKED) {
         const t = e;
-        if (!t.xe) {
-            t.xe = true;
+        if (!t.Fe) {
+            t.Fe = true;
             t.Be.enqueue(EFFECT_USER, t.Ze);
         }
         return;
@@ -1049,12 +1049,12 @@ function actualInsertIntoHeap(e, t) {
 }
 
 function insertIntoHeap(e, t) {
-    let n = e.Ge;
+    let n = e.Le;
     if (n & (REACTIVE_IN_HEAP | REACTIVE_RECOMPUTING_DEPS | REACTIVE_MANUAL_WRITE)) return;
     if (n & REACTIVE_CHECK) {
-        e.Ge = n & -4 | REACTIVE_DIRTY | REACTIVE_IN_HEAP;
+        e.Le = n & -4 | REACTIVE_DIRTY | REACTIVE_IN_HEAP;
     } else {
-        e.Ge = n | REACTIVE_IN_HEAP;
+        e.Le = n | REACTIVE_IN_HEAP;
         // An unmarked node entering a marked heap invalidates the markHeap memo:
         // `_marked` is only reset by runHeap, so a write between two mid-tick
         // pulls (read-time markHeap + updateIfNecessary) would otherwise leave
@@ -1066,16 +1066,16 @@ function insertIntoHeap(e, t) {
 }
 
 function insertIntoHeapHeight(e, t) {
-    let n = e.Ge;
+    let n = e.Le;
     if (n & (REACTIVE_IN_HEAP | REACTIVE_RECOMPUTING_DEPS | REACTIVE_IN_HEAP_HEIGHT | REACTIVE_MANUAL_WRITE)) return;
-    e.Ge = n | REACTIVE_IN_HEAP_HEIGHT;
+    e.Le = n | REACTIVE_IN_HEAP_HEIGHT;
     actualInsertIntoHeap(e, t);
 }
 
 function deleteFromHeap(e, t) {
-    const n = e.Ge;
+    const n = e.Le;
     if (!(n & (REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT))) return;
-    e.Ge = n & -25;
+    e.Le = n & -25;
     const r = e.Xe;
     if (e.et === e) t.h[r] = undefined; else {
         const n = e.tt;
@@ -1093,22 +1093,22 @@ function markHeap(e) {
     e.N = true;
     for (let t = 0; t <= e.C; t++) {
         for (let n = e.h[t]; n !== undefined; n = n.tt) {
-            if (n.Ge & REACTIVE_IN_HEAP) markNode(n);
+            if (n.Le & REACTIVE_IN_HEAP) markNode(n);
         }
     }
 }
 
 function markNode(e, t = REACTIVE_DIRTY) {
-    const n = e.Ge;
+    const n = e.Le;
     if ((n & (REACTIVE_CHECK | REACTIVE_DIRTY)) >= t) return;
-    e.Ge = n & -4 | t;
-    for (let t = e.U; t !== null; t = t.we) {
-        markNode(t.Le, REACTIVE_CHECK);
+    e.Le = n & -4 | t;
+    for (let t = e.G; t !== null; t = t.ve) {
+        markNode(t.Ve, REACTIVE_CHECK);
     }
     if (e.nt !== null) {
         for (let t = e.nt; t !== null; t = t.rt) {
-            for (let e = t.U; e !== null; e = e.we) {
-                markNode(e.Le, REACTIVE_CHECK);
+            for (let e = t.G; e !== null; e = e.ve) {
+                markNode(e.Ve, REACTIVE_CHECK);
             }
         }
     }
@@ -1119,7 +1119,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.Ge & REACTIVE_IN_HEAP) t(n); else adjustHeight(n, e);
+            if (n.Le & REACTIVE_IN_HEAP) t(n); else adjustHeight(n, e);
             n = e.h[e.P];
         }
     }
@@ -1132,17 +1132,17 @@ function adjustHeight(e, t) {
     for (let t = e.je; t; t = t.Ke) {
         const e = t.Ye;
         const r = e.qe || e;
-        if (r.Ve && r.Xe >= n) n = r.Xe + 1;
+        if (r.Ue && r.Xe >= n) n = r.Xe + 1;
     }
     if (e.Xe !== n) {
         e.Xe = n;
-        for (let t = e.U; t !== null; t = t.we) {
+        for (let t = e.G; t !== null; t = t.ve) {
             // Route each subscriber by its own zombie flag, mirroring the
             // post-recompute height-adjust path. Inserting into the running `heap`
             // unconditionally can park a zombie in `dirtyQueue` (or a live node in
             // `zombieQueue`), breaking the flag/queue invariant `deleteFromHeap`
             // relies on — the same corruption class as #2759.
-            insertIntoHeapHeight(t.Le, queueFor(t.Le));
+            insertIntoHeapHeight(t.Ve, queueFor(t.Ve));
         }
     }
 }
@@ -1153,8 +1153,8 @@ const PENDING_OWNER = {};
 function markDisposal(e) {
     let t = e.it;
     while (t) {
-        const e = t.Ge;
-        t.Ge = e | REACTIVE_ZOMBIE;
+        const e = t.Le;
+        t.Le = e | REACTIVE_ZOMBIE;
         // migrate height-adjust entries too, not just recompute entries: every
         // `deleteFromHeap` call site picks the queue from the zombie flag, so a
         // node left physically linked in `dirtyQueue` after being zombified gets
@@ -1180,20 +1180,20 @@ function dispose(e) {
 }
 
 function disposeChildren(e, t = false, n) {
-    const r = e.Ge;
+    const r = e.Le;
     if (r & REACTIVE_DISPOSED) return;
     if (t) {
-        e.Ge = r | REACTIVE_DISPOSED;
+        e.Le = r | REACTIVE_DISPOSED;
         // Companions are created detached and outlive their owner, but a verdict
         // must not: a disposed source can never settle, so an isPending companion
         // latched `true` here would hold a spinner forever (INV-9, the PR #2845
         // edge). Snap runs after the DISPOSED flag is set so the oracle reads
         // false, and notifies subscribers still watching the companion.
                 const t = e;
-        if (t.O || t.p) GlobalQueue.ae(t);
+        if (t._ || t.p) GlobalQueue.ce(t);
     }
-    if (t && e.Ve) e.ut = null;
-    let i = n ? e.We : e.it;
+    if (t && e.Ue) e.ut = null;
+    let i = n ? e.Qe : e.it;
     while (i) {
         const e = i.ot;
         if (i.je) {
@@ -1210,7 +1210,7 @@ function disposeChildren(e, t = false, n) {
         i = e;
     }
     if (n) {
-        e.We = null;
+        e.Qe = null;
     } else {
         e.it = null;
         e.lt = 0;
@@ -1219,7 +1219,7 @@ function disposeChildren(e, t = false, n) {
     // 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.Ge & REACTIVE_DISPOSED)) {
+        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;
@@ -1237,7 +1237,7 @@ function disposeChildren(e, t = false, n) {
 }
 
 function runDisposal(e, t) {
-    let n = t ? e.Me : e.Et;
+    let n = t ? e.He : e.Et;
     if (!n) return;
     if (Array.isArray(n)) {
         for (let e = 0; e < n.length; e++) {
@@ -1247,12 +1247,12 @@ function runDisposal(e, t) {
     } else {
         n.call(n);
     }
-    t ? e.Me = null : e.Et = null;
+    t ? e.He = null : e.Et = null;
 }
 
 function childId(e, t) {
     let n = e;
-    while (n.Ue & CONFIG_TRANSPARENT && n.B) n = n.B;
+    while (n.Ge & CONFIG_TRANSPARENT && n.B) n = n.B;
     if (n.id != null) return formatId(n.id, t ? n.lt++ : n.lt);
     throw new Error("");
 }
@@ -1354,7 +1354,7 @@ function formatId(e, t) {
  * }
  * ```
  */ function isDisposed(e) {
-    return !!(e.Ge & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE));
+    return !!(e.Le & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE));
 }
 
 function disposeRootSelf(e = true) {
@@ -1373,7 +1373,7 @@ function disposeRootSelf(e = true) {
     const n = e?.transparent ?? false;
     const r = {
         id: inheritId(e, n, t),
-        Ue: n ? CONFIG_TRANSPARENT : 0,
+        Ge: n ? CONFIG_TRANSPARENT : 0,
         ze: true,
         Je: t?.ze ? t.Je : t,
         it: null,
@@ -1383,8 +1383,8 @@ function disposeRootSelf(e = true) {
         Be: t?.Be ?? globalQueue,
         dt: t?.dt || defaultContext,
         lt: 0,
-        Me: null,
-        We: null,
+        He: null,
+        Qe: null,
         B: t,
         dispose: disposeRootSelf
     };
@@ -1433,13 +1433,13 @@ function disposeRootSelf(e = true) {
 function unlinkSubs(e) {
     const t = e.Ye;
     const n = e.Ke;
-    const r = e.we;
+    const r = e.ve;
     const i = e.St;
     if (r !== null) r.St = i; else t.Tt = i;
-    if (i !== null) i.we = r; else {
-        t.U = r;
+    if (i !== null) i.ve = r; else {
+        t.G = r;
         if (r === null) {
-            t.F?.();
+            t.W?.();
             // No more subscribers; only tear down if CONFIG_AUTO_DISPOSE is set.
             // A pending node is exempt: its in-flight async work (or the
             // transition holding it) is an observer — tearing down would orphan
@@ -1447,7 +1447,7 @@ 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.Ve && e.Ue & CONFIG_AUTO_DISPOSE && !(e.Ge & REACTIVE_ZOMBIE) && !(e.Qe & STATUS_PENDING) && unobserved(e);
+            e.Ue && e.Ge & CONFIG_AUTO_DISPOSE && !(e.Le & REACTIVE_ZOMBIE) && !(e.xe & STATUS_PENDING) && unobserved(e);
         }
     }
     return n;
@@ -1484,18 +1484,18 @@ function link(e, t, n = false) {
     // read order within the computation.
     const r = t.st;
     if (r !== null && r.Ye === e) {
-        r._t &&= n;
+        r.Ot &&= n;
         return;
     }
     let i = null;
-    const o = t.Ge & REACTIVE_RECOMPUTING_DEPS;
+    const o = t.Le & REACTIVE_RECOMPUTING_DEPS;
     if (o) {
         i = r !== null ? r.Ke : t.je;
         if (i !== null && i.Ye === e) {
-            i.Ot = t.Rt;
+            i._t = t.Rt;
             t.st = i;
             // First touch of this pass: the previous pass's label is stale.
-                        i._t = n;
+                        i.Ot = n;
             return;
         }
     }
@@ -1505,23 +1505,23 @@ function link(e, t, n = false) {
     // (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.Le === t && (!o || s.Ot === t.Rt)) {
+    if (s !== null && s.Ve === t && (!o || s._t === t.Rt)) {
         // 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._t &&= n; else s._t = n;
+        if (o) s.Ot &&= n; else s.Ot = n;
         return;
     }
     const u = t.st = e.Tt = {
         Ye: e,
-        Le: t,
+        Ve: t,
         Ke: i,
         St: s,
-        we: null,
-        Ot: t.Rt,
-        _t: n
+        ve: null,
+        _t: t.Rt,
+        Ot: n
     };
     if (r !== null) r.Ke = u; else t.je = u;
-    if (s !== null) s.we = u; else e.U = u;
+    if (s !== null) s.ve = u; else e.G = u;
 }
 
 // The lazily-created Set is the ONE container for pending sources. Its
@@ -1562,42 +1562,78 @@ function setPendingError(e, t, n) {
 }
 
 function forEachDependent(e, t) {
-    for (let n = e.U; n !== null; n = n.we) t(n.Le, n);
+    for (let n = e.G; n !== null; n = n.ve) 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.U; e !== null; e = e.we) t(e.Le, e);
+        for (let e = n.G; e !== null; e = e.ve) 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.Ue && e.Ge & CONFIG_AUTO_DISPOSE && !e.G && !(e.Le & REACTIVE_ZOMBIE) && !(e.xe & 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.G && e.Ge & CONFIG_AUTO_DISPOSE) (t ??= []).push(e);
+        forEachDependent(e, visit);
+    };
+    forEachDependent(e, visit);
+    if (t) for (const e of t) releaseIfSettledUnobserved(e);
+}
+
 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.W = clock;
-        const o = i.$e?.values().next().value;
-        if (o) {
-            setPendingError(i, o);
-            r !== null && r(i);
+        const i = GlobalQueue.le;
+    const settle = o => {
+        if (r.has(o) || !removePendingSource(o, e)) return;
+        r.add(o);
+        o.F = clock;
+        const s = o.$e?.values().next().value;
+        if (s) {
+            setPendingError(o, s);
+            i !== null && i(o);
         } else {
-            i.Qe &= ~STATUS_PENDING;
-            setPendingError(i);
-            r !== null && r(i);
-            if (i.It) {
-                enqueueSub(i);
+            o.xe &= ~STATUS_PENDING;
+            setPendingError(o);
+            i !== null && i(o);
+            if (o.It) {
+                enqueueSub(o);
                 t = true;
             }
-            i.It = false;
+            o.It = 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.G && o.Ge & 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();
 }
 
@@ -1621,21 +1657,46 @@ function handleAsync(e, t, n) {
     }
     e.ut = 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.xe & 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));
+        settleTransition();
         // NotReadyError from rejected promises should be treated as pending, not error
-                notifyStatus(e, n instanceof NotReadyError ? STATUS_PENDING : STATUS_ERROR, n);
-        e.W = clock;
+                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 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.Ge & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY)) return;
-        globalQueue.initTransition(resolveTransition(e));
-        const o = !!(e.Qe & STATUS_UNINITIALIZED);
+                if (e.Le & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY)) return;
+        settleTransition();
+        const o = !!(e.xe & STATUS_UNINITIALIZED);
         trimStaleDeps(e);
         clearStatus(e);
         const s = resolveLane(e);
@@ -1653,8 +1714,8 @@ function handleAsync(e, t, n) {
             // (A17 — every reader sees the override); the revert reveals whatever
             // has committed by then, so corrections reveal atomically with their
             // transition rather than escaping it.
-            if (e.V === NOT_PENDING) queuePendingNode(e);
-            e.V = r;
+            if (e.U === NOT_PENDING) queuePendingNode(e);
+            e.U = r;
             // The hold is a companion-visible write like any other (A13/A19): the
             // clearStatus() above computed its verdict before the hold existed, so
             // isPending must re-derive (the value is not final until commit — V1)
@@ -1664,16 +1725,16 @@ function handleAsync(e, t, n) {
             // re-show an unchanged view — the revert is the notification point.
                         GlobalQueue.ue !== null && GlobalQueue.ue(e, r);
             if (!hasActiveOverride(e)) insertSubs(e);
-            e.W = clock;
+            e.F = clock;
         } else if (s) {
             // Route through lane's effect queue for independent flushing
-            const t = e.Fe;
+            const t = e.We;
             const n = e.ke;
             const i = e.At;
             try {
                 if (!t && o || !i || !i(r, n)) {
                     e.ke = r;
-                    e.W = clock;
+                    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).
@@ -1706,10 +1767,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.Ue & CONFIG_AUTO_DISPOSE && !e.U && !(e.Qe & STATUS_PENDING)) {
+        if (e.Ge & CONFIG_AUTO_DISPOSE && !e.G && !(e.xe & STATUS_PENDING)) {
             unobserved(e);
+            return true;
         }
+        return false;
     };
     if (i) {
         let n = false, r = false, i, s = true;
@@ -1755,18 +1820,24 @@ 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, c = false, a = false, f = true;
+            let u, l, a = false, c = false, f = true;
             n.next().then(n => {
                 if (f) {
                     u = n;
-                    c = true;
+                    a = true;
                     if (n.done) i = true;
                 } else if (e.ut !== t) {
                     return;
                 } else if (!n.done) {
                     r = true;
-                    asyncWrite(n.value, iterate);
+                    asyncWrite(n.value, iterateOrRelease);
                 } else {
                     i = true;
                     if (r) {
@@ -1776,30 +1847,32 @@ function handleAsync(e, t, n) {
                         // Empty completion settles like the immediately-done sync path.
                         asyncWrite(undefined);
                     }
+                    settleAutodispose();
                 }
             }, n => {
                 if (f) {
                     l = n;
-                    a = true;
+                    c = true;
                 } else if (e.ut === t) {
                     i = true;
                     handleError(n);
+                    settleAutodispose();
                 }
             });
             f = false;
-            if (a) {
+            if (c) {
                 // Match the promise branch, but only rethrow during the initial read.
                 i = true;
                 handleError(l);
                 if (s) throw l;
                 return true;
             }
-            if (c && !u.done) {
+            if (a && !u.done) {
                 o = u.value;
                 r = true;
                 return iterate();
             }
-            return c && u.done;
+            return a && u.done;
         };
         const u = iterate();
         // Later iterate() calls run from asyncWrite, where rethrowing would be unhandled.
@@ -1819,12 +1892,12 @@ function clearStatus(e, t = false) {
     // (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.Qe = t ? 0 : e.Qe & STATUS_UNINITIALIZED;
+    e.xe = t ? 0 : e.xe & STATUS_UNINITIALIZED;
     if (e.De) setPendingError(e);
     // Update pending signal for isPending() reactivity (companions only exist
     // once the verdict layer created them, which installs the hooks).
-        if (e.O || e.p) GlobalQueue.le(e);
-    if (e.nt && GlobalQueue.ce !== null) GlobalQueue.ce(e);
+        if (e._ || e.p) GlobalQueue.le(e);
+    if (e.nt && GlobalQueue.ae !== null) GlobalQueue.ae(e);
     if (e.Nt) e.Nt();
 }
 
@@ -1838,28 +1911,28 @@ function notifyStatus(e, t, n, r, i) {
     if (!r) {
         if (t === STATUS_PENDING && o) {
             addPendingSource(e, o);
-            e.Qe = STATUS_PENDING | e.Qe & STATUS_UNINITIALIZED;
+            e.xe = STATUS_PENDING | e.xe & 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.Qe = t | (t !== STATUS_ERROR ? e.Qe & STATUS_UNINITIALIZED : 0);
+            e.xe = t | (t !== STATUS_ERROR ? e.xe & STATUS_UNINITIALIZED : 0);
             e.De = n;
         }
         GlobalQueue.le !== null && GlobalQueue.le(e);
-        if (e.nt && GlobalQueue.ce !== null) GlobalQueue.ce(e);
+        if (e.nt && GlobalQueue.ae !== null) GlobalQueue.ae(e);
     }
     if (i && !r) {
         assignOrMergeLane(e, i);
     }
-    const c = r || l;
-    const a = r || u ? undefined : i;
+    const a = r || l;
+    const c = r || u ? undefined : i;
     if (e.Nt) {
         if (r && t === STATUS_PENDING) {
             return;
         }
-        if (c) {
+        if (a) {
             e.Nt(t, n);
         } else {
             e.Nt();
@@ -1867,20 +1940,20 @@ function notifyStatus(e, t, n, r, i) {
         return;
     }
     forEachDependent(e, (e, r) => {
-        e.W = clock;
+        e.F = clock;
         if (t === STATUS_PENDING && o && !e.$e?.has(o) || t !== STATUS_PENDING && (e.De !== n || e.$e)) {
             // A pending-observer link is the subscription an `isPending` read created.
             // It exists so the observer re-runs when the source settles, but it must
             // not carry a real (non-NotReadyError) error — the synchronous `isPending`
             // read swallows those, and the async path must match. Re-run the observer
             // so `isPending` re-evaluates (to not-pending) instead of forwarding.
-            if (r._t && t !== STATUS_PENDING && !(n instanceof NotReadyError)) {
+            if (r.Ot && t !== STATUS_PENDING && !(n instanceof NotReadyError)) {
                 enqueueSub(e);
                 schedule();
                 return;
             }
-            if (!c && !e.T) queuePendingNode(e);
-            notifyStatus(e, t, n, c, a);
+            if (!a && !e.T) queuePendingNode(e);
+            notifyStatus(e, t, n, a, c);
         }
     });
 }
@@ -1947,12 +2020,12 @@ function releaseSubtree(e) {
             t = t.ot;
             continue;
         }
-        if (t.Ve) {
+        if (t.Ue) {
             const e = t;
-            e.Ue &= ~CONFIG_IN_SNAPSHOT_SCOPE;
-            if (e.Ge & REACTIVE_SNAPSHOT_STALE) {
-                e.Ge &= ~REACTIVE_SNAPSHOT_STALE;
-                e.Ge |= REACTIVE_DIRTY;
+            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;
                 insertIntoHeap(e, dirtyQueue);
             }
@@ -1965,7 +2038,7 @@ function releaseSubtree(e) {
 function clearSnapshots() {
     if (snapshotSources) {
         for (const e of snapshotSources) {
-            delete e.ve;
+            delete e.me;
             // 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,7 +2050,7 @@ function clearSnapshots() {
 }
 
 function recompute(e, t = false) {
-    const n = e.Fe;
+    const n = e.We;
     if (!t) {
         if (e.T && (!n || activeTransition) && activeTransition !== e.T) globalQueue.initTransition(e.T);
         deleteFromHeap(e, queueFor(e));
@@ -1985,28 +2058,28 @@ function recompute(e, t = false) {
         // 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) {
             markDisposal(e);
-            e.Me = e.Et;
-            e.We = e.it;
+            e.He = e.Et;
+            e.Qe = e.it;
             e.Et = null;
             e.it = null;
             e.lt = 0;
         } else ;
     }
-    let r = !!(e.Ge & REACTIVE_OPTIMISTIC_DIRTY);
+    let r = !!(e.Le & REACTIVE_OPTIMISTIC_DIRTY);
     const i = e.A !== undefined && e.A !== NOT_PENDING;
-    const o = !!(e.Qe & STATUS_UNINITIALIZED);
+    const o = !!(e.xe & STATUS_UNINITIALIZED);
     // Re-ask classification lives in the verdict module; capture the flag before
     // the recompute wipes _flags below.
-        const s = (e.Ge & REACTIVE_REASK) !== 0;
+        const s = (e.Le & REACTIVE_REASK) !== 0;
     const u = context;
     context = e;
     e.st = null;
     e.Rt++;
-    e.Ge = REACTIVE_RECOMPUTING_DEPS;
-    e.W = clock;
-    let l = e.V === NOT_PENDING ? e.ke : e.V;
-    let c = e.Xe;
-    let a = tracking;
+    e.Le = 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;
     tracking = true;
     // A computed's fn establishes its OWN dependencies, so it must never run
@@ -2037,8 +2110,8 @@ function recompute(e, t = false) {
     const S = stale;
     if (d) stale = true;
     try {
-        if (!false && e.Ue & CONFIG_SYNC) {
-            l = e.Ve(l);
+        if (!false && e.Ge & CONFIG_SYNC) {
+            l = e.Ue(l);
             e.ut = null;
         } else {
             // Snapshot `_inFlight` so we can detect whether `_fn` self-registered an async
@@ -2047,13 +2120,16 @@ function recompute(e, t = false) {
             // clobber the fresh subscription, so we skip it and let the internally-registered
             // iteration drive updates.
             const t = e.ut;
-            const n = e.Ve(l);
+            const n = e.Ue(l);
             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;
         }
-        clearStatus(e, t);
+        // 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);
         // _optimisticLane is only ever assigned by engine paths.
                 if (e.i) GlobalQueue.ge(e);
     } catch (t) {
@@ -2068,15 +2144,15 @@ function recompute(e, t = false) {
         notifyStatus(e, t instanceof NotReadyError ? STATUS_PENDING : STATUS_ERROR, t, undefined, t instanceof NotReadyError ? e.i : undefined);
         if (n) GlobalQueue.Te(e);
     } finally {
-        tracking = a;
+        tracking = c;
         latestReadActive = E;
         if (d) stale = S;
-        e.Ge = REACTIVE_NONE | (t ? e.Ge & REACTIVE_SNAPSHOT_STALE : 0);
+        e.Le = REACTIVE_NONE | (t ? e.Le & REACTIVE_SNAPSHOT_STALE : 0);
         context = u;
     }
     if (!e.De) {
         trimStaleDeps(e);
-        const s = i ? unwrapOverride(e.A) : e.V === NOT_PENDING ? e.ke : e.V;
+        const s = i ? unwrapOverride(e.A) : e.U === NOT_PENDING ? e.ke : e.U;
         let u = false;
         try {
             u = !n && o || !e.At || !e.At(s, l);
@@ -2093,14 +2169,19 @@ function recompute(e, t = false) {
         // gate: the explicit recompute(node, true) inside effect() does not enqueue, so
         // effect() can call its runner synchronously for the first run.
                 if (n && u) {
-            e.xe = !e.De;
+            e.Fe = !e.De;
             // 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 (e.De) ; else if (u) {
             const o = i ? e.A : undefined;
-            if (t || n && activeTransition !== e.T || r) {
+            if (t || 
+            // Plain sync flush (no transition on either side) commits effect
+            // values directly — the pending round-trip (queuePendingNode +
+            // 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;
                 // Lane-propagated correction: upstream data is fresh, correct the
                 // override unconditionally. The direct _value commit is the lane's
@@ -2108,10 +2189,10 @@ function recompute(e, t = false) {
                 // commit can't clobber the fresh value.
                                 if (i && r) {
                     e.A = l === undefined ? OVERRIDE_UNDEFINED : l;
-                    e.V = NOT_PENDING;
+                    e.U = NOT_PENDING;
                 }
             } else {
-                e.V = l;
+                e.U = l;
                 // 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
@@ -2119,61 +2200,63 @@ function recompute(e, t = false) {
                 // pending value commits before effects run.
                                 if ((activeTransition || e.T) && GlobalQueue.ue !== null) GlobalQueue.ue(e, l);
             }
-            if (!i || r || e.A !== o) insertSubs(e, r || i);
+            // 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);
         } 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.V === NOT_PENDING) queuePendingNode(e);
-            e.V = l;
-        } else if (e.Xe != c) {
-            for (let t = e.U; t !== null; t = t.we) {
-                insertIntoHeapHeight(t.Le, queueFor(t.Le));
+            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) {
+                insertIntoHeapHeight(t.Ve, queueFor(t.Ve));
             }
         }
     }
     currentOptimisticLane = f;
-    const T = e.V !== NOT_PENDING || e.We !== null || e.Me !== null || (e.Qe & (STATUS_PENDING | STATUS_UNINITIALIZED)) !== 0;
+    const T = e.U !== NOT_PENDING || e.Qe !== null || e.He !== null || (e.xe & (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.Qe & STATUS_PENDING) && (!e.T || i) && queuePendingNode(e);
+        T && (!t || e.xe & STATUS_PENDING) && (!e.T || i) && queuePendingNode(e);
     e.T && n && activeTransition !== e.T && runInTransition(e.T, () => recompute(e));
 }
 
 function updateIfNecessary(e) {
-    if (e.Ge & REACTIVE_CHECK) {
+    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.Ve) {
+            if (r.Ue) {
                 updateIfNecessary(r);
             }
-            if (e.Ge & REACTIVE_DIRTY) {
+            if (e.Le & REACTIVE_DIRTY) {
                 break;
             }
         }
     }
-    if (e.Ge & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY) || e.De && e.W < clock && !e.ut) {
+    if (e.Le & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY) || e.De && e.F < clock && !e.ut) {
         recompute(e);
     }
-    e.Ge = e.Ge & (REACTIVE_SNAPSHOT_STALE | REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT);
+    e.Le = e.Le & (REACTIVE_SNAPSHOT_STALE | REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT);
 }
 
 function computed(e, t) {
     const n = t?.transparent ?? false;
     const r = {
         id: inheritId(t, n, context),
-        Ue: (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),
+        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,
-        F: t?.unobserved,
+        W: t?.unobserved,
         Et: null,
         Be: context?.Be ?? globalQueue,
         dt: context?.dt ?? defaultContext,
         lt: 0,
-        Ve: e,
+        Ue: e,
         ke: undefined,
         Xe: 0,
         nt: null,
@@ -2182,18 +2265,18 @@ function computed(e, t) {
         je: null,
         st: null,
         Rt: 0,
-        U: null,
+        G: null,
         Tt: null,
         B: context,
         ot: null,
         ct: null,
         it: null,
-        Ge: t?.lazy ? REACTIVE_LAZY : REACTIVE_NONE,
-        Qe: STATUS_UNINITIALIZED,
-        W: clock,
-        V: NOT_PENDING,
-        Me: null,
-        We: null,
+        Le: t?.lazy ? REACTIVE_LAZY : REACTIVE_NONE,
+        xe: STATUS_UNINITIALIZED,
+        F: clock,
+        U: NOT_PENDING,
+        He: null,
+        Qe: null,
         ut: null,
         T: null,
         ht: false
@@ -2211,14 +2294,14 @@ function computed(e, t) {
     const s = o?.transparent ?? false;
     const u = {
         id: inheritId(o, s, context),
-        Ue: (s ? CONFIG_TRANSPARENT : 0) | (o?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (o?.sync ? CONFIG_SYNC : 0) | (snapshotCaptureActive && ownerInSnapshotScope(context) ? CONFIG_IN_SNAPSHOT_SCOPE : 0),
+        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,
-        F: o?.unobserved,
+        W: o?.unobserved,
         Et: null,
         Be: context?.Be ?? globalQueue,
         dt: context?.dt ?? defaultContext,
         lt: 0,
-        Ve: e,
+        Ue: e,
         ke: undefined,
         Xe: 0,
         nt: null,
@@ -2227,27 +2310,27 @@ function computed(e, t) {
         je: null,
         st: null,
         Rt: 0,
-        U: null,
+        G: null,
         Tt: null,
         B: context,
         ot: null,
         ct: null,
         it: null,
-        Ge: REACTIVE_LAZY,
-        Qe: STATUS_UNINITIALIZED,
-        W: clock,
-        V: NOT_PENDING,
-        Me: null,
-        We: null,
+        Le: REACTIVE_LAZY,
+        xe: STATUS_UNINITIALIZED,
+        F: clock,
+        U: NOT_PENDING,
+        He: null,
+        Qe: null,
         ut: null,
         T: null,
         ht: false,
-        xe: false,
+        Fe: false,
         gt: undefined,
         bt: t,
         Dt: n,
         ft: undefined,
-        Fe: r,
+        We: r,
         Nt: i
     };
     setupComputedNode(u, lazyOptions);
@@ -2275,8 +2358,8 @@ function setupComputedNode(e, t) {
     if (GlobalQueue.oe !== null) GlobalQueue.oe(e);
     !t?.lazy && recompute(e, true);
     if (snapshotCaptureActive && !t?.lazy) {
-        if (!(e.Qe & STATUS_PENDING) && !(e.Ue & CONFIG_NO_SNAPSHOT)) {
-            e.ve = e.ke === undefined ? NO_SNAPSHOT : e.ke;
+        if (!(e.xe & STATUS_PENDING) && !(e.Ge & CONFIG_NO_SNAPSHOT)) {
+            e.me = e.ke === undefined ? NO_SNAPSHOT : e.ke;
             snapshotSources.add(e);
         }
     }
@@ -2285,19 +2368,19 @@ function setupComputedNode(e, t) {
 function signal(e, t, n = null) {
     const r = {
         At: t?.equals != null ? t.equals : isEqual,
-        Ue: (t?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (t?.Ct ? CONFIG_NO_SNAPSHOT : 0),
-        F: t?.unobserved,
+        Ge: (t?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (t?.Ct ? CONFIG_NO_SNAPSHOT : 0),
+        W: t?.unobserved,
         ke: e,
-        U: null,
+        G: null,
         Tt: null,
-        W: clock,
+        F: clock,
         qe: n,
         rt: n?.nt || null,
-        V: NOT_PENDING
+        U: NOT_PENDING
     };
     n && (n.nt = r);
-    if (snapshotCaptureActive && !(r.Ue & CONFIG_NO_SNAPSHOT) && !((n?.Qe ?? 0) & STATUS_PENDING)) {
-        r.ve = e === undefined ? NO_SNAPSHOT : e;
+    if (snapshotCaptureActive && !(r.Ge & CONFIG_NO_SNAPSHOT) && !((n?.xe ?? 0) & STATUS_PENDING)) {
+        r.me = e === undefined ? NO_SNAPSHOT : e;
         snapshotSources.add(r);
     }
     return r;
@@ -2357,16 +2440,37 @@ 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.Ge & REACTIVE_LAZY) {
-        e.Ge &= ~REACTIVE_LAZY;
+    if (e.Le & REACTIVE_LAZY) {
+        e.Le &= ~REACTIVE_LAZY;
         recompute(e, true);
-    } else if (e.Ge & REACTIVE_DISPOSED) {
+    } else if (e.Le & REACTIVE_DISPOSED) {
         recompute(e, true);
     } else if (t) {
         updateIfNecessary(e);
     }
 }
 
+/**
+ * Sentinel returned by readNodeFast when the plain-signal fast path does not
+ * apply and the caller must fall back to the full read().
+ */ const READ_SLOW = Symbol("read-slow");
+
+/**
+ * read()'s plain-signal fast path as a standalone entry for hot callers
+ * (store traps). Safe to substitute for read() only because the bail
+ * conditions mirror read()'s prelude and fast-path guard exactly: the
+ * latestRead and pendingCheck windows run side-effectful hooks before the
+ * fast path, `_fn` nodes need prepareComputed, and firewall / override /
+ * 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;
+    let t = context;
+    if (t?.ze) t = t.Je;
+    if (t && tracking) link(e, t);
+    return !t || e.U === NOT_PENDING ? e.ke : e.U;
+}
+
 function read(e) {
     // Handle latest() mode: read from _latestValueComputed
     // Checked before isPending so that isPending(() => latest(x)) checks
@@ -2383,16 +2487,16 @@ function read(e) {
     // recompute don't collect into the probe.
         if (pendingCheckActive) {
         GlobalQueue.Ee(e, t, i, r);
-    } else if (typeof n.Ve === "function") {
+    } else if (typeof n.Ue === "function") {
         prepareComputed(e, false);
     }
-    if (!n.Ve && i === e && e.A === undefined && e.ve === undefined && activeTransition === null && currentOptimisticLane === null && !snapshotCaptureActive && true) {
+    if (!n.Ue && i === e && e.A === undefined && e.me === undefined && activeTransition === null && currentOptimisticLane === null && !snapshotCaptureActive && true) {
         if (t && tracking) link(e, t);
-        return !t || e.V === NOT_PENDING ? e.ke : e.V;
+        return !t || e.U === NOT_PENDING ? e.ke : e.U;
     }
     if (t && tracking) {
         link(e, t, pendingCheckActive);
-        if (i.Ve) {
+        if (i.Ue) {
             const n = queueFor(e);
             if (i.Xe >= n.P) {
                 markNode(t);
@@ -2406,7 +2510,7 @@ function read(e) {
             }
         }
     }
-    if (i.Qe & STATUS_PENDING) {
+    if (i.xe & 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
@@ -2415,29 +2519,29 @@ function read(e) {
                 if (!tracking && e !== t) link(e, t);
                 throw i.De;
             }
-        } else if (t && i !== e && i.Qe & STATUS_UNINITIALIZED) {
+        } else if (t && i !== e && i.xe & STATUS_UNINITIALIZED) {
             if (!tracking && e !== t) link(e, t);
             throw i.De;
-        } else if (!t && i.Qe & STATUS_UNINITIALIZED) {
+        } else if (!t && i.xe & STATUS_UNINITIALIZED) {
             throw i.De;
         }
     }
-    if (e.Ve && e.Qe & STATUS_ERROR) {
+    if (e.Ue && e.xe & 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.W < clock) {
+        if (tracking && !pendingCheckActive && e.F < clock) {
             recompute(e);
             return read(e);
         } else throw e.De;
     }
-    if (snapshotCaptureActive && t && t.Ue & CONFIG_IN_SNAPSHOT_SCOPE) {
-        const n = e.ve;
+    if (snapshotCaptureActive && t && t.Ge & CONFIG_IN_SNAPSHOT_SCOPE) {
+        const n = e.me;
         if (n !== undefined) {
             const r = n === NO_SNAPSHOT ? undefined : n;
-            const i = e.V !== NOT_PENDING ? e.V : e.ke;
-            if (i !== r) t.Ge |= REACTIVE_SNAPSHOT_STALE;
+            const i = e.U !== NOT_PENDING ? e.U : e.ke;
+            if (i !== r) t.Le |= REACTIVE_SNAPSHOT_STALE;
             return r;
         }
     }
@@ -2459,11 +2563,11 @@ function read(e) {
     // 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.V === NOT_PENDING || stale && e.T && activeTransition !== e.T ? e.ke : e.V;
+        const o = !t || currentOptimisticLane !== null && GlobalQueue.ye(e, i, t) || e.U === NOT_PENDING || stale && e.T && activeTransition !== e.T ? e.ke : 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.Ve === "function" && e.Ue & CONFIG_AUTO_DISPOSE && !(i.Qe & STATUS_PENDING) && !e.U) {
+    if (!t && i === e && typeof n.Ue === "function" && e.Ge & CONFIG_AUTO_DISPOSE && !(i.xe & STATUS_PENDING) && !e.G) {
         unobserved(e);
     }
     return o;
@@ -2475,17 +2579,20 @@ 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.Oe(e, t);
-    const n = e.V === NOT_PENDING ? e.ke : e.V;
+        if (e.A !== undefined && !projectionWriteActive) return GlobalQueue._e(e, t);
+    const n = e.U === NOT_PENDING ? e.ke : 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.Qe & STATUS_UNINITIALIZED) || !e.At || !e.At(n, t);
+        const r = !!(e.xe & STATUS_UNINITIALIZED) || !e.At || !e.At(n, t);
     if (!r) return t;
-    if (e.V === NOT_PENDING) queuePendingNode(e);
-    e.V = t;
-    GlobalQueue.ue !== null && GlobalQueue.ue(e, t);
-    e.W = clock;
+    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.F = clock;
     insertSubs(e);
     schedule();
     return t;
@@ -2499,11 +2606,11 @@ function setSignal(e, t) {
  * cleanup point.
  */ function suppressComputedRecompute(e) {
     deleteFromHeap(e, queueFor(e));
-    if (!(e.Ge & REACTIVE_MANUAL_WRITE) && e.V === NOT_PENDING) {
+    if (!(e.Le & REACTIVE_MANUAL_WRITE) && e.U === NOT_PENDING) {
         queuePendingNode(e);
         schedule();
     }
-    e.Ge = e.Ge & -4 | REACTIVE_MANUAL_WRITE;
+    e.Le = e.Le & -4 | REACTIVE_MANUAL_WRITE;
 }
 
 /**
@@ -2582,7 +2689,7 @@ function staleValues(e, t = true) {
     if (!t) {
         return;
     }
-    if (typeof t.Ve === "function" && !(t.Ge & (REACTIVE_DISPOSED | REACTIVE_MANUAL_WRITE))) {
+    if (typeof t.Ue === "function" && !(t.Le & (REACTIVE_DISPOSED | REACTIVE_MANUAL_WRITE))) {
         // A refresh with no value-change dirt already queued is a re-ask of the
         // same question: mark it so the recompute classifies any resulting
         // pending window as quiet (not pending). If the node is already dirty
@@ -2590,11 +2697,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.Ge & (REACTIVE_DIRTY | REACTIVE_CHECK | REACTIVE_IN_HEAP))) {
-            t.Ge |= REACTIVE_REASK;
+        if (!(t.Le & (REACTIVE_DIRTY | REACTIVE_CHECK | REACTIVE_IN_HEAP))) {
+            t.Le |= REACTIVE_REASK;
             armReaskClear();
         }
-        t.Ge = t.Ge & ~REACTIVE_CHECK | REACTIVE_DIRTY;
+        t.Le = t.Le & ~REACTIVE_CHECK | REACTIVE_DIRTY;
         insertIntoHeap(t, queueFor(t));
         schedule();
     }
@@ -2642,11 +2749,11 @@ function wireExternalSource(e) {
         equals: false,
         ownedWrite: true
     });
-    const n = externalSourceConfig.factory(e.Ve, () => {
+    const n = externalSourceConfig.factory(e.Ue, () => {
         setSignal(t, undefined);
     });
     cleanup(() => n.dispose());
-    e.Ve = e => {
+    e.Ue = e => {
         read(t);
         return n.track(e);
     };
@@ -2770,7 +2877,7 @@ function isUndefined(e) {
     const n = e.A !== NOT_PENDING;
     const r = n ? unwrapOverride(e.A) : e.ke;
     if (typeof t === "function") t = t(r);
-    const i = !!(e.Qe & STATUS_UNINITIALIZED) || !e.At || !e.At(r, t);
+    const i = !!(e.xe & STATUS_UNINITIALIZED) || !e.At || !e.At(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.
@@ -2795,8 +2902,10 @@ function isUndefined(e) {
     // brand, and erasing it makes the write invisible and routes follow-up
     // writes off the optimistic path into permanent commits (#2898).
         e.A = t === undefined ? OVERRIDE_UNDEFINED : t;
-    GlobalQueue.ue !== null && GlobalQueue.ue(e, t);
-    e.W = clock;
+    // 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.F = clock;
     insertSubs(e, true);
     schedule();
     return t;
@@ -2809,7 +2918,7 @@ function isUndefined(e) {
  */ function transitionBlocked(e) {
     for (let t = 0; t < e.v.length; t++) {
         const n = e.v[t];
-        if (hasActiveOverride(n) && "Qe" in n && n.Qe & STATUS_PENDING && n.De instanceof NotReadyError) {
+        if (hasActiveOverride(n) && "xe" in n && n.xe & STATUS_PENDING && n.De instanceof NotReadyError) {
             return true;
         }
     }
@@ -2827,7 +2936,7 @@ 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.Qe & STATUS_PENDING)) t.Qe &= ~STATUS_UNINITIALIZED;
+                if (!(t.xe & STATUS_PENDING)) t.xe &= ~STATUS_UNINITIALIZED;
         const r = t.A;
         t.A = NOT_PENDING;
         if (r !== NOT_PENDING && t.ke !== unwrapOverride(r)) insertSubs(t, true);
@@ -2839,9 +2948,9 @@ function resolveOptimisticNodes(e) {
     // transition that produced them (A19 — pending is a property of the data).
         for (let n = 0; n < t; n++) {
         const t = e[n];
-        if (t.O || t.p) GlobalQueue.ae(t);
+        if (t._ || t.p) GlobalQueue.ce(t);
         const r = t.t;
-        if (r && (r.O === t || r.p === t)) GlobalQueue.ae(r);
+        if (r && (r._ === t || r.p === t)) GlobalQueue.ce(r);
     }
     e.splice(0, t);
 }
@@ -2894,7 +3003,7 @@ function cleanupCompletedLanes(e) {
  * that reads a pending mid-transition write sees the committed value; the sub
  * is recorded for replay at commit.
  */ function gatedRead(e, t, n) {
-    if (latestReadActive || e.V === NOT_PENDING || e.Ve || t !== e && !(t.Ge & REACTIVE_MANUAL_WRITE)) {
+    if (latestReadActive || e.U === NOT_PENDING || e.Ue || t !== e && !(t.Le & REACTIVE_MANUAL_WRITE)) {
         return false;
     }
     activeTransition.Y.add(n);
@@ -2905,7 +3014,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.Qe & STATUS_PENDING);
+    return e.A !== undefined || !!e.i || t === e && stale && n.t !== e || !!(t.xe & STATUS_PENDING);
 }
 
 /**
@@ -2916,10 +3025,10 @@ function cleanupCompletedLanes(e) {
     if (t) return resolveLane(e) ?? null;
     for (let t = e.je; t; t = t.Ke) {
         const n = t.Ye;
-        if (n.Ge & REACTIVE_OPTIMISTIC_DIRTY) {
+        if (n.Le & REACTIVE_OPTIMISTIC_DIRTY) {
             const t = resolveLane(n);
             if (t) {
-                e.Ge |= REACTIVE_OPTIMISTIC_DIRTY;
+                e.Le |= REACTIVE_OPTIMISTIC_DIRTY;
                 assignOrMergeLane(e, t);
                 return t;
             }
@@ -2947,7 +3056,7 @@ function cleanupCompletedLanes(e) {
 
 function trackOptimisticStore(e) {
     // After initTransition, globalQueue._batch IS activeTransition (same reference)
-    globalQueue.D.L.add(e);
+    globalQueue.D.V.add(e);
     schedule();
 }
 
@@ -2956,8 +3065,8 @@ 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.Oe !== null) return;
-    GlobalQueue.Oe = optimisticWrite;
+    if (GlobalQueue._e !== null) return;
+    GlobalQueue._e = optimisticWrite;
     GlobalQueue.pe = resolveOptimisticNodes;
     GlobalQueue.Re = transitionBlocked;
     GlobalQueue.Ie = cleanupCompletedLanes;
@@ -2987,15 +3096,15 @@ let pendingProbe = null;
  * Get or create the pending signal for a node (lazy).
  * Used by isPending() to track pending state reactively.
  */ function getPendingSignal(e) {
-    if (!e.O) {
+    if (!e._) {
         // Start false, write true if pending - ensures reversion returns to false
-        e.O = optimisticSignal(false, {
+        e._ = optimisticSignal(false, {
             ownedWrite: true
         });
-        e.O.t = e;
-        if (computePendingState(e)) setSignal(e.O, true);
+        e._.t = e;
+        if (computePendingState(e)) setSignal(e._, true);
     }
-    return e.O;
+    return e._;
 }
 
 function collectPendingSources(e) {
@@ -3031,7 +3140,7 @@ 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.Qe & STATUS_ERROR) return false;
+        if (e.xe & STATUS_ERROR) return false;
     if (t.has(e)) return false;
     t.add(e);
     const n = e.qe;
@@ -3041,10 +3150,10 @@ function collectPendingSources(e) {
     // 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.Ge & REACTIVE_RECOMPUTING_DEPS ? r.st : undefined;
+    const i = r.Le & REACTIVE_RECOMPUTING_DEPS ? r.st : undefined;
     if (i !== null) {
         for (let e = r.je ?? null; e !== null; e = e.Ke) {
-            if (!e._t && markWalk(e.Ye, t)) return true;
+            if (!e.Ot && markWalk(e.Ye, t)) return true;
             if (e === i) break;
         }
     }
@@ -3064,12 +3173,12 @@ function quietPending(e) {
 }
 
 function newQuestionInFlight(e) {
-    return !!(e.Qe & STATUS_PENDING) && !(e.Qe & STATUS_UNINITIALIZED) && !quietPending(e);
+    return !!(e.xe & STATUS_PENDING) && !(e.xe & STATUS_UNINITIALIZED) && !quietPending(e);
 }
 
 function computePendingState(e) {
     const t = e;
-    if (t.Ge & REACTIVE_DISPOSED) return false;
+    if (t.Le & REACTIVE_DISPOSED) return false;
     // Mark coverage is transitive by dep-graph reachability: a latest() shadow
     // reaches its owner (and a store leaf its firewall) through its own deps,
     // so the one walk covers direct marks, derivation, and companion chains.
@@ -3080,31 +3189,31 @@ function computePendingState(e) {
         const n = t.qe || t;
         return newQuestionInFlight(n);
     }
-    if (n && e.V !== NOT_PENDING && !hasActiveOverride(e)) {
-        return !!(n.Ge & REACTIVE_MANUAL_WRITE) || !n.ut && !(n.Qe & STATUS_PENDING) || !!(n.Qe & STATUS_PENDING) && quietPending(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);
     }
-    if (e.V !== NOT_PENDING && !(t.Qe & STATUS_UNINITIALIZED)) {
-        if (hasActiveOverride(e)) return !e.At || !e.At(e.V, unwrapOverride(e.A));
+    if (e.U !== NOT_PENDING && !(t.xe & STATUS_UNINITIALIZED)) {
+        if (hasActiveOverride(e)) return !e.At || !e.At(e.U, unwrapOverride(e.A));
         return true;
     }
     return newQuestionInFlight(t);
 }
 
 function syncCompanions(e, t) {
-    if (e.O) updatePendingSignal(e);
+    if (e._) updatePendingSignal(e);
     if (e.p) setSignal(e.p, t);
 }
 
 function updatePendingSignal(e) {
-    if (e.O) {
-        setSignal(e.O, computePendingState(e));
+    if (e._) {
+        setSignal(e._, computePendingState(e));
     }
     if (e.p) updatePendingSignal(e.p);
 }
 
 function updateChildCompanions(e) {
     for (let t = e.nt; t !== null; t = t.rt) {
-        if (t.O || t.p) updatePendingSignal(t);
+        if (t._ || t.p) updatePendingSignal(t);
     }
 }
 
@@ -3122,8 +3231,8 @@ function updateChildCompanions(e) {
     const visit = e => {
         if (r.has(e)) return;
         r.add(e);
-        if (e.O || e.p) n(e);
-        for (let t = e.U; t !== null; t = t.we) visit(t.Le);
+        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) {
             visit(t);
         }
@@ -3132,21 +3241,21 @@ function updateChildCompanions(e) {
 }
 
 function snapCompanionsToState(e) {
-    const t = e.O;
+    const t = e._;
     if (t && (t.A === undefined || t.A === NOT_PENDING)) {
         const n = computePendingState(e);
-        if (t.ke !== n || t.V !== NOT_PENDING) {
+        if (t.ke !== n || t.U !== NOT_PENDING) {
             t.ke = n;
-            t.V = NOT_PENDING;
-            t.W = clock;
+            t.U = NOT_PENDING;
+            t.F = clock;
             insertSubs(t);
             schedule();
         }
     }
     const n = e.p;
-    if (n && !(n.Ge & REACTIVE_DISPOSED)) {
-        if ((n.A === undefined || n.A === NOT_PENDING) && n.V === NOT_PENDING && !Object.is(n.ke, e.ke) && !(n.Ge & (REACTIVE_DIRTY | REACTIVE_CHECK))) {
-            n.Ge |= REACTIVE_DIRTY;
+    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;
             insertIntoHeap(n, queueFor(n));
             insertSubs(n);
             schedule();
@@ -3187,18 +3296,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.Ge & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE))) {
+        if (t.Xe >= e.P && !(t.Le & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE))) {
             markHeap(e);
             prepareComputed(t, true);
         }
         i = read(t);
     } catch (t) {
-        if (t instanceof NotReadyError && (!context || !(e.Qe & STATUS_UNINITIALIZED))) return r;
+        if (t instanceof NotReadyError && (!context || !(e.xe & STATUS_UNINITIALIZED))) return r;
         throw t;
     } finally {
         setLatestReadActive(n);
     }
-    if (t.Qe & STATUS_PENDING) return r;
+    if (t.xe & STATUS_PENDING) return r;
     if (stale && currentOptimisticLane && t.i) {
         const e = findLane(t.i);
         const n = findLane(currentOptimisticLane);
@@ -3210,14 +3319,14 @@ function getLatestValueComputed(e) {
     // speculative value in _pendingValue; a contextless read() only surfaces
     // _value. Overrides stay authoritative (A17), and stale readers keep the
     // other transition's committed view, matching read()'s own selection.
-        if (t.V !== NOT_PENDING && !hasActiveOverride(t) && !(stale && t.T && activeTransition !== t.T)) return t.V;
+        if (t.U !== NOT_PENDING && !hasActiveOverride(t) && !(stale && t.T && activeTransition !== t.T)) return t.U;
     return i;
 }
 
 /** The isPending()-probe read path, installed as GlobalQueue._pendingCheck. */ function pendingCheckRead(e, t, n, r) {
     setPendingCheckActive(false);
-    if (typeof e.Ve === "function") prepareComputed(e, true);
-    const i = n.Qe;
+    if (typeof e.Ue === "function") prepareComputed(e, true);
+    const i = n.xe;
     if (t && i & STATUS_PENDING && i & STATUS_UNINITIALIZED) {
         if (tracking && e !== t) link(e, t);
         setPendingCheckActive(true);
@@ -3229,11 +3338,11 @@ function getLatestValueComputed(e) {
 }
 
 function recordFreshRead(e, t) {
-    if (pendingProbe !== null && e.V !== NOT_PENDING && t === e.V) pendingProbe.freshReads.add(e);
+    if (pendingProbe !== null && e.U !== NOT_PENDING && t === e.U) pendingProbe.freshReads.add(e);
 }
 
 function applyReask(e, t) {
-    const n = !!(e.Qe & STATUS_PENDING);
+    const n = !!(e.xe & STATUS_PENDING);
     const r = t && !(n && !e.ht);
     const i = n && e.ht !== r;
     e.ht = r;
@@ -3276,7 +3385,7 @@ function isPending(e) {
     } catch (e) {
         collectPending();
         if (e instanceof NotReadyError) {
-            const t = !!(e.source?.Qe & STATUS_UNINITIALIZED);
+            const t = !!(e.source?.xe & STATUS_UNINITIALIZED);
             if (r.found && !t) return true;
             if (context && t) throw e;
         }
@@ -3294,9 +3403,9 @@ GlobalQueue.ue = syncCompanions;
 
 GlobalQueue.le = updatePendingSignal;
 
-GlobalQueue.ce = updateChildCompanions;
+GlobalQueue.ae = updateChildCompanions;
 
-GlobalQueue.ae = snapCompanionsToState;
+GlobalQueue.ce = snapCompanionsToState;
 
 GlobalQueue.fe = latestRead;
 
@@ -3308,7 +3417,7 @@ GlobalQueue.Se = applyReask;
 
 GlobalQueue.Te = repollDownstreamVerdicts;
 
-GlobalQueue._e = witnessAffects;
+GlobalQueue.Oe = witnessAffects;
 
 /**
  * Effects are the leaf nodes of our reactive graph. When their sources change, they are
@@ -3318,16 +3427,16 @@ GlobalQueue._e = witnessAffects;
     const i = !!r?.user;
     const o = createEffectNode(e, t, n, i ? EFFECT_USER : EFFECT_RENDER, notifyEffectStatus, r);
     recompute(o, true);
-    !r?.defer && (o.Fe === EFFECT_USER || r?.schedule ? o.Be.enqueue(o.Fe, runEffect.bind(null, o)) : runEffect(o));
+    !r?.defer && (o.We === EFFECT_USER || r?.schedule ? o.Be.enqueue(o.We, 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.Qe;
+    const n = e !== undefined ? e : this.xe;
     const r = t !== undefined ? t : this.De;
     if (n & STATUS_ERROR) {
         this.Be.notify(this, STATUS_PENDING, 0);
-        if (this.Fe === EFFECT_USER) {
+        if (this.We === 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
@@ -3337,9 +3446,9 @@ 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.Qe & STATUS_ERROR) {
-                this.xe = true;
-                this.Be.enqueue(this.Fe, this.Pt ??= runEffect.bind(null, this));
+            if (this.xe & STATUS_ERROR) {
+                this.Fe = true;
+                this.Be.enqueue(this.We, this.Pt ??= runEffect.bind(null, this));
             }
             return;
         }
@@ -3347,13 +3456,13 @@ function notifyEffectStatus(e, t) {
             haltReactivity(unwrapStatusError(r));
             throw r;
         }
-    } else if (this.Fe === EFFECT_RENDER) {
+    } else if (this.We === EFFECT_RENDER) {
         this.Be.notify(this, STATUS_PENDING | STATUS_ERROR, n, r);
     }
 }
 
 function runEffect(e) {
-    if (!e.xe || e.Ge & REACTIVE_DISPOSED) return;
+    if (!e.Fe || e.Le & REACTIVE_DISPOSED) return;
     // Error arm (#2840), user effects only: a compute-phase error that is still
     // the node's settled state at effect time runs the bundle's error handler in
     // this same imperative, writable scope. Unwrap the StatusError used for
@@ -3364,10 +3473,10 @@ 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.Qe & STATUS_ERROR && e.Fe === EFFECT_USER) {
+        if (e.xe & STATUS_ERROR && e.We === EFFECT_USER) {
         const t = unwrapStatusError(e.De);
         e.gt = e.ke;
-        e.xe = false;
+        e.Fe = false;
         try {
             e.Dt ? e.Dt(t, () => {
                 const t = e.ft;
@@ -3392,14 +3501,14 @@ function runEffect(e) {
                 e.ft = n;
     } catch (t) {
         e.De = new StatusError(e, t);
-        e.Qe |= STATUS_ERROR;
+        e.xe |= STATUS_ERROR;
         if (!e.Be.notify(e, STATUS_ERROR, STATUS_ERROR)) {
             haltReactivity(t);
             throw t;
         }
     } finally {
         e.gt = e.ke;
-        e.xe = false;
+        e.Fe = false;
     }
 }
 
@@ -3411,9 +3520,9 @@ GlobalQueue.J = runEffect;
  * Uses stale reads.
  */ function trackedEffect(e, t) {
     const run = () => {
-        if (!n.xe || n.Ge & REACTIVE_DISPOSED) return;
+        if (!n.Fe || n.Le & REACTIVE_DISPOSED) return;
         try {
-            n.xe = false;
+            n.Fe = false;
             recompute(n);
         } finally {}
     };
@@ -3428,11 +3537,11 @@ GlobalQueue.J = runEffect;
         lazy: true
     });
     n.ft = undefined;
-    n.Ue = n.Ue & ~CONFIG_AUTO_DISPOSE | CONFIG_CHILDREN_FORBIDDEN;
-    n.xe = true;
-    n.Fe = EFFECT_TRACKED;
+    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.Qe;
+        const r = e !== undefined ? e : n.xe;
         if (r & STATUS_ERROR) {
             n.Be.notify(n, STATUS_PENDING, 0);
             const e = t !== undefined ? t : n.De;
@@ -3624,7 +3733,7 @@ function accessor(e) {
 function createSignal(e, t) {
     if (typeof e === "function") {
         const n = computed(e, t);
-        n.Ue &= ~CONFIG_AUTO_DISPOSE;
+        n.Ge &= ~CONFIG_AUTO_DISPOSE;
         return [ accessor(n), setMemo.bind(null, n) ];
     }
     const n = signal(e, t);
@@ -3865,7 +3974,7 @@ function createOptimistic(e, t) {
     installOptimisticEngine();
     if (typeof e === "function") {
         const n = optimisticComputed(e, t);
-        n.Ue &= ~CONFIG_AUTO_DISPOSE;
+        n.Ge &= ~CONFIG_AUTO_DISPOSE;
         return [ accessor(n), setSignal.bind(null, n) ];
     }
     const n = optimisticSignal(e, t);
@@ -3954,7 +4063,7 @@ function createOptimistic(e, t) {
  *   on owner disposal
  */ function onSettled(e) {
     const t = getOwner();
-    t && !(t.Ue & CONFIG_CHILDREN_FORBIDDEN) ? createTrackedEffect(() => untrack(e), undefined) : globalQueue.enqueue(EFFECT_USER, () => {
+    t && !(t.Ge & 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
@@ -4058,28 +4167,68 @@ function keyedMatch(e, t, n) {
 // and `in` dependencies should follow the new value's membership. Use
 // membership rather than length arithmetic so sparse arrays and named array
 // props behave like normal property reads.
+// Inline key iteration on purpose: these loops run per array target per
+// reconcile pass, and a shared helper means a closure + per-key call in
+// instruction counts. String-only records (the common case) iterate in
+// place; symbol-bearing records take the nodeKeys array path.
 function syncArrayNodeMembership(e, t) {
     let n = e[STORE_NODE];
     if (n) {
-        const e = nodeKeys(n);
-        for (let r = 0, i = e.length; r < i; r++) {
-            const i = e[r];
-            i in t || setSignal(n[i], undefined);
+        if (symbolKeyedRecords.has(n)) {
+            const e = nodeKeys(n);
+            for (let r = 0, i = e.length; r < i; r++) {
+                e[r] in t || setSignal(n[e[r]], undefined);
+            }
+        } else {
+            for (const e in n) {
+                e in t || setSignal(n[e], undefined);
+            }
         }
     }
     if (n = e[STORE_HAS]) {
-        const e = nodeKeys(n);
-        for (let r = 0, i = e.length; r < i; r++) {
-            const i = e[r];
-            setSignal(n[i], i in t);
+        if (symbolKeyedRecords.has(n)) {
+            const e = nodeKeys(n);
+            for (let r = 0, i = e.length; r < i; r++) {
+                setSignal(n[e[r]], e[r] in t);
+            }
+        } else {
+            for (const e in n) {
+                setSignal(n[e], e in t);
+            }
         }
     }
 }
 
+// Recurse into a matched wrappable child pair without manufacturing a proxy:
+// resolve the child's target through the lookup and dispatch directly. A
+// lookup miss means the child was never observed — no proxy, no nodes, no
+// subscribers anywhere below — so the parent's swap making `next`
+// authoritative IS the whole update; a later read wraps next's child on
+// demand. This turns the diff from O(previous graph) into O(observed graph)
+// and drops the wrap()/$PROXY/$TARGET round-trip per visited child.
+// Wrap-family stores (projections/optimistic) own child proxy creation and
+// keep the proxy-based recursion.
+function applyStateChild(e, t, n, r) {
+    if (n[STORE_WRAP] !== undefined) {
+        applyState(e, wrap(t, n), r);
+        return;
+    }
+    const i = t[$TARGET] ?? storeLookup.get(t);
+    if (i === undefined) return;
+    e = unwrap(e);
+    if (i[STORE_SHALLOW]) {
+        applyStateShallow(e, i);
+    } else if (i[STORE_OVERRIDE] || i[STORE_OPTIMISTIC_OVERRIDE]) {
+        applyStateSlow(e, i, r);
+    } else {
+        applyStateFast(e, i, 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)) {
+    if (isWrappable(e) && isWrappable(t) && !(rawValuesUsed && (isRawValue(t) || isRawValue(e)))) {
         const o = wrap(t, n);
         r && setSignal(r, o);
         applyState(e, o, i);
@@ -4099,18 +4248,51 @@ function applyArrayItem(e, t, n, r, i) {
  * `$TRACK` absence (an enumeration-tracked record already diffs every key).
  */ function applyDescendants(e, t, n, r, i, o, s) {
     const u = n[STORE_LOOKUP] || storeLookup;
-    const l = (o ? getKeys(e, o) : Object.keys(e)).concat(getStoreSymbols(e, o));
-    for (let c = 0, a = l.length; c < a; c++) {
-        const a = l[c];
-        if (r?.[a]) continue;
+    if (o) {
+        const n = getKeys(e, o).concat(getStoreSymbols(e, o));
+        for (let l = 0, a = n.length; l < a; l++) {
+            const a = n[l];
+            if (r?.[a]) continue;
  // main loop already diffed this slot
-                const f = unwrap(o ? getOverrideValue(e, o, a, s) : e[a]);
-        if (!isWrappable(f)) continue;
-        const E = (u.get(f) ?? storeLookup.get(f))?.[$TARGET];
-        if (!E?.[STORE_DESC]) continue;
-        const d = unwrap(t[a]);
-        if (f === d || !isWrappable(d) || Array.isArray(f) !== Array.isArray(d) || i(f) != null && i(f) !== i(d)) continue;
-        applyState(d, wrap(f, n), i);
+                        const c = unwrap(getOverrideValue(e, o, a, s));
+            if (!isWrappable(c)) continue;
+            descendInto(c, t[a], u, i);
+        }
+        return;
+    }
+    // No-override path (every applyStateFast call): iterate in place instead of
+    // building keys + symbols + concat arrays per object per pass. The cheap
+    // bails (noded key, primitive value) stay inline — only genuine descent
+    // candidates pay a call.
+        for (const n in e) {
+        if (r?.[n]) continue;
+ // main loop already diffed this slot
+                const o = unwrap(e[n]);
+        if (!isWrappable(o)) continue;
+        descendInto(o, t[n], u, i);
+    }
+    const l = Object.getOwnPropertySymbols(e);
+    for (let n = 0, o = l.length; n < o; n++) {
+        if (Object.prototype.propertyIsEnumerable.call(e, l[n])) {
+            if (r?.[l[n]]) continue;
+            const o = unwrap(e[l[n]]);
+            if (!isWrappable(o)) continue;
+            descendInto(o, t[l[n]], u, i);
+        }
+    }
+}
+
+function descendInto(e, t, n, r) {
+    const i = lookupTarget(e, n);
+    if (!i?.[STORE_DESC]) return;
+    const o = unwrap(t);
+    if (e === o || !isWrappable(o) || Array.isArray(e) !== Array.isArray(o) || r(e) != null && r(e) !== r(o)) return;
+    if (i[STORE_SHALLOW]) {
+        applyStateShallow(o, i);
+    } else if (i[STORE_OVERRIDE] || i[STORE_OPTIMISTIC_OVERRIDE]) {
+        applyStateSlow(o, i, r);
+    } else {
+        applyStateFast(o, i, r);
     }
 }
 
@@ -4125,36 +4307,134 @@ function applyState(e, t, n) {
     e = unwrap(e);
     const r = t?.[$TARGET];
     if (!r) return;
-    if (r[STORE_OVERRIDE] || r[STORE_OPTIMISTIC_OVERRIDE]) {
+    if (r[STORE_SHALLOW]) {
+        applyStateShallow(e, r);
+    } else if (r[STORE_OVERRIDE] || r[STORE_OPTIMISTIC_OVERRIDE]) {
         applyStateSlow(e, r, n);
     } else {
         applyStateFast(e, r, n);
     }
 }
 
+// Shallow boundary diff: the target's own keys are reactive, its values are
+// raw records replaced by reference — no recursion, no wrapping. Arrays merge
+// positionally (below a shallow boundary the VALUE is the identity; keyed
+// row identity belongs to the consumer, e.g. <For keyed>). Incoming
+// wrappables are sticky-marked raw so they present raw through every store.
+// One pass over a shallow target's node record: replace changed slots with
+// raw next values, null out slots absent from next. Returns whether anything
+// differed.
+function shallowDiffNodes(e, t, n, r) {
+    let i = false;
+    for (const o in e) {
+        if (r && o === "length") continue;
+        if (o in t) {
+            const r = t[o];
+            if (r !== n(o)) {
+                i = true;
+                setSignal(e[o], r);
+            }
+        } else {
+            i = true;
+            setSignal(e[o], undefined);
+        }
+    }
+    return i;
+}
+
+function applyStateShallow(e, t, n) {
+    const r = t[STORE_VALUE];
+    const i = t[STORE_OVERRIDE];
+    const o = t[STORE_OPTIMISTIC_OVERRIDE];
+    if (e === r && !i && !o) return;
+    // Setter-staged writes fold into the diff: previous values resolve through
+    // the override layers (so a replaced slot compares against what readers
+    // saw), and the regular override clears with the swap — reconcile makes
+    // `next` the authoritative base, same as the deep slow path.
+        const prevAt = e => {
+        const t = getOverrideValue(r, i, e, o);
+        return t === $DELETED ? undefined : t;
+    };
+    t[STORE_OVERRIDE] = undefined;
+    const s = t[STORE_LOOKUP];
+    s !== undefined ? s.set(e, t[$PROXY]) : storeLookup.set(e, t);
+    t[STORE_VALUE] = e;
+    markRawIngest(e);
+    const u = t[STORE_NODE];
+    const l = u && u[$TRACK];
+    let a = false;
+    if (Array.isArray(r)) {
+        const n = i?.length ?? o?.length ?? r.length;
+        if (u) {
+            a = shallowDiffNodes(u, e, prevAt, true);
+            if (u.length && n !== e.length) setSignal(u.length, e.length);
+        }
+        if (!a && (l || t[STORE_HAS])) {
+            // Slots without nodes still feed $TRACK enumerators / `in` probes.
+            if (n !== e.length) a = true; else {
+                for (let t = 0, n = e.length; t < n; t++) {
+                    if (prevAt(t) !== e[t]) {
+                        a = true;
+                        break;
+                    }
+                }
+            }
+        }
+    } else {
+        if (u) {
+            a = shallowDiffNodes(u, e, prevAt, false);
+        }
+        if (!a && (l || t[STORE_HAS])) a = true;
+    }
+    let c = t[STORE_HAS];
+    if (c) {
+        for (const t in c) {
+            setSignal(c[t], t in e);
+        }
+    }
+    a && notifySelf(t);
+}
+
 function applyStateFast(e, t, n) {
     const r = t[STORE_VALUE];
     if (e === r) return;
     const i = t[STORE_NODE];
     // swap
-        (t[STORE_LOOKUP] || storeLookup).set(e, t[$PROXY]);
+        {
+        const n = t[STORE_LOOKUP];
+        n !== undefined ? n.set(e, t[$PROXY]) : storeLookup.set(e, t);
+    }
     t[STORE_VALUE] = e;
     // merge
         if (Array.isArray(r)) {
         let o = false;
         const s = r.length;
         if (e.length && s && isWrappable(e[0]) && n(e[0]) != null) {
-            let u, l, c, a, f, E, d, S;
-            for (c = 0, a = Math.min(s, e.length); c < a && keyedMatch(E = r[c], e[c], n); c++) {
-                isWrappable(E) && isWrappable(e[c]) && applyState(e[c], wrap(E, t), n);
+            let u, l, a, c, f, E, d, S;
+            for (a = 0, c = Math.min(s, e.length); a < c && keyedMatch(E = r[a], e[a], n); a++) {
+                // keyedMatch established both sides wrappable unless they're the
+                // SAME reference — and an identical slot is a guaranteed no-op
+                // (the child's STORE_VALUE tracks the previous graph), so skip
+                // 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]))) {
+                        i?.[a] && setSignal(i[a], wrapValue(e[a], t));
+                    } else applyStateChild(e[a], E, t, n);
+                }
             }
-            const T = new Array(e.length), _ = new Map;
-            for (a = s - 1, f = e.length - 1; a >= c && f >= c && keyedMatch(E = r[a], e[f], n); a--, 
+            // Every position key-matched at equal length (the steady-state shape
+            // of a polling tick): membership, length, and order are unchanged —
+            // nothing below could do observable work, so skip the staging
+            // allocations and membership sync outright.
+                        if (a === e.length && a === s) return;
+            const T = new Array(e.length), O = new Map;
+            for (c = s - 1, f = e.length - 1; c >= a && f >= a && keyedMatch(E = r[c], e[f], n); c--, 
             f--) {
                 T[f] = E;
             }
-            if (c > f || c > a) {
-                for (l = c; l <= f; l++) {
+            if (a > f || a > c) {
+                for (l = a; l <= f; l++) {
                     o = true;
                     i?.[l] && setSignal(i[l], wrapValue(e[l], t));
                 }
@@ -4168,33 +4448,35 @@ function applyStateFast(e, t, n) {
                 return;
             }
             d = new Array(f + 1);
-            for (l = f; l >= c; l--) {
+            for (l = f; l >= a; l--) {
                 E = e[l];
                 S = itemKey(E, n);
-                u = _.get(S);
+                u = O.get(S);
                 d[l] = u === undefined ? -1 : u;
-                _.set(S, l);
+                O.set(S, l);
             }
-            for (u = c; u <= a; u++) {
+            for (u = a; u <= c; u++) {
                 E = r[u];
                 S = itemKey(E, n);
-                l = _.get(S);
+                l = O.get(S);
                 if (l !== undefined && l !== -1) {
                     T[l] = E;
                     l = d[l];
-                    _.set(S, l);
+                    O.set(S, l);
                 }
             }
-            for (l = c; l < e.length; l++) {
+            for (l = a; l < e.length; l++) {
                 if (l in T) {
                     applyArrayItem(e[l], T[l], t, i?.[l], n);
                 } else i?.[l] && setSignal(i[l], wrapValue(e[l], t));
             }
-            if (c < e.length) o = true;
+            if (a < e.length) o = true;
         } else if (e.length) {
             for (let s = 0, u = e.length; s < u; s++) {
                 const u = r[s];
-                if (isWrappable(u) && isWrappable(e[s])) applyState(e[s], wrap(u, t), n); else {
+                if (isWrappable(u) && isWrappable(e[s]) && !(rawValuesUsed && (isRawValue(u) || isRawValue(e[s])))) {
+                    if (u !== e[s]) applyStateChild(e[s], u, t, n);
+                } else {
                     if (u !== e[s]) o = true;
                     i?.[s] && setSignal(i[s], wrapValue(e[s], t));
                 }
@@ -4213,17 +4495,42 @@ function applyStateFast(e, t, n) {
     let s;
     if (o) {
         s = o[$TRACK];
-        if (s || symbolKeyedRecords.has(o)) {
+        // The per-key body is duplicated across both loops on purpose: this is
+        // the hottest object-diff site and a shared helper costs a per-key call
+        // in instruction counts (CodSpeed regressed ~7% on deep-tree reconciles
+        // with the extracted form).
+                if (s || symbolKeyedRecords.has(o)) {
             const i = s ? getAllKeys(r, undefined, e) : nodeKeys(o);
             for (let u = 0, l = i.length; u < l; u++) {
-                diffNodeKey(i[u], o, r, e, t, s, n);
+                const l = i[u];
+                const a = o[l];
+                const c = unwrap(r[l]);
+                const f = unwrap(e[l]);
+                if (c === f) continue;
+                if (!c || !isWrappable(c) || !isWrappable(f) || 
+                // Raw-marked values are leaves replaced by reference — a "wrappable
+                // pair" is only recursable when both sides are actual store children.
+                rawValuesUsed && (isRawValue(c) || isRawValue(f)) || Array.isArray(c) !== Array.isArray(f) || n(c) != null && n(c) !== n(f)) {
+                    s && setSignal(s, void 0);
+                    a && setSignal(a, isWrappable(f) ? wrap(f, t) : f);
+                } else applyStateChild(f, c, t, n);
             }
         } else {
             // Untracked, string-only node records (the overwhelmingly common case)
             // iterate in place — nodeKeys() allocated a fresh key array per object
             // per pass, which dominates allocation on large-graph reconciles.
             for (const i in o) {
-                diffNodeKey(i, o, r, e, t, s, n);
+                const u = o[i];
+                const l = unwrap(r[i]);
+                const a = unwrap(e[i]);
+                if (l === a) continue;
+                if (!l || !isWrappable(l) || !isWrappable(a) || 
+                // Raw-marked values are leaves replaced by reference — a "wrappable
+                // pair" is only recursable when both sides are actual store children.
+                rawValuesUsed && (isRawValue(l) || isRawValue(a)) || Array.isArray(l) !== Array.isArray(a) || n(l) != null && n(l) !== n(a)) {
+                    s && setSignal(s, void 0);
+                    u && setSignal(u, isWrappable(a) ? wrap(a, t) : a);
+                } else applyStateChild(a, l, t, n);
             }
         }
     }
@@ -4238,26 +4545,16 @@ function applyStateFast(e, t, n) {
     }
 }
 
-// One node-key step of the fast object diff — shared by the array-iterating
-// (tracked / symbol-keyed) and for-in (plain) loops in applyStateFast.
-function diffNodeKey(e, t, n, r, i, o, s) {
-    const u = t[e];
-    const l = unwrap(n[e]);
-    let c = unwrap(r[e]);
-    if (l === c) return;
-    if (!l || !isWrappable(l) || !isWrappable(c) || Array.isArray(l) !== Array.isArray(c) || s(l) != null && s(l) !== s(c)) {
-        o && setSignal(o, void 0);
-        u && setSignal(u, isWrappable(c) ? wrap(c, i) : c);
-    } else applyState(c, wrap(l, i), s);
-}
-
 function applyStateSlow(e, t, n) {
     const r = t[STORE_VALUE];
     const i = t[STORE_OVERRIDE];
     const o = t[STORE_OPTIMISTIC_OVERRIDE];
     let s = t[STORE_NODE];
     // swap
-        (t[STORE_LOOKUP] || storeLookup).set(e, t[$PROXY]);
+        {
+        const n = t[STORE_LOOKUP];
+        n !== undefined ? n.set(e, t[$PROXY]) : storeLookup.set(e, t);
+    }
     t[STORE_VALUE] = e;
     t[STORE_OVERRIDE] = undefined;
     // merge
@@ -4265,23 +4562,27 @@ function applyStateSlow(e, t, n) {
         let u = false;
         const l = getOverrideValue(r, i, "length", o);
         if (e.length && l && isWrappable(e[0]) && n(e[0]) != null) {
-            let c, a, f, E, d, S, T, _;
+            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++) {
-                isWrappable(S) && isWrappable(e[f]) && applyState(e[f], wrap(S, t), n);
+                if (isWrappable(S) && isWrappable(e[f]) && S !== e[f]) {
+                    if (rawValuesUsed && (isRawValue(S) || isRawValue(e[f]))) {
+                        s?.[f] && setSignal(s[f], wrapValue(e[f], t));
+                    } else applyState(e[f], wrap(S, t), n);
+                }
             }
-            const O = new Array(e.length), p = new Map;
+            const _ = new Array(e.length), p = 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--) {
-                O[d] = S;
+                _[d] = S;
             }
             if (f > d || f > E) {
-                for (a = f; a <= d; a++) {
+                for (c = f; c <= d; c++) {
                     u = true;
-                    s?.[a] && setSignal(s[a], wrapValue(e[a], t));
+                    s?.[c] && setSignal(s[c], wrapValue(e[c], t));
                 }
-                for (;a < e.length; a++) {
+                for (;c < e.length; c++) {
                     u = true;
-                    applyArrayItem(e[a], O[a], t, s?.[a], n);
+                    applyArrayItem(e[c], _[c], t, s?.[c], n);
                 }
                 const r = e.length;
                 syncArrayNodeMembership(t, e);
@@ -4290,43 +4591,45 @@ function applyStateSlow(e, t, n) {
                 return;
             }
             T = new Array(d + 1);
-            for (a = d; a >= f; a--) {
-                S = e[a];
-                _ = itemKey(S, n);
-                c = p.get(_);
-                T[a] = c === undefined ? -1 : c;
-                p.set(_, a);
+            for (c = d; c >= f; c--) {
+                S = e[c];
+                O = itemKey(S, n);
+                a = p.get(O);
+                T[c] = a === undefined ? -1 : a;
+                p.set(O, c);
             }
-            for (c = f; c <= E; c++) {
-                S = getOverrideValue(r, i, c, o);
-                _ = itemKey(S, n);
-                a = p.get(_);
-                if (a !== undefined && a !== -1) {
-                    O[a] = S;
-                    a = T[a];
-                    p.set(_, a);
+            for (a = f; a <= E; a++) {
+                S = getOverrideValue(r, i, a, o);
+                O = itemKey(S, n);
+                c = p.get(O);
+                if (c !== undefined && c !== -1) {
+                    _[c] = S;
+                    c = T[c];
+                    p.set(O, c);
                 }
             }
-            for (a = f; a < e.length; a++) {
-                if (a in O) {
-                    applyArrayItem(e[a], O[a], t, s?.[a], n);
-                } else s?.[a] && setSignal(s[a], wrapValue(e[a], t));
+            for (c = f; c < e.length; c++) {
+                if (c in _) {
+                    applyArrayItem(e[c], _[c], t, s?.[c], n);
+                } else s?.[c] && setSignal(s[c], wrapValue(e[c], t));
             }
             if (f < e.length) u = true;
         } else if (e.length) {
-            for (let l = 0, c = e.length; l < c; l++) {
-                const c = getOverrideValue(r, i, l, o);
-                if (isWrappable(c) && isWrappable(e[l])) applyState(e[l], wrap(c, t), n); else {
-                    if (c !== e[l]) u = true;
+            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 (a !== e[l]) applyState(e[l], wrap(a, t), n);
+                } else {
+                    if (a !== e[l]) u = true;
                     s?.[l] && setSignal(s[l], wrapValue(e[l], t));
                 }
             }
         }
-        const c = e.length;
+        const a = e.length;
         syncArrayNodeMembership(t, e);
-        if (l !== c) {
+        if (l !== a) {
             u = true;
-            s?.length && setSignal(s.length, c);
+            s?.length && setSignal(s.length, a);
         }
         u && notifySelf(t);
         return;
@@ -4336,13 +4639,13 @@ function applyStateSlow(e, t, n) {
     if (s) {
         u = s[$TRACK];
         const l = u ? getAllKeys(r, i, e) : nodeKeys(s);
-        for (let c = 0, a = l.length; c < a; c++) {
-            const a = l[c];
-            const f = s[a];
-            const E = unwrap(getOverrideValue(r, i, a, o));
-            let d = unwrap(e[a]);
+        for (let a = 0, c = l.length; a < c; a++) {
+            const c = l[a];
+            const f = s[c];
+            const E = unwrap(getOverrideValue(r, i, c, o));
+            let d = unwrap(e[c]);
             if (E === d) continue;
-            if (!E || !isWrappable(E) || !isWrappable(d) || Array.isArray(E) !== Array.isArray(d) || n(E) != null && n(E) !== n(d)) {
+            if (!E || !isWrappable(E) || !isWrappable(d) || rawValuesUsed && (isRawValue(E) || isRawValue(d)) || Array.isArray(E) !== Array.isArray(d) || n(E) != null && n(E) !== n(d)) {
                 u && setSignal(u, void 0);
                 f && setSignal(f, isWrappable(d) ? wrap(d, t) : d);
             } else applyState(d, wrap(E, t), n);
@@ -4410,9 +4713,16 @@ const NOKEY = () => null;
 function createProjectionInternal(e, t, n) {
     let r;
     const i = new WeakMap;
+    // A shallow projection's children are raw and never wrapped, so the
+    // wrapper only ever runs for the root — flagging unconditionally is safe.
+        const o = !!n?.shallow;
     const wrapper = e => {
         e[STORE_WRAP] = wrapProjection;
         e[STORE_LOOKUP] = i;
+        if (o) {
+            e[STORE_SHALLOW] = true;
+            markRawIngest(e[STORE_VALUE]);
+        }
         Object.defineProperty(e, STORE_FIREWALL, {
             get() {
                 return r;
@@ -4427,14 +4737,14 @@ function createProjectionInternal(e, t, n) {
         i.set(e, t);
         return t;
     };
-    const o = wrapProjection(t);
+    const s = wrapProjection(t);
     r = computed(() => {
         if (!r) r = getOwner();
-        runProjectionComputed(o, e, n?.key || "id");
+        runProjectionComputed(s, e, n?.key || "id");
     }, undefined);
-    r.Ue &= ~CONFIG_AUTO_DISPOSE;
+    r.Ge &= ~CONFIG_AUTO_DISPOSE;
     return {
-        store: o,
+        store: s,
         node: r
     };
 }
@@ -4582,7 +4892,7 @@ function createWriteTraps(e, t) {
 // the record witnesses it into the active isPending() probe.
 $AFFECTS = Symbol(0);
 
-const STORE_VALUE = "v", STORE_OVERRIDE = "o", STORE_OPTIMISTIC_OVERRIDE = "x", STORE_NODE = "n", STORE_HAS = "h", STORE_CUSTOM_PROTO = "c", STORE_WRAP = "w", STORE_LOOKUP = "l", STORE_FIREWALL = "f", STORE_OPTIMISTIC = "p", STORE_OPTIMISTIC_OWNERS = "t", STORE_PARENT = "u", STORE_DESC = "d";
+const STORE_VALUE = "v", STORE_OVERRIDE = "o", STORE_OPTIMISTIC_OVERRIDE = "x", STORE_NODE = "n", STORE_HAS = "h", STORE_CUSTOM_PROTO = "c", STORE_WRAP = "w", STORE_LOOKUP = "l", STORE_FIREWALL = "f", STORE_OPTIMISTIC = "p", STORE_OPTIMISTIC_OWNERS = "t", STORE_PARENT = "u", STORE_DESC = "d", STORE_SHALLOW = "s";
 
 const STORE_SELF_PENDING = Symbol(0);
 
@@ -4606,6 +4916,7 @@ function initStoreFields(e) {
     e[STORE_SNAPSHOT_PROPS] = undefined;
     e[STORE_PARENT] = undefined;
     e[STORE_DESC] = undefined;
+    e[STORE_SHALLOW] = undefined;
     e[$PROXY] = null;
 }
 
@@ -4630,24 +4941,107 @@ function createStoreProxy(e, t = storeTraps, n) {
     return r[$PROXY] = new Proxy(r, t);
 }
 
+// The global lookup maps raw value -> StoreNode TARGET (not proxy): reconcile
+// and the unwrap/snapshot walks resolve targets through it constantly, and a
+// target hit is a plain field read away from its proxy while a proxy hit
+// costs a trap to get back to the target. Per-family STORE_LOOKUP maps
+// (projections/optimistic) still map raw -> proxy — their wrap functions own
+// that contract — so mixed-lookup consumers resolve through lookupTarget().
 const storeLookup = new WeakMap;
 
 // Node records that hold at least one user (non-`$TRACK`) symbol-keyed node.
 // Lets reconcile enumerate symbols only for records that need it (#2851).
 const symbolKeyedRecords = new WeakSet;
 
+function lookupTarget(e, t) {
+    if (t !== undefined && t !== storeLookup) {
+        const n = t.get(e);
+        if (n !== undefined) return n[$TARGET];
+    }
+    return storeLookup.get(e);
+}
+
+// Values marked raw never acquire a proxy identity: wrap() serves them as-is
+// everywhere — deep stores hold them as leaf values replaced by reference.
+// Once raw, always raw (identity stays single, just unwrapped). Consulted
+// only on wrap-creation and ingest paths; reads never touch it.
+const rawValues = new WeakSet;
+
+/**
+ * Marks a value as raw: no store will ever wrap it — every store presents it
+ * as-is, tracked by reference at whatever slot holds it and updated by
+ * replacement. Useful for class instances and external objects (editors,
+ * scene graphs, Maps) and for record-shaped data updated wholesale. Sticky
+ * for the value's lifetime.
+ */
+// Flipped on the first mark and exported as a LIVE binding: reconcile
+// consults it on every recursable pair, and importing the boolean directly
+// lets those sites skip even the function call when no shallow store or raw
+// mark exists anywhere in the app.
+let rawValuesUsed = false;
+
+function isRawValue(e) {
+    return rawValuesUsed && rawValues.has(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);
+    }
+}
+
+function markRawIngest(e) {
+    if (Array.isArray(e)) {
+        for (let t = 0, n = e.length; t < n; t++) markRawOne(e[t]);
+    } else {
+        for (const t in e) markRawOne(e[t]);
+    }
+}
+
 function wrap(e, t) {
+    // Raw is raw in every family: the mark must preempt family wrapping too,
+    // or a shallow projection/optimistic store would proxy its raw records.
+    if (rawValuesUsed && rawValues.has(e)) return e;
     if (t?.[STORE_WRAP]) {
         const n = t[STORE_WRAP](e, t);
         const r = n[$TARGET];
         if (r && !r[STORE_PARENT] && r !== t) r[STORE_PARENT] = t;
         return n;
     }
-    let n = e[$PROXY] || storeLookup.get(e);
-    if (!n) {
-        storeLookup.set(e, n = createStoreProxy(e));
-        if (t) n[$TARGET][STORE_PARENT] = t;
+    const n = storeLookup.get(e);
+    if (n !== undefined) return n[$PROXY];
+    let r = e[$PROXY];
+    if (!r) {
+        r = createStoreProxy(e);
+        const n = r[$TARGET];
+        storeLookup.set(e, n);
+        if (t) n[STORE_PARENT] = t;
+    }
+    return r;
+}
+
+// Shallow store root: the target itself is fully reactive (per-key nodes,
+// membership, $TRACK); its values are served raw. Seed values are marked at
+// creation; reconcile and the set trap mark on ingest.
+function wrapShallow(e) {
+    const t = storeLookup.get(e);
+    if (t !== undefined) {
+        if (t[STORE_SHALLOW]) return t[$PROXY];
     }
+    const n = createStoreProxy(e);
+    const r = n[$TARGET];
+    r[STORE_SHALLOW] = true;
+    storeLookup.set(e, r);
+    markRawIngest(e);
     return n;
 }
 
@@ -4669,7 +5063,7 @@ function writeOnly(e) {
 }
 
 function unwrapStoreValue(e, t, n) {
-    const r = e?.[$TARGET] || n?.get(e)?.[$TARGET];
+    const r = e?.[$TARGET] || lookupTarget(e, n);
     if (!r) return e;
     const i = r[STORE_OVERRIDE];
     if (!i) return r[STORE_VALUE];
@@ -4733,7 +5127,7 @@ function ownEnumerableKeysPlain(e) {
  * The value a store leaf's backing signal currently shows to readers: active
  * override, else held pending value, else committed value.
  */ function visibleNodeValue(e) {
-    return e.A !== undefined && e.A !== NOT_PENDING ? unwrapOverride(e.A) : e.V !== NOT_PENDING ? e.V : e.ke;
+    return e.A !== undefined && e.A !== NOT_PENDING ? unwrapOverride(e.A) : e.U !== NOT_PENDING ? e.U : e.ke;
 }
 
 function hasOwnStoreProperty(e, t) {
@@ -4788,7 +5182,7 @@ function getNode(e, t, n, r, i = isEqual, o) {
     }
     if (o && n in o) {
         const e = o[n];
-        s.ve = e === undefined ? NO_SNAPSHOT : e;
+        s.me = e === undefined ? NO_SNAPSHOT : e;
         snapshotSources?.add(s);
     }
     if (typeof n === "symbol" && n !== $TRACK && n !== $AFFECTS) symbolKeyedRecords.add(t);
@@ -4841,7 +5235,7 @@ const affectsScopes = new Map;
 // holds the root, and must still descend to pick up records added since.
 i) {
     if (!isWrappable(e)) return;
-    const o = e[$TARGET] || (r ?? storeLookup).get(e)?.[$TARGET];
+    const o = e[$TARGET] || lookupTarget(e, r);
     const s = o ? o[STORE_VALUE] : e;
     if (i.has(s)) return;
     i.add(s);
@@ -4868,9 +5262,9 @@ i) {
                 const l = o || r ? getStoreSymbols(s, u) : [];
         for (let e = 0, o = l.length; e < o; e++) {
             const o = l[e];
-            const c = getPropertyDescriptor(s, u, o);
-            if (!c || c.get) continue;
-            walkAffectsScope(c.value, t, n, r, i);
+            const a = getPropertyDescriptor(s, u, o);
+            if (!a || a.get) continue;
+            walkAffectsScope(a.value, t, n, r, i);
         }
     } else {
         const e = o || r ? getStoreKeys(s, u) : getKeys(s, u);
@@ -4906,11 +5300,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._e(n);
+    if (n?.k) GlobalQueue.Oe(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._e(e);
+            if (e !== n && e.k && i.scope.has(r) && (i.key === undefined || i.key === t)) GlobalQueue.Oe(e);
         }
     }
 }
@@ -5058,7 +5452,7 @@ function prepareStoreWrite(e, t, n) {
     }
     const r = e[STORE_VALUE];
     const i = r[n];
-    if (snapshotCaptureActive && typeof n !== "symbol" && !((e[STORE_FIREWALL]?.Qe ?? 0) & STATUS_PENDING)) {
+    if (snapshotCaptureActive && typeof n !== "symbol" && !((e[STORE_FIREWALL]?.xe ?? 0) & STATUS_PENDING)) {
         if (!e[STORE_SNAPSHOT_PROPS]) {
             e[STORE_SNAPSHOT_PROPS] = Object.create(null);
             snapshotSources?.add(e);
@@ -5123,24 +5517,24 @@ function notifyStoreProperty(e, t, n, r, i, o) {
         const n = upsertStoreNode(e, getNodes(e, STORE_HAS), t, o);
         setSignal(n, u);
     }
-    const c = getNodes(e, STORE_NODE);
+    const a = getNodes(e, STORE_NODE);
     if (n === "set") {
-        if (c[t]) {
-            setSignal(c[t], () => isWrappable(r) ? wrap(r, e) : r);
+        if (a[t]) {
+            setSignal(a[t], () => isWrappable(r) ? wrap(r, e) : r);
         } else if (!s) {
-            const n = upsertStoreNode(e, c, t, i, e[STORE_SNAPSHOT_PROPS]);
+            const n = upsertStoreNode(e, a, t, i, e[STORE_SNAPSHOT_PROPS]);
             setSignal(n, () => isWrappable(r) ? wrap(r, e) : r);
         }
     } else if (n === "invalidate") {
-        if (c[t]) {
-            setSignal(c[t], {});
-            delete c[t];
+        if (a[t]) {
+            setSignal(a[t], {});
+            delete a[t];
         }
     } else {
-        if (c[t]) {
-            setSignal(c[t], undefined);
+        if (a[t]) {
+            setSignal(a[t], undefined);
         } else if (!s) {
-            const n = upsertStoreNode(e, c, t, i, e[STORE_SNAPSHOT_PROPS]);
+            const n = upsertStoreNode(e, a, t, i, e[STORE_SNAPSHOT_PROPS]);
             setSignal(n, undefined);
         }
     }
@@ -5159,7 +5553,7 @@ let Writing = null;
  * itself (the derive function works its own draft while uninitialized).
  */ function throwIfUninitialized(e) {
     const t = e[STORE_FIREWALL];
-    if (t && t.Qe & STATUS_UNINITIALIZED) throw t.De ?? new NotReadyError(t);
+    if (t && t.xe & STATUS_UNINITIALIZED) throw t.De ?? new NotReadyError(t);
 }
 
 const storeTraps = {
@@ -5182,8 +5576,20 @@ const storeTraps = {
             const n = e[STORE_NODE];
             const r = n && n[t];
             if (r !== undefined && e[STORE_VALUE][$TARGET] === undefined) {
-                let t = read(r);
+                // readNodeFast is read()'s plain-signal fast path hoisted over the
+                // call; READ_SLOW means a global read window (latest/pending-check/
+                // transition/lane/snapshot capture) or a node layer is active, and
+                // only then does the full read() resolution have anything to do.
+                let t = readNodeFast(r);
+                if (t === READ_SLOW) t = read(r);
                 if (t === $DELETED) t = undefined;
+                // Every node-writing site wraps wrappables before setSignal (see the
+                // dev assertion below), so re-wrapping on read is redundant — except
+                // during snapshot capture, where read() can surface a raw captured
+                // value seeded from snapshot props.
+                                if (!snapshotCaptureActive) {
+                    return t;
+                }
                 return isWrappable(t) ? wrap(t, e) : t;
             }
         }
@@ -5196,40 +5602,52 @@ const storeTraps = {
         }
         const u = getOverlayLayer(e, t);
         const l = !!u;
-        const c = !!e[STORE_VALUE][$TARGET];
-        const a = u ?? e[STORE_VALUE];
+        const a = !!e[STORE_VALUE][$TARGET];
+        const c = u ?? e[STORE_VALUE];
         if (!o) {
-            const r = Object.getOwnPropertyDescriptor(a, t);
+            const r = Object.getOwnPropertyDescriptor(c, t);
             if (r && r.get) return r.get.call(n);
             if (!r && !l && e[STORE_CUSTOM_PROTO]) {
-                const e = unwrapStoreValue(a);
+                const e = unwrapStoreValue(c);
                 if (hasInheritedAccessor(e, t)) {
-                    return Reflect.get(a, t, n);
+                    return Reflect.get(c, t, n);
                 }
             }
         }
         if (writeOnly(n)) {
             if (isPrototypePollutionKey$1(t) && !hasOwnStoreProperty(e, t)) return undefined;
-            let n = o && (l || !c) ? visibleNodeValue(o) : a[t];
+            let n = o && (l || !a) ? visibleNodeValue(o) : c[t];
             n === $DELETED && (n = undefined);
             if (!isWrappable(n)) return n;
+            // Shallow boundary: records are replaced, never edited in place. Reads
+            // inside a setter serve the raw so read-then-replace, filter/pop and
+            // projection derives all work; in-place mutation of a raw is inert by
+            // construction — the same contract as a markRaw child in a deep store.
+                        if (e[STORE_SHALLOW]) return n;
             const r = wrap(n, e);
             Writing?.add(r);
             return r;
         }
-        let f = o ? l || !c ? read(i[t]) : (read(i[t]), a[t]) : a[t];
+        let f = o ? l || !a ? read(i[t]) : (read(i[t]), c[t]) : c[t];
         f === $DELETED && (f = undefined);
         if (!o) {
-            if (!l && typeof f === "function" && !Object.prototype.hasOwnProperty.call(a, t)) {
+            if (!l && typeof f === "function" && !Object.prototype.hasOwnProperty.call(c, t)) {
                 let t;
-                return !Array.isArray(e[STORE_VALUE]) && (t = Object.getPrototypeOf(e[STORE_VALUE])) && t !== Object.prototype ? f.bind(a) : f;
+                return !Array.isArray(e[STORE_VALUE]) && (t = Object.getPrototypeOf(e[STORE_VALUE])) && t !== Object.prototype ? f.bind(c) : f;
             } else if (getObserver() && !r) {
                 return read(getNode(e, i, t, isWrappable(f) ? wrap(f, e) : f, isEqual, e[STORE_SNAPSHOT_PROPS]));
             }
         }
         // 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()) throwIfUninitialized(e);
         return isWrappable(f) ? wrap(f, e) : f;
     },
     has(e, t) {
@@ -5260,37 +5678,49 @@ const storeTraps = {
                 const {base: i, overrideKey: o, state: s} = prepareStoreWrite(e, r, t);
                 const u = getOverlayLayer(e, t);
                 const l = u ? u[t] : i;
-                const c = u ? u[t] !== $DELETED : t in e[STORE_VALUE];
-                const a = unwrapStoreValue(n);
+                const a = u ? u[t] !== $DELETED : t in e[STORE_VALUE];
+                // 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 === a && 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 (a !== undefined && a === 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] = a;
+                    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", a, l, c);
+                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 a === "number" && typeof l === "number" && a < 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 = a; 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;
@@ -5300,13 +5730,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) ;
@@ -5453,7 +5883,7 @@ function storeSetter(e, t) {
 }
 
 function createStore(e, t, n) {
-    const r = typeof e === "function", i = r ? createProjectionInternal(e, t, n).store : wrap(e);
+    const r = typeof e === "function", i = r ? createProjectionInternal(e, t, n).store : t?.shallow ? wrapShallow(e) : wrap(e);
     return [ i, r ? e => {
         // Mark the projection as manually written before notifying property nodes.
         suppressComputedRecompute(i[$REFRESH]);
@@ -5485,9 +5915,9 @@ function createStore(e, t, n) {
  * flush that would surface them, before effects run — verdict-only, netting
  * no visual change.
  */ function notifyMarkBoundaries(e) {
-    if (!e.U && !e.nt) return;
+    if (!e.G && !e.nt) return;
     const t = new NotReadyError(e);
-    t.me = true;
+    t.we = true;
     const n = new Set;
     const visit = e => {
         if (n.has(e)) return;
@@ -5513,7 +5943,7 @@ function createStore(e, t, n) {
  * earlier overlapping registration get covered, and dedup stops re-descent.
  */ function registerAffectsMark(e) {
     markAffects(e);
-    globalQueue.D.G.push(e);
+    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);
@@ -5575,6 +6005,8 @@ function createOptimisticStore(e, t, n) {
     installOptimisticEngine();
     GlobalQueue.ee ||= clearOptimisticStores;
     const r = typeof e === "function";
+    // Plain form: the second slot carries options.
+        if (!r && n === undefined) n = t;
     const i = r ? t : e;
     const o = r ? e : undefined;
     // Create optimistic projection store
@@ -5638,23 +6070,23 @@ function clearOptimisticStores(e, t) {
             delete n[l];
             if (i) delete i[l];
             s = true;
-            const c = r?.[l];
-            if (c) {
+            const a = r?.[l];
+            if (a) {
                 // Clear lane association so effects go to regular queue
-                c.i = undefined;
+                a.i = undefined;
                 // Re-read from base — this key left the optimistic layer above, so the
                 // overlay resolves to STORE_OVERRIDE or STORE_VALUE.
                                 const t = getOverlayLayer(e, l);
                 const n = t ? t[l] : e[STORE_VALUE][l];
                 const r = n === $DELETED ? undefined : n;
                 const i = isWrappable(r) ? wrap(r, e) : r;
-                const o = visibleNodeValue(c);
-                c.A = NOT_PENDING;
-                c.R = null;
-                c.V = NOT_PENDING;
-                c.ke = i;
-                if (!c.At || !c.At(o, i)) {
-                    insertSubs(c, true);
+                const o = visibleNodeValue(a);
+                a.A = NOT_PENDING;
+                a.R = null;
+                a.U = NOT_PENDING;
+                a.ke = i;
+                if (!a.At || !a.At(o, i)) {
+                    insertSubs(a, true);
                     schedule();
                 }
             }
@@ -5678,9 +6110,14 @@ function clearOptimisticStores(e, t) {
 function createOptimisticProjectionInternal(e, t, n) {
     let r;
     const i = new WeakMap;
+    const o = !!n?.shallow;
     const wrapper = e => {
         e[STORE_WRAP] = wrapProjection;
         e[STORE_LOOKUP] = i;
+        if (o) {
+            e[STORE_SHALLOW] = true;
+            markRawIngest(e[STORE_VALUE]);
+        }
         e[STORE_OPTIMISTIC] = true;
  // Mark as optimistic store
                 Object.defineProperty(e, STORE_FIREWALL, {
@@ -5697,7 +6134,7 @@ function createOptimisticProjectionInternal(e, t, n) {
         i.set(e, t);
         return t;
     };
-    const o = wrapProjection(t);
+    const s = wrapProjection(t);
     // If there's a projection function, create a computed to drive it
         if (e) {
         // All writes inside firewall recompute must go to STORE_OVERRIDE (base), not
@@ -5706,7 +6143,7 @@ function createOptimisticProjectionInternal(e, t, n) {
         // async yields because they fire outside any enclosing try/finally. It also
         // consumes stale optimistic overlays once fresh projected data lands.
         const clearProjectionOverride = () => {
-            const e = o[$TARGET];
+            const e = s[$TARGET];
             if (e?.[STORE_OPTIMISTIC_OVERRIDE]) clearOptimisticOverride(e);
         };
         const wrapCommit = e => {
@@ -5722,15 +6159,15 @@ function createOptimisticProjectionInternal(e, t, n) {
         r = computed(() => {
             setProjectionWriteActive(true);
             try {
-                runProjectionComputed(o, e, n?.key || "id", wrapCommit, clearProjectionOverride);
+                runProjectionComputed(s, e, n?.key || "id", wrapCommit, clearProjectionOverride);
             } finally {
                 setProjectionWriteActive(false);
             }
         }, undefined);
-        r.Ue &= ~CONFIG_AUTO_DISPOSE;
+        r.Ge &= ~CONFIG_AUTO_DISPOSE;
     }
     return {
-        store: o,
+        store: s,
         node: r
     };
 }
@@ -5836,11 +6273,11 @@ function updatePath(e, t, n = 0) {
 });
 
 function snapshotImpl(e, t, n, r) {
-    let i, o, s, u, l, c;
+    let i, o, s, u, l, a;
     if (!isWrappable(e)) return e;
     if (n && n.has(e)) return n.get(e);
     if (!n) n = new Map;
-    if (i = e[$TARGET] || r?.get(e)?.[$TARGET]) {
+    if (i = e[$TARGET] || lookupTarget(e, r)) {
         if (t) {
             trackSelf(i, $TRACK);
             // A tracked walk reads THROUGH the record without touching the proxy
@@ -5870,26 +6307,26 @@ function snapshotImpl(e, t, n, r) {
     }
     if (o) {
         const o = s?.length ?? e.length;
-        for (let a = 0; a < o; a++) {
-            c = s && a in s ? s[a] : e[a];
-            if (c === $DELETED) continue;
-            if (t && isWrappable(c)) wrap(c, i);
-            if ((l = snapshotImpl(c, t, n, r)) !== c || u) {
+        for (let c = 0; c < o; c++) {
+            a = s && c in s ? s[c] : e[c];
+            if (a === $DELETED) continue;
+            if (t && isWrappable(a) && !(rawValuesUsed && isRawValue(a))) wrap(a, i);
+            if ((l = snapshotImpl(a, t, n, r)) !== a || u) {
                 if (!u) n.set(e, u = [ ...e ]);
-                u[a] = l;
+                u[c] = l;
             }
         }
         // Enumerate array symbols separately to avoid scanning indices twice.
         // Spread copies omit symbols, so assign them after the numeric walk.
-                const a = r ? getStoreSymbols(e, s) : [];
-        for (let o = 0, f = a.length; o < f; o++) {
-            const f = a[o];
+                const c = r ? getStoreSymbols(e, s) : [];
+        for (let o = 0, f = c.length; o < f; o++) {
+            const f = c[o];
             const E = getPropertyDescriptor(e, s, f);
             if (!E || E.get) continue;
-            c = s && f in s ? s[f] : e[f];
-            if (t && isWrappable(c)) wrap(c, i);
-            l = snapshotImpl(c, t, n, r);
-            if (l !== c || u) {
+            a = s && f in s ? s[f] : e[f];
+            if (t && isWrappable(a) && !(rawValuesUsed && isRawValue(a))) wrap(a, i);
+            l = snapshotImpl(a, t, n, r);
+            if (l !== a || u) {
                 if (!u) n.set(e, u = Object.assign([ ...e ], e));
                 u[f] = l;
             }
@@ -5904,31 +6341,31 @@ function snapshotImpl(e, t, n, r) {
         // A lookup means this object belongs to an immutable store backing tree,
         // even if that nested value has not needed its own proxy yet.
         const o = r ? getStoreKeys(e, undefined) : getKeys(e, undefined);
-        for (let s = 0, a = o.length; s < a; s++) {
-            const a = o[s];
-            const f = Object.getOwnPropertyDescriptor(e, a);
+        for (let s = 0, c = o.length; s < c; s++) {
+            const c = o[s];
+            const f = Object.getOwnPropertyDescriptor(e, c);
             if (f.get) continue;
-            c = f.value;
-            if (t && isWrappable(c)) wrap(c, i);
-            if ((l = snapshotImpl(c, t, n, r)) !== c || u) {
+            a = f.value;
+            if (t && isWrappable(a) && !(rawValuesUsed && isRawValue(a))) wrap(a, i);
+            if ((l = snapshotImpl(a, t, n, r)) !== a || u) {
                 if (!u) {
                     u = Object.create(Object.getPrototypeOf(e));
                     Object.assign(u, e);
                 }
-                u[a] = l;
+                u[c] = l;
             }
         }
     } else {
         // An override only exists on a store record, and the target branch above
         // always set `lookup` alongside it — so this branch is always store-keyed.
         const o = getStoreKeys(e, s);
-        for (let a = 0, f = o.length; a < f; a++) {
-            let f = o[a];
+        for (let c = 0, f = o.length; c < f; c++) {
+            let f = o[c];
             const E = getPropertyDescriptor(e, s, f);
             if (E.get) continue;
-            c = f in s ? s[f] : e[f];
-            if (t && isWrappable(c)) wrap(c, i);
-            if ((l = snapshotImpl(c, t, n, r)) !== e[f] || u) {
+            a = f in s ? s[f] : e[f];
+            if (t && isWrappable(a) && !(rawValuesUsed && isRawValue(a))) wrap(a, i);
+            if ((l = snapshotImpl(a, t, n, r)) !== e[f] || u) {
                 if (!u) {
                     u = Object.create(Object.getPrototypeOf(e));
                     Object.assign(u, e);
@@ -6151,24 +6588,24 @@ function mapArray(e, t, n) {
     const i = t.length > 1;
     const o = t;
     const s = {
-        vt: createOwner(),
-        wt: 0,
-        Gt: e,
-        Lt: [],
-        Ut: o,
+        wt: createOwner(),
+        vt: 0,
+        Lt: e,
         Vt: [],
+        Gt: o,
+        Ut: [],
         kt: [],
-        Ft: r,
-        xt: r || n?.keyed === false ? [] : undefined,
-        Qt: i && n?.keyed !== false ? [] : undefined,
-        Wt: n?.keyed === false,
-        Mt: n?.fallback
+        Wt: r,
+        Ft: r || n?.keyed === false ? [] : undefined,
+        xt: i && n?.keyed !== false ? [] : undefined,
+        Qt: n?.keyed === false,
+        Ht: n?.fallback
     };
     const u = computed(updateKeyedMap.bind(s));
     // Untracked reads inside the internal owner resolve via _parentComputed; routing
     // them through node lets store-proxy lookups see pending writes (not stale _value).
-        s.vt.Je = u;
-    u.Ue &= ~CONFIG_AUTO_DISPOSE;
+        s.wt.Je = u;
+    u.Ge &= ~CONFIG_AUTO_DISPOSE;
     return accessor(u);
 }
 
@@ -6186,52 +6623,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.Gt() || [], t = e.length;
+    const e = this.Lt() || [], t = e.length;
     e[$TRACK];
  // top level tracking
-        runWithOwner(this.vt, () => {
+        runWithOwner(this.wt, () => {
         let n, r, i, o, 
         // Mappers write freshly-created row/index signals into the STAGE
         // arrays (`rows`/`indexes`), never into `this._rows`/`this._indexes`.
-        s = this.xt ? this.Wt ? () => {
+        s = this.Ft ? this.Qt ? () => {
             i[r] = signal(e[r], pureOptions);
-            return this.Ut(accessor(i[r]), r);
+            return this.Gt(accessor(i[r]), r);
         } : () => {
             i[r] = signal(e[r], pureOptions);
             o && (o[r] = signal(r, pureOptions));
-            return this.Ut(accessor(i[r]), o ? accessor(o[r]) : undefined);
-        } : this.Qt ? () => {
+            return this.Gt(accessor(i[r]), o ? accessor(o[r]) : undefined);
+        } : this.xt ? () => {
             const t = e[r];
             o[r] = signal(r, pureOptions);
-            return this.Ut(t, accessor(o[r]));
+            return this.Gt(t, accessor(o[r]));
         } : () => {
             const t = e[r];
-            return this.Ut(t);
+            return this.Gt(t);
         };
         // fast path for empty arrays
                 if (t === 0) {
-            if (this.wt !== 0) {
-                this.vt.dispose(false);
+            if (this.vt !== 0) {
+                this.wt.dispose(false);
                 this.kt = [];
-                this.Lt = [];
                 this.Vt = [];
-                this.wt = 0;
+                this.Ut = [];
+                this.vt = 0;
+                this.Ft && (this.Ft = []);
                 this.xt && (this.xt = []);
-                this.Qt && (this.Qt = []);
             }
-            if (this.Mt && !this.Vt[0]) {
+            if (this.Ht && !this.Ut[0]) {
                 // an aborted fallback attempt leaves an owner without a mapping;
                 // dispose it before re-creating
                 this.kt[0]?.dispose();
-                this.Vt[0] = runWithOwner(this.kt[0] = createOwner(), this.Mt);
+                this.Ut[0] = runWithOwner(this.kt[0] = createOwner(), this.Ht);
             }
         }
         // fast path for new create
-         else if (this.wt === 0) {
+         else if (this.vt === 0) {
             const u = new Array(t);
             const l = new Array(t);
-            i = this.xt && new Array(t);
-            o = this.Qt && new Array(t);
+            i = this.Ft && new Array(t);
+            o = this.xt && new Array(t);
             try {
                 for (r = 0; r < t; r++) u[r] = runWithOwner(l[r] = createOwner(), s);
             } catch (e) {
@@ -6241,41 +6678,41 @@ function updateKeyedMap() {
             // commit
                         if (this.kt[0]) this.kt[0].dispose();
  // previous fallback
-                        this.Vt = u;
+                        this.Ut = u;
             this.kt = l;
-            i && (this.xt = i);
-            o && (this.Qt = o);
-            this.Lt = e.slice(0);
-            this.wt = t;
+            i && (this.Ft = i);
+            o && (this.xt = o);
+            this.Vt = e.slice(0);
+            this.vt = t;
         } else {
-            let u, l, c, a, f, E, d, S, T;
+            let u, l, a, c, f, E, d, S, T;
             // skip common prefix
-                        for (u = 0, l = Math.min(this.wt, t); u < l && (this.Lt[u] === e[u] || this.xt && compare(this.Ft, this.Lt[u], e[u])); u++) {
-                if (this.xt) setSignal(this.xt[u], e[u]);
+                        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]);
             }
             // skip common suffix — counted only; retained entries land in one pass
             // at commit instead of being staged and copied twice
-                        for (l = this.wt - 1, c = t - 1; l >= u && c >= u && (this.Lt[l] === e[c] || this.xt && compare(this.Ft, this.Lt[l], e[c])); l--, 
-            c--) ;
+                        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--, 
+            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.wt === t) {
-                this.Lt = e.slice(0);
+                        if (u === t && this.vt === t) {
+                this.Vt = e.slice(0);
                 return;
             }
-            const _ = t - this.wt;
-            const O = new Array(t);
+            const O = t - this.vt;
+            const _ = new Array(t);
             const p = new Array(t);
-            i = this.xt ? new Array(t) : undefined;
-            o = this.Qt ? new Array(t) : undefined;
+            i = this.Ft ? new Array(t) : undefined;
+            o = this.xt ? 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(c + 1);
-            for (r = c; r >= u; r--) {
-                a = e[r];
-                f = this.Ft ? this.Ft(a) : a;
+            d = new Array(a + 1);
+            for (r = a; r >= u; r--) {
+                c = e[r];
+                f = this.Wt ? this.Wt(c) : c;
                 n = E.get(f);
                 d[r] = n === undefined ? -1 : n;
                 E.set(f, r);
@@ -6284,24 +6721,24 @@ function updateKeyedMap() {
             // in the new set; if so, stage them at their new positions; if not,
             // queue them for disposal at commit
                         for (n = u; n <= l; n++) {
-                a = this.Lt[n];
-                f = this.Ft ? this.Ft(a) : a;
+                c = this.Vt[n];
+                f = this.Wt ? this.Wt(c) : c;
                 r = E.get(f);
                 if (r !== undefined && r !== -1) {
-                    O[r] = this.Vt[n];
+                    _[r] = this.Ut[n];
                     p[r] = this.kt[n];
-                    i && (i[r] = this.xt[n]);
-                    o && (o[r] = this.Qt[n]);
+                    i && (i[r] = this.Ft[n]);
+                    o && (o[r] = this.xt[n]);
                     r = d[r];
                     E.set(f, r);
                 } else (S ??= []).push(this.kt[n]);
             }
             // 2) create new rows into the temp arrays; an abort disposes only these
                         try {
-                for (r = u; r <= c; r++) {
+                for (r = u; r <= a; r++) {
                     if (p[r] !== undefined) continue;
                     (T ??= []).push(p[r] = createOwner());
-                    O[r] = runWithOwner(p[r], s);
+                    _[r] = runWithOwner(p[r], s);
                 }
             } catch (e) {
                 if (T) for (n = 0; n < T.length; n++) T[n].dispose();
@@ -6311,38 +6748,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++) {
-                O[n] = this.Vt[n];
+                _[n] = this.Ut[n];
                 p[n] = this.kt[n];
-                i && (i[n] = this.xt[n]);
-                o && (o[n] = this.Qt[n]);
+                i && (i[n] = this.Ft[n]);
+                o && (o[n] = this.xt[n]);
             }
-            for (r = u; r <= c; r++) {
+            for (r = u; r <= a; r++) {
                 if (i) setSignal(i[r], e[r]);
                 if (o) setSignal(o[r], r);
             }
-            for (r = c + 1; r < t; r++) {
-                O[r] = this.Vt[r - _];
-                p[r] = this.kt[r - _];
+            for (r = a + 1; r < t; r++) {
+                _[r] = this.Ut[r - O];
+                p[r] = this.kt[r - O];
                 if (i) {
-                    i[r] = this.xt[r - _];
+                    i[r] = this.Ft[r - O];
                     setSignal(i[r], e[r]);
                 }
                 if (o) {
-                    o[r] = this.Qt[r - _];
-                    if (_ !== 0) setSignal(o[r], r);
+                    o[r] = this.xt[r - O];
+                    if (O !== 0) setSignal(o[r], r);
                 }
             }
-            this.Vt = O;
+            this.Ut = _;
             this.kt = p;
-            i && (this.xt = i);
-            o && (this.Qt = o);
-            this.wt = t;
+            i && (this.Ft = i);
+            o && (this.xt = o);
+            this.vt = t;
             // save a copy of the mapped items for the next update
-                        this.Lt = e.slice(0);
+                        this.Vt = e.slice(0);
             if (S) for (n = 0; n < S.length; n++) S[n].dispose();
         }
     });
-    return this.Vt;
+    return this.Ut;
 }
 
 /**
@@ -6362,22 +6799,22 @@ function updateKeyedMap() {
  */ function repeat(e, t, n) {
     const r = t;
     const i = {
-        vt: createOwner(),
-        wt: 0,
-        Ht: 0,
+        wt: createOwner(),
+        vt: 0,
+        Mt: 0,
         $t: e,
-        Ut: r,
+        Gt: r,
         kt: [],
-        Vt: [],
+        Ut: [],
         jt: n?.from,
-        Mt: n?.fallback
+        Ht: n?.fallback
     };
     const o = computed(updateRepeat.bind(i));
     // Same as mapArray: untracked reads inside the internal owner resolve via
     // _parentComputed, so async reads in row callbacks register with the node
     // (pending tracking + post-settle retry) instead of vanishing.
-        i.vt.Je = o;
-    o.Ue &= ~CONFIG_AUTO_DISPOSE;
+        i.wt.Je = o;
+    o.Ge &= ~CONFIG_AUTO_DISPOSE;
     return accessor(o);
 }
 
@@ -6391,53 +6828,53 @@ function updateKeyedMap() {
 function updateRepeat() {
     const e = this.$t();
     const t = this.jt?.() || 0;
-    runWithOwner(this.vt, () => {
+    runWithOwner(this.wt, () => {
         if (e === 0) {
-            if (this.wt !== 0) {
-                this.vt.dispose(false);
+            if (this.vt !== 0) {
+                this.wt.dispose(false);
                 this.kt = [];
-                this.Vt = [];
-                this.wt = 0;
+                this.Ut = [];
+                this.vt = 0;
                 // Reset offset to match the cleared data (#2767, repro 2).
-                                this.Ht = 0;
+                                this.Mt = 0;
             }
-            if (this.Mt && !this.Vt[0]) {
+            if (this.Ht && !this.Ut[0]) {
                 // an aborted fallback attempt leaves an owner without a mapping;
                 // dispose it before re-creating
                 this.kt[0]?.dispose();
-                this.Vt[0] = runWithOwner(this.kt[0] = createOwner(), this.Mt);
+                this.Ut[0] = runWithOwner(this.kt[0] = createOwner(), this.Ht);
             }
             return;
         }
         const n = t + e;
-        const r = this.Ht + this.wt;
+        const r = this.Mt + this.vt;
         // 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.Ht);
+                const i = Math.max(t, this.Mt);
         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.Ht];
-            s[e - t] = this.Vt[e - this.Ht];
+            u[e - t] = this.kt[e - this.Mt];
+            s[e - t] = this.Ut[e - this.Mt];
         }
         try {
             for (let e = t; e < n; e++) {
                 if (e >= i && e < o) continue;
-                s[e - t] = runWithOwner(u[e - t] = createOwner(), () => this.Ut(e));
+                s[e - t] = runWithOwner(u[e - t] = createOwner(), () => this.Gt(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.wt === 0) this.kt[0]?.dispose(); else for (let e = this.Ht; e < r; e++) if (e < t || e >= n) this.kt[e - this.Ht].dispose();
-        this.Vt = s;
+                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.Ht = t;
-        this.wt = e;
+        this.Mt = t;
+        this.vt = e;
     });
-    return this.Vt;
+    return this.Ut;
 }
 
 function compare(e, t, n) {
@@ -6450,12 +6887,12 @@ function boundaryComputed(e, t) {
     });
     n.Nt = (e, t) => {
         // Use passed values if provided, otherwise read from node
-        const r = e !== undefined ? e : n.Qe;
+        const r = e !== undefined ? e : n.xe;
         const i = t !== undefined ? t : n.De;
         // 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.Qe &= ~n.Kt;
+                n.xe &= ~n.Kt;
         const o = n.Be.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
@@ -6463,8 +6900,8 @@ function boundaryComputed(e, t) {
         // untouched, so the tree still recomputes when the foreign source settles.
                 const s = r & ~n.Kt & (STATUS_PENDING | STATUS_ERROR);
         if (s) {
-            n.Qe &= ~s;
-            if (n.De === i && !(n.Qe & (STATUS_PENDING | STATUS_ERROR))) n.De = undefined;
+            n.xe &= ~s;
+            if (n.De === i && !(n.xe & (STATUS_PENDING | STATUS_ERROR))) n.De = 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
@@ -6476,7 +6913,7 @@ function boundaryComputed(e, t) {
         }
     };
     n.Kt = t;
-    n.Ue &= ~CONFIG_AUTO_DISPOSE;
+    n.Ge &= ~CONFIG_AUTO_DISPOSE;
     recompute(n, true);
     return n;
 }
@@ -6537,8 +6974,8 @@ class RevealController {
         Ct: true
     });
     ln=true;
-    cn=true;
-    an=false;
+    an=true;
+    cn=false;
     constructor(e, t) {
         this.rn = e;
         this.sn = t;
@@ -6596,10 +7033,10 @@ class RevealController {
         untrack(() => this.en());
     }
     en(e, t) {
-        if (this.an) return;
-        this.an = true;
+        if (this.cn) return;
+        this.cn = true;
         const n = this.ln;
-        const r = this.cn;
+        const r = this.an;
         try {
             const n = e ?? read(this.Xt), r = untrack(this.rn), i = r === "sequential" && !!untrack(this.sn), o = t ?? i;
             if (n) {
@@ -6651,10 +7088,10 @@ class RevealController {
             }
         } finally {
             this.ln = this.Yt();
-            this.cn = this.Zt();
-            this.an = false;
+            this.an = this.Zt();
+            this.cn = false;
         }
-        if (this.Jt && (n !== this.ln || r !== this.cn)) this.Jt.en();
+        if (this.Jt && (n !== this.ln || r !== this.an)) this.Jt.en();
     }
 }
 
@@ -6674,8 +7111,8 @@ class CollectionQueue extends Queue {
     });
     tn;
     nn=false;
-    _n;
-    On=ON_INIT;
+    On;
+    _n=ON_INIT;
     constructor(e) {
         super();
         this.Sn = e;
@@ -6686,16 +7123,16 @@ class CollectionQueue extends Queue {
     }
     notify(e, t, n, r) {
         if (!(t & this.Sn)) return super.notify(e, t, n, r);
-        if (this.nn && this._n) {
+        if (this.nn && this.On) {
             const e = untrack(() => {
                 try {
-                    return this._n();
+                    return this.On();
                 } catch {
                     return ON_INIT;
                 }
             });
-            if (e !== this.On) {
-                this.On = e;
+            if (e !== this._n) {
+                this._n = e;
                 this.nn = false;
                 this.qt.clear();
             }
@@ -6726,25 +7163,25 @@ class CollectionQueue extends Queue {
         t &= ~this.Sn;
         return t ? super.notify(e, t, n, r) : true;
     }
-    He() {
+    Me() {
         for (const e of this.qt) {
             // 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.Ge & REACTIVE_DISPOSED || !e.k && !(e.Qe & this.Sn) && !(this.Sn & STATUS_ERROR && e.Qe & STATUS_PENDING)) this.qt.delete(e);
+            if (e.Le & REACTIVE_DISPOSED || !e.k && !(e.xe & this.Sn) && !(this.Sn & STATUS_ERROR && e.xe & STATUS_PENDING)) this.qt.delete(e);
         }
         if (!this.qt.size) {
             if (this.Sn & STATUS_PENDING && this.Bt && !this.nn && this.Tn) {
-                this.Bt = !!(this.Tn.Qe & this.Sn);
+                this.Bt = !!(this.Tn.xe & this.Sn);
             } else {
                 this.Bt = false;
             }
             if (!this.Bt) {
                 setSignal(this.Xt, false);
-                if (this._n) {
+                if (this.On) {
                     try {
-                        this.On = untrack(() => this._n());
+                        this._n = untrack(() => this.On());
                     } catch {
                         /* value not yet committed — _prevOn stays stale, next notify will reset */}
                 }
@@ -6762,7 +7199,7 @@ function createCollectionBoundary(e, t, n, r) {
         ownedWrite: true,
         Ct: true
     });
-    if (r) o._n = r;
+    if (r) o.On = r;
     const s = o.Tn = createBoundChildren(i, t, o, e);
     // Prime source tracking so reveal registration sees pending sources.
         untrack(() => {
@@ -6772,7 +7209,7 @@ function createCollectionBoundary(e, t, n, r) {
         } catch (e) {
             if (e instanceof NotReadyError) t = true; else throw e;
         }
-        o.Bt = t || !!(s.Qe & e) || s.De instanceof NotReadyError;
+        o.Bt = t || !!(s.xe & e) || s.De instanceof NotReadyError;
     });
     const u = _revealUsed && e === STATUS_PENDING ? getContext(RevealControllerContext) : null;
     if (u) {