@solidjs/signals 2.0.0-rc.5 → 2.0.0-rc.6

package/dist/node.cjs

@@ -496,11 +496,11 @@ function canUseSimpleSyncFlush(e) {
 function sweepTransientStoreNodes() {
     if (transientStoreNodes.size === 0) return;
     for (const e of transientStoreNodes) {
-        if (e.$ !== null) {
+        if (e.B !== null) {
             transientStoreNodes.delete(e);
             continue;
         }
-        if (e.B !== NOT_PENDING) continue;
+        if (e.$ !== NOT_PENDING) continue;
         if (e.o?.m !== undefined && e.o?.m !== 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,
@@ -630,7 +630,7 @@ function mergeTransitionState(e, t) {
         let n = false;
     for (let i = e.oe; i !== null; i = i.se) {
         const r = i.ue;
-        if (r.B !== NOT_PENDING) {
+        if (r.$ !== NOT_PENDING) {
             const e = r.O;
             const i = e != null ? currentTransition(e) : null;
             // Skip the awaiting transaction's own cargo (t === target: a
@@ -682,7 +682,7 @@ function mergeTransitionState(e, t) {
         // duplicate fire of an unchanged view.
                 if (!hasActiveOverride$1(i)) {
             i.D |= CONFIG_HELD_TRUTH;
-            for (let e = i.$; e !== null; e = e.fe) {
+            for (let e = i.B; e !== null; e = e.fe) {
                 const t = e.ce;
                 if (t.ae && !(t.D & CONFIG_AUTHORITATIVE_READ)) enqueueSub(t);
             }
@@ -884,8 +884,8 @@ class GlobalQueue extends Queue {
     static We=null;
     static je=null;
     static Me=null;
-    static $e=null;
     static Be=null;
+    static $e=null;
     /** Authoritative-view reader wakeup (until()): installed at first until() call.
    * Call sites are gated by CONFIG_AUTHORITATIVE_OBSERVED, which only until()'s
    * carve-out read can set, so `!` invocations are safe once the gate holds. */
@@ -1133,7 +1133,7 @@ function insertSubs(e, t = false) {
     const i = (n & CONFIG_HAS_LANE ? e.o?.l : undefined) || currentOptimisticLane;
     const r = (n & CONFIG_HAS_SNAPSHOT) !== 0 && e.o?.et !== undefined;
     const o = reaskArmed;
-    for (let n = e.$; n !== null; n = n.fe) {
+    for (let n = e.B; n !== null; n = n.fe) {
         const e = n.ce;
         // A value-change notification is a new question for the subscriber: any
         // pending re-ask mark (refresh) it carried is superseded.
@@ -1166,26 +1166,32 @@ function insertSubs(e, t = false) {
 function commitPendingNode(e) {
     const t = e;
     if (!t.it) {
-        if (e.B !== NOT_PENDING) {
-            e.ot = e.B;
-            e.B = NOT_PENDING;
+        if (e.$ !== NOT_PENDING) {
+            e.ot = e.$;
+            e.$ = NOT_PENDING;
         }
         if (e.D & CONFIG_HAS_COMPANIONS) GlobalQueue.we(e);
         return;
     }
-    if (e.B !== NOT_PENDING) {
-        e.ot = e.B;
-        e.B = NOT_PENDING;
+    if (e.$ !== NOT_PENDING) {
+        e.ot = e.$;
+        e.$ = NOT_PENDING;
         // Set _modified for effects, but not for tracked effects (they handle their own scheduling)
                 if (e.ae && e.ae !== EFFECT_TRACKED) e.st = true;
+        // A quiet re-ask classification preserved through a held landing dies
+        // with the value commit — the commit IS the reveal (#3178). Gated on the
+        // staged value: status propagation queues pending nodes whose windows
+        // are still OPEN (no staged value), and their live classification must
+        // survive this sweep.
+                if (e.o) e.o.ut = false;
     }
     // The committed hold is the first observable answer for a loading-window
     // node — the window closes here, not at compute time (#2990). Unconditional
     // store to an always-present computed slot.
-        t.ut = false;
+        t.lt = false;
     t.L &= ~REACTIVE_MANUAL_WRITE;
-    if (!(t.lt & STATUS_PENDING)) t.lt &= ~STATUS_UNINITIALIZED;
-    if (t.o != null && (t.o.ft !== null || t.o.ct !== null)) GlobalQueue.Te(t, false, true);
+    if (!(t.ct & STATUS_PENDING)) t.ct &= ~STATUS_UNINITIALIZED;
+    if (t.o != null && (t.o.dt !== null || t.o.Et !== null)) GlobalQueue.Te(t, false, true);
     if (e.D & CONFIG_HAS_COMPANIONS) GlobalQueue.we(e);
 }
 
@@ -1314,7 +1320,7 @@ function finalizePureQueue(e = null, t = false) {
 
 function checkBoundaryChildren(e) {
     for (const t of e.W) {
-        t.dt?.();
+        t.St?.();
         checkBoundaryChildren(t);
     }
 }
@@ -1382,15 +1388,15 @@ function runQueue$1(e, t) {
 
 function reporterBlocksSource(e, t) {
     if (e.L & (REACTIVE_ZOMBIE | REACTIVE_DISPOSED)) return false;
-    if (e.o?.Et?.has(t)) return true;
+    if (e.o?.Tt?.has(t)) return true;
     for (let n = e.oe; n; n = n.se) {
         let e = n.ue;
         while (e) {
-            if (e === t || e.St === t) return true;
+            if (e === t || e._t === t) return true;
             e = e.o?.i;
         }
     }
-    return !!(e.lt & STATUS_PENDING && e.o?.ze instanceof NotReadyError && e.o?.ze.source === t);
+    return !!(e.ct & STATUS_PENDING && e.o?.ze instanceof NotReadyError && e.o?.ze.source === t);
 }
 
 function transitionComplete(e) {
@@ -1406,7 +1412,7 @@ function transitionComplete(e) {
             }
             i.delete(e);
         }
-        if (!r) e.J.delete(n); else if (n.lt & STATUS_PENDING && n.o?.ze?.source === n) {
+        if (!r) e.J.delete(n); else if (n.ct & STATUS_PENDING && n.o?.ze?.source === n) {
             t = false;
             break;
         }
@@ -1419,6 +1425,13 @@ function transitionComplete(e) {
     return t;
 }
 
+/** A fresh, unentered transaction (#3146): the optimistic store's truth
+ * flight DECLARES an owned transaction instead of relying on whatever the
+ * ambient adoption machinery stamped on its firewall. Activate it with
+ * initTransition; it is a plain batch until then. */ function createTransition() {
+    return createBatch();
+}
+
 function currentTransition(e) {
     while (e.P && typeof e.P === "object") e = e.P;
     return e;
@@ -1470,25 +1483,25 @@ function runInTransition(e, t) {
         const t = e;
         if (!t.st) {
             t.st = true;
-            t.Tt.enqueue(EFFECT_USER, t._t);
+            t.At.enqueue(EFFECT_USER, t.Ot);
         }
         return;
     }
     const t = queueFor(e);
-    if (t.H > e.At) t.H = e.At;
+    if (t.H > e.Nt) t.H = e.Nt;
     insertIntoHeap(e, t);
 }
 
 function actualInsertIntoHeap(e, t) {
-    const n = (e.pe?.Ot ? e.pe.Nt?.At : e.pe?.At) ?? -1;
-    if (n >= e.At) e.At = n + 1;
-    const i = e.At;
+    const n = (e.pe?.It ? e.pe.Rt?.Nt : e.pe?.Nt) ?? -1;
+    if (n >= e.Nt) e.Nt = n + 1;
+    const i = e.Nt;
     const r = t.G[i];
     if (r === undefined) t.G[i] = e; else {
-        const t = r.It;
-        t.Rt = e;
-        e.It = t;
-        r.It = e;
+        const t = r.Ct;
+        t.gt = e;
+        e.Ct = t;
+        r.Ct = e;
     }
     if (i > t.U) t.U = i;
 }
@@ -1524,23 +1537,23 @@ function deleteFromHeap(e, t) {
     const n = e.L;
     if (!(n & (REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT))) return;
     e.L = n & -25;
-    const i = e.At;
-    if (e.It === e) t.G[i] = undefined; else {
-        const n = e.Rt;
+    const i = e.Nt;
+    if (e.Ct === e) t.G[i] = undefined; else {
+        const n = e.gt;
         const r = t.G[i];
         const o = n ?? r;
-        if (e === r) t.G[i] = n; else e.It.Rt = n;
-        o.It = e.It;
+        if (e === r) t.G[i] = n; else e.Ct.gt = n;
+        o.Ct = e.Ct;
     }
-    e.It = e;
-    e.Rt = undefined;
+    e.Ct = e;
+    e.gt = undefined;
 }
 
 function markHeap(e) {
     if (e.F) return;
     e.F = true;
     for (let t = 0; t <= e.U; t++) {
-        for (let n = e.G[t]; n !== undefined; n = n.Rt) {
+        for (let n = e.G[t]; n !== undefined; n = n.gt) {
             if (n.L & REACTIVE_IN_HEAP) markNode(n);
         }
     }
@@ -1550,15 +1563,15 @@ function markNode(e, t = REACTIVE_DIRTY) {
     const n = e.L;
     if ((n & (REACTIVE_CHECK | REACTIVE_DIRTY)) >= t) return;
     e.L = n & -4 | t;
-    for (let t = e.$; t !== null; t = t.fe) {
+    for (let t = e.B; t !== null; t = t.fe) {
         markNode(t.ce, REACTIVE_CHECK);
     }
     // Firewall children (projection machinery only): gate the cold-extension
     // deref on the config bit — markNode runs per sub edge per write, and an
     // unconditional _x chase here taxed every propagation (diamond -22%).
         if (e.D & CONFIG_FW_CHILDREN) {
-        for (let t = e.o.Ct; t !== null; t = t.gt) {
-            for (let e = t.$; e !== null; e = e.fe) {
+        for (let t = e.o.vt; t !== null; t = t.yt) {
+            for (let e = t.B; e !== null; e = e.fe) {
                 markNode(e.ce, REACTIVE_CHECK);
             }
         }
@@ -1579,15 +1592,15 @@ function runHeap(e, t) {
 
 function adjustHeight(e, t) {
     deleteFromHeap(e, t);
-    let n = e.At;
+    let n = e.Nt;
     for (let t = e.oe; t; t = t.se) {
         const e = t.ue;
-        const i = e.St || e;
-        if (i.it && i.At >= n) n = i.At + 1;
+        const i = e._t || e;
+        if (i.it && i.Nt >= n) n = i.Nt + 1;
     }
-    if (e.At !== n) {
-        e.At = n;
-        for (let t = e.$; t !== null; t = t.fe) {
+    if (e.Nt !== n) {
+        e.Nt = n;
+        for (let t = e.B; t !== null; t = t.fe) {
             // 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
@@ -1602,7 +1615,7 @@ const PENDING_OWNER = {};
 
  // Dummy owner to trigger store's read() path
 function markDisposal(e) {
-    let t = e.vt;
+    let t = e.wt;
     while (t) {
         const e = t.L;
         t.L = e | REACTIVE_ZOMBIE;
@@ -1616,7 +1629,7 @@ function markDisposal(e) {
             if (e & REACTIVE_IN_HEAP) insertIntoHeap(t, zombieQueue); else insertIntoHeapHeight(t, zombieQueue);
         }
         markDisposal(t);
-        t = t.yt;
+        t = t.Pt;
     }
 }
 
@@ -1644,10 +1657,10 @@ function disposeChildren(e, t = false, n) {
                 const t = e;
         if (t.o?.I || t.o?.R) GlobalQueue.we(t);
     }
-    if (t && e.it && e.o !== null) e.o.wt = null;
-    let r = n ? e.o?.ft ?? null : e.vt;
+    if (t && e.it && e.o !== null) e.o.bt = null;
+    let r = n ? e.o?.dt ?? null : e.wt;
     while (r) {
-        const e = r.yt;
+        const e = r.Pt;
         const t = r;
         // Owner teardown is death regardless of the child's own lifecycle
         // (#3024): strip AUTO_DISPOSE so a post-disposal read freezes at the
@@ -1670,34 +1683,34 @@ function disposeChildren(e, t = false, n) {
         r = e;
     }
     if (n) {
-        if (e.o !== null) e.o.ft = null;
+        if (e.o !== null) e.o.dt = null;
     } else {
-        e.vt = null;
-        e.Pt = 0;
+        e.wt = null;
+        e.Dt = 0;
     }
     // O(1) splice out of parent's chain on individual dispose. Skipped during
     // batch dispose (parent already disposed) and zombie disposal (node sits on
     // parent's _pendingFirstChild). We leave node._nextSibling intact so outer
     // walks that already advanced past us still reach later siblings.
         if (t && !n && !(i & REACTIVE_ZOMBIE) && e.pe !== null && !(e.pe.L & REACTIVE_DISPOSED)) {
-        const t = e.bt;
-        const n = e.yt;
-        if (t !== null) t.yt = n; else e.pe.vt = n;
-        if (n !== null) n.bt = t;
-        e.bt = null;
+        const t = e.Gt;
+        const n = e.Pt;
+        if (t !== null) t.Pt = n; else e.pe.wt = n;
+        if (n !== null) n.Gt = t;
+        e.Gt = null;
     }
     runDisposal(e, n);
     // Final effect-returned cleanup fires at true disposal, after `_disposal`
     // to mirror rerun ordering (compute-phase teardown first, cleanup last).
-        if (t && e.Dt) {
-        const t = e.Dt;
-        e.Dt = undefined;
+        if (t && e.kt) {
+        const t = e.kt;
+        e.kt = undefined;
         t();
     }
 }
 
 function runDisposal(e, t) {
-    let n = t ? e.o?.ct : e.Gt;
+    let n = t ? e.o?.Et : e.xt;
     if (!n) return;
     if (Array.isArray(n)) {
         for (let e = 0; e < n.length; e++) {
@@ -1708,14 +1721,14 @@ function runDisposal(e, t) {
         n.call(n);
     }
     if (t) {
-        if (e.o !== null) e.o.ct = null;
-    } else e.Gt = null;
+        if (e.o !== null) e.o.Et = null;
+    } else e.xt = null;
 }
 
 function childId(e, t) {
     let n = e;
     while (n.D & CONFIG_TRANSPARENT && n.pe) n = n.pe;
-    if (n.id != null) return formatId(n.id, t ? n.Pt++ : n.Pt);
+    if (n.id != null) return formatId(n.id, t ? n.Dt++ : n.Dt);
     throw new Error("");
 }
 
@@ -1796,7 +1809,7 @@ function formatId(e, t) {
  * checks. `cleanup()` is the unchecked primitive used by internals.
  */ function cleanup(e) {
     if (!context) return e;
-    if (!context.Gt) context.Gt = e; else if (Array.isArray(context.Gt)) context.Gt.push(e); else context.Gt = [ context.Gt, e ];
+    if (!context.xt) context.xt = e; else if (Array.isArray(context.xt)) context.xt.push(e); else context.xt = [ context.xt, e ];
     return e;
 }
 
@@ -1836,27 +1849,27 @@ function disposeRootSelf(e = true) {
     const i = {
         id: inheritId(e, n, t),
         D: n ? CONFIG_TRANSPARENT : 0,
-        Ot: true,
-        Nt: t?.Ot ? t.Nt : t,
-        vt: null,
-        yt: null,
-        bt: null,
+        It: true,
+        Rt: t?.It ? t.Rt : t,
+        wt: null,
+        Pt: null,
         Gt: null,
-        Tt: t?.Tt ?? globalQueue,
-        kt: t?.kt || defaultContext,
-        Pt: 0,
+        xt: null,
+        At: t?.At ?? globalQueue,
+        Ft: t?.Ft || defaultContext,
+        Dt: 0,
         o: null,
         pe: t,
         dispose: disposeRootSelf
     };
     if (t) {
-        const e = t.vt;
+        const e = t.wt;
         if (e === null) {
-            t.vt = i;
+            t.wt = i;
         } else {
-            i.yt = e;
-            e.bt = i;
-            t.vt = i;
+            i.Pt = e;
+            e.Gt = i;
+            t.wt = i;
         }
     }
     return i;
@@ -1895,10 +1908,10 @@ function unlinkSubs(e) {
     const t = e.ue;
     const n = e.se;
     const i = e.fe;
-    const r = e.xt;
-    if (i !== null) i.xt = r; else t.Ft = r;
+    const r = e.Ht;
+    if (i !== null) i.Ht = r; else t.Ut = r;
     if (r !== null) r.fe = i; else {
-        t.$ = i;
+        t.B = i;
         if (i === null) {
             t.o?.Y?.();
             // No more subscribers; only tear down if CONFIG_AUTO_DISPOSE is set.
@@ -1908,7 +1921,7 @@ function unlinkSubs(e) {
             // this same last-one-out check when that observer releases (the
             // untracked-read dormancy sweep guards on pending identically).
                         const e = t;
-            e.it && e.D & CONFIG_AUTO_DISPOSE && !(e.L & REACTIVE_ZOMBIE) && !(e.lt & STATUS_PENDING) && unobserved(e);
+            e.it && e.D & CONFIG_AUTO_DISPOSE && !(e.L & REACTIVE_ZOMBIE) && !(e.ct & STATUS_PENDING) && unobserved(e);
         }
     }
     return n;
@@ -1974,7 +1987,7 @@ function sweepDormant() {
         // is an observer; the settle path re-runs last-one-out), lost its
         // AUTO_DISPOSE bit (owner teardown strips it, #3024), or already been
         // torn down.
-        if (!e.$ && e.D & CONFIG_AUTO_DISPOSE && !(e.lt & STATUS_PENDING) && !(e.L & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE))) {
+        if (!e.B && e.D & CONFIG_AUTO_DISPOSE && !(e.ct & STATUS_PENDING) && !(e.L & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE))) {
             unobserved(e);
         }
     }
@@ -1990,7 +2003,7 @@ function link(e, t, n = false) {
     // read order within the computation.
     const i = t.le;
     if (i !== null && i.ue === e) {
-        i.Ht &&= n;
+        i.Lt &&= n;
         return;
     }
     let r = null;
@@ -2001,7 +2014,7 @@ function link(e, t, n = false) {
             r.tt = t.nt;
             t.le = r;
             // First touch of this pass: the previous pass's label is stale.
-                        r.Ht = n;
+                        r.Lt = n;
             return;
         }
     }
@@ -2010,24 +2023,24 @@ function link(e, t, n = false) {
     // [deps.._depsTail] prefix — the O(1) equivalent of scanning the dep list
     // (the old alien-signals `isValidLink` walk, O(n²) when a computation
     // re-reads earlier deps non-consecutively, e.g. store leaf reads).
-        const s = e.Ft;
+        const s = e.Ut;
     if (s !== null && s.ce === t && (!o || s.tt === t.nt)) {
         // 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.Ht &&= n; else s.Ht = n;
+        if (o) s.Lt &&= n; else s.Lt = n;
         return;
     }
-    const u = t.le = e.Ft = {
+    const u = t.le = e.Ut = {
         ue: e,
         ce: t,
         se: r,
-        xt: s,
+        Ht: s,
         fe: null,
         tt: t.nt,
-        Ht: n
+        Lt: n
     };
     if (i !== null) i.se = u; else t.oe = u;
-    if (s !== null) s.fe = u; else e.$ = u;
+    if (s !== null) s.fe = u; else e.B = u;
     // New subscriber edge: staged-rewrite skips (§12d) must not miss it.
         bumpNotifyEpoch();
 }
@@ -2038,20 +2051,22 @@ function link(e, t, n = false) {
 // overlapping source landed beside the Set and removePendingSource refused
 // to clear it, stranding the Set members' pending forever (#2893).
 function addPendingSource(e, t) {
-    if (e.o?.Et?.has(t)) return false;
-    (ext(e).Et ??= new Set).add(t);
+    if (e.o?.Tt?.has(t)) return false;
+    (ext(e).Tt ??= new Set).add(t);
     return true;
 }
 
 function removePendingSource(e, t) {
-    if (!e.o?.Et?.delete(t)) return false;
-    if (e.o?.Et.size === 0) if (e.o !== null) e.o.Et = undefined;
+    const n = e.o?.Tt;
+    if (!n?.delete(t)) return false;
+    if (!n.size) e.o.Tt = undefined;
     return true;
 }
 
 function clearPendingSources(e) {
-    e.o?.Et?.clear();
-    if (e.o !== null) e.o.Et = undefined;
+    // This set is node-owned and never shared; dropping the sole reference
+    // releases the set and every entry without a redundant clear() walk.
+    if (e.o !== null) e.o.Tt = undefined;
 }
 
 /**
@@ -2061,13 +2076,13 @@ function clearPendingSources(e) {
  * with NO read-visible pending status, no downstream propagation, no
  * transition, no lane registration. Commit #0 keeps serving.
  */ function parkLoadingWindow(e, t) {
-    ext(e).Ut = true;
+    ext(e).Vt = true;
     if (t.source) addPendingSource(e, t.source);
     // A settled error is the node's answer ("the error stays the answer until
     // this retry can actually run") — the park must not replace it: reads
     // throw `_error` while STATUS_ERROR is set, and overwriting it here leaks
     // a pending-class NotReadyError from a read-invisible park (#2989).
-        if (!(e.lt & STATUS_ERROR)) setPendingError(e, t.source, t);
+        if (!(e.ct & STATUS_ERROR)) setPendingError(e, t.source, t);
 }
 
 function setPendingError(e, t, n) {
@@ -2086,10 +2101,10 @@ function setPendingError(e, t, n) {
 }
 
 function forEachDependent(e, t) {
-    for (let n = e.$; n !== null; n = n.fe) t(n.ce, n);
+    for (let n = e.B; n !== null; n = n.fe) t(n.ce, n);
     // `?? null`: affects() marks route plain signals (no `_child` slot) through here.
-        for (let n = e.o?.Ct ?? null; n !== null; n = n.gt) {
-        for (let e = n.$; e !== null; e = e.fe) t(e.ce, e);
+        for (let n = e.o?.vt ?? null; n !== null; n = n.yt) {
+        for (let e = n.B; e !== null; e = e.fe) t(e.ce, e);
     }
 }
 
@@ -2104,7 +2119,7 @@ function forEachDependent(e, t) {
 // callbacks handle their own release (settleAutodispose in handleAsync); this
 // covers derivatively-pending dependents, which have no callbacks of their own.
 function releaseIfSettledUnobserved(e) {
-    e.it && e.D & CONFIG_AUTO_DISPOSE && !e.$ && !(e.L & REACTIVE_ZOMBIE) && !(e.lt & STATUS_PENDING) && unobserved(e);
+    e.it && e.D & CONFIG_AUTO_DISPOSE && !e.B && !(e.L & REACTIVE_ZOMBIE) && !(e.ct & STATUS_PENDING) && unobserved(e);
 }
 
 // Error-path sweep: notifyStatus(STATUS_ERROR) clears dependents' pending
@@ -2117,7 +2132,7 @@ function releaseSettledDependents(e) {
     const visit = e => {
         if (n.has(e)) return;
         n.add(e);
-        if (!e.$ && e.D & CONFIG_AUTO_DISPOSE) (t ??= []).push(e);
+        if (!e.B && e.D & CONFIG_AUTO_DISPOSE) (t ??= []).push(e);
         forEachDependent(e, visit);
     };
     forEachDependent(e, visit);
@@ -2156,6 +2171,10 @@ function settleErroredDependents(e, t) {
 }
 
 function settlePendingSource(e) {
+    // The normal landing path already cleared the source's own set. Superseded
+    // re-parks arrive here with an abandoned self entry, which must retire in
+    // the same walk as its propagated copies.
+    removePendingSource(e, e);
     let t = false;
     let n;
     const i = new Set;
@@ -2165,29 +2184,29 @@ function settlePendingSource(e) {
         if (i.has(o) || !removePendingSource(o, e)) return;
         i.add(o);
         o.Z = clock;
-        const s = o.o?.Et?.values().next().value;
+        const s = o.o?.Tt?.values().next().value;
         // STATUS_ERROR + pending sources only coexist via an errored loading
         // window's park (notifyStatus(STATUS_ERROR) clears pending sources
         // otherwise): the settled error stays the answer through the settle —
         // nulling it here would have reads throw `null` until the re-enqueued
         // retry lands, or lose it entirely if that retry parks again (#2989).
-                const u = o.lt & STATUS_ERROR;
+                const u = o.ct & STATUS_ERROR;
         if (s) {
             if (!u) setPendingError(o, s);
             r?.(o);
         } else {
-            o.lt &= ~STATUS_PENDING;
+            o.ct &= ~STATUS_PENDING;
             if (!u) setPendingError(o);
             r?.(o);
-            if (o.o?.Ut) {
+            if (o.o?.Vt) {
                 enqueueSub(o);
                 t = true;
             }
-            if (o.o !== null) o.o.Ut = false;
+            if (o.o !== null) o.o.Vt = 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.$ && o.D & CONFIG_AUTO_DISPOSE) (n ??= []).push(o);
+                        if (!o.B && o.D & CONFIG_AUTO_DISPOSE) (n ??= []).push(o);
         }
         forEachDependent(o, settle);
     };
@@ -2204,9 +2223,9 @@ function isThenable(e) {
 }
 
 /** Fire and clear a node's iterator-flight cancellation hook (#3122). */ function releaseFlightTeardown(e) {
-    const t = e.o?.Lt;
+    const t = e.o?.Qt;
     if (t != null) {
-        e.o.Lt = null;
+        e.o.Qt = null;
         t();
     }
 }
@@ -2221,9 +2240,9 @@ function handleAsync(e, t, n) {
         });
     }
     if (!r && !i) {
-        if (e.o !== null) e.o.wt = null;
+        if (e.o !== null) e.o.bt = null;
         // A sync landing is the first real answer for a loadingValue node.
-                e.ut = false;
+                e.lt = false;
         return t;
     }
     // Flight replacement relies on recompute's supersede release for iterator
@@ -2231,7 +2250,7 @@ function handleAsync(e, t, n) {
     // self-registration — runs during a recompute of `el`, which has already
     // fired _flightTeardown. A future non-recompute registration path must
     // release it here before overwriting _inFlight.
-        ext(e).wt = t;
+        ext(e).bt = 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
@@ -2245,7 +2264,7 @@ function handleAsync(e, t, n) {
     // are the transaction's reveal machinery and always re-enter.
         const settleTransition = () => {
         const t = resolveTransition(e);
-        if (t && e.lt & STATUS_UNINITIALIZED && !currentTransition(t).J.has(e)) {
+        if (t && e.ct & STATUS_UNINITIALIZED && !currentTransition(t).J.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.O = null;
@@ -2254,21 +2273,25 @@ function handleAsync(e, t, n) {
         globalQueue.initTransition(t);
     };
     const handleError = n => {
-        if (e.o?.wt !== t) return;
+        if (e.o?.bt !== t) return;
         // NotReadyError from rejected promises should be treated as pending, not error
                 let i = n instanceof NotReadyError;
-        if (i && e.ut) {
+        if (i && e.lt) {
             // Loading window: the flight died waiting on an unready source. Keep
             // serving commit #0 — same parking as recompute's catch for sync
             // dependency throws. The dead flight is released so the clock-gated
             // error-retry pull (updateIfNecessary) can also re-ask.
-            if (e.o !== null) e.o.wt = null;
+            if (e.o !== null) e.o.bt = null;
             parkLoadingWindow(e, n);
             e.Z = clock;
             return;
         }
         settleTransition();
         notifyStatus(e, i ? STATUS_PENDING : STATUS_ERROR, n);
+        // A NotReady rejection is a landing into another pending source. The
+        // rejected flight will never settle its self entry, so transfer ownership
+        // after notifyStatus has propagated the replacement source.
+                if (i) settlePendingSource(e);
         e.Z = clock;
         // A real error settles derivatively-pending dependents (notifyStatus
         // cleared their pending sources), so stranded lazy ones release here —
@@ -2276,17 +2299,25 @@ function handleAsync(e, t, n) {
                 if (!i) releaseSettledDependents(e);
     };
     const asyncWrite = (i, r) => {
-        if (e.o?.wt !== t) return;
+        if (e.o?.bt !== 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.L & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY)) return;
         settleTransition();
-        const o = !!(e.lt & STATUS_UNINITIALIZED);
+        const o = !!(e.ct & STATUS_UNINITIALIZED);
+        // Captured before clearStatus wipes it: a quiet re-ask's landing may be
+        // transition-held below, and the displayed value keeps answering the same
+        // question until the hold commits — the classification must survive to
+        // that reveal or companion synchronization briefly classifies the held
+        // old value as pending, a one-frame pulse to direct observers (#3178).
+        // A truthy capture implies `_x` exists, so the restore writes it directly.
+                const s = e.o?.ut;
         trimStaleDeps(e);
         clearStatus(e);
-        const s = resolveLane(e);
-        if (s) s.T.delete(e);
+        if (s) e.o.ut = true;
+        const u = resolveLane(e);
+        if (u) u.T.delete(e);
         if (n) {
             n(i);
             if (o) clearStatus(e, true);
@@ -2300,8 +2331,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.B === NOT_PENDING) queuePendingNode(e);
-            e.B = i;
+            if (e.$ === NOT_PENDING) queuePendingNode(e);
+            e.$ = i;
             // 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)
@@ -2325,11 +2356,11 @@ function handleAsync(e, t, n) {
                 GlobalQueue.Ke?.(e);
             }
             e.Z = clock;
-        } else if (s) {
+        } else if (u) {
             // Route through lane's effect queue for independent flushing
             const t = e.ae;
             const n = e.ot;
-            const r = e.Vt;
+            const r = e.Wt;
             try {
                 if (!t && o || !r || !r(i, n)) {
                     e.ot = i;
@@ -2361,8 +2392,12 @@ function handleAsync(e, t, n) {
         // (`_pendingValue` set above or inside setSignal) is not — the verdict's
         // held-value branch is window-gated, and commitPendingNode closes the
         // window when the hold commits, so no one-frame isPending pulse can leak
-        // to live observers between the landing and its commit (#2990).
-                if (e.B === NOT_PENDING) e.ut = false;
+        // to live observers between the landing and its commit (#2990). The
+        // quiet re-ask classification follows the same schedule (#3178).
+                if (e.$ === NOT_PENDING) {
+            e.lt = false;
+            if (s) e.o.ut = false;
+        }
         settlePendingSource(e);
         schedule();
         flush();
@@ -2376,7 +2411,7 @@ function handleAsync(e, t, n) {
     // 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.D & CONFIG_AUTO_DISPOSE && !e.$ && !(e.lt & STATUS_PENDING)) {
+        if (e.D & CONFIG_AUTO_DISPOSE && !e.B && !(e.ct & STATUS_PENDING)) {
             unobserved(e);
             return true;
         }
@@ -2411,7 +2446,7 @@ function handleAsync(e, t, n) {
         // owner-death backstop, but its disposal list can be zombie-deferred
         // until the SUPERSEDING flight settles. The teardown slot fires at the
         // _inFlight release sites so supersede stops this stream immediately.
-                ext(e).Lt = close;
+                ext(e).Qt = close;
         // Release check before each next pull: an unobserved lazy node must tear
         // down (its close above runs via disposal, closing the iterator) instead
         // of pumping the stream forever with zero subscribers (#2935).
@@ -2441,7 +2476,7 @@ function handleAsync(e, t, n) {
                     n = i;
                     f = true;
                     if (i.done) u = true;
-                } else if (e.o?.wt !== t) {
+                } else if (e.o?.bt !== t) {
                     return;
                 } else if (!i.done) {
                     s = true;
@@ -2461,7 +2496,7 @@ function handleAsync(e, t, n) {
                 if (a && l) {
                     i = n;
                     c = true;
-                } else if (e.o?.wt === t) {
+                } else if (e.o?.bt === t) {
                     u = true;
                     handleError(n);
                     settleAutodispose();
@@ -2521,13 +2556,13 @@ function handleAsync(e, t, n) {
         // becomes disposal-bearing, which is exactly the class a directly
         // returned iterable already occupies.
                 const registerDeferredClose = t => {
-            if (!e.Gt) e.Gt = t; else if (Array.isArray(e.Gt)) e.Gt.push(t); else e.Gt = [ e.Gt, t ];
+            if (!e.xt) e.xt = t; else if (Array.isArray(e.xt)) e.xt.push(t); else e.xt = [ e.xt, t ];
         };
         t.then(i => {
             if (s) {
                 o = i;
                 n = true;
-            } else if (e.o?.wt === t && !(e.L & REACTIVE_DISPOSED) && flattenIfIterable(i, registerDeferredClose)) ; else {
+            } else if (e.o?.bt === t && !(e.L & REACTIVE_DISPOSED) && flattenIfIterable(i, registerDeferredClose)) ; else {
                 asyncWrite(i);
                 settleAutodispose();
             }
@@ -2552,12 +2587,12 @@ function handleAsync(e, t, n) {
             // is opened — first-flight work on a loadingValue node is loading-class
             // (invisible to boundaries and transitions); the flight itself is
             // already registered in _inFlight and lands through asyncWrite.
-            if (e.ut) return e.ot;
+            if (e.lt) return e.ot;
             globalQueue.initTransition(resolveTransition(e));
             throw new NotReadyError(context);
         } else if (!flattenIfIterable(o)) {
             // Synchronously-resolved promise: the first real answer landed.
-            e.ut = false;
+            e.lt = false;
         }
         // A sync-resolved promise holding an AsyncIterable flattened LIVE (we
         // are still inside the synchronous read): full initial-drain semantics
@@ -2567,30 +2602,30 @@ function handleAsync(e, t, n) {
     if (s !== null) {
         if (!s) {
             // Loading window: serve commit #0 (see the promise branch above).
-            if (e.ut) return e.ot;
+            if (e.lt) return e.ot;
             globalQueue.initTransition(resolveTransition(e));
             throw new NotReadyError(context);
         }
         // A sync first yield (or immediate empty completion) is the first real
         // answer; async yields clear inside asyncWrite.
-                e.ut = false;
+                e.lt = false;
     }
     return o;
 }
 
 function clearStatus(e, t = false) {
-    if (e.o?.Et) clearPendingSources(e);
-    if (e.o?.Ut) if (e.o !== null) e.o.Ut = false;
+    if (e.o?.Tt) clearPendingSources(e);
+    if (e.o?.Vt) if (e.o !== null) e.o.Vt = false;
     // The pending window is over; its quiet classification dies with it.
     // (Unconditional: _reask is baked into the node literals, so this is a
     // plain store to an existing slot — no shape change.)
-        if (e.o !== null) e.o.Qt = false;
-    e.lt = t ? 0 : e.lt & STATUS_UNINITIALIZED;
+        if (e.o !== null) e.o.ut = false;
+    e.ct = t ? 0 : e.ct & STATUS_UNINITIALIZED;
     if (e.o?.ze) setPendingError(e);
     // Update pending signal for isPending() reactivity (companions only exist
     // once the verdict layer created them, which installs the hooks).
         if (e.o?.I || e.o?.R) GlobalQueue.ve(e);
-    if (e.o?.Ct && e.D & CONFIG_CHILD_COMPANIONS && GlobalQueue.ye !== null) GlobalQueue.ye(e);
+    if (e.o?.vt && e.D & CONFIG_CHILD_COMPANIONS && GlobalQueue.ye !== null) GlobalQueue.ye(e);
     const n = statusNotifierOf(e);
     if (n) n.call(e);
 }
@@ -2605,17 +2640,17 @@ function notifyStatus(e, t, n, i, r) {
     if (!i) {
         if (t === STATUS_PENDING && o) {
             addPendingSource(e, o);
-            e.lt = STATUS_PENDING | e.lt & STATUS_UNINITIALIZED;
+            e.ct = STATUS_PENDING | e.ct & 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.lt = t | (t !== STATUS_ERROR ? e.lt & STATUS_UNINITIALIZED : 0);
+            e.ct = t | (t !== STATUS_ERROR ? e.ct & STATUS_UNINITIALIZED : 0);
             ext(e).ze = n;
         }
         GlobalQueue.ve?.(e);
-        if (e.o?.Ct && e.D & CONFIG_CHILD_COMPANIONS && GlobalQueue.ye !== null) GlobalQueue.ye(e);
+        if (e.o?.vt && e.D & CONFIG_CHILD_COMPANIONS && GlobalQueue.ye !== null) GlobalQueue.ye(e);
     }
     if (r && !i) {
         assignOrMergeLane(e, r);
@@ -2636,13 +2671,13 @@ function notifyStatus(e, t, n, i, r) {
     }
     forEachDependent(e, (e, i) => {
         e.Z = clock;
-        if (t === STATUS_PENDING && o && !e.o?.Et?.has(o) || t !== STATUS_PENDING && (e.o?.ze !== n || e.o?.Et)) {
+        if (t === STATUS_PENDING && o && !e.o?.Tt?.has(o) || t !== STATUS_PENDING && (e.o?.ze !== n || e.o?.Tt)) {
             // 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 (i.Ht && t !== STATUS_PENDING && !(n instanceof NotReadyError)) {
+            if (i.Lt && t !== STATUS_PENDING && !(n instanceof NotReadyError)) {
                 enqueueSub(e);
                 schedule();
                 return;
@@ -2687,7 +2722,7 @@ let snapshotSources = null;
 
 function ownerInSnapshotScope(e) {
     while (e) {
-        if (e.Wt) return true;
+        if (e.jt) return true;
         e = e.pe;
     }
     return false;
@@ -2699,20 +2734,20 @@ function setSnapshotCapture(e) {
 }
 
 function markSnapshotScope(e) {
-    e.Wt = true;
+    e.jt = true;
 }
 
 function releaseSnapshotScope(e) {
-    e.Wt = false;
+    e.jt = false;
     releaseSubtree(e);
     schedule();
 }
 
 function releaseSubtree(e) {
-    let t = e.vt;
+    let t = e.wt;
     while (t) {
-        if (t.Wt) {
-            t = t.yt;
+        if (t.jt) {
+            t = t.Pt;
             continue;
         }
         if (t.it) {
@@ -2721,12 +2756,12 @@ function releaseSubtree(e) {
             if (e.L & REACTIVE_SNAPSHOT_STALE) {
                 e.L &= ~REACTIVE_SNAPSHOT_STALE;
                 e.L |= REACTIVE_DIRTY;
-                if (dirtyQueue.H > e.At) dirtyQueue.H = e.At;
+                if (dirtyQueue.H > e.Nt) dirtyQueue.H = e.Nt;
                 insertIntoHeap(e, dirtyQueue);
             }
         }
         releaseSubtree(t);
-        t = t.yt;
+        t = t.Pt;
     }
 }
 
@@ -2752,7 +2787,7 @@ function recompute(e, t = false) {
         if (e.O && (!n || activeTransition) && activeTransition !== e.O) globalQueue.initTransition(e.O);
         deleteFromHeap(e, queueFor(e));
         if (e.o !== null) {
-            e.o.wt = null;
+            e.o.bt = null;
             // Supersede is where an iterator flight dies (#3122): close it now.
             // Its cleanup(close) registration may sit in a zombie-deferred
             // disposal list that a held transition only drains when the
@@ -2761,30 +2796,30 @@ function recompute(e, t = false) {
                         releaseFlightTeardown(e);
         }
         // Tracked effects run after finalizePureQueue, so dispose immediately instead of deferring
-                if (e.O || n === EFFECT_TRACKED) disposeChildren(e); else if (e.vt !== null || e.Gt !== null) {
+                if (e.O || n === EFFECT_TRACKED) disposeChildren(e); else if (e.wt !== null || e.xt !== null) {
             markDisposal(e);
             const t = ext(e);
-            t.ct = e.Gt;
-            t.ft = e.vt;
-            e.Gt = null;
-            e.vt = null;
-            e.Pt = 0;
+            t.Et = e.xt;
+            t.dt = e.wt;
+            e.xt = null;
+            e.wt = null;
+            e.Dt = 0;
         } else ;
     }
     let i = !!(e.L & REACTIVE_OPTIMISTIC_DIRTY);
     const r = (e.D & CONFIG_OPTIMISTIC) !== 0 && e.o?.m !== NOT_PENDING && e.o?.m !== undefined;
-    const o = !!(e.lt & STATUS_UNINITIALIZED);
+    const o = !!(e.ct & STATUS_UNINITIALIZED);
     // Outgoing error, captured before the compute clears status: if this run
     // recovers to an unchanged value, dependents still holding this object must
     // be swept (settleErroredDependents, #2949).
-        const s = e.lt & STATUS_ERROR ? e.o?.ze : undefined;
+        const s = e.ct & STATUS_ERROR ? e.o?.ze : undefined;
     // Pending SOURCE-hood, captured before the compute clears status: a node
     // whose own flight parked dependents self-registers in _pendingSources
     // (notifyStatus, isSource). If this recompute supersedes that flight and
     // settles synchronously, those dependents settle HERE — asyncWrite's
     // settlePendingSource walk never runs for a landing that was preempted
     // (#3181).
-        const u = (e.lt & STATUS_PENDING) !== 0 && e.o?.Et?.has(e) === true;
+        const u = e.o?.Tt?.has(e);
     // Re-ask classification lives in the verdict module; capture the flag before
     // the recompute wipes _flags below.
         const l = (e.L & REACTIVE_REASK) !== 0;
@@ -2792,15 +2827,15 @@ function recompute(e, t = false) {
     // is transition-held below, the window must stay open until the hold
     // commits (commitPendingNode) — a closed window plus a held value reads as
     // a pending frame to live observers of the verdict (#2990).
-        const f = e.ut;
+        const f = e.lt;
     const c = context;
     context = e;
     e.le = null;
     e.nt++;
     e.L = REACTIVE_RECOMPUTING_DEPS;
     e.Z = clock;
-    let a = e.B === NOT_PENDING ? e.ot : e.B;
-    let d = e.At;
+    let a = e.$ === NOT_PENDING ? e.ot : e.$;
+    let d = e.Nt;
     let p = false;
     let E = tracking;
     let S = currentOptimisticLane;
@@ -2817,7 +2852,7 @@ function recompute(e, t = false) {
     // engine-driven paths, and _optimisticNodes is only pushed by
     // _optimisticWrite, so the hook is installed whenever either gate holds.
         if (i) {
-        const t = GlobalQueue.$e(e, true);
+        const t = GlobalQueue.Be(e, true);
         if (t) currentOptimisticLane = t;
         // `false` = wake-only lane demotion: recompute plain so a mid-tick
         // latest()/isPending() pull stages instead of direct-committing (#3009).
@@ -2827,7 +2862,7 @@ function recompute(e, t = false) {
         // Lane adoption: parent-deeper-than-owned-child can run before its OPT-dirty
         // child propagates. Walk deps once and inherit the OPT lane so this node
         // recomputes under the right posture and propagates correctly.
-        const t = GlobalQueue.$e(e, false);
+        const t = GlobalQueue.Be(e, false);
         if (t) {
             i = true;
             currentOptimisticLane = t;
@@ -2839,39 +2874,39 @@ function recompute(e, t = false) {
     try {
         if (!false && e.D & CONFIG_SYNC) {
             a = e.it(a);
-            if (e.o !== null) e.o.wt = null;
-            e.ut = false;
+            if (e.o !== null) e.o.bt = null;
+            e.lt = false;
         } else {
             // Snapshot `_inFlight` so we can detect whether `_fn` self-registered an async
             // subscription (e.g. `createProjection` calls `handleAsync` from inside its body
             // with a setter callback). In that case, the outer `handleAsync` call below would
             // clobber the fresh subscription, so we skip it and let the internally-registered
             // iteration drive updates.
-            const t = e.o?.wt;
+            const t = e.o?.bt;
             const n = e.it(a);
             const i = typeof n === "object" && n !== null;
-            const r = e.o?.wt !== t;
+            const r = e.o?.bt !== t;
             a = r || !i ? n : handleAsync(e, n);
             if (!r && !i) {
-                if (e.o !== null) e.o.wt = null;
+                if (e.o !== null) e.o.bt = null;
                 // A sync (non-object) return is the first real answer; async-shaped
                 // results clear inside handleAsync at their own landing points, and a
                 // self-registered flight (inFlightChanged — projections) clears when
                 // its internal handleAsync lands.
-                                e.ut = false;
+                                e.lt = false;
             }
         }
         // On a status-free node clearStatus is a guaranteed no-op: every field
         // its body gates on is either _statusFlags or lives in the cold
         // extension — no extension, no status to clear. (_x from an unrelated
         // installer just makes clearStatus a cheap re-verified no-op.)
-                if (e.lt !== 0 || e.o !== null) clearStatus(e, t);
+                if (e.ct !== 0 || e.o !== null) clearStatus(e, t);
         // _optimisticLane is only ever assigned by engine paths (CONFIG_HAS_LANE
         // is their sticky presence mark).
                 if (e.D & CONFIG_HAS_LANE && e.o?.l) GlobalQueue.Ye(e);
     } catch (t) {
         const n = t instanceof NotReadyError;
-        if (n && e.ut) {
+        if (n && e.lt) {
             // Loading window with an unready sync dependency: register for the
             // source's settle (the settlePendingSource walk runs off
             // _pendingSources + _blocked alone) but take NO read-visible pending
@@ -2883,13 +2918,16 @@ function recompute(e, t = false) {
         } else {
             // Track pending async in the lane (not the lane's source — it creates the lane
             // but doesn't belong to it). Set lane BEFORE notifyStatus for downstream propagation.
-            if (n && currentOptimisticLane) GlobalQueue.Be(e);
+            if (n && currentOptimisticLane) GlobalQueue.$e(e);
             let i = false;
             if (n) {
-                ext(e).Ut = true;
+                ext(e).Vt = true;
                 if (GlobalQueue.De !== null) i = GlobalQueue.De(e, l);
             }
             notifyStatus(e, n ? STATUS_PENDING : STATUS_ERROR, t, undefined, n ? e.o?.l : undefined);
+            // The replacement source is fully propagated now. If no new flight
+            // re-owned self, retire the superseded flight and its dependent copies.
+                        if (n && u && !e.o?.bt) settlePendingSource(e);
             if (i) GlobalQueue.Ge(e);
         }
     } finally {
@@ -2907,10 +2945,10 @@ function recompute(e, t = false) {
     }
     if (!e.o?.ze) {
         trimStaleDeps(e);
-        const l = r ? unwrapOverride(e.o?.m) : e.B === NOT_PENDING ? e.ot : e.B;
+        const l = r ? unwrapOverride(e.o?.m) : e.$ === NOT_PENDING ? e.ot : e.$;
         let c = false;
         try {
-            c = !n && o || !e.Vt || !e.Vt(l, a);
+            c = !n && o || !e.Wt || !e.Wt(l, a);
         } catch (t) {
             // A throwing user comparator is an error of this node's computation.
             // Route it through the same status path as a compute-phase throw so
@@ -2927,7 +2965,7 @@ function recompute(e, t = false) {
             e.st = !e.o?.ze;
             // Reuse one bound runner per effect — runEffect no-ops on a stale
             // `_modified`, so re-enqueueing the same function is harmless.
-                        if (!t) e.Tt.enqueue(n, e.jt ??= GlobalQueue._e.bind(null, e));
+                        if (!t) e.At.enqueue(n, e.Mt ??= GlobalQueue._e.bind(null, e));
         }
         if (e.o?.ze) ; else if (c) {
             const o = r ? e.o?.m : undefined;
@@ -2948,13 +2986,13 @@ function recompute(e, t = false) {
                 // commit can't clobber the fresh value.
                                 if (r && i) {
                     ext(e).m = a === undefined ? OVERRIDE_UNDEFINED : a;
-                    e.B = NOT_PENDING;
+                    e.$ = NOT_PENDING;
                 }
             } else {
-                e.B = a;
+                e.$ = a;
                 // A window landing that gets held re-opens the window until the hold
                 // commits — the verdict's held-value branch is window-gated (#2990).
-                                if (f) e.ut = true;
+                                if (f) e.lt = true;
                 // 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
@@ -2964,14 +3002,14 @@ function recompute(e, t = false) {
             }
             // insertSubs only walks _subs (no scheduling of its own), so a
             // subscriber-less node has nothing to notify.
-                        if (e.$ !== null && (!r || i || e.o?.m !== o)) insertSubs(e, i || r);
+                        if (e.B !== null && (!r || i || e.o?.m !== o)) insertSubs(e, i || r);
         } else if (r) {
             // 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.B === NOT_PENDING) queuePendingNode(e);
-            e.B = a;
-            if (f) e.ut = true;
+            if (e.$ === NOT_PENDING) queuePendingNode(e);
+            e.$ = a;
+            if (f) e.lt = true;
  // see the held branch above (#2990)
             // A authoritative-view reader (until()) observed this node past its
             // override — and "authoritative arrival equal to the override" is
@@ -2979,8 +3017,8 @@ function recompute(e, t = false) {
             // A17 silence holds for every ordinary subscriber. (Hook installed by
             // until(), the only setter of the gating bit.)
                         if (e.D & CONFIG_AUTHORITATIVE_OBSERVED) GlobalQueue.Ke(e);
-        } else if (e.At != d) {
-            for (let t = e.$; t !== null; t = t.fe) {
+        } else if (e.Nt != d) {
+            for (let t = e.B; t !== null; t = t.fe) {
                 insertIntoHeapHeight(t.ce, queueFor(t.ce));
             }
         }
@@ -2990,26 +3028,19 @@ function recompute(e, t = false) {
         // recoveries ride insertSubs above; a comparator throw re-errored the node
         // (el._x?._error re-set), so this only runs on a genuinely clean recovery.
                 if (s !== undefined && !c && !e.o?.ze) settleErroredDependents(e, s);
-        // Pending twin of the sweep above (#3181): a flight superseded by this
-        // synchronous settle leaves every registered dependent still flagged
-        // STATUS_PENDING with a pending source that will never land — asyncWrite
-        // owns the walk only for flights that actually land. An unchanged value
-        // is the dangerous shape (a projection reconciling in place: a memo over
-        // it re-throws its cached NotReadyError forever, and every reader that
-        // suspended through that memo re-parks on the dead source), but the walk
-        // runs on the changed shape too, exactly as the landing path does —
-        // insertSubs notifies value SUBSCRIBERS, not pending REGISTRANTS, and
-        // the two sets only partially overlap.
-                if (u && !(e.lt & STATUS_PENDING)) settlePendingSource(e);
+        // #3181: a synchronous settle supersedes the old landing callback, so
+        // recompute owns its pending-source sweep. An uninitialized node without
+        // a replacement source still has no truth to reveal and must stay parked.
+                if (u && !(e.ct & (STATUS_PENDING | STATUS_UNINITIALIZED))) settlePendingSource(e);
     }
     currentOptimisticLane = S;
-    const A = e.B !== NOT_PENDING || e.o !== null && (e.o.ft !== null || e.o.ct !== null) || (e.lt & (STATUS_PENDING | STATUS_UNINITIALIZED)) !== 0;
+    const A = e.$ !== NOT_PENDING || e.o !== null && (e.o.dt !== null || e.o.Et !== null) || (e.ct & (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.
-        A && (!t || e.lt & STATUS_PENDING) && (!e.O || r) && queuePendingNode(e);
+        A && (!t || e.ct & STATUS_PENDING) && (!e.O || r) && queuePendingNode(e);
     e.O && n && activeTransition !== e.O && runInTransition(e.O, () => recompute(e));
     // Missed-wake reschedule (see the finally above): values this pass read
     // before the nested commit are stale, so run again now that the heap will
@@ -3033,7 +3064,7 @@ function updateIfNecessary(e) {
     if (e.L & REACTIVE_CHECK) {
         for (let t = e.oe; t; t = t.se) {
             const n = t.ue;
-            const i = n.St || n;
+            const i = n._t || n;
             if (i.it) {
                 updateIfNecessary(i);
             }
@@ -3042,7 +3073,7 @@ function updateIfNecessary(e) {
             }
         }
     }
-    if (e.L & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY) || e.o?.ze && e.Z < clock && !e.o?.wt) {
+    if (e.L & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY) || e.o?.ze && e.Z < clock && !e.o?.bt) {
         recompute(e);
     }
     e.L = e.L & (REACTIVE_SNAPSHOT_STALE | REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT);
@@ -3056,34 +3087,34 @@ function computed(e, t) {
         const i = t !== null && typeof t === "object" && "loadingValue" in t;
     const r = {
         id: inheritId(t, n, context),
-        D: (n ? CONFIG_TRANSPARENT : 0) | (t?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (!context || t?.lazy ? CONFIG_AUTO_DISPOSE : 0) | (t?.sync ? CONFIG_SYNC : 0) | (t?.Mt ? CONFIG_NO_SNAPSHOT : 0) | (snapshotCaptureActive && ownerInSnapshotScope(context) ? CONFIG_IN_SNAPSHOT_SCOPE : 0),
-        Vt: t?.equals ?? isEqual,
-        Gt: null,
-        Tt: context?.Tt ?? globalQueue,
-        kt: context?.kt ?? defaultContext,
-        Pt: 0,
+        D: (n ? CONFIG_TRANSPARENT : 0) | (t?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (!context || t?.lazy ? CONFIG_AUTO_DISPOSE : 0) | (t?.sync ? CONFIG_SYNC : 0) | (t?.qt ? CONFIG_NO_SNAPSHOT : 0) | (snapshotCaptureActive && ownerInSnapshotScope(context) ? CONFIG_IN_SNAPSHOT_SCOPE : 0),
+        Wt: t?.equals ?? isEqual,
+        xt: null,
+        At: context?.At ?? globalQueue,
+        Ft: context?.Ft ?? defaultContext,
+        Dt: 0,
         it: e,
         ot: i ? t.loadingValue : undefined,
-        At: 0,
-        Rt: undefined,
-        It: null,
+        Nt: 0,
+        gt: undefined,
+        Ct: null,
         oe: null,
         le: null,
         nt: 0,
-        $: null,
-        Ft: null,
+        B: null,
+        Ut: null,
         pe: context,
-        yt: null,
-        bt: null,
-        vt: null,
+        Pt: null,
+        Gt: null,
+        wt: null,
         L: t?.lazy ? REACTIVE_LAZY : REACTIVE_NONE,
         // A loadingValue node is born committed: commit #0 is already in _value.
-        lt: i ? 0 : STATUS_UNINITIALIZED,
+        ct: i ? 0 : STATUS_UNINITIALIZED,
         Z: clock,
-        B: NOT_PENDING,
+        $: NOT_PENDING,
         O: null,
         Je: -1,
-        ut: i,
+        lt: i,
         // Cold machinery (async/transition/optimistic/verdict slots) lives one
         // hop away in the lazily-allocated extension — the core literal MUST
         // stay under V8's in-object boundary (§12: past ~39 fields every
@@ -3107,18 +3138,18 @@ function computed(e, t) {
         R: undefined,
         i: undefined,
         K: 0,
-        wt: null,
-        Lt: null,
+        bt: null,
+        Qt: null,
         ze: undefined,
-        Ut: undefined,
-        Et: undefined,
-        qt: undefined,
-        Qt: false,
-        Ct: null,
+        Vt: undefined,
+        Tt: undefined,
+        Bt: undefined,
+        ut: false,
+        vt: null,
         Y: undefined,
         et: undefined,
-        ct: null,
-        ft: null,
+        Et: null,
+        dt: null,
         $t: undefined
     };
 }
@@ -3132,38 +3163,38 @@ function computed(e, t) {
     const o = r?.transparent ?? false;
     const s = {
         id: inheritId(r, o, context),
-        D: (o ? CONFIG_TRANSPARENT : 0) | (r?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (r?.sync ? CONFIG_SYNC : 0) | (r?.Bt ?? 0) | (snapshotCaptureActive && ownerInSnapshotScope(context) ? CONFIG_IN_SNAPSHOT_SCOPE : 0),
-        Vt: false,
-        Gt: null,
-        Tt: context?.Tt ?? globalQueue,
-        kt: context?.kt ?? defaultContext,
-        Pt: 0,
+        D: (o ? CONFIG_TRANSPARENT : 0) | (r?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (r?.sync ? CONFIG_SYNC : 0) | (r?.Kt ?? 0) | (snapshotCaptureActive && ownerInSnapshotScope(context) ? CONFIG_IN_SNAPSHOT_SCOPE : 0),
+        Wt: false,
+        xt: null,
+        At: context?.At ?? globalQueue,
+        Ft: context?.Ft ?? defaultContext,
+        Dt: 0,
         it: e,
         ot: undefined,
-        At: 0,
-        Rt: undefined,
-        It: null,
+        Nt: 0,
+        gt: undefined,
+        Ct: null,
         oe: null,
         le: null,
         nt: 0,
-        $: null,
-        Ft: null,
+        B: null,
+        Ut: null,
         pe: context,
-        yt: null,
-        bt: null,
-        vt: null,
+        Pt: null,
+        Gt: null,
+        wt: null,
         L: REACTIVE_LAZY,
-        lt: STATUS_UNINITIALIZED,
+        ct: STATUS_UNINITIALIZED,
         Z: clock,
-        B: NOT_PENDING,
+        $: NOT_PENDING,
         O: null,
         Je: -1,
-        ut: false,
+        lt: false,
         st: false,
-        Kt: undefined,
-        Yt: t,
-        Zt: n,
-        Dt: undefined,
+        Yt: undefined,
+        Zt: t,
+        zt: n,
+        kt: undefined,
         ae: i,
         o: null
     };
@@ -3193,7 +3224,7 @@ function setEffectStatusNotify(e) {
  * the field) fall back to the shared notifier. Presence doubles as the
  * "display consumer" membership test in the status walks, exactly as the
  * per-node field did when every effect carried one. */ function statusNotifierOf(e) {
-    const t = e.o?.qt;
+    const t = e.o?.Bt;
     if (t !== undefined) return t;
     return e.ae ? effectStatusNotify ?? undefined : undefined;
 }
@@ -3203,23 +3234,23 @@ const lazyOptions = {
 };
 
 function setupComputedNode(e, t) {
-    e.It = e;
-    const n = context?.Ot ? context.Nt : context;
+    e.Ct = e;
+    const n = context?.It ? context.Rt : context;
     if (context) {
-        const t = context.vt;
+        const t = context.wt;
         if (t === null) {
-            context.vt = e;
+            context.wt = e;
         } else {
-            e.yt = t;
-            t.bt = e;
-            context.vt = e;
+            e.Pt = t;
+            t.Gt = e;
+            context.wt = e;
         }
     }
-    if (n) e.At = n.At + 1;
+    if (n) e.Nt = n.Nt + 1;
     if (GlobalQueue.Re !== null) GlobalQueue.Re(e);
     !t?.lazy && recompute(e, true);
     if (snapshotCaptureActive && !t?.lazy) {
-        if (!(e.lt & STATUS_PENDING) && !(e.D & CONFIG_NO_SNAPSHOT)) {
+        if (!(e.ct & STATUS_PENDING) && !(e.D & CONFIG_NO_SNAPSHOT)) {
             ext(e).et = e.ot === undefined ? NO_SNAPSHOT : e.ot;
             e.D |= CONFIG_HAS_SNAPSHOT;
             snapshotSources.add(e);
@@ -3229,15 +3260,15 @@ function setupComputedNode(e, t) {
 
 function signal(e, t, n = null) {
     const i = {
-        Vt: t?.equals ?? isEqual,
-        D: (t?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (t?.Mt ? CONFIG_NO_SNAPSHOT : 0),
+        Wt: t?.equals ?? isEqual,
+        D: (t?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (t?.qt ? CONFIG_NO_SNAPSHOT : 0),
         ot: e,
-        $: null,
-        Ft: null,
+        B: null,
+        Ut: null,
         Z: clock,
-        St: n,
-        gt: n?.o?.Ct || null,
-        B: NOT_PENDING,
+        _t: n,
+        yt: n?.o?.vt || null,
+        $: NOT_PENDING,
         // Signal-literal diet (§12e): NO _time/_fn/_statusFlags slots. Stores
         // materialize one signal per touched leaf, so signal bytes are store
         // bytes. _time is write-only on signals (every read site is computed-
@@ -3249,10 +3280,10 @@ function signal(e, t, n = null) {
     };
     if (t?.unobserved) ext(i).Y = t.unobserved;
     if (n) {
-        ext(n).Ct = i;
+        ext(n).vt = i;
         n.D |= CONFIG_FW_CHILDREN;
     }
-    if (snapshotCaptureActive && !(i.D & CONFIG_NO_SNAPSHOT) && !((n?.lt ?? 0) & STATUS_PENDING)) {
+    if (snapshotCaptureActive && !(i.D & CONFIG_NO_SNAPSHOT) && !((n?.ct ?? 0) & STATUS_PENDING)) {
         ext(i).et = e === undefined ? NO_SNAPSHOT : e;
         i.D |= CONFIG_HAS_SNAPSHOT;
         snapshotSources.add(i);
@@ -3354,7 +3385,7 @@ function isEqual(e, t) {
  * Pay-for-use: reached through GlobalQueue._notifyAuthoritativeObservers,
  * installed at first until() call — apps that never use until() shake it.
  */ function notifyAuthoritativeObservers(e) {
-    for (let t = e.$; t !== null; t = t.fe) {
+    for (let t = e.B; t !== null; t = t.fe) {
         const e = t.ce;
         if (!(e.D & CONFIG_AUTHORITATIVE_READ)) continue;
         // Missed-wake latch (#3037), same contract as insertSubs: the reader may
@@ -3374,15 +3405,15 @@ function isEqual(e, t) {
 }
 
 function readNodeFast(e) {
-    if (latestReadActive || pendingCheckActive || e.it || e.St || e.o?.m !== undefined || e.o?.et !== undefined || activeTransition !== null || currentOptimisticLane !== null || snapshotCaptureActive || false) return READ_SLOW;
+    if (latestReadActive || pendingCheckActive || e.it || e._t || e.o?.m !== undefined || e.o?.et !== undefined || activeTransition !== null || currentOptimisticLane !== null || snapshotCaptureActive || false) return READ_SLOW;
     let t = context;
-    if (t?.Ot) t = t.Nt;
+    if (t?.It) t = t.Rt;
     if (t && tracking) link(e, t);
     // Children-forbidden readers (createTrackedEffect / onSettled callbacks) get
     // committed visibility: like the effect half of createEffect and event
     // handlers, effect-phase code never observes its own unsettled write — the
     // write lands in the same flush's continuation (#3006).
-        return !t || e.B === NOT_PENDING || t.D & CONFIG_CHILDREN_FORBIDDEN ? e.ot : e.B;
+        return !t || e.$ === NOT_PENDING || t.D & CONFIG_CHILDREN_FORBIDDEN ? e.ot : e.$;
 }
 
 function read(e) {
@@ -3392,9 +3423,9 @@ function read(e) {
     // than the original node (which stays "pending" while held in a transition).
     if (latestReadActive) return GlobalQueue.Pe(e);
     let t = context;
-    if (t?.Ot) t = t.Nt;
+    if (t?.It) t = t.Rt;
     const n = e;
-    const i = e.St;
+    const i = e._t;
     const r = i || e;
     // Handle isPending() mode: collect pending state while preserving normal read semantics.
     // Probe mode is suspended while preparing the node so nested reads during a
@@ -3407,13 +3438,13 @@ function read(e) {
     if (!n.it && r === e && e.o?.m === undefined && e.o?.et === undefined && activeTransition === null && currentOptimisticLane === null && !snapshotCaptureActive && true) {
         if (t && tracking) link(e, t);
         // Committed visibility for children-forbidden readers — see readNodeFast.
-                return !t || e.B === NOT_PENDING || t.D & CONFIG_CHILDREN_FORBIDDEN ? e.ot : e.B;
+                return !t || e.$ === NOT_PENDING || t.D & CONFIG_CHILDREN_FORBIDDEN ? e.ot : e.$;
     }
     if (t && tracking) {
         link(e, t, pendingCheckActive);
         if (r.it) {
             const n = queueFor(e);
-            if (r.At >= n.H) {
+            if (r.Nt >= n.H) {
                 markNode(t);
                 markHeap(n);
                 updateIfNecessary(r);
@@ -3425,14 +3456,14 @@ function read(e) {
             // node no-ops and updateIfNecessary refuses disposed nodes (#2983) —
             // a dead target serves its last value, which is already quiescent.
              else if (t.D & CONFIG_FRESH_READ) updateIfNecessary(r);
-            const i = r.At;
+            const i = r.Nt;
             // parent check is shallow, might need to be recursive
-                        if (i >= t.At && e.pe !== t) {
-                t.At = i + 1;
+                        if (i >= t.Nt && e.pe !== t) {
+                t.Nt = i + 1;
             }
         }
     }
-    if (r.lt & STATUS_PENDING) {
+    if (r.ct & STATUS_PENDING) {
         if (t && !(stale && r.O && activeTransition !== r.O)) {
             // 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
@@ -3441,7 +3472,7 @@ function read(e) {
                 if (!tracking && e !== t) link(e, t);
                 throw r.o?.ze;
             }
-        } else if (t && r.lt & STATUS_UNINITIALIZED) {
+        } else if (t && r.ct & STATUS_UNINITIALIZED) {
             // A stale (render) reader of a node held pending in ANOTHER transition
             // normally keeps showing the node's committed value instead of
             // entangling the two transactions — but an uninitialized node has no
@@ -3454,7 +3485,7 @@ function read(e) {
             // never re-ran when either landed (#3043 port).
             if (!tracking && e !== t) link(e, t);
             throw r.o?.ze;
-        } else if (!t && r.lt & STATUS_UNINITIALIZED) {
+        } else if (!t && r.ct & STATUS_UNINITIALIZED) {
             throw r.o?.ze;
         }
     }
@@ -3462,7 +3493,7 @@ function read(e) {
     // firewall-backed reads follow the same rules (memo parity, #2897 ruling):
     // an errored derive throws for every late reader instead of silently
     // serving node values (the seed, or last-good data after a failed refetch).
-        if (r.it && r.lt & STATUS_ERROR) {
+        if (r.it && r.ct & 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
@@ -3476,7 +3507,7 @@ function read(e) {
         const n = e.o?.et;
         if (n !== undefined) {
             const i = n === NO_SNAPSHOT ? undefined : n;
-            const r = e.B !== NOT_PENDING ? e.B : e.ot;
+            const r = e.$ !== NOT_PENDING ? e.$ : e.ot;
             if (r !== i) t.L |= REACTIVE_SNAPSHOT_STALE;
             return i;
         }
@@ -3511,7 +3542,7 @@ function read(e) {
     // (The lane-context clause lives with the engine.) Children-forbidden readers
     // (createTrackedEffect / onSettled callbacks) get committed visibility — see
     // readNodeFast (#3006).
-        const o = !t || currentOptimisticLane !== null && GlobalQueue.Me(e, r, t) || e.B === NOT_PENDING || t.D & CONFIG_CHILDREN_FORBIDDEN || stale && e.O && activeTransition !== e.O || 
+        const o = !t || currentOptimisticLane !== null && GlobalQueue.Me(e, r, t) || e.$ === NOT_PENDING || t.D & CONFIG_CHILDREN_FORBIDDEN || stale && e.O && activeTransition !== e.O || 
     // A17 for HELD truth (#3164, see CONFIG_HELD_TRUTH): staged confirming
     // truth — fold-staged onto an armed family, or entangle-stolen by an
     // awaited until() — is masked from ordinary readers until its
@@ -3520,11 +3551,11 @@ function read(e) {
     // compose override + staged truth into a state no timeline contains).
     // Authoritative readers (until()'s predicate) and latest() see the
     // staged truth — the tunnel that keeps the hold deadlock-free.
-    e.D & CONFIG_HELD_TRUTH && !latestReadActive && !(t.D & CONFIG_AUTHORITATIVE_READ) ? e.ot : e.B;
+    e.D & CONFIG_HELD_TRUTH && !latestReadActive && !(t.D & CONFIG_AUTHORITATIVE_READ) ? e.ot : e.$;
     // 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.me(e, o);
-    if (!t && r === e && typeof n.it === "function" && e.D & CONFIG_AUTO_DISPOSE && !(r.lt & STATUS_PENDING) && !e.$) {
+    if (!t && r === e && typeof n.it === "function" && e.D & CONFIG_AUTO_DISPOSE && !(r.ct & STATUS_PENDING) && !e.B) {
         // Deferred, not inline (#3078): an inline unobserved() here made untracked
         // reads destructive — dispose on this read, full revival recompute on the
         // next — so consecutive reads could answer differently with no write in
@@ -3545,15 +3576,15 @@ function setSignal(e, t) {
     // always-present config instead of a missing-property probe), and every
     // module that installs one installs the engine first.
         if (e.D & CONFIG_OPTIMISTIC && !projectionWriteActive) return GlobalQueue.Fe(e, t);
-    const n = e.B === NOT_PENDING ? e.ot : e.B;
+    const n = e.$ === NOT_PENDING ? e.ot : e.$;
     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 i = !!(e.lt & STATUS_UNINITIALIZED) || !e.Vt || !e.Vt(n, t);
+        const i = !!(e.ct & STATUS_UNINITIALIZED) || !e.Wt || !e.Wt(n, t);
     if (!i) return t;
-    const r = e.B !== NOT_PENDING;
+    const r = e.$ !== NOT_PENDING;
     if (!r) queuePendingNode(e);
-    e.B = t;
+    e.$ = 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 and
@@ -3582,12 +3613,12 @@ function setSignal(e, t) {
  * cleanup point.
  */ function suppressComputedRecompute(e) {
     deleteFromHeap(e, queueFor(e));
-    if (!(e.L & REACTIVE_MANUAL_WRITE) && e.B === NOT_PENDING) {
+    if (!(e.L & REACTIVE_MANUAL_WRITE) && e.$ === NOT_PENDING) {
         queuePendingNode(e);
         schedule();
     }
     e.L = e.L & -4 | REACTIVE_MANUAL_WRITE;
-    e.zt = clock;
+    e.Xt = clock;
 }
 
 /**
@@ -3657,7 +3688,7 @@ function staleValues(e, t = true) {
             // refresh is a later, explicit re-ask and lifts the mask — otherwise
             // any setStore early in an action silently swallows every refresh()
             // for the rest of the transaction (#3026).
-            if (e.zt === clock) return;
+            if (e.Xt === clock) return;
             e.L &= ~REACTIVE_MANUAL_WRITE;
             // No REASK below: the batch carries a manual value change, so the
             // recompute is not a quiet re-ask of an unchanged question.
@@ -3797,7 +3828,7 @@ function enableExternalSource(e) {
     if (!t) {
         throw new NoOwnerError;
     }
-    const n = hasContext(e, t) ? t.kt[e.id] : e.defaultValue;
+    const n = hasContext(e, t) ? t.Ft[e.id] : e.defaultValue;
     if (isUndefined(n)) {
         throw new ContextNotFoundError;
     }
@@ -3818,14 +3849,14 @@ function enableExternalSource(e) {
     }
     // We're creating a new object to avoid child context values being exposed to parent owners. If
     // we don't do this, everything will be a singleton and all hell will break lose.
-        n.kt = {
-        ...n.kt,
+        n.Ft = {
+        ...n.Ft,
         [e.id]: isUndefined(t) ? e.defaultValue : t
     };
 }
 
 function hasContext(e, t) {
-    return !isUndefined(t?.kt[e.id]);
+    return !isUndefined(t?.Ft[e.id]);
 }
 
 function isUndefined(e) {
@@ -3849,14 +3880,14 @@ function isUndefined(e) {
     const n = e.o?.m !== NOT_PENDING;
     const i = n ? unwrapOverride(e.o?.m) : e.ot;
     if (typeof t === "function") t = t(i);
-    const r = !!(e.lt & STATUS_UNINITIALIZED) || 
+    const r = !!(e.ct & STATUS_UNINITIALIZED) || 
     // A dirty node's _value is stale (its queued recompute hasn't run — e.g.
     // a latest() shadow marked by the previous landing's companion snap), so
     // equality against it must not swallow the write. Without this, a sync
     // push returning the shadow to that stale value was dropped, the snap
     // recompute then committed the parent's old value, and the banner showed
     // the previous transition's target (#3041 follow-up).
-    !!((e.L ?? 0) & (REACTIVE_DIRTY | REACTIVE_CHECK)) || !e.Vt || !e.Vt(i, t);
+    !!((e.L ?? 0) & (REACTIVE_DIRTY | REACTIVE_CHECK)) || !e.Wt || !e.Wt(i, t);
     if (!r) {
         // Same-value write with an active override still entangles the current
         // action's transition — the hold must outlast all overlapping actions.
@@ -3899,7 +3930,7 @@ function isUndefined(e) {
  */ function transitionBlocked(e) {
     for (let t = 0; t < e.j.length; t++) {
         const n = e.j[t];
-        if (hasActiveOverride$1(n) && "lt" in n && n.lt & STATUS_PENDING && n.o?.ze instanceof NotReadyError) {
+        if (hasActiveOverride$1(n) && "ct" in n && n.ct & STATUS_PENDING && n.o?.ze instanceof NotReadyError) {
             return true;
         }
     }
@@ -3917,7 +3948,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.lt & STATUS_PENDING)) t.lt &= ~STATUS_UNINITIALIZED;
+                if (!(t.ct & STATUS_PENDING)) t.ct &= ~STATUS_UNINITIALIZED;
         const i = t.o?.m;
         ext(t).m = NOT_PENDING;
         if (i !== NOT_PENDING && t.ot !== unwrapOverride(i)) insertSubs(t, true);
@@ -3987,7 +4018,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.B === NOT_PENDING || e.it || t !== e && !(t.L & REACTIVE_MANUAL_WRITE)) {
+    if (latestReadActive || e.$ === NOT_PENDING || e.it || t !== e && !(t.L & REACTIVE_MANUAL_WRITE)) {
         return false;
     }
     activeTransition.ie.add(n);
@@ -3998,7 +4029,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) {
-    if (e.o?.m !== undefined || !!e.o?.l || !!(t.lt & STATUS_PENDING)) {
+    if (e.o?.m !== undefined || !!e.o?.l || !!(t.ct & STATUS_PENDING)) {
         // The committed view hides a staged in-flight value that will promote
         // silently (commitPendingNode never re-notifies). gatedRead records plain
         // signals for replay at commit; async memos are excluded from it by the
@@ -4007,7 +4038,7 @@ function cleanupCompletedLanes(e) {
         // committed value to a reader that never re-ran after the landing, so a
         // pending-gated branch stayed one value behind permanently (#3041
         // follow-up). Record the reader under the same replay contract.
-        if (e.B !== NOT_PENDING) (activeTransition ?? globalQueue.V).ie.add(n);
+        if (e.$ !== NOT_PENDING) (activeTransition ?? globalQueue.V).ie.add(n);
         return true;
     }
     if (t === e && stale && n.o?.i !== e) {
@@ -4022,7 +4053,7 @@ function cleanupCompletedLanes(e) {
         // into the transaction (#3041 follow-up: a pending-gated branch that
         // first read its async source during the landing flush stayed one value
         // behind permanently); with none, into the ambient batch.
-        if (e.B !== NOT_PENDING) (activeTransition ?? globalQueue.V).ie.add(n);
+        if (e.$ !== NOT_PENDING) (activeTransition ?? globalQueue.V).ie.add(n);
         return true;
     }
     return false;
@@ -4103,8 +4134,8 @@ function trackOptimisticStore(e) {
     GlobalQueue.We = gatedRead;
     GlobalQueue.je = laneSuspends;
     GlobalQueue.Me = laneReadsCommitted;
-    GlobalQueue.$e = recomputeLane;
-    GlobalQueue.Be = laneAsyncPending;
+    GlobalQueue.Be = recomputeLane;
+    GlobalQueue.$e = laneAsyncPending;
     GlobalQueue.Ye = laneAsyncSettled;
     GlobalQueue.Ze = trackOptimisticStore;
 }
@@ -4140,7 +4171,7 @@ let pendingProbe = null;
  * O(all-leaves-ever-read)-per-update pathology). Entries are permanent like
  * the companions themselves; a store with no leaf-level isPending()/latest()
  * reads never allocates the set or pays the walk. */ function markFirewallChildCompanions(e) {
-    const t = e.St;
+    const t = e._t;
     if (!t) return;
     t.D |= CONFIG_CHILD_COMPANIONS;
     (ext(t).$t ??= new Set).add(e);
@@ -4165,7 +4196,7 @@ function getPendingSignal(e) {
 function collectPendingSources(e) {
     if (!pendingProbe) return;
     pendingProbe.sources.add(e);
-    const t = e.St || e;
+    const t = e._t || e;
     if (t !== e) pendingProbe.sources.add(t);
 }
 
@@ -4195,10 +4226,10 @@ 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.lt & STATUS_ERROR) return false;
+        if (e.ct & STATUS_ERROR) return false;
     if (t.has(e)) return false;
     t.add(e);
-    const n = e.St;
+    const n = e._t;
     if (n && markWalk(n, t)) return true;
     // Mid-recompute (the clearStatus companion poke runs before
     // trimStaleDeps), only the validated prefix [_deps.._depsTail] is this
@@ -4208,7 +4239,7 @@ function collectPendingSources(e) {
     const r = i.L & REACTIVE_RECOMPUTING_DEPS ? i.le : undefined;
     if (r !== null) {
         for (let e = i.oe ?? null; e !== null; e = e.se) {
-            if (!e.Ht && markWalk(e.ue, t)) return true;
+            if (!e.Lt && markWalk(e.ue, t)) return true;
             if (e === r) break;
         }
     }
@@ -4220,11 +4251,11 @@ function collectPendingSources(e) {
 }
 
 function quietPending(e) {
-    if (e.o?.Et) {
-        for (const t of e.o.Et) if (!t.o?.Qt) return false;
+    if (e.o?.Tt) {
+        for (const t of e.o.Tt) if (!t.o?.ut) return false;
         return true;
     }
-    return e.o?.Qt ?? false;
+    return e.o?.ut ?? false;
 }
 
 // NOTE: a loadingValue node's open loading window (_loading) is verdict-quiet
@@ -4235,7 +4266,7 @@ function quietPending(e) {
 // verdict fully correlated with transition-class machinery and keeps server
 // (always false) and client hydration trivially consistent.
 function newQuestionInFlight(e) {
-    return !!(e.lt & STATUS_PENDING) && !(e.lt & STATUS_UNINITIALIZED) && !quietPending(e);
+    return !!(e.ct & STATUS_PENDING) && !(e.ct & STATUS_UNINITIALIZED) && !quietPending(e);
 }
 
 function computePendingState(e) {
@@ -4245,22 +4276,26 @@ function computePendingState(e) {
     // reaches its owner (and a store leaf its firewall) through its own deps,
     // so the one walk covers direct marks, derivation, and companion chains.
         if (markCovered(e)) return true;
-    const n = e.St;
+    const n = e._t;
     if (e.o?.i) {
         const t = e.o?.i;
-        const n = t.St || t;
+        const n = t._t || t;
         return newQuestionInFlight(n);
     }
-    if (n && e.B !== NOT_PENDING && !hasActiveOverride$1(e)) {
-        return !!(n.L & REACTIVE_MANUAL_WRITE) || !n.o?.wt && !(n.lt & STATUS_PENDING) || !!(n.lt & STATUS_PENDING) && quietPending(n);
+    if (n && e.$ !== NOT_PENDING && !hasActiveOverride$1(e)) {
+        return !!(n.L & REACTIVE_MANUAL_WRITE) || !n.o?.bt && !(n.ct & STATUS_PENDING) || !!(n.ct & STATUS_PENDING) && quietPending(n);
     }
     // `!comp._loading`: a hold created while the loading window is still open is
     // the window's own landing in flight to its commit — verdict-quiet like the
     // rest of the window (the UNINITIALIZED check suppresses exactly this frame
     // for windowless first loads; born-committed nodes need their own gate, #2990).
-        if (e.B !== NOT_PENDING && !(t.lt & STATUS_UNINITIALIZED) && !t.ut) {
-        if (hasActiveOverride$1(e)) return !e.Vt || !e.Vt(e.B, unwrapOverride(e.o?.m));
-        return true;
+        if (e.$ !== NOT_PENDING && !(t.ct & STATUS_UNINITIALIZED) && !t.lt) {
+        if (hasActiveOverride$1(e)) return !e.Wt || !e.Wt(e.$, unwrapOverride(e.o?.m));
+        // A quiet re-ask's held landing still answers the same question: the
+        // classification survives the landing (asyncWrite) and dies with the
+        // commit (commitPendingNode) — verdict-quiet through the reveal, like
+        // the loading window above (#3178).
+                if (!t.o?.ut) return true;
     }
     return newQuestionInFlight(t);
 }
@@ -4298,8 +4333,8 @@ function updateChildCompanions(e) {
         if (i.has(e)) return;
         i.add(e);
         if (e.o?.I || e.o?.R) n(e);
-        for (let t = e.$; t !== null; t = t.fe) visit(t.ce);
-        for (let t = e.o?.Ct ?? null; t !== null; t = t.gt) {
+        for (let t = e.B; t !== null; t = t.fe) visit(t.ce);
+        for (let t = e.o?.vt ?? null; t !== null; t = t.yt) {
             visit(t);
         }
     };
@@ -4345,16 +4380,16 @@ function snapCompanionsToState(e) {
     const t = e.o?.I;
     if (t && (t.o?.m === undefined || t.o?.m === NOT_PENDING)) {
         const n = computePendingState(e);
-        if (t.ot !== n || t.B !== NOT_PENDING) {
+        if (t.ot !== n || t.$ !== NOT_PENDING) {
             t.ot = n;
-            t.B = NOT_PENDING;
+            t.$ = NOT_PENDING;
             insertSubs(t);
             schedule();
         }
     }
     const n = e.o?.R;
     if (n && !(n.L & REACTIVE_DISPOSED)) {
-        if ((n.o?.m === undefined || n.o?.m === NOT_PENDING) && n.B === NOT_PENDING && !Object.is(n.ot, e.ot) && !(n.L & (REACTIVE_DIRTY | REACTIVE_CHECK))) {
+        if ((n.o?.m === undefined || n.o?.m === NOT_PENDING) && n.$ === NOT_PENDING && !Object.is(n.ot, e.ot) && !(n.L & (REACTIVE_DIRTY | REACTIVE_CHECK))) {
             n.L |= REACTIVE_DIRTY;
             insertIntoHeap(n, queueFor(n));
             insertSubs(n);
@@ -4391,7 +4426,7 @@ function getLatestValueComputed(e) {
         // created lazily, possibly after the write was processed — syncCompanions
         // only pushes into companions that already exist, so the first latest()
         // read inside a held transition showed the committed value (#3041).
-                if (e.B !== NOT_PENDING && !hasActiveOverride$1(e)) setSignal(t, e.B);
+                if (e.$ !== NOT_PENDING && !hasActiveOverride$1(e)) setSignal(t, e.$);
         setContextInternal(r);
         setPendingCheckActive(i);
         setLatestReadActive(n);
@@ -4412,7 +4447,7 @@ 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.At >= e.H && !(t.L & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE))) {
+        if (t.Nt >= e.H && !(t.L & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE))) {
             markHeap(e);
             // Suspend probe collection during the pull (mirrors pendingCheckRead's
             // prepare): a probe through latest() answers for the SHADOW — the
@@ -4433,12 +4468,12 @@ function getLatestValueComputed(e) {
         }
         r = read(t);
     } catch (t) {
-        if (t instanceof NotReadyError && (!context || !(e.lt & STATUS_UNINITIALIZED))) return i;
+        if (t instanceof NotReadyError && (!context || !(e.ct & STATUS_UNINITIALIZED))) return i;
         throw t;
     } finally {
         setLatestReadActive(n);
     }
-    if (t.lt & STATUS_PENDING) return i;
+    if (t.ct & STATUS_PENDING) return i;
     if (stale && currentOptimisticLane && t.o?.l) {
         const e = findLane(t.o?.l);
         const n = findLane(currentOptimisticLane);
@@ -4450,7 +4485,7 @@ 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.B !== NOT_PENDING && !hasActiveOverride$1(t) && !(stale && t.O && activeTransition !== t.O)) return t.B;
+        if (t.$ !== NOT_PENDING && !hasActiveOverride$1(t) && !(stale && t.O && activeTransition !== t.O)) return t.$;
     return r;
 }
 
@@ -4466,14 +4501,14 @@ function getLatestValueComputed(e) {
     if (typeof e.it !== "function") return false;
     const t = e.o?.i;
     if (t === undefined) return false;
-    const n = t.St || t;
-    return !(n.lt & STATUS_UNINITIALIZED);
+    const n = t._t || t;
+    return !(n.ct & STATUS_UNINITIALIZED);
 }
 
 /** The isPending()-probe read path, installed as GlobalQueue._pendingCheck. */ function pendingCheckRead(e, t, n, i) {
     setPendingCheckActive(false);
     if (typeof e.it === "function") prepareComputed(e, true);
-    const r = n.lt;
+    const r = n.ct;
     if (t && r & STATUS_PENDING && r & STATUS_UNINITIALIZED && 
     // The suspend-throw is for a genuinely-first-load source: the tracked
     // reader has nothing to pair a verdict with, so it parks on the source.
@@ -4520,24 +4555,24 @@ function getLatestValueComputed(e) {
     // writes whose source async is still computing.
         if (!t) return false;
     for (const [e, t] of n.J) {
-        if (t.size && e.lt & STATUS_PENDING && e.o?.ze?.source === e) return true;
+        if (t.size && e.ct & STATUS_PENDING && e.o?.ze?.source === e) return true;
     }
     return false;
 }
 
 function recordFreshRead(e, t) {
-    if (pendingProbe !== null && e.B !== NOT_PENDING && t === e.B) {
+    if (pendingProbe !== null && e.$ !== NOT_PENDING && t === e.$) {
         if (heldAwaitingAsync(e)) return;
         pendingProbe.freshReads.add(e);
     }
 }
 
 function applyReask(e, t) {
-    const n = !!(e.lt & STATUS_PENDING);
-    const i = t && !(n && !e.o?.Qt);
-    const r = n && (e.o?.Qt ?? false) !== i;
+    const n = !!(e.ct & STATUS_PENDING);
+    const i = t && !(n && !e.o?.ut);
+    const r = n && (e.o?.ut ?? false) !== i;
     // Allocation-free for the quiet case: false is the extension default.
-        if (i) ext(e).Qt = true; else if (e.o !== null) e.o.Qt = false;
+        if (i) ext(e).ut = true; else if (e.o !== null) e.o.ut = false;
     return r;
 }
 
@@ -4604,7 +4639,7 @@ function isPending(e) {
     } catch (e) {
         collectPending();
         if (e instanceof NotReadyError) {
-            const t = !!(e.source?.lt & STATUS_UNINITIALIZED);
+            const t = !!(e.source?.ct & STATUS_UNINITIALIZED);
             if (i.found && !t) return true;
             if (context && t) throw e;
         }
@@ -4648,15 +4683,15 @@ GlobalQueue.xe = wakeSuppressedProbes;
     const r = !!i?.user;
     const o = createEffectNode(e, t, n, r ? EFFECT_USER : EFFECT_RENDER, i);
     recompute(o, true);
-    !i?.defer && (o.ae === EFFECT_USER || i?.schedule ? o.Tt.enqueue(o.ae, runEffect.bind(null, o)) : runEffect(o));
+    !i?.defer && (o.ae === EFFECT_USER || i?.schedule ? o.At.enqueue(o.ae, 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.lt;
+    const n = e !== undefined ? e : this.ct;
     const i = t !== undefined ? t : this.o?.ze;
     if (n & STATUS_ERROR) {
-        this.Tt.notify(this, STATUS_PENDING, 0);
+        this.At.notify(this, STATUS_PENDING, 0);
         if (this.ae === 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,
@@ -4667,18 +4702,18 @@ 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.lt & STATUS_ERROR) {
+            if (this.ct & STATUS_ERROR) {
                 this.st = true;
-                this.Tt.enqueue(this.ae, this.jt ??= runEffect.bind(null, this));
+                this.At.enqueue(this.ae, this.Mt ??= runEffect.bind(null, this));
             }
             return;
         }
-        if (!this.Tt.notify(this, STATUS_ERROR, STATUS_ERROR)) {
+        if (!this.At.notify(this, STATUS_ERROR, STATUS_ERROR)) {
             haltReactivity(unwrapStatusError(i));
             throw i;
         }
     } else if (this.ae === EFFECT_RENDER) {
-        this.Tt.notify(this, STATUS_PENDING | STATUS_ERROR, n, i);
+        this.At.notify(this, STATUS_PENDING | STATUS_ERROR, n, i);
     }
 }
 
@@ -4694,41 +4729,41 @@ 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.lt & STATUS_ERROR && e.ae === EFFECT_USER) {
+        if (e.ct & STATUS_ERROR && e.ae === EFFECT_USER) {
         const t = unwrapStatusError(e.o?.ze);
-        e.Kt = e.ot;
+        e.Yt = e.ot;
         e.st = false;
         try {
-            e.Zt ? e.Zt(t, () => {
-                const t = e.Dt;
-                e.Dt = undefined;
+            e.zt ? e.zt(t, () => {
+                const t = e.kt;
+                e.kt = undefined;
                 t?.();
             }) : console.error(t);
         } catch (t) {
-            if (!e.Tt.notify(e, STATUS_ERROR, STATUS_ERROR)) {
+            if (!e.At.notify(e, STATUS_ERROR, STATUS_ERROR)) {
                 haltReactivity(t);
                 throw t;
             }
         }
         return;
     }
-    const t = e.Dt;
-    e.Dt = undefined;
+    const t = e.kt;
+    e.kt = undefined;
     try {
         t?.();
-        const n = e.Yt(e.ot, e.Kt);
+        const n = e.Zt(e.ot, e.Yt);
         if (false && n !== undefined && typeof n !== "function") ;
         // The final cleanup is invoked by disposeChildren at true disposal.
-                e.Dt = n;
+                e.kt = n;
     } catch (t) {
         ext(e).ze = new StatusError(e, t);
-        e.lt |= STATUS_ERROR;
-        if (!e.Tt.notify(e, STATUS_ERROR, STATUS_ERROR)) {
+        e.ct |= STATUS_ERROR;
+        if (!e.At.notify(e, STATUS_ERROR, STATUS_ERROR)) {
             haltReactivity(t);
             throw t;
         }
     } finally {
-        e.Kt = e.ot;
+        e.Yt = e.ot;
         e.st = false;
     }
 }
@@ -4748,24 +4783,24 @@ GlobalQueue._e = runEffect;
         } finally {}
     };
     const n = computed(() => {
-        const t = n.Dt;
-        n.Dt = undefined;
+        const t = n.kt;
+        n.kt = undefined;
         t?.();
         const i = staleValues(e);
-        n.Dt = i;
+        n.kt = i;
     }, {
         ...t,
         lazy: true
     });
-    n.Dt = undefined;
+    n.kt = undefined;
     n.D = n.D & ~CONFIG_AUTO_DISPOSE | CONFIG_CHILDREN_FORBIDDEN;
     n.st = true;
     n.ae = EFFECT_TRACKED;
     // Status dispatch rides the SHARED notifier (statusNotifierOf keys off
     // _type): its error arm is behavior-identical to the closure that used to
     // live here, without the per-node NodeExtension allocation.
-        n._t = run;
-    n.Tt.enqueue(EFFECT_USER, run);
+        n.Ot = run;
+    n.At.enqueue(EFFECT_USER, run);
 }
 
 // Install the shared effect status notifier (statusNotifierOf serves it to
@@ -4967,7 +5002,74 @@ function createMemo(e, t) {
     return accessor(computed(e, t));
 }
 
-function createEffect(e, t, n) {
+/**
+ * Creates a reactive effect with **separate compute and effect phases**.
+ *
+ * - `compute(prev)` runs reactively — *put all reactive reads here*. The
+ *   returned value is passed to `effect` and is also the new "previous" value
+ *   for the next run.
+ * - `effect(next, prev?)` runs imperatively (untracked) after the queue
+ *   flushes. *Put DOM writes / fetch / logging / subscriptions here.* It may
+ *   return a cleanup function which runs before the next effect or on
+ *   disposal.
+ *
+ * Reactive reads inside `effect` will *not* re-trigger this effect — that's
+ * intentional. If you need a single-phase tracked effect, use
+ * `createTrackedEffect` (with the tradeoffs noted there).
+ *
+ * Pass an `EffectBundle` (`{ effect, error }`) instead of a plain function to
+ * intercept **compute-phase** errors — errors thrown by `compute` or arriving
+ * from upstream reactive sources (including async rejections), which your own
+ * code has no frame to `try/catch`. The `error` handler is the error arm of
+ * the effect phase: it runs on the same schedule and in the same imperative,
+ * writable scope as `effect` (setting error state via signals is fine), and
+ * only for *settled* errors — a transient error that recovers before the
+ * effect phase runs `effect` with the recovered value instead, and a held
+ * transition defers it exactly as it defers `effect`. Without an `error`
+ * handler a compute-phase error is logged and the effect simply skips that
+ * run — a non-render effect's reactivity failing does not crash the app.
+ * Rethrowing from `error` escalates it to the nearest error boundary
+ * (halting the system if none exists).
+ *
+ * The **effect phase is different**: it is your own imperative code, so handle
+ * failures with `try/catch` where they occur. An uncaught effect-phase throw
+ * is treated as an unhandled application error — caught by the nearest
+ * `createErrorBoundary`/`<Errored>`, and permanently halting the reactive
+ * system if there is none. It is *not* routed to the bundle's `error` handler.
+ *
+ * ```typescript
+ * createEffect<T>(compute, effectFn | { effect, error }, options?: EffectOptions);
+ * ```
+ * @param compute a function that receives its previous value and returns a new value used to react on a computation
+ * @param effectFn a function that receives the new value and is used to perform side effects (return a cleanup function), or an `EffectBundle` with `effect` and `error` handlers
+ * @param options `EffectOptions` -- name, defer, schedule, transparent
+ *
+ * @example
+ * ```ts
+ * const [count, setCount] = createSignal(0);
+ *
+ * createEffect(
+ *   () => count(),                  // compute: tracks `count`
+ *   value => console.log(value)     // effect: side effect
+ * );
+ *
+ * setCount(1); // logs 1 after the next flush
+ * ```
+ *
+ * @example
+ * ```ts
+ * createEffect(
+ *   () => userId(),
+ *   id => {
+ *     const ctrl = new AbortController();
+ *     fetch(`/users/${id}`, { signal: ctrl.signal });
+ *     return () => ctrl.abort(); // cleanup before next run / disposal
+ *   }
+ * );
+ * ```
+ *
+ * @description https://docs.solidjs.com/reference/basic-reactivity/create-effect
+ */ function createEffect(e, t, n) {
     effect(e, t.effect || t, t.error, {
         user: true,
         ...n
@@ -5142,9 +5244,9 @@ function createEffect(e, t, n) {
             // route through the inherited queue.
             const r = getOwner();
             const o = new MicrotaskQueue;
-            o.pe = r.Tt;
+            o.pe = r.At;
  // notify() forwards up the normal chain
-                        r.Tt = o;
+                        r.At = o;
             // A user effect rather than a bare computed: computeds are pull-based and
             // are only re-enqueued when a pending source *resolves* — a rejection just
             // marks them errored, so nothing would re-run and the promise would never
@@ -5164,7 +5266,7 @@ function createEffect(e, t, n) {
             // stale mainline value and resolves with old data.
             {
                 user: true,
-                Bt: CONFIG_DIRECT_COMMIT
+                Kt: CONFIG_DIRECT_COMMIT
             });
         });
     });
@@ -5250,8 +5352,8 @@ function createEffect(e, t, n) {
                 if (r === null) {
                     r = getOwner();
                     const e = new MicrotaskQueue;
-                    e.pe = r.Tt;
-                    r.Tt = e;
+                    e.pe = r.At;
+                    r.At = e;
                 }
                 return read(t);
             }, t => {
@@ -5262,7 +5364,7 @@ function createEffect(e, t, n) {
                 dispose(r);
             }, {
                 user: true,
-                Bt: CONFIG_DIRECT_COMMIT | CONFIG_AUTHORITATIVE_READ | CONFIG_FRESH_READ
+                Kt: CONFIG_DIRECT_COMMIT | CONFIG_AUTHORITATIVE_READ | CONFIG_FRESH_READ
             });
             make();
         });
@@ -5347,8 +5449,8 @@ function createEffect(e, t, n) {
             // entire point of the hold.
             const u = getOwner();
             const l = new MicrotaskQueue;
-            l.pe = u.Tt;
-            u.Tt = l;
+            l.pe = u.At;
+            u.At = l;
             let f;
             let c;
             const settle = e => {
@@ -5377,7 +5479,7 @@ function createEffect(e, t, n) {
             // the hold itself is keeping uncommitted.
             {
                 user: true,
-                Bt: CONFIG_AUTHORITATIVE_READ | CONFIG_DIRECT_COMMIT
+                Kt: CONFIG_AUTHORITATIVE_READ | CONFIG_DIRECT_COMMIT
             });
             if (t?.timeout !== undefined) f = setTimeout(() => settle(() => r(new TimeoutError)), t.timeout);
             if (o !== undefined) {
@@ -5871,7 +5973,7 @@ r) {
  * flush that would surface them, before effects run — verdict-only, netting
  * no visual change.
  */ function notifyMarkBoundaries(e) {
-    if (!e.$ && !e.o?.Ct) return;
+    if (!e.B && !e.o?.vt) return;
     const t = new NotReadyError(e);
     t.Xe = true;
     const n = new Set;
@@ -6529,7 +6631,7 @@ function drainFolds() {
                 !plainProto(t.ovl ? t.v : r) ? Reflect.ownKeys(o) : e;
                 for (const e of n) {
                     const t = o[e];
-                    if (t !== undefined && t.B !== NOT_PENDING) {
+                    if (t !== undefined && t.$ !== NOT_PENDING) {
                         i = true;
                         break;
                     }
@@ -6962,7 +7064,7 @@ const UNSAFE_KEYS = new Set([ "__proto__", "prototype", "constructor" ]);
  * / onSettled callbacks) get COMMITTED visibility (#3006), same as core. */ function inOwnerContext() {
     const e = getOwner();
     if (e === null) return false;
-    const t = e.Ot ? e.Nt : e;
+    const t = e.It ? e.Rt : e;
     return t != null && !(t.D & CONFIG_CHILDREN_FORBIDDEN);
 }
 
@@ -6973,7 +7075,7 @@ const UNSAFE_KEYS = new Set([ "__proto__", "prototype", "constructor" ]);
  * committed to them regardless of staged writes. */ function inForbiddenScope() {
     const e = getOwner();
     if (e === null) return false;
-    const t = e.Ot ? e.Nt : e;
+    const t = e.It ? e.Rt : e;
     return t != null && !!(t.D & CONFIG_CHILDREN_FORBIDDEN);
 }
 
@@ -6984,7 +7086,7 @@ const UNSAFE_KEYS = new Set([ "__proto__", "prototype", "constructor" ]);
     if (t === null) return false;
     for (const e of Reflect.ownKeys(t)) {
         const n = t[e];
-        if (n.B !== NOT_PENDING && n.O != null && n.O.P !== true) return true;
+        if (n.$ !== NOT_PENDING && n.O != null && n.O.P !== true) return true;
     }
     return false;
 }
@@ -6998,28 +7100,39 @@ function readSource(e) {
         const t = heldMaskView(e);
         if (t !== null) return t;
     }
-    // Signal-parity visibility (core read(): owner-context reads serve
-    // _pendingValue, context-free reads serve committed — effects recompute
-    // BEFORE commitPendingNodes in the flush, so the pending view must be
-    // servable). Drafts (setter window OR projection write-override) and
-    // owner-context reads see the pending backing; context-free reads see
-    // committed. Node reads apply the same rule, so both homes agree.
-        if (e.pb !== null && (inDraft(e) || getWriteOverride() || 
-    // Owner-context readers see the pending backing — EXCEPT held truth
-    // on an optimistic family (#3164 fold): a live pb on an opt family
-    // outside the draft/write-override windows is a staged landing
-    // (tentative drafts never outlive their setter), and only the
-    // authoritative postures and latest() see it (the backing-level twin
-    // of core read()'s A17-for-held-truth arm; ordinary readers keep
-    // committed until the transaction's reveal).
-    inOwnerContext() && !heldTruthMasked(e) || 
+    return pendingBackingVisible(e, false) ? e.pb : e.v;
+}
+
+/** The single pb-vs-committed visibility decision (#3147), shared by per-key
+ * backing reads (readSource) and deep()/snapshot composition (snapshotWalk)
+ * so the two reader families can never disagree about a HELD landing.
+ *
+ * Signal-parity visibility (core read(): owner-context reads serve
+ * _pendingValue, context-free reads serve committed — effects recompute
+ * BEFORE commitPendingNodes in the flush, so the pending view must be
+ * servable). Drafts (setter window OR projection write-override) and
+ * owner-context reads see the pending backing; context-free reads see
+ * committed. Node reads apply the same rule, so all homes agree.
+ *
+ * `speculative` is deep()/snapshot's posture: an untrack/deep PEEK that sees
+ * ordinary pending staging regardless of owner context (the documented
+ * divergence from context-free per-key reads) — but never through a hold:
+ * held truth stays masked exactly as it is for per-key readers. */ function pendingBackingVisible(e, t) {
+    return e.pb !== null && (inDraft(e) || getWriteOverride() || 
+    // Owner-context (and speculative-peek) readers see the pending
+    // backing — EXCEPT held truth on an optimistic family (#3164 fold):
+    // a live pb on an opt family outside the draft/write-override windows
+    // is a staged landing (tentative drafts never outlive their setter),
+    // and only the authoritative postures and latest() see it (the
+    // backing-level twin of core read()'s A17-for-held-truth arm;
+    // ordinary readers keep committed until the transaction's reveal).
+    (t || inOwnerContext()) && !heldTruthMasked(e) || 
     // A projection's pending backing is authoritative-elect: serve it to
     // context-free readers too UNLESS a transition is holding the node
     // commits (downstream async hold — stale committed is the contract)
     // or the reader is a CHILDREN_FORBIDDEN scope, which never observes
     // its own unsettled write (#3082, signal parity per #3006).
-    e.fam !== null && !heldTruthMasked(e) && !foldHeld(e) && !inForbiddenScope())) return e.pb;
-    return e.v;
+    e.fam !== null && !heldTruthMasked(e) && !foldHeld(e) && !inForbiddenScope());
 }
 
 /** #3164 fold: HELD truth on an optimistic family — a pending backing
@@ -7099,14 +7212,14 @@ function isOwnAccessor(e, t) {
     // Authoritative-view reads (until()'s predicate) skip the override arm
     // only: staged pending values are authoritative, overrides are the
     // caller's optimism.
-    const n = !authoritativeServe() && hasActiveOverride(e) ? unwrapOverride(e.o?.m) : e.B !== NOT_PENDING && (latestReadActive || 
+    const n = !authoritativeServe() && hasActiveOverride(e) ? unwrapOverride(e.o?.m) : e.$ !== NOT_PENDING && (latestReadActive || 
     // Owner-context pending visibility — except HELD truth (#3164,
     // see CONFIG_HELD_TRUTH: fold-staged or entangle-stolen
     // confirming truth), which only authoritative/latest readers
     // see (core read()'s A17-for-held-truth twin; ordinary readers
     // keep committed until the transaction's reveal — latest() is
     // exempted by the leading arm above).
-    (inOwnerContext() || authoritativeServe()) && !(e.D & CONFIG_HELD_TRUTH && !authoritativeServe())) ? e.B : t;
+    (inOwnerContext() || authoritativeServe()) && !(e.D & CONFIG_HELD_TRUTH && !authoritativeServe())) ? e.$ : t;
     return n === FORCE ? t : n;
 }
 
@@ -7197,7 +7310,7 @@ function isOwnAccessor(e, t) {
     // proj R23); the derive is the author.
     if (projectionWriteActive || getWriteOverride()) return;
     const t = e.fam?.node;
-    if (t != null && t.lt & (STATUS_UNINITIALIZED | STATUS_ERROR)) read(t);
+    if (t != null && t.ct & (STATUS_UNINITIALIZED | STATUS_ERROR)) read(t);
 }
 
 /** latest() pull (#3075): bring the projection computed up to date so the
@@ -7696,12 +7809,17 @@ function snapshotWalk(e, t, n) {
         if (e === undefined) break;
         if (e.fam !== null) n = e.fam;
         if (e.fam?.opt === true) (r ??= []).push(e);
+        // The shared visibility decision (#3147): the speculative peek serves
+        // pending staging, but a HELD landing is masked to committed exactly as
+        // it is for per-key readers — the two families must answer alike while
+        // a transaction holds store landings.
+                const t = pendingBackingVisible(e, true);
         // Snapshot runs mid-flush (tracked memos execute before commit), so a
         // pending prototype overlay must present as a REAL merged container.
-                if (e.ovl) materializePB(e);
-        const t = e.pb ?? e.v;
-        if (t === i) break;
-        i = t;
+                if (t && e.ovl) materializePB(e);
+        const o = t ? e.pb : e.v;
+        if (o === i) break;
+        i = o;
     }
     if (!isWrappable(i)) return i;
     // Optimistic families: compose the visible view; a composed view is a fresh
@@ -8469,8 +8587,8 @@ function runProjectionComputedNext(e, t, n, i, r) {
     // for the whole first flight — the derive works a detached shadow of the
     // seed so draft writes cannot tear through to readers (#2988). Every commit
     // point reconciles the shadow through the normal commit path.
-        const l = o.ut ? JSON.parse(JSON.stringify(e[$TARGET][STORE_VALUE])) : null;
-    const f = wrapDraft(e, () => !s || o.o?.wt === u, r);
+        const l = o.lt ? JSON.parse(JSON.stringify(e[$TARGET][STORE_VALUE])) : null;
+    const f = wrapDraft(e, () => !s || o.o?.bt === u, r);
     storeSetterNext(f, r => {
         u = t(l ?? r);
         s = true;
@@ -8484,7 +8602,7 @@ function runProjectionComputedNext(e, t, n, i, r) {
             i ? i(write, t) : write();
         };
         const f = handleAsync(o, u, commit);
-        if (!o.ut) commit(f);
+        if (!o.lt) commit(f);
     }, false);
     return o;
 }
@@ -8577,8 +8695,8 @@ const UNSET = Symbol();
                 i ??= n;
                 const r = new StatusError(i, e);
                 ext(i).ze = r;
-                i.lt = (i.lt ?? 0) | STATUS_ERROR;
-                t = n.Tt.notify(i, STATUS_ERROR, STATUS_ERROR, r);
+                i.ct = (i.ct ?? 0) | STATUS_ERROR;
+                t = n.At.notify(i, STATUS_ERROR, STATUS_ERROR, r);
             }
             if (!t && r === UNSET) r = e;
         }
@@ -9164,14 +9282,22 @@ function installNextBlockedHalf() {
     const e = GlobalQueue.Ue;
     GlobalQueue.Ue = t => {
         for (const e of t.q) {
-            const t = e?.[$TARGET];
-            const n = t?.fam?.node;
+            const n = e?.[$TARGET];
+            const i = n?.fam;
+            const r = i?.node;
             // The hold exists to keep optimistic state alive until the store's own
             // truth lands (#2951). Once the family carries NO live overrides (a
             // landing consumed them, or they never existed), a pending firewall is
             // no reason to park the transaction — blocking then leaks it forever
             // when the in-flight question is never answered (undisposed fixtures).
-                        if (n != null && n.lt & STATUS_PENDING && familyHasLiveOverrides(t.fam)) return true;
+                        if (r == null || !(r.ct & STATUS_PENDING)) continue;
+            // Ownership is declared (#3146): only the flight's OWN transaction
+            // parks on the flight (the #2951 anchor routed the bare write there).
+            // A transaction that merely brushed the store never waits for truth
+            // it does not carry.
+                        const o = i.ft != null ? liveTransition(i.ft) : null;
+            if (o !== null && o !== currentTransition(t)) continue;
+            if (familyHasLiveOverrides(i)) return true;
         }
         return e(t);
     };
@@ -9221,14 +9347,35 @@ function createOptimisticStoreNext(e, t, n) {
     }
     if (i) {
         const t = e;
+        // #3146: an async settle event belongs to the flight's OWN transaction.
+        // A live declared one re-enters (a merge if the generic settle path
+        // already entered a graph-stamped stranger — the landing supersedes any
+        // recompute deriving from that stranger's world); a dead one renews (per
+        // A18(1) each arrival reveals on its own schedule, so per-yield
+        // transactions die with their commit and the next settle event opens the
+        // flight's next one — still declared, never anonymous). An UNDECLARED
+        // flight (loading window) keeps the ambient reveal (#2933: the loading
+        // rail is transaction-invisible).
+                const enterFlightTransition = () => {
+            const e = o.ft;
+            if (e == null) return;
+            let t = liveTransition(e);
+            if (t === null) o.ft = t = createTransition();
+            o.node.O = t;
+            globalQueue.initTransition(t);
+        };
         // Landing router (#3164 fold ruling): while a transaction retains
         // optimistic edits on this family, truth landings stage INTO it and
         // reveal atomically at settle; with no retainer they commit immediately
         // under the authoritative posture (async commits land outside the
-        // computed's sync body, so the posture is re-applied here).
+        // computed's sync body, so the posture is re-applied here) — inside the
+        // flight-owned transaction (#3146). Sync commits (the derive's body,
+        // owner is the firewall itself) reveal with their own recompute's flush.
                 const wrapCommit = (e, t) => {
             const n = retainingTransition(o);
-            if (n === null) runAuthoritative(e); else stageLanding(o, n, t);
+            if (n !== null) return void stageLanding(o, n, t);
+            if (getOwner() !== o.node) enterFlightTransition();
+            runAuthoritative(e);
         };
         // Draft writes (the derive mutating its draft, sync body and post-await
         // continuations alike) are the same truth channel per-operation: bind
@@ -9240,12 +9387,49 @@ function createOptimisticStoreNext(e, t, n) {
             const t = retainingTransition(o);
             if (t === null) e(); else runFolded(t, e);
         };
+        // Flight declaration (#3146): a recompute that registered a truth-flight
+        // OWNS its transaction. The ask's transaction is recorded on the family
+        // (created by the flight's own pending throw when none was ambient, the
+        // causing write's/refresh's when one was — graph-driven causality) and
+        // the firewall is stamped so every settle path resolves the flight's
+        // transaction by construction, not by whatever last brushed the node.
+        // When the ask took none (a dead stale stamp — the previous flight's,
+        // cleared nowhere — bare-returns the pre-throw entry), the flight opens
+        // its own here, same activation point as the pre-throw's creation: the
+        // ambient batch (the causing write, same-tick bare optimism) adopts into
+        // it exactly as it would have there, and the pending notification that
+        // follows this unwind registers observers against it. The flight
+        // also registers as its own async reporter: the transaction lives
+        // exactly as long as the question is unanswered, observed or not — the
+        // #2951 refetch-hold no longer depends on a tracked observer having
+        // happened to register one. Loading-window flights declare nothing
+        // (#2933: the loading rail is transaction-invisible); a sync run clears
+        // the declaration.
+                const declareFlight = e => {
+            if (e.o?.bt == null) {
+                if (!e.lt) o.ft = null;
+                return;
+            }
+            if (e.lt) return;
+            let t = activeTransition;
+            if (t === null) globalQueue.initTransition(t = createTransition());
+            o.ft = t;
+            e.O = t;
+            let n = t.J.get(e);
+            if (n === undefined) t.J.set(e, n = new Set);
+            n.add(e);
+        };
         let i;
         if (n?.seedLoadingValue) i = {
             loadingValue: undefined
         };
         const r = computed(() => {
-            runAuthoritative(() => runProjectionComputedNext(s, t, n?.key === undefined ? "id" : n.key, wrapCommit, aroundDraftWrite));
+            const e = getOwner();
+            try {
+                runAuthoritative(() => runProjectionComputedNext(s, t, n?.key === undefined ? "id" : n.key, wrapCommit, aroundDraftWrite));
+            } finally {
+                declareFlight(e);
+            }
         }, i);
         r.D &= ~CONFIG_AUTO_DISPOSE;
         o.node = r;
@@ -9429,13 +9613,18 @@ function createOptimisticStoreNext(e, t, n) {
  * overrides — the same view the draft was seeded from) and emit engine writes
  * for exactly the changed keys. Visible-view diffing keeps no-op writes from
  * entangling lanes (RUL-10 / opt R38). */ function notifyOptimisticWrites(e, t) {
-    // A bare write while the store's own truth is in flight rides THAT
-    // transaction (#2951, legacy parity): entangle the firewall's transition so
-    // the override survives until the refetch settles instead of flash-reverting
+    // A bare write while the store's own truth is in flight rides the FLIGHT'S
+    // OWN transaction (#2951 via the #3146 declaration): entangle it so the
+    // override survives until the refetch settles instead of flash-reverting
     // at plain flush end. The blocked-check store-half keeps that transaction
-    // from settling while the firewall is pending.
-    const n = e.fam?.node;
-    if (n?.O) globalQueue.initTransition(n.O);
+    // from settling while the firewall is pending. Declared ownership replaces
+    // the old circumstantial route through the firewall's `_transition` stamp,
+    // which was whatever last brushed the node.
+    const n = e.fam?.ft;
+    if (n != null) {
+        const e = liveTransition(n);
+        if (e !== null) globalQueue.initTransition(e);
+    }
     const i = e.v;
     // Patch channel (override-application site): the draft IS the intended
     // visible state; prev is the view before these overrides apply. Bypasses
@@ -9937,23 +10126,23 @@ function mapArray(e, t, n) {
     const r = t.length > 1;
     const o = t;
     const s = {
-        Xt: createOwner(),
-        Jt: 0,
-        en: e,
-        tn: [],
-        nn: o,
-        rn: [],
+        Jt: createOwner(),
+        en: 0,
+        tn: e,
+        nn: [],
+        rn: o,
         sn: [],
-        un: i,
-        ln: i || n?.keyed === false ? [] : undefined,
-        cn: r && n?.keyed !== false ? [] : undefined,
-        an: n?.keyed === false,
-        dn: n?.fallback
+        un: [],
+        ln: i,
+        cn: i || n?.keyed === false ? [] : undefined,
+        an: r && n?.keyed !== false ? [] : undefined,
+        dn: n?.keyed === false,
+        pn: n?.fallback
     };
     const u = computed(updateKeyedMap.bind(s));
     // Untracked reads inside the internal owner resolve via _parentComputed; routing
     // them through node lets store-proxy lookups see pending writes (not stale _value).
-        s.Xt.Nt = u;
+        s.Jt.Rt = u;
     u.D &= ~CONFIG_AUTO_DISPOSE;
     return accessor(u);
 }
@@ -9972,52 +10161,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.en() || [], t = e.length;
+    const e = this.tn() || [], t = e.length;
     e[$TRACK];
  // top level tracking
-        runWithOwner(this.Xt, () => {
+        runWithOwner(this.Jt, () => {
         let n, i, r, o, 
         // Mappers write freshly-created row/index signals into the STAGE
         // arrays (`rows`/`indexes`), never into `this._rows`/`this._indexes`.
-        s = this.ln ? this.an ? () => {
+        s = this.cn ? this.dn ? () => {
             r[i] = signal(e[i], pureOptions);
-            return this.nn(accessor(r[i]), i);
+            return this.rn(accessor(r[i]), i);
         } : () => {
             r[i] = signal(e[i], pureOptions);
             o && (o[i] = signal(i, pureOptions));
-            return this.nn(accessor(r[i]), o ? accessor(o[i]) : undefined);
-        } : this.cn ? () => {
+            return this.rn(accessor(r[i]), o ? accessor(o[i]) : undefined);
+        } : this.an ? () => {
             const t = e[i];
             o[i] = signal(i, pureOptions);
-            return this.nn(t, accessor(o[i]));
+            return this.rn(t, accessor(o[i]));
         } : () => {
             const t = e[i];
-            return this.nn(t);
+            return this.rn(t);
         };
         // fast path for empty arrays
                 if (t === 0) {
-            if (this.Jt !== 0) {
-                this.Xt.dispose(false);
+            if (this.en !== 0) {
+                this.Jt.dispose(false);
+                this.un = [];
+                this.nn = [];
                 this.sn = [];
-                this.tn = [];
-                this.rn = [];
-                this.Jt = 0;
-                this.ln && (this.ln = []);
+                this.en = 0;
                 this.cn && (this.cn = []);
+                this.an && (this.an = []);
             }
-            if (this.dn && !this.rn[0]) {
+            if (this.pn && !this.sn[0]) {
                 // an aborted fallback attempt leaves an owner without a mapping;
                 // dispose it before re-creating
-                this.sn[0]?.dispose();
-                this.rn[0] = runWithOwner(this.sn[0] = createOwner(), this.dn);
+                this.un[0]?.dispose();
+                this.sn[0] = runWithOwner(this.un[0] = createOwner(), this.pn);
             }
         }
         // fast path for new create
-         else if (this.Jt === 0) {
+         else if (this.en === 0) {
             const u = new Array(t);
             const l = new Array(t);
-            r = this.ln && new Array(t);
-            o = this.cn && new Array(t);
+            r = this.cn && new Array(t);
+            o = this.an && new Array(t);
             try {
                 for (i = 0; i < t; i++) u[i] = runWithOwner(l[i] = createOwner(), s);
             } catch (e) {
@@ -10025,43 +10214,43 @@ function updateKeyedMap() {
                 throw e;
             }
             // commit
-                        if (this.sn[0]) this.sn[0].dispose();
+                        if (this.un[0]) this.un[0].dispose();
  // previous fallback
-                        this.rn = u;
-            this.sn = l;
-            r && (this.ln = r);
-            o && (this.cn = o);
-            this.tn = e.slice(0);
-            this.Jt = t;
+                        this.sn = u;
+            this.un = l;
+            r && (this.cn = r);
+            o && (this.an = o);
+            this.nn = e.slice(0);
+            this.en = t;
         } else {
             let u, l, f, c, a, d, p, E, S;
             // skip common prefix
-                        for (u = 0, l = Math.min(this.Jt, t); u < l && (this.tn[u] === e[u] || this.ln && compare(this.un, this.tn[u], e[u])); u++) {
-                if (this.ln) setSignal(this.ln[u], e[u]);
+                        for (u = 0, l = Math.min(this.en, t); u < l && (this.nn[u] === e[u] || this.cn && compare(this.ln, this.nn[u], e[u])); u++) {
+                if (this.cn) setSignal(this.cn[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.Jt - 1, f = t - 1; l >= u && f >= u && (this.tn[l] === e[f] || this.ln && compare(this.un, this.tn[l], e[f])); l--, 
+                        for (l = this.en - 1, f = t - 1; l >= u && f >= u && (this.nn[l] === e[f] || this.cn && compare(this.ln, this.nn[l], e[f])); l--, 
             f--) ;
             // 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.Jt === t) {
-                this.tn = e.slice(0);
+                        if (u === t && this.en === t) {
+                this.nn = e.slice(0);
                 return;
             }
-            const T = t - this.Jt;
+            const T = t - this.en;
             const _ = new Array(t);
             const h = new Array(t);
-            r = this.ln ? new Array(t) : undefined;
-            o = this.cn ? new Array(t) : undefined;
+            r = this.cn ? new Array(t) : undefined;
+            o = this.an ? 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
                         d = new Map;
             p = new Array(f + 1);
             for (i = f; i >= u; i--) {
                 c = e[i];
-                a = this.un ? this.un(c) : c;
+                a = this.ln ? this.ln(c) : c;
                 n = d.get(a);
                 p[i] = n === undefined ? -1 : n;
                 d.set(a, i);
@@ -10070,17 +10259,17 @@ 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++) {
-                c = this.tn[n];
-                a = this.un ? this.un(c) : c;
+                c = this.nn[n];
+                a = this.ln ? this.ln(c) : c;
                 i = d.get(a);
                 if (i !== undefined && i !== -1) {
-                    _[i] = this.rn[n];
-                    h[i] = this.sn[n];
-                    r && (r[i] = this.ln[n]);
-                    o && (o[i] = this.cn[n]);
+                    _[i] = this.sn[n];
+                    h[i] = this.un[n];
+                    r && (r[i] = this.cn[n]);
+                    o && (o[i] = this.an[n]);
                     i = p[i];
                     d.set(a, i);
-                } else (E ??= []).push(this.sn[n]);
+                } else (E ??= []).push(this.un[n]);
             }
             // 2) create new rows into the temp arrays; an abort disposes only these
                         try {
@@ -10097,38 +10286,38 @@ function updateKeyedMap() {
             // into the fresh arrays, swap them in (new identity for downstream
             // change propagation), then dispose exited rows
                         for (n = 0; n < u; n++) {
-                _[n] = this.rn[n];
-                h[n] = this.sn[n];
-                r && (r[n] = this.ln[n]);
-                o && (o[n] = this.cn[n]);
+                _[n] = this.sn[n];
+                h[n] = this.un[n];
+                r && (r[n] = this.cn[n]);
+                o && (o[n] = this.an[n]);
             }
             for (i = u; i <= f; i++) {
                 if (r) setSignal(r[i], e[i]);
                 if (o) setSignal(o[i], i);
             }
             for (i = f + 1; i < t; i++) {
-                _[i] = this.rn[i - T];
-                h[i] = this.sn[i - T];
+                _[i] = this.sn[i - T];
+                h[i] = this.un[i - T];
                 if (r) {
-                    r[i] = this.ln[i - T];
+                    r[i] = this.cn[i - T];
                     setSignal(r[i], e[i]);
                 }
                 if (o) {
-                    o[i] = this.cn[i - T];
+                    o[i] = this.an[i - T];
                     if (T !== 0) setSignal(o[i], i);
                 }
             }
-            this.rn = _;
-            this.sn = h;
-            r && (this.ln = r);
-            o && (this.cn = o);
-            this.Jt = t;
+            this.sn = _;
+            this.un = h;
+            r && (this.cn = r);
+            o && (this.an = o);
+            this.en = t;
             // save a copy of the mapped items for the next update
-                        this.tn = e.slice(0);
+                        this.nn = e.slice(0);
             if (E) for (n = 0; n < E.length; n++) E[n].dispose();
         }
     });
-    return this.rn;
+    return this.sn;
 }
 
 /**
@@ -10148,21 +10337,21 @@ function updateKeyedMap() {
  */ function repeat(e, t, n) {
     const i = t;
     const r = {
-        Xt: createOwner(),
-        Jt: 0,
-        pn: 0,
-        En: e,
-        nn: i,
+        Jt: createOwner(),
+        en: 0,
+        En: 0,
+        Sn: e,
+        rn: i,
+        un: [],
         sn: [],
-        rn: [],
-        Sn: n?.from,
-        dn: n?.fallback
+        Tn: n?.from,
+        pn: n?.fallback
     };
     const o = computed(updateRepeat.bind(r));
     // 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.
-        r.Xt.Nt = o;
+        r.Jt.Rt = o;
     o.D &= ~CONFIG_AUTO_DISPOSE;
     return accessor(o);
 }
@@ -10175,55 +10364,55 @@ function updateKeyedMap() {
 // for the post-settle retry. The overlap math also subsumes the previous
 // disjoint-window/front-clear/end-clear/shift special cases.
 function updateRepeat() {
-    const e = this.En();
-    const t = this.Sn?.() || 0;
-    runWithOwner(this.Xt, () => {
+    const e = this.Sn();
+    const t = this.Tn?.() || 0;
+    runWithOwner(this.Jt, () => {
         if (e === 0) {
-            if (this.Jt !== 0) {
-                this.Xt.dispose(false);
+            if (this.en !== 0) {
+                this.Jt.dispose(false);
+                this.un = [];
                 this.sn = [];
-                this.rn = [];
-                this.Jt = 0;
+                this.en = 0;
                 // Reset offset to match the cleared data (#2767, repro 2).
-                                this.pn = 0;
+                                this.En = 0;
             }
-            if (this.dn && !this.rn[0]) {
+            if (this.pn && !this.sn[0]) {
                 // an aborted fallback attempt leaves an owner without a mapping;
                 // dispose it before re-creating
-                this.sn[0]?.dispose();
-                this.rn[0] = runWithOwner(this.sn[0] = createOwner(), this.dn);
+                this.un[0]?.dispose();
+                this.sn[0] = runWithOwner(this.un[0] = createOwner(), this.pn);
             }
             return;
         }
         const n = t + e;
-        const i = this.pn + this.Jt;
+        const i = this.En + this.en;
         // Retained overlap [keepStart, keepEnd) in global indexes; empty when the
         // windows are disjoint or when coming from empty/fallback.
-                const r = Math.max(t, this.pn);
+                const r = Math.max(t, this.En);
         const o = Math.min(n, i);
         const s = new Array(e);
         const u = new Array(e);
         for (let e = r; e < o; e++) {
-            u[e - t] = this.sn[e - this.pn];
-            s[e - t] = this.rn[e - this.pn];
+            u[e - t] = this.un[e - this.En];
+            s[e - t] = this.sn[e - this.En];
         }
         try {
             for (let e = t; e < n; e++) {
                 if (e >= r && e < o) continue;
-                s[e - t] = runWithOwner(u[e - t] = createOwner(), () => this.nn(e));
+                s[e - t] = runWithOwner(u[e - t] = createOwner(), () => this.rn(e));
             }
         } catch (e) {
             for (let e = t; e < n; e++) if ((e < r || e >= o) && u[e - t]) u[e - t].dispose();
             throw e;
         }
         // commit: dispose the previous fallback or the rows leaving the window
-                if (this.Jt === 0) this.sn[0]?.dispose(); else for (let e = this.pn; e < i; e++) if (e < t || e >= n) this.sn[e - this.pn].dispose();
-        this.rn = s;
-        this.sn = u;
-        this.pn = t;
-        this.Jt = e;
+                if (this.en === 0) this.un[0]?.dispose(); else for (let e = this.En; e < i; e++) if (e < t || e >= n) this.un[e - this.En].dispose();
+        this.sn = s;
+        this.un = u;
+        this.En = t;
+        this.en = e;
     });
-    return this.rn;
+    return this.sn;
 }
 
 function compare(e, t, n) {
@@ -10234,23 +10423,23 @@ function boundaryComputed(e, t) {
     const n = computed(e, {
         lazy: true
     });
-    ext(n).qt = (e, t) => {
+    ext(n).Bt = (e, t) => {
         // Use passed values if provided, otherwise read from node
-        const i = e !== undefined ? e : n.lt;
+        const i = e !== undefined ? e : n.ct;
         const r = t !== undefined ? t : n.o?.ze;
         // 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.lt &= ~n.Tn;
-        const o = n.Tt.notify(n, STATUS_PENDING | STATUS_ERROR, i, r);
+                n.ct &= ~n._n;
+        const o = n.At.notify(n, STATUS_PENDING | STATUS_ERROR, i, r);
         // The queue is the only propagation channel: a foreign status must not stay
         // reader-visible on the tree, or reads re-throw it across the boundary and
         // link unrelated ambient contexts (the #2809 nested-boundary loop). Deps are
         // untouched, so the tree still recomputes when the foreign source settles.
-                const s = i & ~n.Tn & (STATUS_PENDING | STATUS_ERROR);
+                const s = i & ~n._n & (STATUS_PENDING | STATUS_ERROR);
         if (s) {
-            n.lt &= ~s;
-            if (n.o?.ze === r && !(n.lt & (STATUS_PENDING | STATUS_ERROR))) if (n.o !== null) n.o.ze = undefined;
+            n.ct &= ~s;
+            if (n.o?.ze === r && !(n.ct & (STATUS_PENDING | STATUS_ERROR))) if (n.o !== null) n.o.ze = 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
@@ -10261,16 +10450,16 @@ function boundaryComputed(e, t) {
             throw r;
         }
     };
-    n.Tn = t;
+    n._n = t;
     n.D &= ~CONFIG_AUTO_DISPOSE;
     recompute(n, true);
     return n;
 }
 
 function createBoundChildren(e, t, n, i) {
-    const r = e.Tt;
-    r.addChild(e.Tt = n);
-    cleanup(() => r.removeChild(e.Tt));
+    const r = e.At;
+    r.addChild(e.At = n);
+    cleanup(() => r.removeChild(e.At));
     return runWithOwner(e, () => {
         const e = computed(t);
         return boundaryComputed(() => flatten(read(e)), i);
@@ -10292,53 +10481,53 @@ function isRevealController(e) {
 }
 
 function isSlotReady(e) {
-    return isRevealController(e) ? e._n() : e.hn.size === 0 && !e.An;
+    return isRevealController(e) ? e.hn() : e.An.size === 0 && !e.On;
 }
 
 function isSlotMinimallyReady(e) {
-    return isRevealController(e) ? e.On() : isSlotReady(e);
+    return isRevealController(e) ? e.Nn() : isSlotReady(e);
 }
 
 function setSlotState(e, t, n, i) {
-    setSignal(e.Nn, n);
-    setSignal(e.In, i);
+    setSignal(e.In, n);
+    setSignal(e.Rn, i);
     if (isRevealController(e)) {
-        if (!n && e.Rn === t) e.Rn = undefined;
-        return e.Cn(n, i);
+        if (!n && e.Cn === t) e.Cn = undefined;
+        return e.gn(n, i);
     }
-    if (!n && e.gn === t && e.vn) e.gn = undefined;
+    if (!n && e.vn === t && e.yn) e.vn = undefined;
 }
 
 class RevealController {
-    yn;
     wn;
-    Pn=[];
-    Rn;
-    Nn=signal(false, {
+    Pn;
+    bn=[];
+    Cn;
+    In=signal(false, {
         ownedWrite: true,
-        Mt: true
+        qt: true
     });
-    In=signal(false, {
+    Rn=signal(false, {
         ownedWrite: true,
-        Mt: true
+        qt: true
     });
-    bn=true;
     mn=true;
-    Dn=false;
+    Dn=true;
+    Gn=false;
     constructor(e, t) {
-        this.yn = e;
-        this.wn = t;
+        this.wn = e;
+        this.Pn = t;
     }
-    Gn(e) {
-        for (let t = 0; t < this.Pn.length; t++) {
-            const n = this.Pn[t];
-            if ((isRevealController(n) ? n.Rn : n.gn) !== this) continue;
+    kn(e) {
+        for (let t = 0; t < this.bn.length; t++) {
+            const n = this.bn[t];
+            if ((isRevealController(n) ? n.Cn : n.vn) !== this) continue;
             if (e(n) === false) return false;
         }
         return true;
     }
-    _n() {
-        return this.Gn(isSlotReady);
+    hn() {
+        return this.kn(isSlotReady);
     }
     /**
    * "Minimally ready" = this group has something visible to show under its own policy.
@@ -10346,13 +10535,13 @@ class RevealController {
    * - `together`: every direct slot is minimally ready.
    * - `sequential`: the first owned slot is minimally ready (frontier can advance).
    * - `natural`: any owned slot is minimally ready.
-   */    On() {
-        const e = untrack(this.yn);
-        if (e === "together") return this.Gn(isSlotMinimallyReady);
+   */    Nn() {
+        const e = untrack(this.wn);
+        if (e === "together") return this.kn(isSlotMinimallyReady);
         if (e === "natural") {
             let e = false;
             let t = false;
-            this.Gn(n => {
+            this.kn(n => {
                 e = true;
                 if (isSlotMinimallyReady(n)) {
                     t = true;
@@ -10363,45 +10552,45 @@ class RevealController {
         }
         // sequential: only the first owned slot matters.
                 let t = true;
-        this.Gn(e => {
+        this.kn(e => {
             t = isSlotMinimallyReady(e);
             return false;
         });
         return t;
     }
-    kn(e) {
-        if (this.Pn.includes(e)) return;
-        this.Pn.push(e);
-        const t = untrack(this.yn);
-        setSignal(e.Nn, true), setSignal(e.In, t === "sequential" ? !!untrack(this.wn) : false);
-        untrack(() => this.Cn());
-    }
     xn(e) {
-        const t = this.Pn.indexOf(e);
-        if (t >= 0) this.Pn.splice(t, 1);
-        untrack(() => this.Cn());
-    }
-    Cn(e, t) {
-        if (this.Dn) return;
-        this.Dn = true;
-        const n = this.bn;
-        const i = this.mn;
+        if (this.bn.includes(e)) return;
+        this.bn.push(e);
+        const t = untrack(this.wn);
+        setSignal(e.In, true), setSignal(e.Rn, t === "sequential" ? !!untrack(this.Pn) : false);
+        untrack(() => this.gn());
+    }
+    Fn(e) {
+        const t = this.bn.indexOf(e);
+        if (t >= 0) this.bn.splice(t, 1);
+        untrack(() => this.gn());
+    }
+    gn(e, t) {
+        if (this.Gn) return;
+        this.Gn = true;
+        const n = this.mn;
+        const i = this.Dn;
         try {
-            const n = e ?? read(this.Nn), i = untrack(this.yn), r = i === "sequential" && !!untrack(this.wn), o = t ?? r;
+            const n = e ?? read(this.In), i = untrack(this.wn), r = i === "sequential" && !!untrack(this.Pn), o = t ?? r;
             if (n) {
                 // Held by an outer group. Propagate the hold (and whatever collapsed policy
                 // the outer asked for) down the whole subtree. Inner order is ignored while
                 // held; it resumes once the outer releases us.
-                this.Gn(e => setSlotState(e, this, true, o));
+                this.kn(e => setSlotState(e, this, true, o));
             } else if (i === "natural") {
                 // Each child reveals based on its own readiness. A nested controller slot
                 // is released to run its own order locally — we bypass setSlotState for it
                 // so the parent backpointer survives for upward readiness notifications.
-                this.Gn(e => {
+                this.kn(e => {
                     if (isRevealController(e)) {
+                        setSignal(e.Rn, false);
                         setSignal(e.In, false);
-                        setSignal(e.Nn, false);
-                        e.Cn(false, false);
+                        e.gn(false, false);
                     } else {
                         setSlotState(e, this, !isSlotReady(e), false);
                     }
@@ -10412,11 +10601,11 @@ class RevealController {
                 // sequential's first slot being ready is minimally ready; natural having any
                 // ready child is minimally ready. This lets `together` guarantee a single
                 // cohesive reveal without waiting for every grandchild.
-                const e = this.Gn(isSlotMinimallyReady);
-                this.Gn(t => setSlotState(t, this, !e, false));
+                const e = this.kn(isSlotMinimallyReady);
+                this.kn(t => setSlotState(t, this, !e, false));
             } else {
                 let e = false;
-                this.Gn(t => {
+                this.kn(t => {
                     if (e) return setSlotState(t, this, true, r);
                     if (isSlotReady(t)) return setSlotState(t, this, false, false);
                     e = true;
@@ -10427,63 +10616,63 @@ class RevealController {
                     // advancing past this slot, and we bypass setSlotState so the parent
                     // backpointer survives for upward readiness notifications.
                                         if (isRevealController(t)) {
+                        setSignal(t.Rn, false);
                         setSignal(t.In, false);
-                        setSignal(t.Nn, false);
-                        t.Cn(false, false);
+                        t.gn(false, false);
                     } else {
                         setSlotState(t, this, true, false);
                     }
                 });
             }
         } finally {
-            this.bn = this._n();
-            this.mn = this.On();
-            this.Dn = false;
+            this.mn = this.hn();
+            this.Dn = this.Nn();
+            this.Gn = false;
         }
-        if (this.Rn && (n !== this.bn || i !== this.mn)) this.Rn.Cn();
+        if (this.Cn && (n !== this.mn || i !== this.Dn)) this.Cn.gn();
     }
 }
 
 class CollectionQueue extends Queue {
-    Fn;
-    hn=new Set;
     Hn;
-    An=true;
-    Nn=signal(false, {
+    An=new Set;
+    Un;
+    On=true;
+    In=signal(false, {
         ownedWrite: true,
-        Mt: true
+        qt: true
     });
     ze;
-    In=signal(false, {
+    Rn=signal(false, {
         ownedWrite: true,
-        Mt: true
+        qt: true
     });
-    gn;
-    vn=false;
-    Un;
-    Ln=ON_INIT;
+    vn;
+    yn=false;
+    Ln;
+    Vn=ON_INIT;
     constructor(e) {
         super();
-        this.Fn = e;
+        this.Hn = e;
     }
     run(e) {
-        if (!e || read(this.Nn) && (!_revealUsed || read(this.In))) return;
+        if (!e || read(this.In) && (!_revealUsed || read(this.Rn))) return;
         return super.run(e);
     }
     notify(e, t, n, i) {
-        if (!(t & this.Fn)) return super.notify(e, t, n, i);
-        if (this.vn && this.Un) {
+        if (!(t & this.Hn)) return super.notify(e, t, n, i);
+        if (this.yn && this.Ln) {
             const e = untrack(() => {
                 try {
-                    return this.Un();
+                    return this.Ln();
                 } catch {
                     return ON_INIT;
                 }
             });
-            if (e !== this.Ln) {
-                this.Ln = e;
-                this.vn = false;
-                this.hn.clear();
+            if (e !== this.Vn) {
+                this.Vn = e;
+                this.yn = false;
+                this.An.clear();
             }
         }
         // Routing is dimension-independent: each boundary consumes only its own
@@ -10496,47 +10685,47 @@ class CollectionQueue extends Queue {
         // dimension, while a status already caught by an inner boundary arrives with
         // its dimension consumed from the mask and is correctly not re-routed
         // (the Loading > Errored > content composition escape, #2856).
-                if (this.Fn & STATUS_PENDING && this.vn) return super.notify(e, t, n, i);
-        if (n & this.Fn) {
-            this.An = true;
+                if (this.Hn & STATUS_PENDING && this.yn) return super.notify(e, t, n, i);
+        if (n & this.Hn) {
+            this.On = true;
             const t = i?.source || e.o?.ze?.source;
             if (t) {
-                const e = this.hn.size === 0;
-                this.hn.add(t);
-                if (e) setSignal(this.Nn, true);
-                if (this.Fn & STATUS_ERROR) {
+                const e = this.An.size === 0;
+                this.An.add(t);
+                if (e) setSignal(this.In, true);
+                if (this.Hn & STATUS_ERROR) {
                     setSignal(this.ze, unwrapStatusError(t.o?.ze));
                 }
             }
         }
-        t &= ~this.Fn;
+        t &= ~this.Hn;
         return t ? super.notify(e, t, n, i) : true;
     }
-    dt() {
-        for (const e of this.hn) {
+    St() {
+        for (const e of this.An) {
             // 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.L & REACTIVE_DISPOSED || !e.o?.K && !(e.lt & this.Fn) && !(this.Fn & STATUS_ERROR && e.lt & STATUS_PENDING)) this.hn.delete(e);
+            if (e.L & REACTIVE_DISPOSED || !e.o?.K && !(e.ct & this.Hn) && !(this.Hn & STATUS_ERROR && e.ct & STATUS_PENDING)) this.An.delete(e);
         }
-        if (!this.hn.size) {
-            if (this.Fn & STATUS_PENDING && this.An && !this.vn && this.Hn) {
-                this.An = !!(this.Hn.lt & this.Fn);
+        if (!this.An.size) {
+            if (this.Hn & STATUS_PENDING && this.On && !this.yn && this.Un) {
+                this.On = !!(this.Un.ct & this.Hn);
             } else {
-                this.An = false;
+                this.On = false;
             }
-            if (!this.An) {
-                setSignal(this.Nn, false);
-                if (this.Un) {
+            if (!this.On) {
+                setSignal(this.In, false);
+                if (this.Ln) {
                     try {
-                        this.Ln = untrack(() => this.Un());
+                        this.Vn = untrack(() => this.Ln());
                     } catch {
                         /* value not yet committed — _prevOn stays stale, next notify will reset */}
                 }
             }
         }
-        if (_revealUsed) this.gn?.Cn();
+        if (_revealUsed) this.vn?.gn();
     }
 }
 
@@ -10546,10 +10735,10 @@ function createCollectionBoundary(e, t, n, i) {
     const o = new CollectionQueue(e);
     if (e === STATUS_ERROR) o.ze = signal(undefined, {
         ownedWrite: true,
-        Mt: true
+        qt: true
     });
-    if (i) o.Un = i;
-    const s = o.Hn = createBoundChildren(r, t, o, e);
+    if (i) o.Ln = i;
+    const s = o.Un = createBoundChildren(r, t, o, e);
     // Prime source tracking so reveal registration sees pending sources.
         untrack(() => {
         let t = false;
@@ -10558,23 +10747,23 @@ function createCollectionBoundary(e, t, n, i) {
         } catch (e) {
             if (e instanceof NotReadyError) t = true; else throw e;
         }
-        o.An = t || !!(s.lt & e) || s.o?.ze instanceof NotReadyError;
+        o.On = t || !!(s.ct & e) || s.o?.ze instanceof NotReadyError;
     });
     const u = _revealUsed && e === STATUS_PENDING ? getContext(RevealControllerContext) : null;
     if (u) {
-        o.gn = u;
-        u.kn(o);
-        cleanup(() => u.xn(o));
+        o.vn = u;
+        u.xn(o);
+        cleanup(() => u.Fn(o));
     }
     return accessor(computed(() => {
-        if (!read(o.Nn)) {
+        if (!read(o.In)) {
             const e = read(s);
-            if (!untrack(() => read(o.Nn))) return o.vn = true, e;
+            if (!untrack(() => read(o.In))) return o.yn = true, e;
         }
         // Collapsed reveal slots suppress their own output entirely; the
         // renderer treats the hole as empty, so the cast never leaks to users
         // outside a `createRevealOrder` scope.
-                if (_revealUsed && read(o.In)) return undefined;
+                if (_revealUsed && read(o.Rn)) return undefined;
         return n(o);
     }, 
     // Boundary structure, not a user source: its value is fallback-or-content and
@@ -10582,7 +10771,7 @@ function createCollectionBoundary(e, t, n, i) {
     // by snapshot capture. The tree no longer carries foreign status flags, so
     // capture can't rely on PENDING to skip this node the way it used to.
     {
-        Mt: true
+        qt: true
     }));
 }
 
@@ -10636,7 +10825,7 @@ function createCollectionBoundary(e, t, n, i) {
  * ```
  */ function createErrorBoundary(e, t) {
     return createCollectionBoundary(STATUS_ERROR, e, e => t(accessor(e.ze), () => {
-        for (const t of e.hn) {
+        for (const t of e.An) {
             // Non-computed sources (patch-channel registrations under plain
             // owners) are not recomputable — their reset is the record's next
             // transition re-applying the patch (re-audit 2, P1-4).
@@ -10698,12 +10887,12 @@ function createCollectionBoundary(e, t, n, i) {
         computed(() => {
             r();
             o();
-            s.Cn();
+            s.gn();
         });
         if (i) {
-            s.Rn = i;
-            i.kn(s);
-            cleanup(() => i.xn(s));
+            s.Cn = i;
+            i.xn(s);
+            cleanup(() => i.Fn(s));
         }
         return t;
     });