@solidjs/signals 2.0.0-beta.31 → 2.0.0-beta.33

package/dist/node.cjs

@@ -653,8 +653,8 @@ class GlobalQueue extends Queue {
     static Ae=null;
     static he=null;
     static Ne=null;
-    static ye=null;
     static Pe=null;
+    static ye=null;
     static Ce=null;
     static ge=null;
     static be=null;
@@ -875,9 +875,13 @@ function commitPendingNode(e) {
         // Set _modified for effects, but not for tracked effects (they handle their own scheduling)
                 if (e.Fe && e.Fe !== EFFECT_TRACKED) e.Qe = true;
     }
+    // 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.xe = false;
     t.D &= ~REACTIVE_MANUAL_WRITE;
-    if (!(t.xe & STATUS_PENDING)) t.xe &= ~STATUS_UNINITIALIZED;
-    if (t.He !== null || t.Me !== null) GlobalQueue.ee(t, false, true);
+    if (!(t.He & STATUS_PENDING)) t.He &= ~STATUS_UNINITIALIZED;
+    if (t.Me !== null || t.$e !== null) GlobalQueue.ee(t, false, true);
     if (e._ || e.R) GlobalQueue.Ee(e);
 }
 
@@ -942,7 +946,7 @@ function finalizePureQueue(e = null, t = false) {
 
 function checkBoundaryChildren(e) {
     for (const t of e.v) {
-        t.$e?.();
+        t.je?.();
         checkBoundaryChildren(t);
     }
 }
@@ -1010,15 +1014,15 @@ function runQueue$1(e, t) {
 
 function reporterBlocksSource(e, t) {
     if (e.D & (REACTIVE_ZOMBIE | REACTIVE_DISPOSED)) return false;
-    if (e.je?.has(t)) return true;
-    for (let n = e.Ke; n; n = n.Ye) {
-        let e = n.qe;
+    if (e.Ke?.has(t)) return true;
+    for (let n = e.Ye; n; n = n.qe) {
+        let e = n.Be;
         while (e) {
-            if (e === t || e.Be === t) return true;
+            if (e === t || e.Ze === t) return true;
             e = e.t;
         }
     }
-    return !!(e.xe & STATUS_PENDING && e.me instanceof NotReadyError && e.me.source === t);
+    return !!(e.He & STATUS_PENDING && e.me instanceof NotReadyError && e.me.source === t);
 }
 
 function transitionComplete(e) {
@@ -1034,7 +1038,7 @@ function transitionComplete(e) {
             }
             r.delete(e);
         }
-        if (!i) e.$.delete(n); else if (n.xe & STATUS_PENDING && n.me?.source === n) {
+        if (!i) e.$.delete(n); else if (n.He & STATUS_PENDING && n.me?.source === n) {
             t = false;
             break;
         }
@@ -1075,25 +1079,25 @@ function runInTransition(e, t) {
         const t = e;
         if (!t.Qe) {
             t.Qe = true;
-            t.Ze.enqueue(EFFECT_USER, t.Xe);
+            t.Xe.enqueue(EFFECT_USER, t.ze);
         }
         return;
     }
     const t = queueFor(e);
-    if (t.P > e.ze) t.P = e.ze;
+    if (t.P > e.Je) t.P = e.Je;
     insertIntoHeap(e, t);
 }
 
 function actualInsertIntoHeap(e, t) {
-    const n = (e.Z?.Je ? e.Z.et?.ze : e.Z?.ze) ?? -1;
-    if (n >= e.ze) e.ze = n + 1;
-    const r = e.ze;
+    const n = (e.Z?.et ? e.Z.tt?.Je : e.Z?.Je) ?? -1;
+    if (n >= e.Je) e.Je = n + 1;
+    const r = e.Je;
     const i = t.h[r];
     if (i === undefined) t.h[r] = e; else {
-        const t = i.tt;
-        t.nt = e;
-        e.tt = t;
-        i.tt = e;
+        const t = i.nt;
+        t.rt = e;
+        e.nt = t;
+        i.nt = e;
     }
     if (r > t.C) t.C = r;
 }
@@ -1126,23 +1130,23 @@ function deleteFromHeap(e, t) {
     const n = e.D;
     if (!(n & (REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT))) return;
     e.D = n & -25;
-    const r = e.ze;
-    if (e.tt === e) t.h[r] = undefined; else {
-        const n = e.nt;
+    const r = e.Je;
+    if (e.nt === e) t.h[r] = undefined; else {
+        const n = e.rt;
         const i = t.h[r];
         const o = n ?? i;
-        if (e === i) t.h[r] = n; else e.tt.nt = n;
-        o.tt = e.tt;
+        if (e === i) t.h[r] = n; else e.nt.rt = n;
+        o.nt = e.nt;
     }
-    e.tt = e;
-    e.nt = undefined;
+    e.nt = e;
+    e.rt = undefined;
 }
 
 function markHeap(e) {
     if (e.N) return;
     e.N = true;
     for (let t = 0; t <= e.C; t++) {
-        for (let n = e.h[t]; n !== undefined; n = n.nt) {
+        for (let n = e.h[t]; n !== undefined; n = n.rt) {
             if (n.D & REACTIVE_IN_HEAP) markNode(n);
         }
     }
@@ -1155,8 +1159,8 @@ function markNode(e, t = REACTIVE_DIRTY) {
     for (let t = e.U; t !== null; t = t.Ge) {
         markNode(t.Ve, REACTIVE_CHECK);
     }
-    if (e.rt !== null) {
-        for (let t = e.rt; t !== null; t = t.it) {
+    if (e.it !== null) {
+        for (let t = e.it; t !== null; t = t.ot) {
             for (let e = t.U; e !== null; e = e.Ge) {
                 markNode(e.Ve, REACTIVE_CHECK);
             }
@@ -1178,14 +1182,14 @@ function runHeap(e, t) {
 
 function adjustHeight(e, t) {
     deleteFromHeap(e, t);
-    let n = e.ze;
-    for (let t = e.Ke; t; t = t.Ye) {
-        const e = t.qe;
-        const r = e.Be || e;
-        if (r.ke && r.ze >= n) n = r.ze + 1;
-    }
-    if (e.ze !== n) {
-        e.ze = n;
+    let n = e.Je;
+    for (let t = e.Ye; t; t = t.qe) {
+        const e = t.Be;
+        const r = e.Ze || e;
+        if (r.ke && r.Je >= n) n = r.Je + 1;
+    }
+    if (e.Je !== n) {
+        e.Je = n;
         for (let t = e.U; t !== null; t = t.Ge) {
             // Route each subscriber by its own zombie flag, mirroring the
             // post-recompute height-adjust path. Inserting into the running `heap`
@@ -1201,7 +1205,7 @@ const PENDING_OWNER = {};
 
  // Dummy owner to trigger store's read() path
 function markDisposal(e) {
-    let t = e.ot;
+    let t = e.st;
     while (t) {
         const e = t.D;
         t.D = e | REACTIVE_ZOMBIE;
@@ -1215,17 +1219,21 @@ function markDisposal(e) {
             if (e & REACTIVE_IN_HEAP) insertIntoHeap(t, zombieQueue); else insertIntoHeapHeight(t, zombieQueue);
         }
         markDisposal(t);
-        t = t.st;
+        t = t.ut;
     }
 }
 
 function dispose(e) {
-    let t = e.Ke;
+    // Leave every scheduler heap on disposal (mirrors `unobserved`): a node
+    // still queued here would be recomputed by the next flush, and recompute()
+    // rewriting `_flags` would clear REACTIVE_DISPOSED — resurrecting it (#2983).
+    deleteFromHeap(e, queueFor(e));
+    let t = e.Ye;
     while (t !== null) {
         t = unlinkSubs(t);
     }
-    e.Ke = null;
-    e.ut = null;
+    e.Ye = null;
+    e.lt = null;
     disposeChildren(e, true);
 }
 
@@ -1242,52 +1250,57 @@ function disposeChildren(e, t = false, n) {
                 const t = e;
         if (t._ || t.R) GlobalQueue.Ee(t);
     }
-    if (t && e.ke) e.lt = null;
-    let i = n ? e.He : e.ot;
+    if (t && e.ke) e.ct = null;
+    let i = n ? e.Me : e.st;
     while (i) {
-        const e = i.st;
-        if (i.Ke) {
-            const e = i;
-            deleteFromHeap(e, queueFor(e));
-            let t = e.Ke;
+        const e = i.ut;
+        const t = i;
+        // Heap removal must not be gated on `_deps`: a dependency-free
+        // computation queued by refresh() has a null dep list but still sits in
+        // the dirty heap, and left there the post-disposal flush recomputes it —
+        // recompute() rewriting `_flags` clears REACTIVE_DISPOSED and the node
+        // comes back to life (post-unmount runs, leaked cleanups, #2983).
+                if (t.D & (REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT)) deleteFromHeap(t, queueFor(t));
+        if (t.Ye) {
+            let e = t.Ye;
             do {
-                t = unlinkSubs(t);
-            } while (t !== null);
-            e.Ke = null;
-            e.ut = null;
+                e = unlinkSubs(e);
+            } while (e !== null);
+            t.Ye = null;
+            t.lt = null;
         }
         disposeChildren(i, true);
         i = e;
     }
     if (n) {
-        e.He = null;
+        e.Me = null;
     } else {
-        e.ot = null;
-        e.ct = 0;
+        e.st = null;
+        e.ft = 0;
     }
     // O(1) splice out of parent's chain on individual dispose. Skipped during
     // batch dispose (parent already disposed) and zombie disposal (node sits on
     // parent's _pendingFirstChild). We leave node._nextSibling intact so outer
     // walks that already advanced past us still reach later siblings.
         if (t && !n && !(r & REACTIVE_ZOMBIE) && e.Z !== null && !(e.Z.D & REACTIVE_DISPOSED)) {
-        const t = e.ft;
-        const n = e.st;
-        if (t !== null) t.st = n; else e.Z.ot = n;
-        if (n !== null) n.ft = t;
-        e.ft = null;
+        const t = e.Et;
+        const n = e.ut;
+        if (t !== null) t.ut = n; else e.Z.st = n;
+        if (n !== null) n.Et = t;
+        e.Et = 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.Et) {
-        const t = e.Et;
-        e.Et = undefined;
+        if (t && e.dt) {
+        const t = e.dt;
+        e.dt = undefined;
         t();
     }
 }
 
 function runDisposal(e, t) {
-    let n = t ? e.Me : e.dt;
+    let n = t ? e.$e : e.St;
     if (!n) return;
     if (Array.isArray(n)) {
         for (let e = 0; e < n.length; e++) {
@@ -1297,13 +1310,13 @@ function runDisposal(e, t) {
     } else {
         n.call(n);
     }
-    t ? e.Me = null : e.dt = null;
+    t ? e.$e = null : e.St = null;
 }
 
 function childId(e, t) {
     let n = e;
     while (n.Ue & CONFIG_TRANSPARENT && n.Z) n = n.Z;
-    if (n.id != null) return formatId(n.id, t ? n.ct++ : n.ct);
+    if (n.id != null) return formatId(n.id, t ? n.ft++ : n.ft);
     throw new Error("");
 }
 
@@ -1384,7 +1397,7 @@ function formatId(e, t) {
  * checks. `cleanup()` is the unchecked primitive used by internals.
  */ function cleanup(e) {
     if (!context) return e;
-    if (!context.dt) context.dt = e; else if (Array.isArray(context.dt)) context.dt.push(e); else context.dt = [ context.dt, e ];
+    if (!context.St) context.St = e; else if (Array.isArray(context.St)) context.St.push(e); else context.St = [ context.St, e ];
     return e;
 }
 
@@ -1424,28 +1437,28 @@ function disposeRootSelf(e = true) {
     const r = {
         id: inheritId(e, n, t),
         Ue: n ? CONFIG_TRANSPARENT : 0,
-        Je: true,
-        et: t?.Je ? t.et : t,
-        ot: null,
+        et: true,
+        tt: t?.et ? t.tt : t,
         st: null,
-        ft: null,
-        dt: null,
-        Ze: t?.Ze ?? globalQueue,
-        St: t?.St || defaultContext,
-        ct: 0,
+        ut: null,
+        Et: null,
+        St: null,
+        Xe: t?.Xe ?? globalQueue,
+        Tt: t?.Tt || defaultContext,
+        ft: 0,
+        $e: null,
         Me: null,
-        He: null,
         Z: t,
         dispose: disposeRootSelf
     };
     if (t) {
-        const e = t.ot;
+        const e = t.st;
         if (e === null) {
-            t.ot = r;
+            t.st = r;
         } else {
-            r.st = e;
-            e.ft = r;
-            t.ot = r;
+            r.ut = e;
+            e.Et = r;
+            t.st = r;
         }
     }
     return r;
@@ -1481,11 +1494,11 @@ function disposeRootSelf(e = true) {
 
 // https://github.com/stackblitz/alien-signals/blob/v2.0.3/src/system.ts#L100
 function unlinkSubs(e) {
-    const t = e.qe;
-    const n = e.Ye;
+    const t = e.Be;
+    const n = e.qe;
     const r = e.Ge;
-    const i = e.Tt;
-    if (r !== null) r.Tt = i; else t.Ot = i;
+    const i = e.Ot;
+    if (r !== null) r.Ot = i; else t._t = i;
     if (i !== null) i.Ge = r; else {
         t.U = r;
         if (r === null) {
@@ -1497,31 +1510,31 @@ function unlinkSubs(e) {
             // this same last-one-out check when that observer releases (the
             // untracked-read dispose in core.ts guards on pending identically).
                         const e = t;
-            e.ke && e.Ue & CONFIG_AUTO_DISPOSE && !(e.D & REACTIVE_ZOMBIE) && !(e.xe & STATUS_PENDING) && unobserved(e);
+            e.ke && e.Ue & CONFIG_AUTO_DISPOSE && !(e.D & REACTIVE_ZOMBIE) && !(e.He & STATUS_PENDING) && unobserved(e);
         }
     }
     return n;
 }
 
 function trimStaleDeps(e) {
-    const t = e.ut;
-    let n = t !== null ? t.Ye : e.Ke;
+    const t = e.lt;
+    let n = t !== null ? t.qe : e.Ye;
     if (n !== null) {
         do {
             n = unlinkSubs(n);
         } while (n !== null);
-        if (t !== null) t.Ye = null; else e.Ke = null;
+        if (t !== null) t.qe = null; else e.Ye = null;
     }
 }
 
 function unobserved(e) {
     deleteFromHeap(e, queueFor(e));
-    let t = e.Ke;
+    let t = e.Ye;
     while (t !== null) {
         t = unlinkSubs(t);
     }
-    e.Ke = null;
-    e.ut = null;
+    e.Ye = null;
+    e.lt = null;
     disposeChildren(e, true);
 }
 
@@ -1532,20 +1545,20 @@ function link(e, t, n = false) {
     // not relabel the value dependency as probe-only — the value read is what
     // real-error propagation and affects() coverage key off, regardless of
     // read order within the computation.
-    const r = t.ut;
-    if (r !== null && r.qe === e) {
-        r._t &&= n;
+    const r = t.lt;
+    if (r !== null && r.Be === e) {
+        r.Rt &&= n;
         return;
     }
     let i = null;
     const o = t.D & REACTIVE_RECOMPUTING_DEPS;
     if (o) {
-        i = r !== null ? r.Ye : t.Ke;
-        if (i !== null && i.qe === e) {
-            i.Rt = t.It;
-            t.ut = i;
+        i = r !== null ? r.qe : t.Ye;
+        if (i !== null && i.Be === e) {
+            i.It = t.At;
+            t.lt = i;
             // First touch of this pass: the previous pass's label is stale.
-                        i._t = n;
+                        i.Rt = n;
             return;
         }
     }
@@ -1554,23 +1567,23 @@ 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.Ot;
-    if (s !== null && s.Ve === t && (!o || s.Rt === t.It)) {
+        const s = e._t;
+    if (s !== null && s.Ve === t && (!o || s.It === t.At)) {
         // Gen-matched during a recompute = repeat touch this pass (AND); outside
         // a recompute there is no pass boundary, so the latest read labels it.
-        if (o) s._t &&= n; else s._t = n;
+        if (o) s.Rt &&= n; else s.Rt = n;
         return;
     }
-    const u = t.ut = e.Ot = {
-        qe: e,
+    const u = t.lt = e._t = {
+        Be: e,
         Ve: t,
-        Ye: i,
-        Tt: s,
+        qe: i,
+        Ot: s,
         Ge: null,
-        Rt: t.It,
-        _t: n
+        It: t.At,
+        Rt: n
     };
-    if (r !== null) r.Ye = u; else t.Ke = u;
+    if (r !== null) r.qe = u; else t.Ye = u;
     if (s !== null) s.Ge = u; else e.U = u;
 }
 
@@ -1580,20 +1593,36 @@ 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.je?.has(t)) return false;
-    (e.je ??= new Set).add(t);
+    if (e.Ke?.has(t)) return false;
+    (e.Ke ??= new Set).add(t);
     return true;
 }
 
 function removePendingSource(e, t) {
-    if (!e.je?.delete(t)) return false;
-    if (e.je.size === 0) e.je = undefined;
+    if (!e.Ke?.delete(t)) return false;
+    if (e.Ke.size === 0) e.Ke = undefined;
     return true;
 }
 
 function clearPendingSources(e) {
-    e.je?.clear();
-    e.je = undefined;
+    e.Ke?.clear();
+    e.Ke = undefined;
+}
+
+/**
+ * A loading-window node hit an unready source (sync throw in recompute, or a
+ * NotReadyError-rejected flight): register for the source's settle — the
+ * settlePendingSource walk runs off `_pendingSources` + `_blocked` alone —
+ * with NO read-visible pending status, no downstream propagation, no
+ * transition, no lane registration. Commit #0 keeps serving.
+ */ function parkLoadingWindow(e, t) {
+    e.ht = 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.He & STATUS_ERROR)) setPendingError(e, t.source, t);
 }
 
 function setPendingError(e, t, n) {
@@ -1614,7 +1643,7 @@ function setPendingError(e, t, n) {
 function forEachDependent(e, t) {
     for (let n = e.U; n !== null; n = n.Ge) t(n.Ve, n);
     // `?? null`: affects() marks route plain signals (no `_child` slot) through here.
-        for (let n = e.rt ?? null; n !== null; n = n.it) {
+        for (let n = e.it ?? null; n !== null; n = n.ot) {
         for (let e = n.U; e !== null; e = e.Ge) t(e.Ve, e);
     }
 }
@@ -1630,7 +1659,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.ke && e.Ue & CONFIG_AUTO_DISPOSE && !e.U && !(e.D & REACTIVE_ZOMBIE) && !(e.xe & STATUS_PENDING) && unobserved(e);
+    e.ke && e.Ue & CONFIG_AUTO_DISPOSE && !e.U && !(e.D & REACTIVE_ZOMBIE) && !(e.He & STATUS_PENDING) && unobserved(e);
 }
 
 // Error-path sweep: notifyStatus(STATUS_ERROR) clears dependents' pending
@@ -1691,19 +1720,25 @@ function settlePendingSource(e) {
         if (r.has(o) || !removePendingSource(o, e)) return;
         r.add(o);
         o.H = clock;
-        const s = o.je?.values().next().value;
+        const s = o.Ke?.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.He & STATUS_ERROR;
         if (s) {
-            setPendingError(o, s);
+            if (!u) setPendingError(o, s);
             i !== null && i(o);
         } else {
-            o.xe &= ~STATUS_PENDING;
-            setPendingError(o);
+            o.He &= ~STATUS_PENDING;
+            if (!u) setPendingError(o);
             i !== null && i(o);
-            if (o.At) {
+            if (o.ht) {
                 enqueueSub(o);
                 t = true;
             }
-            o.At = false;
+            o.ht = 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.
@@ -1733,10 +1768,12 @@ function handleAsync(e, t, n) {
         });
     }
     if (!i && !r) {
-        e.lt = null;
+        e.ct = null;
+        // A sync landing is the first real answer for a loadingValue node.
+                e.xe = false;
         return t;
     }
-    e.lt = t;
+    e.ct = 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
@@ -1750,7 +1787,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.xe & STATUS_UNINITIALIZED && !currentTransition(t).$.has(e)) {
+        if (t && e.He & STATUS_UNINITIALIZED && !currentTransition(t).$.has(e)) {
             // Drop the stale stamp too: the plain settle write (setSignal) and the
             // stash-path restamp both re-enter the transaction through it.
             e.T = null;
@@ -1759,10 +1796,20 @@ function handleAsync(e, t, n) {
         globalQueue.initTransition(t);
     };
     const handleError = n => {
-        if (e.lt !== t) return;
-        settleTransition();
+        if (e.ct !== t) return;
         // NotReadyError from rejected promises should be treated as pending, not error
-                const r = n instanceof NotReadyError;
+                let r = n instanceof NotReadyError;
+        if (r && e.xe) {
+            // 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.
+            e.ct = null;
+            parkLoadingWindow(e, n);
+            e.H = clock;
+            return;
+        }
+        settleTransition();
         notifyStatus(e, r ? STATUS_PENDING : STATUS_ERROR, n);
         e.H = clock;
         // A real error settles derivatively-pending dependents (notifyStatus
@@ -1771,13 +1818,13 @@ function handleAsync(e, t, n) {
                 if (!r) releaseSettledDependents(e);
     };
     const asyncWrite = (r, i) => {
-        if (e.lt !== t) return;
+        if (e.ct !== 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.D & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY)) return;
         settleTransition();
-        const o = !!(e.xe & STATUS_UNINITIALIZED);
+        const o = !!(e.He & STATUS_UNINITIALIZED);
         trimStaleDeps(e);
         clearStatus(e);
         const s = resolveLane(e);
@@ -1811,7 +1858,7 @@ function handleAsync(e, t, n) {
             // Route through lane's effect queue for independent flushing
             const t = e.Fe;
             const n = e.We;
-            const i = e.ht;
+            const i = e.Nt;
             try {
                 if (!t && o || !i || !i(r, n)) {
                     e.We = r;
@@ -1838,6 +1885,13 @@ function handleAsync(e, t, n) {
                 notifyStatus(e, STATUS_ERROR, t);
             }
         }
+        // First real answer landing: the window closes when the answer becomes
+        // OBSERVABLE. A direct commit is observable now; a transition-held write
+        // (`_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.k === NOT_PENDING) e.xe = false;
         settlePendingSource(e);
         schedule();
         flush();
@@ -1851,7 +1905,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.Ue & CONFIG_AUTO_DISPOSE && !e.U && !(e.xe & STATUS_PENDING)) {
+        if (e.Ue & CONFIG_AUTO_DISPOSE && !e.U && !(e.He & STATUS_PENDING)) {
             unobserved(e);
             return true;
         }
@@ -1884,8 +1938,16 @@ function handleAsync(e, t, n) {
             handleError(i);
             throw i;
         } else if (!n) {
+            // Loading window: serve commit #0 instead of suspending. No transition
+            // 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.xe) return e.We;
             globalQueue.initTransition(resolveTransition(e));
             throw new NotReadyError(context);
+        } else {
+            // Synchronously-resolved promise: the first real answer landed.
+            e.xe = false;
         }
     }
     if (r) {
@@ -1909,12 +1971,27 @@ function handleAsync(e, t, n) {
         };
         const iterate = () => {
             let u, l, a = false, c = false, f = true;
-            n.next().then(n => {
-                if (f) {
+            // Protocol tolerance, matching `for await`: `await` unwraps whatever
+            // next() returns — a thenable OR a bare IteratorResult. Real producers
+            // use the bare form as a promise-free fast path when a value is already
+            // buffered (seroval's deserialized streams do), so a bare result is
+            // assimilated as an already-settled step instead of crashing on `.then`.
+                        const E = n.next();
+            const d = isThenable(E) ? E : {
+                then: e => void e(E)
+            };
+            d.then(n => {
+                // The sync stash only serves the INITIAL drain (handleAsync's caller
+                // consumes syncValue / throws NotReady from it). A sync-settled step
+                // after an async gap — seroval buffering values between pulls, a
+                // sync-thenable producer mid-stream — has no caller reading the
+                // stash: it must write through the async path or the value is
+                // silently dropped.
+                if (f && s) {
                     u = n;
                     a = true;
                     if (n.done) i = true;
-                } else if (e.lt !== t) {
+                } else if (e.ct !== t) {
                     return;
                 } else if (!n.done) {
                     r = true;
@@ -1934,7 +2011,7 @@ function handleAsync(e, t, n) {
                 if (f) {
                     l = n;
                     c = true;
-                } else if (e.lt === t) {
+                } else if (e.ct === t) {
                     i = true;
                     handleError(n);
                     settleAutodispose();
@@ -1959,26 +2036,31 @@ function handleAsync(e, t, n) {
         // Later iterate() calls run from asyncWrite, where rethrowing would be unhandled.
                 s = false;
         if (!r && !u) {
+            // Loading window: serve commit #0 (see the promise branch above).
+            if (e.xe) return e.We;
             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.xe = false;
     }
     return o;
 }
 
 function clearStatus(e, t = false) {
-    if (e.je) clearPendingSources(e);
-    if (e.At) e.At = false;
+    if (e.Ke) clearPendingSources(e);
+    if (e.ht) e.ht = false;
     // The pending window is over; its quiet classification dies with it.
     // (Unconditional: _reask is baked into the node literals, so this is a
     // plain store to an existing slot — no shape change.)
-        e.Nt = false;
-    e.xe = t ? 0 : e.xe & STATUS_UNINITIALIZED;
+        e.Pt = false;
+    e.He = t ? 0 : e.He & STATUS_UNINITIALIZED;
     if (e.me) setPendingError(e);
     // Update pending signal for isPending() reactivity (companions only exist
     // once the verdict layer created them, which installs the hooks).
         if (e._ || e.R) GlobalQueue.ce(e);
-    if (e.rt && GlobalQueue.fe !== null) GlobalQueue.fe(e);
+    if (e.it && GlobalQueue.fe !== null) GlobalQueue.fe(e);
     if (e.yt) e.yt();
 }
 
@@ -1992,17 +2074,17 @@ function notifyStatus(e, t, n, r, i) {
     if (!r) {
         if (t === STATUS_PENDING && o) {
             addPendingSource(e, o);
-            e.xe = STATUS_PENDING | e.xe & STATUS_UNINITIALIZED;
+            e.He = STATUS_PENDING | e.He & STATUS_UNINITIALIZED;
             // Preserve the current source on this propagation so render-effect notification
             // can register every distinct pending source with the transition.
                         setPendingError(e, o, n);
         } else {
             clearPendingSources(e);
-            e.xe = t | (t !== STATUS_ERROR ? e.xe & STATUS_UNINITIALIZED : 0);
+            e.He = t | (t !== STATUS_ERROR ? e.He & STATUS_UNINITIALIZED : 0);
             e.me = n;
         }
         GlobalQueue.ce !== null && GlobalQueue.ce(e);
-        if (e.rt && GlobalQueue.fe !== null) GlobalQueue.fe(e);
+        if (e.it && GlobalQueue.fe !== null) GlobalQueue.fe(e);
     }
     if (i && !r) {
         assignOrMergeLane(e, i);
@@ -2022,13 +2104,13 @@ function notifyStatus(e, t, n, r, i) {
     }
     forEachDependent(e, (e, r) => {
         e.H = clock;
-        if (t === STATUS_PENDING && o && !e.je?.has(o) || t !== STATUS_PENDING && (e.me !== n || e.je)) {
+        if (t === STATUS_PENDING && o && !e.Ke?.has(o) || t !== STATUS_PENDING && (e.me !== n || e.Ke)) {
             // A pending-observer link is the subscription an `isPending` read created.
             // It exists so the observer re-runs when the source settles, but it must
             // not carry a real (non-NotReadyError) error — the synchronous `isPending`
             // read swallows those, and the async path must match. Re-run the observer
             // so `isPending` re-evaluates (to not-pending) instead of forwarding.
-            if (r._t && t !== STATUS_PENDING && !(n instanceof NotReadyError)) {
+            if (r.Rt && t !== STATUS_PENDING && !(n instanceof NotReadyError)) {
                 enqueueSub(e);
                 schedule();
                 return;
@@ -2073,7 +2155,7 @@ let snapshotSources = null;
 
 function ownerInSnapshotScope(e) {
     while (e) {
-        if (e.Pt) return true;
+        if (e.Ct) return true;
         e = e.Z;
     }
     return false;
@@ -2085,20 +2167,20 @@ function setSnapshotCapture(e) {
 }
 
 function markSnapshotScope(e) {
-    e.Pt = true;
+    e.Ct = true;
 }
 
 function releaseSnapshotScope(e) {
-    e.Pt = false;
+    e.Ct = false;
     releaseSubtree(e);
     schedule();
 }
 
 function releaseSubtree(e) {
-    let t = e.ot;
+    let t = e.st;
     while (t) {
-        if (t.Pt) {
-            t = t.st;
+        if (t.Ct) {
+            t = t.ut;
             continue;
         }
         if (t.ke) {
@@ -2107,12 +2189,12 @@ function releaseSubtree(e) {
             if (e.D & REACTIVE_SNAPSHOT_STALE) {
                 e.D &= ~REACTIVE_SNAPSHOT_STALE;
                 e.D |= REACTIVE_DIRTY;
-                if (dirtyQueue.P > e.ze) dirtyQueue.P = e.ze;
+                if (dirtyQueue.P > e.Je) dirtyQueue.P = e.Je;
                 insertIntoHeap(e, dirtyQueue);
             }
         }
         releaseSubtree(t);
-        t = t.st;
+        t = t.ut;
     }
 }
 
@@ -2135,37 +2217,42 @@ function recompute(e, t = false) {
     if (!t) {
         if (e.T && (!n || activeTransition) && activeTransition !== e.T) globalQueue.initTransition(e.T);
         deleteFromHeap(e, queueFor(e));
-        e.lt = null;
+        e.ct = null;
         // Tracked effects run after finalizePureQueue, so dispose immediately instead of deferring
-                if (e.T || n === EFFECT_TRACKED) disposeChildren(e); else if (e.ot !== null || e.dt !== null) {
+                if (e.T || n === EFFECT_TRACKED) disposeChildren(e); else if (e.st !== null || e.St !== null) {
             markDisposal(e);
-            e.Me = e.dt;
-            e.He = e.ot;
-            e.dt = null;
-            e.ot = null;
-            e.ct = 0;
+            e.$e = e.St;
+            e.Me = e.st;
+            e.St = null;
+            e.st = null;
+            e.ft = 0;
         } else ;
     }
     let r = !!(e.D & REACTIVE_OPTIMISTIC_DIRTY);
     const i = e.A !== undefined && e.A !== NOT_PENDING;
-    const o = !!(e.xe & STATUS_UNINITIALIZED);
+    const o = !!(e.He & 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.xe & STATUS_ERROR ? e.me : undefined;
+        const s = e.He & STATUS_ERROR ? e.me : undefined;
     // Re-ask classification lives in the verdict module; capture the flag before
     // the recompute wipes _flags below.
         const u = (e.D & REACTIVE_REASK) !== 0;
-    const l = context;
+    // Captured before the compute clears it on a sync landing: if that landing
+    // 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 l = e.xe;
+    const a = context;
     context = e;
-    e.ut = null;
-    e.It++;
+    e.lt = null;
+    e.At++;
     e.D = REACTIVE_RECOMPUTING_DEPS;
     e.H = clock;
-    let a = e.k === NOT_PENDING ? e.We : e.k;
-    let c = e.ze;
-    let f = tracking;
-    let E = currentOptimisticLane;
+    let c = e.k === NOT_PENDING ? e.We : e.k;
+    let f = e.Je;
+    let E = tracking;
+    let d = currentOptimisticLane;
     tracking = true;
     // A computed's fn establishes its OWN dependencies, so it must never run
     // inside a latest() read window: read() short-circuits through the
@@ -2173,7 +2260,7 @@ function recompute(e, t = false) {
     // computed) inside latest(fn) came out permanently dependency-less (#2926).
     // latestRead() already suspends the flag for its pull-recomputes; this
     // covers creation-time computes and flushes that run inside the window.
-        const d = latestReadActive;
+        const S = latestReadActive;
     latestReadActive = false;
     // Lane posture lives with the engine: OPTIMISTIC_DIRTY is only ever set by
     // engine-driven paths, and _optimisticNodes is only pushed by
@@ -2191,56 +2278,76 @@ function recompute(e, t = false) {
             currentOptimisticLane = t;
         }
     }
-    const S = n && n !== EFFECT_USER;
-    const T = stale;
-    if (S) stale = true;
+    const T = n && n !== EFFECT_USER;
+    const O = stale;
+    if (T) stale = true;
     try {
         if (!false && e.Ue & CONFIG_SYNC) {
-            a = e.ke(a);
-            e.lt = null;
+            c = e.ke(c);
+            e.ct = null;
+            e.xe = 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.lt;
-            const n = e.ke(a);
+            const t = e.ct;
+            const n = e.ke(c);
             const r = typeof n === "object" && n !== null;
-            const i = e.lt !== t;
-            a = i || !r ? n : handleAsync(e, n);
-            if (!i && !r) e.lt = null;
+            const i = e.ct !== t;
+            c = i || !r ? n : handleAsync(e, n);
+            if (!i && !r) {
+                e.ct = 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.xe = false;
+            }
         }
         // On a status-free node clearStatus is a guaranteed no-op: every branch
         // in its body is gated on one of these fields, and with _statusFlags === 0
         // the flags write (create or not) stores the 0 already there.
-                if (e.xe !== 0 || e.yt !== undefined || e.me || e.Nt || e.At || e.je !== undefined || e._ !== undefined || e.R !== undefined || e.rt !== null) clearStatus(e, t);
+                if (e.He !== 0 || e.yt !== undefined || e.me || e.Pt || e.ht || e.Ke !== undefined || e._ !== undefined || e.R !== undefined || e.it !== null) clearStatus(e, t);
         // _optimisticLane is only ever assigned by engine paths.
                 if (e.i) GlobalQueue.De(e);
     } catch (t) {
-        // Track pending async in the lane (not the lane's source — it creates the lane
-        // but doesn't belong to it). Set lane BEFORE notifyStatus for downstream propagation.
-        if (t instanceof NotReadyError && currentOptimisticLane) GlobalQueue.be(e);
-        let n = false;
-        if (t instanceof NotReadyError) {
-            e.At = true;
-            if (GlobalQueue.Oe !== null) n = GlobalQueue.Oe(e, u);
-        }
-        notifyStatus(e, t instanceof NotReadyError ? STATUS_PENDING : STATUS_ERROR, t, undefined, t instanceof NotReadyError ? e.i : undefined);
-        if (n) GlobalQueue._e(e);
+        const n = t instanceof NotReadyError;
+        if (n && e.xe) {
+            // 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
+            // status, no downstream propagation, no transition, no lane
+            // registration — the committed loading value keeps serving. If the
+            // node is currently errored the error stays the answer until this
+            // retry can actually run.
+            parkLoadingWindow(e, t);
+        } 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);
+            let r = false;
+            if (n) {
+                e.ht = true;
+                if (GlobalQueue.Oe !== null) r = GlobalQueue.Oe(e, u);
+            }
+            notifyStatus(e, n ? STATUS_PENDING : STATUS_ERROR, t, undefined, n ? e.i : undefined);
+            if (r) GlobalQueue._e(e);
+        }
     } finally {
-        tracking = f;
-        latestReadActive = d;
-        if (S) stale = T;
+        tracking = E;
+        latestReadActive = S;
+        if (T) stale = O;
         e.D = REACTIVE_NONE | (t ? e.D & REACTIVE_SNAPSHOT_STALE : 0);
-        context = l;
+        context = a;
     }
     if (!e.me) {
         trimStaleDeps(e);
         const u = i ? unwrapOverride(e.A) : e.k === NOT_PENDING ? e.We : e.k;
-        let l = false;
+        let a = false;
         try {
-            l = !n && o || !e.ht || !e.ht(u, a);
+            a = !n && o || !e.Nt || !e.Nt(u, c);
         } 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
@@ -2253,13 +2360,13 @@ function recompute(e, t = false) {
         // its runner — happen here instead. `!create` matches the previous `initialized`
         // gate: the explicit recompute(node, true) inside effect() does not enqueue, so
         // effect() can call its runner synchronously for the first run.
-                if (n && l) {
+                if (n && a) {
             e.Qe = !e.me;
             // Reuse one bound runner per effect — runEffect no-ops on a stale
             // `_modified`, so re-enqueueing the same function is harmless.
-                        if (!t) e.Ze.enqueue(n, e.Ct ??= GlobalQueue.te.bind(null, e));
+                        if (!t) e.Xe.enqueue(n, e.gt ??= GlobalQueue.te.bind(null, e));
         }
-        if (e.me) ; else if (l) {
+        if (e.me) ; else if (a) {
             const o = i ? e.A : undefined;
             if (t || 
             // Plain sync flush (no transition on either side) commits effect
@@ -2267,23 +2374,26 @@ function recompute(e, t = false) {
             // commitPendingNodes) exists to sequence transition reveals, and
             // paying it per effect on the plain path is pure overhead.
             n && (activeTransition !== e.T || activeTransition === null) || r) {
-                e.We = a;
+                e.We = c;
                 // Lane-propagated correction: upstream data is fresh, correct the
                 // override unconditionally. The direct _value commit is the lane's
                 // own reveal schedule; drop any superseded older hold so its queued
                 // commit can't clobber the fresh value.
                                 if (i && r) {
-                    e.A = a === undefined ? OVERRIDE_UNDEFINED : a;
+                    e.A = c === undefined ? OVERRIDE_UNDEFINED : c;
                     e.k = NOT_PENDING;
                 }
             } else {
-                e.k = a;
+                e.k = c;
+                // 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 (l) e.xe = 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
                 // auto-revert/re-derive at commit. Skipped for plain flushes where the
                 // pending value commits before effects run.
-                                if ((activeTransition || e.T) && GlobalQueue.ae !== null) GlobalQueue.ae(e, a);
+                                if ((activeTransition || e.T) && GlobalQueue.ae !== null) GlobalQueue.ae(e, c);
             }
             // insertSubs only walks _subs (no scheduling of its own), so a
             // subscriber-less node has nothing to notify.
@@ -2293,8 +2403,10 @@ function recompute(e, t = false) {
             // 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.k === NOT_PENDING) queuePendingNode(e);
-            e.k = a;
-        } else if (e.ze != c) {
+            e.k = c;
+            if (l) e.xe = true;
+ // see the held branch above (#2990)
+                } else if (e.Je != f) {
             for (let t = e.U; t !== null; t = t.Ge) {
                 insertIntoHeapHeight(t.Ve, queueFor(t.Ve));
             }
@@ -2304,24 +2416,24 @@ function recompute(e, t = false) {
         // in an errored run and may sit on stale commits (#2949). Changed-value
         // recoveries ride insertSubs above; a comparator throw re-errored the node
         // (el._error re-set), so this only runs on a genuinely clean recovery.
-                if (s !== undefined && !l && !e.me) settleErroredDependents(e, s);
+                if (s !== undefined && !a && !e.me) settleErroredDependents(e, s);
     }
-    currentOptimisticLane = E;
-    const O = e.k !== NOT_PENDING || e.He !== null || e.Me !== null || (e.xe & (STATUS_PENDING | STATUS_UNINITIALIZED)) !== 0;
+    currentOptimisticLane = d;
+    const _ = e.k !== NOT_PENDING || e.Me !== null || e.$e !== null || (e.He & (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.
-        O && (!t || e.xe & STATUS_PENDING) && (!e.T || i) && queuePendingNode(e);
+        _ && (!t || e.He & STATUS_PENDING) && (!e.T || i) && queuePendingNode(e);
     e.T && n && activeTransition !== e.T && runInTransition(e.T, () => recompute(e));
 }
 
 function updateIfNecessary(e) {
     if (e.D & REACTIVE_CHECK) {
-        for (let t = e.Ke; t; t = t.Ye) {
-            const n = t.qe;
-            const r = n.Be || n;
+        for (let t = e.Ye; t; t = t.qe) {
+            const n = t.Be;
+            const r = n.Ze || n;
             if (r.ke) {
                 updateIfNecessary(r);
             }
@@ -2330,7 +2442,7 @@ function updateIfNecessary(e) {
             }
         }
     }
-    if (e.D & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY) || e.me && e.H < clock && !e.lt) {
+    if (e.D & (REACTIVE_DIRTY | REACTIVE_OPTIMISTIC_DIRTY) || e.me && e.H < clock && !e.ct) {
         recompute(e);
     }
     e.D = e.D & (REACTIVE_SNAPSHOT_STALE | REACTIVE_IN_HEAP | REACTIVE_IN_HEAP_HEIGHT);
@@ -2338,42 +2450,48 @@ function updateIfNecessary(e) {
 
 function computed(e, t) {
     const n = t?.transparent ?? false;
-    const r = {
+    // `in` (not `!== undefined`): an explicit `loadingValue: undefined` on a
+    // `T | undefined` node is a real commit #0. The typeof guard tolerates
+    // non-object option values that older call shapes force through `as any`.
+        const r = t !== null && typeof t === "object" && "loadingValue" in t;
+    const i = {
         id: inheritId(t, n, context),
-        Ue: (n ? CONFIG_TRANSPARENT : 0) | (t?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (!context || t?.lazy ? CONFIG_AUTO_DISPOSE : 0) | (t?.sync ? CONFIG_SYNC : 0) | (t?.gt ? CONFIG_NO_SNAPSHOT : 0) | (snapshotCaptureActive && ownerInSnapshotScope(context) ? CONFIG_IN_SNAPSHOT_SCOPE : 0),
-        ht: t?.equals != null ? t.equals : isEqual,
+        Ue: (n ? CONFIG_TRANSPARENT : 0) | (t?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (!context || t?.lazy ? CONFIG_AUTO_DISPOSE : 0) | (t?.sync ? CONFIG_SYNC : 0) | (t?.bt ? CONFIG_NO_SNAPSHOT : 0) | (snapshotCaptureActive && ownerInSnapshotScope(context) ? CONFIG_IN_SNAPSHOT_SCOPE : 0),
+        Nt: t?.equals != null ? t.equals : isEqual,
         F: t?.unobserved,
-        dt: null,
-        Ze: context?.Ze ?? globalQueue,
-        St: context?.St ?? defaultContext,
-        ct: 0,
+        St: null,
+        Xe: context?.Xe ?? globalQueue,
+        Tt: context?.Tt ?? defaultContext,
+        ft: 0,
         ke: e,
-        We: undefined,
-        ze: 0,
-        rt: null,
-        nt: undefined,
-        tt: null,
-        Ke: null,
-        ut: null,
-        It: 0,
+        We: r ? t.loadingValue : undefined,
+        Je: 0,
+        it: null,
+        rt: undefined,
+        nt: null,
+        Ye: null,
+        lt: null,
+        At: 0,
         U: null,
-        Ot: null,
+        _t: null,
         Z: context,
+        ut: null,
+        Et: null,
         st: null,
-        ft: null,
-        ot: null,
         D: t?.lazy ? REACTIVE_LAZY : REACTIVE_NONE,
-        xe: STATUS_UNINITIALIZED,
+        // A loadingValue node is born committed: commit #0 is already in _value.
+        He: r ? 0 : STATUS_UNINITIALIZED,
         H: clock,
         k: NOT_PENDING,
+        $e: null,
         Me: null,
-        He: null,
-        lt: null,
+        ct: null,
         T: null,
-        Nt: false
+        Pt: false,
+        xe: r
     };
-    setupComputedNode(r, t);
-    return r;
+    setupComputedNode(i, t);
+    return i;
 }
 
 /**
@@ -2386,41 +2504,42 @@ function computed(e, t) {
     const u = {
         id: inheritId(o, s, context),
         Ue: (s ? CONFIG_TRANSPARENT : 0) | (o?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (o?.sync ? CONFIG_SYNC : 0) | (snapshotCaptureActive && ownerInSnapshotScope(context) ? CONFIG_IN_SNAPSHOT_SCOPE : 0),
-        ht: false,
+        Nt: false,
         F: o?.unobserved,
-        dt: null,
-        Ze: context?.Ze ?? globalQueue,
-        St: context?.St ?? defaultContext,
-        ct: 0,
+        St: null,
+        Xe: context?.Xe ?? globalQueue,
+        Tt: context?.Tt ?? defaultContext,
+        ft: 0,
         ke: e,
         We: undefined,
-        ze: 0,
-        rt: null,
-        nt: undefined,
-        tt: null,
-        Ke: null,
-        ut: null,
-        It: 0,
+        Je: 0,
+        it: null,
+        rt: undefined,
+        nt: null,
+        Ye: null,
+        lt: null,
+        At: 0,
         U: null,
-        Ot: null,
+        _t: null,
         Z: context,
+        ut: null,
+        Et: null,
         st: null,
-        ft: null,
-        ot: null,
         D: REACTIVE_LAZY,
-        xe: STATUS_UNINITIALIZED,
+        He: STATUS_UNINITIALIZED,
         H: clock,
         k: NOT_PENDING,
+        $e: null,
         Me: null,
-        He: null,
-        lt: null,
+        ct: null,
         T: null,
-        Nt: false,
+        Pt: false,
+        xe: false,
         Qe: false,
-        bt: undefined,
-        Dt: t,
-        wt: n,
-        Et: undefined,
+        Dt: undefined,
+        wt: t,
+        vt: n,
+        dt: undefined,
         Fe: r,
         yt: i
     };
@@ -2433,23 +2552,23 @@ const lazyOptions = {
 };
 
 function setupComputedNode(e, t) {
-    e.tt = e;
-    const n = context?.Je ? context.et : context;
+    e.nt = e;
+    const n = context?.et ? context.tt : context;
     if (context) {
-        const t = context.ot;
+        const t = context.st;
         if (t === null) {
-            context.ot = e;
+            context.st = e;
         } else {
-            e.st = t;
-            t.ft = e;
-            context.ot = e;
+            e.ut = t;
+            t.Et = e;
+            context.st = e;
         }
     }
-    if (n) e.ze = n.ze + 1;
+    if (n) e.Je = n.Je + 1;
     if (GlobalQueue.ue !== null) GlobalQueue.ue(e);
     !t?.lazy && recompute(e, true);
     if (snapshotCaptureActive && !t?.lazy) {
-        if (!(e.xe & STATUS_PENDING) && !(e.Ue & CONFIG_NO_SNAPSHOT)) {
+        if (!(e.He & STATUS_PENDING) && !(e.Ue & CONFIG_NO_SNAPSHOT)) {
             e.Le = e.We === undefined ? NO_SNAPSHOT : e.We;
             snapshotSources.add(e);
         }
@@ -2458,19 +2577,19 @@ function setupComputedNode(e, t) {
 
 function signal(e, t, n = null) {
     const r = {
-        ht: t?.equals != null ? t.equals : isEqual,
-        Ue: (t?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (t?.gt ? CONFIG_NO_SNAPSHOT : 0),
+        Nt: t?.equals != null ? t.equals : isEqual,
+        Ue: (t?.ownedWrite ? CONFIG_OWNED_WRITE : 0) | (t?.bt ? CONFIG_NO_SNAPSHOT : 0),
         F: t?.unobserved,
         We: e,
         U: null,
-        Ot: null,
+        _t: null,
         H: clock,
-        Be: n,
-        it: n?.rt || null,
+        Ze: n,
+        ot: n?.it || null,
         k: NOT_PENDING
     };
-    n && (n.rt = r);
-    if (snapshotCaptureActive && !(r.Ue & CONFIG_NO_SNAPSHOT) && !((n?.xe ?? 0) & STATUS_PENDING)) {
+    n && (n.it = r);
+    if (snapshotCaptureActive && !(r.Ue & CONFIG_NO_SNAPSHOT) && !((n?.He ?? 0) & STATUS_PENDING)) {
         r.Le = e === undefined ? NO_SNAPSHOT : e;
         snapshotSources.add(r);
     }
@@ -2555,9 +2674,9 @@ function isEqual(e, t) {
  * snapshot / transition / lane / dev-strictRead state all take the full
  * resolution. Anything slow returns READ_SLOW; the caller then calls read().
  */ function readNodeFast(e) {
-    if (latestReadActive || pendingCheckActive || e.ke || e.Be || e.A !== undefined || e.Le !== undefined || activeTransition !== null || currentOptimisticLane !== null || snapshotCaptureActive || false) return READ_SLOW;
+    if (latestReadActive || pendingCheckActive || e.ke || e.Ze || e.A !== undefined || e.Le !== undefined || activeTransition !== null || currentOptimisticLane !== null || snapshotCaptureActive || false) return READ_SLOW;
     let t = context;
-    if (t?.Je) t = t.et;
+    if (t?.et) t = t.tt;
     if (t && tracking) link(e, t);
     return !t || e.k === NOT_PENDING ? e.We : e.k;
 }
@@ -2569,9 +2688,9 @@ function read(e) {
     // than the original node (which stays "pending" while held in a transition).
     if (latestReadActive) return GlobalQueue.de(e);
     let t = context;
-    if (t?.Je) t = t.et;
+    if (t?.et) t = t.tt;
     const n = e;
-    const r = e.Be;
+    const r = e.Ze;
     const i = r || e;
     // Handle isPending() mode: collect pending state while preserving normal read semantics.
     // Probe mode is suspended while preparing the node so nested reads during a
@@ -2589,31 +2708,31 @@ function read(e) {
         link(e, t, pendingCheckActive);
         if (i.ke) {
             const n = queueFor(e);
-            if (i.ze >= n.P) {
+            if (i.Je >= n.P) {
                 markNode(t);
                 markHeap(n);
                 updateIfNecessary(i);
             }
-            const r = i.ze;
+            const r = i.Je;
             // parent check is shallow, might need to be recursive
-                        if (r >= t.ze && e.Z !== t) {
-                t.ze = r + 1;
+                        if (r >= t.Je && e.Z !== t) {
+                t.Je = r + 1;
             }
         }
     }
-    if (i.xe & STATUS_PENDING) {
+    if (i.He & STATUS_PENDING) {
         if (t && !(stale && i.T && activeTransition !== i.T)) {
             // Per-lane suspension lives with the engine (a non-null lane implies it
             // is installed): under a lane, only same-lane pending async without an
             // active override throws.
-            if (currentOptimisticLane === null || GlobalQueue.Pe(i)) {
+            if (currentOptimisticLane === null || GlobalQueue.ye(i)) {
                 if (!tracking && e !== t) link(e, t);
                 throw i.me;
             }
-        } else if (t && i !== e && i.xe & STATUS_UNINITIALIZED) {
+        } else if (t && i !== e && i.He & STATUS_UNINITIALIZED) {
             if (!tracking && e !== t) link(e, t);
             throw i.me;
-        } else if (!t && i.xe & STATUS_UNINITIALIZED) {
+        } else if (!t && i.He & STATUS_UNINITIALIZED) {
             throw i.me;
         }
     }
@@ -2621,7 +2740,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 (i.ke && i.xe & STATUS_ERROR) {
+        if (i.ke && i.He & 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
@@ -2651,7 +2770,7 @@ function read(e) {
     // _pendingValue for correct fetching. The sub is recorded for replay at commit
     // so it re-runs with the new committed view. (Gate details live with the
     // engine — a non-null lane implies it is installed.)
-        if (currentOptimisticLane !== null && activeTransition !== null && t !== null && GlobalQueue.ye(e, i, t)) {
+        if (currentOptimisticLane !== null && activeTransition !== null && t !== null && GlobalQueue.Pe(e, i, t)) {
         return e.We;
     }
     // In optimistic lane context, return _value for optimistic/lane-assigned signals
@@ -2662,7 +2781,7 @@ function read(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.Te(e, o);
-    if (!t && i === e && typeof n.ke === "function" && e.Ue & CONFIG_AUTO_DISPOSE && !(i.xe & STATUS_PENDING) && !e.U) {
+    if (!t && i === e && typeof n.ke === "function" && e.Ue & CONFIG_AUTO_DISPOSE && !(i.He & STATUS_PENDING) && !e.U) {
         unobserved(e);
     }
     return o;
@@ -2679,7 +2798,7 @@ function setSignal(e, t) {
     if (typeof t === "function") t = t(n);
     // Uninitialized check first: the first commit has no previous value, so the
     // user comparator must not run against `undefined` (matches recompute).
-        const r = !!(e.xe & STATUS_UNINITIALIZED) || !e.ht || !e.ht(n, t);
+        const r = !!(e.He & STATUS_UNINITIALIZED) || !e.Nt || !e.Nt(n, t);
     if (!r) return t;
     if (e.k === NOT_PENDING) queuePendingNode(e);
     e.k = t;
@@ -2920,7 +3039,7 @@ function enableExternalSource(e) {
     if (!t) {
         throw new NoOwnerError;
     }
-    const n = hasContext(e, t) ? t.St[e.id] : e.defaultValue;
+    const n = hasContext(e, t) ? t.Tt[e.id] : e.defaultValue;
     if (isUndefined(n)) {
         throw new ContextNotFoundError;
     }
@@ -2941,14 +3060,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.St = {
-        ...n.St,
+        n.Tt = {
+        ...n.Tt,
         [e.id]: isUndefined(t) ? e.defaultValue : t
     };
 }
 
 function hasContext(e, t) {
-    return !isUndefined(t?.St[e.id]);
+    return !isUndefined(t?.Tt[e.id]);
 }
 
 function isUndefined(e) {
@@ -2972,7 +3091,7 @@ function isUndefined(e) {
     const n = e.A !== NOT_PENDING;
     const r = n ? unwrapOverride(e.A) : e.We;
     if (typeof t === "function") t = t(r);
-    const i = !!(e.xe & STATUS_UNINITIALIZED) || !e.ht || !e.ht(r, t);
+    const i = !!(e.He & STATUS_UNINITIALIZED) || !e.Nt || !e.Nt(r, t);
     if (!i) {
         // Same-value write with an active override still entangles the current
         // action's transition — the hold must outlast all overlapping actions.
@@ -3013,7 +3132,7 @@ function isUndefined(e) {
  */ function transitionBlocked(e) {
     for (let t = 0; t < e.L.length; t++) {
         const n = e.L[t];
-        if (hasActiveOverride(n) && "xe" in n && n.xe & STATUS_PENDING && n.me instanceof NotReadyError) {
+        if (hasActiveOverride(n) && "He" in n && n.He & STATUS_PENDING && n.me instanceof NotReadyError) {
             return true;
         }
     }
@@ -3031,7 +3150,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.xe & STATUS_PENDING)) t.xe &= ~STATUS_UNINITIALIZED;
+                if (!(t.He & STATUS_PENDING)) t.He &= ~STATUS_UNINITIALIZED;
         const r = t.A;
         t.A = NOT_PENDING;
         if (r !== NOT_PENDING && t.We !== unwrapOverride(r)) insertSubs(t, true);
@@ -3109,7 +3228,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.A !== undefined || !!e.i || !!(t.xe & STATUS_PENDING)) return true;
+    if (e.A !== undefined || !!e.i || !!(t.He & STATUS_PENDING)) return true;
     if (t === e && stale && n.t !== e) {
         // The committed view can hide a same-tick ambient write (a lane member —
         // even just an isPending companion flip — puts the reader "under a lane"
@@ -3130,8 +3249,8 @@ function cleanupCompletedLanes(e) {
  * can run before its OPT-dirty child propagates).
  */ function recomputeLane(e, t) {
     if (t) return resolveLane(e) ?? null;
-    for (let t = e.Ke; t; t = t.Ye) {
-        const n = t.qe;
+    for (let t = e.Ye; t; t = t.qe) {
+        const n = t.Be;
         if (n.D & REACTIVE_OPTIMISTIC_DIRTY) {
             const t = resolveLane(n);
             if (t) {
@@ -3178,8 +3297,8 @@ function trackOptimisticStore(e) {
     GlobalQueue.Ae = transitionBlocked;
     GlobalQueue.he = cleanupCompletedLanes;
     GlobalQueue.Ne = runLaneEffects;
-    GlobalQueue.ye = gatedRead;
-    GlobalQueue.Pe = laneSuspends;
+    GlobalQueue.Pe = gatedRead;
+    GlobalQueue.ye = laneSuspends;
     GlobalQueue.Ce = laneReadsCommitted;
     GlobalQueue.ge = recomputeLane;
     GlobalQueue.be = laneAsyncPending;
@@ -3217,7 +3336,7 @@ let pendingProbe = null;
 function collectPendingSources(e) {
     if (!pendingProbe) return;
     pendingProbe.sources.add(e);
-    const t = e.Be || e;
+    const t = e.Ze || e;
     if (t !== e) pendingProbe.sources.add(t);
 }
 
@@ -3247,20 +3366,20 @@ function collectPendingSources(e) {
     // not flow through it — matching the rails' behavior, where propagation
     // stopped at errored nodes. A DIRECT mark on an errored node still reads
     // pending (the count check above), also matching.
-        if (e.xe & STATUS_ERROR) return false;
+        if (e.He & STATUS_ERROR) return false;
     if (t.has(e)) return false;
     t.add(e);
-    const n = e.Be;
+    const n = e.Ze;
     if (n && markWalk(n, t)) return true;
     // Mid-recompute (the clearStatus companion poke runs before
     // trimStaleDeps), only the validated prefix [_deps.._depsTail] is this
     // pass's dependency set — walking past it would read dropped deps and
     // latch a stale verdict on the companion.
         const r = e;
-    const i = r.D & REACTIVE_RECOMPUTING_DEPS ? r.ut : undefined;
+    const i = r.D & REACTIVE_RECOMPUTING_DEPS ? r.lt : undefined;
     if (i !== null) {
-        for (let e = r.Ke ?? null; e !== null; e = e.Ye) {
-            if (!e._t && markWalk(e.qe, t)) return true;
+        for (let e = r.Ye ?? null; e !== null; e = e.qe) {
+            if (!e.Rt && markWalk(e.Be, t)) return true;
             if (e === i) break;
         }
     }
@@ -3272,15 +3391,22 @@ function collectPendingSources(e) {
 }
 
 function quietPending(e) {
-    if (e.je) {
-        for (const t of e.je) if (!t.Nt) return false;
+    if (e.Ke) {
+        for (const t of e.Ke) if (!t.Pt) return false;
         return true;
     }
-    return e.Nt;
+    return e.Pt;
 }
 
+// NOTE: a loadingValue node's open loading window (_loading) is verdict-quiet
+// on purpose: commit #0 answers the question by declaration, so the window
+// reads NOT pending — first-load affordances live in the value channel
+// (null / skeleton provenance the author encoded), and isPending stays what
+// it always was: refetch truth for an answered question. This keeps the
+// verdict fully correlated with transition-class machinery and keeps server
+// (always false) and client hydration trivially consistent.
 function newQuestionInFlight(e) {
-    return !!(e.xe & STATUS_PENDING) && !(e.xe & STATUS_UNINITIALIZED) && !quietPending(e);
+    return !!(e.He & STATUS_PENDING) && !(e.He & STATUS_UNINITIALIZED) && !quietPending(e);
 }
 
 function computePendingState(e) {
@@ -3290,17 +3416,21 @@ 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.Be;
+    const n = e.Ze;
     if (e.t) {
         const t = e.t;
-        const n = t.Be || t;
+        const n = t.Ze || t;
         return newQuestionInFlight(n);
     }
     if (n && e.k !== NOT_PENDING && !hasActiveOverride(e)) {
-        return !!(n.D & REACTIVE_MANUAL_WRITE) || !n.lt && !(n.xe & STATUS_PENDING) || !!(n.xe & STATUS_PENDING) && quietPending(n);
-    }
-    if (e.k !== NOT_PENDING && !(t.xe & STATUS_UNINITIALIZED)) {
-        if (hasActiveOverride(e)) return !e.ht || !e.ht(e.k, unwrapOverride(e.A));
+        return !!(n.D & REACTIVE_MANUAL_WRITE) || !n.ct && !(n.He & STATUS_PENDING) || !!(n.He & 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.k !== NOT_PENDING && !(t.He & STATUS_UNINITIALIZED) && !t.xe) {
+        if (hasActiveOverride(e)) return !e.Nt || !e.Nt(e.k, unwrapOverride(e.A));
         return true;
     }
     return newQuestionInFlight(t);
@@ -3319,7 +3449,7 @@ function updatePendingSignal(e) {
 }
 
 function updateChildCompanions(e) {
-    for (let t = e.rt; t !== null; t = t.it) {
+    for (let t = e.it; t !== null; t = t.ot) {
         if (t._ || t.R) updatePendingSignal(t);
     }
 }
@@ -3340,7 +3470,7 @@ function updateChildCompanions(e) {
         r.add(e);
         if (e._ || e.R) n(e);
         for (let t = e.U; t !== null; t = t.Ge) visit(t.Ve);
-        for (let t = e.rt ?? null; t !== null; t = t.it) {
+        for (let t = e.it ?? null; t !== null; t = t.ot) {
             visit(t);
         }
     };
@@ -3403,18 +3533,18 @@ function getLatestValueComputed(e) {
         // until the flush (#2922). Mirror the tracked-read pull here: mark the
         // queued staleness through the graph, then bring the shadow up to date.
         const e = queueFor(t);
-        if (t.ze >= e.P && !(t.D & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE))) {
+        if (t.Je >= e.P && !(t.D & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE))) {
             markHeap(e);
             prepareComputed(t, true);
         }
         i = read(t);
     } catch (t) {
-        if (t instanceof NotReadyError && (!context || !(e.xe & STATUS_UNINITIALIZED))) return r;
+        if (t instanceof NotReadyError && (!context || !(e.He & STATUS_UNINITIALIZED))) return r;
         throw t;
     } finally {
         setLatestReadActive(n);
     }
-    if (t.xe & STATUS_PENDING) return r;
+    if (t.He & STATUS_PENDING) return r;
     if (stale && currentOptimisticLane && t.i) {
         const e = findLane(t.i);
         const n = findLane(currentOptimisticLane);
@@ -3433,7 +3563,7 @@ function getLatestValueComputed(e) {
 /** The isPending()-probe read path, installed as GlobalQueue._pendingCheck. */ function pendingCheckRead(e, t, n, r) {
     setPendingCheckActive(false);
     if (typeof e.ke === "function") prepareComputed(e, true);
-    const i = n.xe;
+    const i = n.He;
     if (t && i & STATUS_PENDING && i & STATUS_UNINITIALIZED) {
         if (tracking && e !== t) link(e, t);
         setPendingCheckActive(true);
@@ -3449,10 +3579,10 @@ function recordFreshRead(e, t) {
 }
 
 function applyReask(e, t) {
-    const n = !!(e.xe & STATUS_PENDING);
-    const r = t && !(n && !e.Nt);
-    const i = n && e.Nt !== r;
-    e.Nt = r;
+    const n = !!(e.He & STATUS_PENDING);
+    const r = t && !(n && !e.Pt);
+    const i = n && e.Pt !== r;
+    e.Pt = r;
     return i;
 }
 
@@ -3492,7 +3622,7 @@ function isPending(e) {
     } catch (e) {
         collectPending();
         if (e instanceof NotReadyError) {
-            const t = !!(e.source?.xe & STATUS_UNINITIALIZED);
+            const t = !!(e.source?.He & STATUS_UNINITIALIZED);
             if (r.found && !t) return true;
             if (context && t) throw e;
         }
@@ -3534,15 +3664,15 @@ GlobalQueue.Re = witnessAffects;
     const i = !!r?.user;
     const o = createEffectNode(e, t, n, i ? EFFECT_USER : EFFECT_RENDER, notifyEffectStatus, r);
     recompute(o, true);
-    !r?.defer && (o.Fe === EFFECT_USER || r?.schedule ? o.Ze.enqueue(o.Fe, runEffect.bind(null, o)) : runEffect(o));
+    !r?.defer && (o.Fe === EFFECT_USER || r?.schedule ? o.Xe.enqueue(o.Fe, runEffect.bind(null, o)) : runEffect(o));
 }
 
 function notifyEffectStatus(e, t) {
     // Use passed values if provided, otherwise read from node
-    const n = e !== undefined ? e : this.xe;
+    const n = e !== undefined ? e : this.He;
     const r = t !== undefined ? t : this.me;
     if (n & STATUS_ERROR) {
-        this.Ze.notify(this, STATUS_PENDING, 0);
+        this.Xe.notify(this, STATUS_PENDING, 0);
         if (this.Fe === EFFECT_USER) {
             // The error handler is the error arm of the effect phase (#2840 ruling):
             // queue it like the effect function. It runs in the same imperative,
@@ -3553,18 +3683,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.xe & STATUS_ERROR) {
+            if (this.He & STATUS_ERROR) {
                 this.Qe = true;
-                this.Ze.enqueue(this.Fe, this.Ct ??= runEffect.bind(null, this));
+                this.Xe.enqueue(this.Fe, this.gt ??= runEffect.bind(null, this));
             }
             return;
         }
-        if (!this.Ze.notify(this, STATUS_ERROR, STATUS_ERROR)) {
+        if (!this.Xe.notify(this, STATUS_ERROR, STATUS_ERROR)) {
             haltReactivity(unwrapStatusError(r));
             throw r;
         }
     } else if (this.Fe === EFFECT_RENDER) {
-        this.Ze.notify(this, STATUS_PENDING | STATUS_ERROR, n, r);
+        this.Xe.notify(this, STATUS_PENDING | STATUS_ERROR, n, r);
     }
 }
 
@@ -3580,41 +3710,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.xe & STATUS_ERROR && e.Fe === EFFECT_USER) {
+        if (e.He & STATUS_ERROR && e.Fe === EFFECT_USER) {
         const t = unwrapStatusError(e.me);
-        e.bt = e.We;
+        e.Dt = e.We;
         e.Qe = false;
         try {
-            e.wt ? e.wt(t, () => {
-                const t = e.Et;
-                e.Et = undefined;
+            e.vt ? e.vt(t, () => {
+                const t = e.dt;
+                e.dt = undefined;
                 t?.();
             }) : console.error(t);
         } catch (t) {
-            if (!e.Ze.notify(e, STATUS_ERROR, STATUS_ERROR)) {
+            if (!e.Xe.notify(e, STATUS_ERROR, STATUS_ERROR)) {
                 haltReactivity(t);
                 throw t;
             }
         }
         return;
     }
-    const t = e.Et;
-    e.Et = undefined;
+    const t = e.dt;
+    e.dt = undefined;
     try {
         t?.();
-        const n = e.Dt(e.We, e.bt);
+        const n = e.wt(e.We, e.Dt);
         if (false && n !== undefined && typeof n !== "function") ;
         // The final cleanup is invoked by disposeChildren at true disposal.
-                e.Et = n;
+                e.dt = n;
     } catch (t) {
         e.me = new StatusError(e, t);
-        e.xe |= STATUS_ERROR;
-        if (!e.Ze.notify(e, STATUS_ERROR, STATUS_ERROR)) {
+        e.He |= STATUS_ERROR;
+        if (!e.Xe.notify(e, STATUS_ERROR, STATUS_ERROR)) {
             haltReactivity(t);
             throw t;
         }
     } finally {
-        e.bt = e.We;
+        e.Dt = e.We;
         e.Qe = false;
     }
 }
@@ -3634,32 +3764,32 @@ GlobalQueue.te = runEffect;
         } finally {}
     };
     const n = computed(() => {
-        const t = n.Et;
-        n.Et = undefined;
+        const t = n.dt;
+        n.dt = undefined;
         t?.();
         const r = staleValues(e);
-        n.Et = r;
+        n.dt = r;
     }, {
         ...t,
         lazy: true
     });
-    n.Et = undefined;
+    n.dt = undefined;
     n.Ue = n.Ue & ~CONFIG_AUTO_DISPOSE | CONFIG_CHILDREN_FORBIDDEN;
     n.Qe = true;
     n.Fe = EFFECT_TRACKED;
     n.yt = (e, t) => {
-        const r = e !== undefined ? e : n.xe;
+        const r = e !== undefined ? e : n.He;
         if (r & STATUS_ERROR) {
-            n.Ze.notify(n, STATUS_PENDING, 0);
+            n.Xe.notify(n, STATUS_PENDING, 0);
             const e = t !== undefined ? t : n.me;
-            if (!n.Ze.notify(n, STATUS_ERROR, STATUS_ERROR)) {
+            if (!n.Xe.notify(n, STATUS_ERROR, STATUS_ERROR)) {
                 haltReactivity(unwrapStatusError(e));
                 throw e;
             }
         }
     };
-    n.Xe = run;
-    n.Ze.enqueue(EFFECT_USER, run);
+    n.ze = run;
+    n.Xe.enqueue(EFFECT_USER, run);
 }
 
 function restoreTransition(e, t) {
@@ -3852,38 +3982,6 @@ function createSignal(e, t) {
     return [ accessor(n), setSignal.bind(null, n) ];
 }
 
-/**
- * Creates a readonly derived reactive memoized signal.
- *
- * ```typescript
- * const value = createMemo<T>(compute, options?: MemoOptions<T>);
- * ```
- * @param compute a function that receives its previous value and returns a new value used to react on a computation
- * @param options `MemoOptions` -- id, name, equals, unobserved, lazy
- *
- * @example
- * ```ts
- * const [first, setFirst] = createSignal("Ada");
- * const [last, setLast] = createSignal("Lovelace");
- *
- * const fullName = createMemo(() => `${first()} ${last()}`);
- *
- * fullName(); // "Ada Lovelace"
- * ```
- *
- * @example
- * ```ts
- * // Async memo — reads surface as pending inside <Loading>
- * const user = createMemo(async () => {
- *   const res = await fetch(`/users/${id()}`);
- *   return res.json();
- * });
- * ```
- *
- * @description https://docs.solidjs.com/reference/basic-reactivity/create-memo
- */
-// NoInfer keeps the previous-value parameter from influencing T inference, so
-// the memo/effect result type is still driven by the compute return type.
 function createMemo(e, t) {
     return accessor(computed(e, t));
 }
@@ -3909,7 +4007,7 @@ function createEffect(e, t, n) {
  * ```
  * @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
- * @param options `EffectOptions` -- name, defer, schedule
+ * @param options `EffectOptions` -- name, defer, schedule, transparent
  *
  * @example
  * ```ts
@@ -4057,9 +4155,9 @@ function createEffect(e, t, n) {
             // route through the inherited queue.
             const i = getOwner();
             const o = new MicrotaskQueue;
-            o.Z = i.Ze;
+            o.Z = i.Xe;
  // notify() forwards up the normal chain
-                        i.Ze = o;
+                        i.Xe = 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
@@ -4906,10 +5004,18 @@ function createProjectionInternal(e, t, n) {
         return t;
     };
     const s = wrapProjection(t);
+    // seedLoadingValue: the firewall is born committed (the seed is commit #0);
+    // the internal handleAsync serves it during the derive's first flight. The
+    // node's own value channel is void, so the loading value itself is
+    // `undefined` — presence of the key is what flips the mode.
+        let u;
+    if (n?.seedLoadingValue) u = {
+        loadingValue: undefined
+    };
     r = computed(() => {
         if (!r) r = getOwner();
         runProjectionComputed(s, e, n?.key === undefined ? "id" : n.key);
-    }, undefined);
+    }, u);
     r.Ue &= ~CONFIG_AUTO_DISPOSE;
     return {
         store: s,
@@ -4984,16 +5090,43 @@ function createProjectionInternal(e, t, n) {
     const o = getOwner();
     let s = false;
     let u;
-    const l = new Proxy(e, createWriteTraps(() => !s || o.lt === u, i));
-    storeSetter(l, i => {
-        u = t(i);
+    // Open loading window (seedLoadingValue): the observable store IS commit #0
+    // for the whole first flight, so the derive works a detached shadow of the
+    // seed — draft writes (pre-await, or between yields) land on the shadow and
+    // cannot tear through to readers (#2988; store reads resolve from the live
+    // backing, and the born-committed firewall removed the status gate that hid
+    // windowless drafts). Every commit point — sync return, each yield, the
+    // async landing — reconciles the shadow through the normal commit path, so
+    // a fully-sync derive still lands immediately (commit #0 superseded before
+    // any observer runs, same as a sync answer superseding loadingValue). The
+    // JSON round-trip matches the server's frozen-seed copy (seedLock): a
+    // loading-window seed is renderable data by contract. Optimistic note:
+    // onDraftWrite (override clearing) shifts from write-time to commit-time
+    // for the shadow run — an invisible draft write must not clobber a visible
+    // optimistic override mid-window.
+        const l = o.xe ? JSON.parse(JSON.stringify(e[$TARGET][STORE_VALUE])) : null;
+    const a = new Proxy(e, createWriteTraps(() => !s || o.ct === u, i));
+    storeSetter(a, i => {
+        u = t(l ?? i);
         s = true;
         const commit = t => {
+            // Shadow run: a void/self return is the mutation form — the shadow
+            // carries the writes and is what commits. Commit a detached snapshot,
+            // never the shadow itself: reconcile adopts a new root value by
+            // identity, and handing it the live shadow would fuse the draft to the
+            // observable store — later shadow writes would mutate the backing
+            // silently and the next yield would diff the shadow against itself.
+            if (l && (t === undefined || t === l)) t = JSON.parse(JSON.stringify(l));
             if (t === i || t === undefined) return;
             const write = () => storeSetter(e, e => reconcileState(t, e, n, true));
             r ? r(write) : write();
         };
-        commit(handleAsync(o, u, commit));
+        const a = handleAsync(o, u, commit);
+        // A still-open window after handleAsync means the return was the
+        // commit-#0 fall-through, not a landing — real landings arrive through
+        // the setter. A closed one is a genuine sync landing (windowless nodes
+        // were never open); commit it.
+                if (!o.xe) commit(a);
     });
     return o;
 }
@@ -5653,7 +5786,7 @@ function prepareStoreWrite(e, t, n) {
     }
     const r = e[STORE_VALUE];
     const i = r[n];
-    if (snapshotCaptureActive && typeof n !== "symbol" && !((e[STORE_FIREWALL]?.xe ?? 0) & STATUS_PENDING)) {
+    if (snapshotCaptureActive && typeof n !== "symbol" && !((e[STORE_FIREWALL]?.He ?? 0) & STATUS_PENDING)) {
         if (!e[STORE_SNAPSHOT_PROPS]) {
             e[STORE_SNAPSHOT_PROPS] = Object.create(null);
             snapshotSources?.add(e);
@@ -5776,7 +5909,7 @@ let Writing = null;
  */ function throwIfUnreadable(e) {
     const t = e[STORE_FIREWALL];
     if (!t) return;
-    const n = t.xe;
+    const n = t.He;
     if (n & STATUS_ERROR || n & STATUS_UNINITIALIZED && n & STATUS_PENDING) throw t.me ?? new NotReadyError(t);
 }
 
@@ -6139,7 +6272,7 @@ function createStore(e, t, n) {
  * flush that would surface them, before effects run — verdict-only, netting
  * no visual change.
  */ function notifyMarkBoundaries(e) {
-    if (!e.U && !e.rt) return;
+    if (!e.U && !e.it) return;
     const t = new NotReadyError(e);
     t.ve = true;
     const n = new Set;
@@ -6242,7 +6375,7 @@ function createOptimisticStore(e, t, n) {
                 const e = GlobalQueue.Ae;
         GlobalQueue.Ae = t => {
             for (const e of t.V) {
-                if ((e[$TARGET]?.[STORE_FIREWALL]?.xe ?? 0) & STATUS_PENDING) return true;
+                if ((e[$TARGET]?.[STORE_FIREWALL]?.He ?? 0) & STATUS_PENDING) return true;
             }
             return e(t);
         };
@@ -6328,7 +6461,7 @@ function clearOptimisticStores(e, t) {
                 a.p = null;
                 a.k = NOT_PENDING;
                 a.We = i;
-                if (!a.ht || !a.ht(o, i)) {
+                if (!a.Nt || !a.Nt(o, i)) {
                     insertSubs(a, true);
                     schedule();
                 }
@@ -6399,6 +6532,11 @@ function createOptimisticProjectionInternal(e, t, n) {
                 setProjectionWriteActive(t);
             }
         };
+        // seedLoadingValue: born-committed firewall, same as createProjection.
+                let t;
+        if (n?.seedLoadingValue) t = {
+            loadingValue: undefined
+        };
         r = computed(() => {
             setProjectionWriteActive(true);
             try {
@@ -6406,7 +6544,7 @@ function createOptimisticProjectionInternal(e, t, n) {
             } finally {
                 setProjectionWriteActive(false);
             }
-        }, undefined);
+        }, t);
         r.Ue &= ~CONFIG_AUTO_DISPOSE;
     }
     return {
@@ -6831,23 +6969,23 @@ function mapArray(e, t, n) {
     const i = t.length > 1;
     const o = t;
     const s = {
-        vt: createOwner(),
-        Lt: 0,
-        Gt: e,
-        Vt: [],
-        Ut: o,
-        kt: [],
+        Lt: createOwner(),
+        Gt: 0,
+        Vt: e,
+        Ut: [],
+        kt: o,
         Wt: [],
-        Ft: r,
-        Qt: r || n?.keyed === false ? [] : undefined,
-        xt: i && n?.keyed !== false ? [] : undefined,
-        Ht: n?.keyed === false,
-        Mt: n?.fallback
+        Ft: [],
+        Qt: r,
+        xt: r || n?.keyed === false ? [] : undefined,
+        Ht: i && n?.keyed !== false ? [] : undefined,
+        Mt: n?.keyed === false,
+        $t: n?.fallback
     };
     const u = computed(updateKeyedMap.bind(s));
     // Untracked reads inside the internal owner resolve via _parentComputed; routing
     // them through node lets store-proxy lookups see pending writes (not stale _value).
-        s.vt.et = u;
+        s.Lt.tt = u;
     u.Ue &= ~CONFIG_AUTO_DISPOSE;
     return accessor(u);
 }
@@ -6866,52 +7004,52 @@ const pureOptions = {
 // strong-abort ordering: removed rows now dispose AFTER the pass's new rows
 // are created (you cannot destroy state before knowing the pass will land).
 function updateKeyedMap() {
-    const e = this.Gt() || [], t = e.length;
+    const e = this.Vt() || [], t = e.length;
     e[$TRACK];
  // top level tracking
-        runWithOwner(this.vt, () => {
+        runWithOwner(this.Lt, () => {
         let n, r, i, o, 
         // Mappers write freshly-created row/index signals into the STAGE
         // arrays (`rows`/`indexes`), never into `this._rows`/`this._indexes`.
-        s = this.Qt ? this.Ht ? () => {
+        s = this.xt ? this.Mt ? () => {
             i[r] = signal(e[r], pureOptions);
-            return this.Ut(accessor(i[r]), r);
+            return this.kt(accessor(i[r]), r);
         } : () => {
             i[r] = signal(e[r], pureOptions);
             o && (o[r] = signal(r, pureOptions));
-            return this.Ut(accessor(i[r]), o ? accessor(o[r]) : undefined);
-        } : this.xt ? () => {
+            return this.kt(accessor(i[r]), o ? accessor(o[r]) : undefined);
+        } : this.Ht ? () => {
             const t = e[r];
             o[r] = signal(r, pureOptions);
-            return this.Ut(t, accessor(o[r]));
+            return this.kt(t, accessor(o[r]));
         } : () => {
             const t = e[r];
-            return this.Ut(t);
+            return this.kt(t);
         };
         // fast path for empty arrays
                 if (t === 0) {
-            if (this.Lt !== 0) {
-                this.vt.dispose(false);
+            if (this.Gt !== 0) {
+                this.Lt.dispose(false);
+                this.Ft = [];
+                this.Ut = [];
                 this.Wt = [];
-                this.Vt = [];
-                this.kt = [];
-                this.Lt = 0;
-                this.Qt && (this.Qt = []);
+                this.Gt = 0;
                 this.xt && (this.xt = []);
+                this.Ht && (this.Ht = []);
             }
-            if (this.Mt && !this.kt[0]) {
+            if (this.$t && !this.Wt[0]) {
                 // an aborted fallback attempt leaves an owner without a mapping;
                 // dispose it before re-creating
-                this.Wt[0]?.dispose();
-                this.kt[0] = runWithOwner(this.Wt[0] = createOwner(), this.Mt);
+                this.Ft[0]?.dispose();
+                this.Wt[0] = runWithOwner(this.Ft[0] = createOwner(), this.$t);
             }
         }
         // fast path for new create
-         else if (this.Lt === 0) {
+         else if (this.Gt === 0) {
             const u = new Array(t);
             const l = new Array(t);
-            i = this.Qt && new Array(t);
-            o = this.xt && new Array(t);
+            i = this.xt && new Array(t);
+            o = this.Ht && new Array(t);
             try {
                 for (r = 0; r < t; r++) u[r] = runWithOwner(l[r] = createOwner(), s);
             } catch (e) {
@@ -6919,43 +7057,43 @@ function updateKeyedMap() {
                 throw e;
             }
             // commit
-                        if (this.Wt[0]) this.Wt[0].dispose();
+                        if (this.Ft[0]) this.Ft[0].dispose();
  // previous fallback
-                        this.kt = u;
-            this.Wt = l;
-            i && (this.Qt = i);
-            o && (this.xt = o);
-            this.Vt = e.slice(0);
-            this.Lt = t;
+                        this.Wt = u;
+            this.Ft = l;
+            i && (this.xt = i);
+            o && (this.Ht = o);
+            this.Ut = e.slice(0);
+            this.Gt = t;
         } else {
             let u, l, a, c, f, E, d, S, T;
             // skip common prefix
-                        for (u = 0, l = Math.min(this.Lt, t); u < l && (this.Vt[u] === e[u] || this.Qt && compare(this.Ft, this.Vt[u], e[u])); u++) {
-                if (this.Qt) setSignal(this.Qt[u], e[u]);
+                        for (u = 0, l = Math.min(this.Gt, t); u < l && (this.Ut[u] === e[u] || this.xt && compare(this.Qt, this.Ut[u], e[u])); u++) {
+                if (this.xt) setSignal(this.xt[u], e[u]);
             }
             // skip common suffix — counted only; retained entries land in one pass
             // at commit instead of being staged and copied twice
-                        for (l = this.Lt - 1, a = t - 1; l >= u && a >= u && (this.Vt[l] === e[a] || this.Qt && compare(this.Ft, this.Vt[l], e[a])); l--, 
+                        for (l = this.Gt - 1, a = t - 1; l >= u && a >= u && (this.Ut[l] === e[a] || this.xt && compare(this.Qt, this.Ut[l], e[a])); l--, 
             a--) ;
             // no structural change (every position matched in place at equal
             // length — the common post-reconcile shape): keep the same mapped
             // array identity so downstream consumers don't re-run at all
-                        if (u === t && this.Lt === t) {
-                this.Vt = e.slice(0);
+                        if (u === t && this.Gt === t) {
+                this.Ut = e.slice(0);
                 return;
             }
-            const O = t - this.Lt;
+            const O = t - this.Gt;
             const _ = new Array(t);
             const R = new Array(t);
-            i = this.Qt ? new Array(t) : undefined;
-            o = this.xt ? new Array(t) : undefined;
+            i = this.xt ? new Array(t) : undefined;
+            o = this.Ht ? new Array(t) : undefined;
             // 0) prepare a map of all indices in the changed window of newItems,
             // scanning backwards so we encounter them in natural order
                         E = new Map;
             d = new Array(a + 1);
             for (r = a; r >= u; r--) {
                 c = e[r];
-                f = this.Ft ? this.Ft(c) : c;
+                f = this.Qt ? this.Qt(c) : c;
                 n = E.get(f);
                 d[r] = n === undefined ? -1 : n;
                 E.set(f, r);
@@ -6964,17 +7102,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.Vt[n];
-                f = this.Ft ? this.Ft(c) : c;
+                c = this.Ut[n];
+                f = this.Qt ? this.Qt(c) : c;
                 r = E.get(f);
                 if (r !== undefined && r !== -1) {
-                    _[r] = this.kt[n];
-                    R[r] = this.Wt[n];
-                    i && (i[r] = this.Qt[n]);
-                    o && (o[r] = this.xt[n]);
+                    _[r] = this.Wt[n];
+                    R[r] = this.Ft[n];
+                    i && (i[r] = this.xt[n]);
+                    o && (o[r] = this.Ht[n]);
                     r = d[r];
                     E.set(f, r);
-                } else (S ??= []).push(this.Wt[n]);
+                } else (S ??= []).push(this.Ft[n]);
             }
             // 2) create new rows into the temp arrays; an abort disposes only these
                         try {
@@ -6991,38 +7129,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.kt[n];
-                R[n] = this.Wt[n];
-                i && (i[n] = this.Qt[n]);
-                o && (o[n] = this.xt[n]);
+                _[n] = this.Wt[n];
+                R[n] = this.Ft[n];
+                i && (i[n] = this.xt[n]);
+                o && (o[n] = this.Ht[n]);
             }
             for (r = u; r <= a; r++) {
                 if (i) setSignal(i[r], e[r]);
                 if (o) setSignal(o[r], r);
             }
             for (r = a + 1; r < t; r++) {
-                _[r] = this.kt[r - O];
-                R[r] = this.Wt[r - O];
+                _[r] = this.Wt[r - O];
+                R[r] = this.Ft[r - O];
                 if (i) {
-                    i[r] = this.Qt[r - O];
+                    i[r] = this.xt[r - O];
                     setSignal(i[r], e[r]);
                 }
                 if (o) {
-                    o[r] = this.xt[r - O];
+                    o[r] = this.Ht[r - O];
                     if (O !== 0) setSignal(o[r], r);
                 }
             }
-            this.kt = _;
-            this.Wt = R;
-            i && (this.Qt = i);
-            o && (this.xt = o);
-            this.Lt = t;
+            this.Wt = _;
+            this.Ft = R;
+            i && (this.xt = i);
+            o && (this.Ht = o);
+            this.Gt = t;
             // save a copy of the mapped items for the next update
-                        this.Vt = e.slice(0);
+                        this.Ut = e.slice(0);
             if (S) for (n = 0; n < S.length; n++) S[n].dispose();
         }
     });
-    return this.kt;
+    return this.Wt;
 }
 
 /**
@@ -7042,21 +7180,21 @@ function updateKeyedMap() {
  */ function repeat(e, t, n) {
     const r = t;
     const i = {
-        vt: createOwner(),
-        Lt: 0,
-        $t: 0,
-        jt: e,
-        Ut: r,
+        Lt: createOwner(),
+        Gt: 0,
+        jt: 0,
+        Kt: e,
+        kt: r,
+        Ft: [],
         Wt: [],
-        kt: [],
-        Kt: n?.from,
-        Mt: n?.fallback
+        Yt: n?.from,
+        $t: n?.fallback
     };
     const o = computed(updateRepeat.bind(i));
     // Same as mapArray: untracked reads inside the internal owner resolve via
     // _parentComputed, so async reads in row callbacks register with the node
     // (pending tracking + post-settle retry) instead of vanishing.
-        i.vt.et = o;
+        i.Lt.tt = o;
     o.Ue &= ~CONFIG_AUTO_DISPOSE;
     return accessor(o);
 }
@@ -7069,55 +7207,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.jt();
-    const t = this.Kt?.() || 0;
-    runWithOwner(this.vt, () => {
+    const e = this.Kt();
+    const t = this.Yt?.() || 0;
+    runWithOwner(this.Lt, () => {
         if (e === 0) {
-            if (this.Lt !== 0) {
-                this.vt.dispose(false);
+            if (this.Gt !== 0) {
+                this.Lt.dispose(false);
+                this.Ft = [];
                 this.Wt = [];
-                this.kt = [];
-                this.Lt = 0;
+                this.Gt = 0;
                 // Reset offset to match the cleared data (#2767, repro 2).
-                                this.$t = 0;
+                                this.jt = 0;
             }
-            if (this.Mt && !this.kt[0]) {
+            if (this.$t && !this.Wt[0]) {
                 // an aborted fallback attempt leaves an owner without a mapping;
                 // dispose it before re-creating
-                this.Wt[0]?.dispose();
-                this.kt[0] = runWithOwner(this.Wt[0] = createOwner(), this.Mt);
+                this.Ft[0]?.dispose();
+                this.Wt[0] = runWithOwner(this.Ft[0] = createOwner(), this.$t);
             }
             return;
         }
         const n = t + e;
-        const r = this.$t + this.Lt;
+        const r = this.jt + this.Gt;
         // Retained overlap [keepStart, keepEnd) in global indexes; empty when the
         // windows are disjoint or when coming from empty/fallback.
-                const i = Math.max(t, this.$t);
+                const i = Math.max(t, this.jt);
         const o = Math.min(n, r);
         const s = new Array(e);
         const u = new Array(e);
         for (let e = i; e < o; e++) {
-            u[e - t] = this.Wt[e - this.$t];
-            s[e - t] = this.kt[e - this.$t];
+            u[e - t] = this.Ft[e - this.jt];
+            s[e - t] = this.Wt[e - this.jt];
         }
         try {
             for (let e = t; e < n; e++) {
                 if (e >= i && e < o) continue;
-                s[e - t] = runWithOwner(u[e - t] = createOwner(), () => this.Ut(e));
+                s[e - t] = runWithOwner(u[e - t] = createOwner(), () => this.kt(e));
             }
         } catch (e) {
             for (let e = t; e < n; e++) if ((e < i || e >= o) && u[e - t]) u[e - t].dispose();
             throw e;
         }
         // commit: dispose the previous fallback or the rows leaving the window
-                if (this.Lt === 0) this.Wt[0]?.dispose(); else for (let e = this.$t; e < r; e++) if (e < t || e >= n) this.Wt[e - this.$t].dispose();
-        this.kt = s;
-        this.Wt = u;
-        this.$t = t;
-        this.Lt = e;
+                if (this.Gt === 0) this.Ft[0]?.dispose(); else for (let e = this.jt; e < r; e++) if (e < t || e >= n) this.Ft[e - this.jt].dispose();
+        this.Wt = s;
+        this.Ft = u;
+        this.jt = t;
+        this.Gt = e;
     });
-    return this.kt;
+    return this.Wt;
 }
 
 function compare(e, t, n) {
@@ -7130,21 +7268,21 @@ function boundaryComputed(e, t) {
     });
     n.yt = (e, t) => {
         // Use passed values if provided, otherwise read from node
-        const r = e !== undefined ? e : n.xe;
+        const r = e !== undefined ? e : n.He;
         const i = t !== undefined ? t : n.me;
         // Notify both status dimensions like a render effect does; the queue chain
         // consumes this boundary's own type and forwards the remainder upward until
         // a boundary that handles it is found.
-                n.xe &= ~n.Yt;
-        const o = n.Ze.notify(n, STATUS_PENDING | STATUS_ERROR, r, i);
+                n.He &= ~n.qt;
+        const o = n.Xe.notify(n, STATUS_PENDING | STATUS_ERROR, r, i);
         // The queue is the only propagation channel: a foreign status must not stay
         // reader-visible on the tree, or reads re-throw it across the boundary and
         // link unrelated ambient contexts (the #2809 nested-boundary loop). Deps are
         // untouched, so the tree still recomputes when the foreign source settles.
-                const s = r & ~n.Yt & (STATUS_PENDING | STATUS_ERROR);
+                const s = r & ~n.qt & (STATUS_PENDING | STATUS_ERROR);
         if (s) {
-            n.xe &= ~s;
-            if (n.me === i && !(n.xe & (STATUS_PENDING | STATUS_ERROR))) n.me = undefined;
+            n.He &= ~s;
+            if (n.me === i && !(n.He & (STATUS_PENDING | STATUS_ERROR))) n.me = undefined;
         }
         // An ERROR the chain could not deliver to any boundary is uncaught. The
         // scrub above already removed it from reader-visible state, so without
@@ -7155,16 +7293,16 @@ function boundaryComputed(e, t) {
             throw i;
         }
     };
-    n.Yt = t;
+    n.qt = t;
     n.Ue &= ~CONFIG_AUTO_DISPOSE;
     recompute(n, true);
     return n;
 }
 
 function createBoundChildren(e, t, n, r) {
-    const i = e.Ze;
-    i.addChild(e.Ze = n);
-    cleanup(() => i.removeChild(e.Ze));
+    const i = e.Xe;
+    i.addChild(e.Xe = n);
+    cleanup(() => i.removeChild(e.Xe));
     return runWithOwner(e, () => {
         const e = computed(t);
         return boundaryComputed(() => flatten(read(e)), r);
@@ -7186,53 +7324,53 @@ function isRevealController(e) {
 }
 
 function isSlotReady(e) {
-    return isRevealController(e) ? e.qt() : e.Bt.size === 0 && !e.Zt;
+    return isRevealController(e) ? e.Bt() : e.Zt.size === 0 && !e.Xt;
 }
 
 function isSlotMinimallyReady(e) {
-    return isRevealController(e) ? e.Xt() : isSlotReady(e);
+    return isRevealController(e) ? e.zt() : isSlotReady(e);
 }
 
 function setSlotState(e, t, n, r) {
-    setSignal(e.zt, n);
-    setSignal(e.Jt, r);
+    setSignal(e.Jt, n);
+    setSignal(e.en, r);
     if (isRevealController(e)) {
-        if (!n && e.en === t) e.en = undefined;
-        return e.tn(n, r);
+        if (!n && e.tn === t) e.tn = undefined;
+        return e.nn(n, r);
     }
-    if (!n && e.nn === t && e.rn) e.nn = undefined;
+    if (!n && e.rn === t && e.sn) e.rn = undefined;
 }
 
 class RevealController {
-    sn;
     un;
-    ln=[];
-    en;
-    zt=signal(false, {
+    ln;
+    an=[];
+    tn;
+    Jt=signal(false, {
         ownedWrite: true,
-        gt: true
+        bt: true
     });
-    Jt=signal(false, {
+    en=signal(false, {
         ownedWrite: true,
-        gt: true
+        bt: true
     });
-    an=true;
     cn=true;
-    fn=false;
+    fn=true;
+    En=false;
     constructor(e, t) {
-        this.sn = e;
-        this.un = t;
+        this.un = e;
+        this.ln = t;
     }
-    En(e) {
-        for (let t = 0; t < this.ln.length; t++) {
-            const n = this.ln[t];
-            if ((isRevealController(n) ? n.en : n.nn) !== this) continue;
+    dn(e) {
+        for (let t = 0; t < this.an.length; t++) {
+            const n = this.an[t];
+            if ((isRevealController(n) ? n.tn : n.rn) !== this) continue;
             if (e(n) === false) return false;
         }
         return true;
     }
-    qt() {
-        return this.En(isSlotReady);
+    Bt() {
+        return this.dn(isSlotReady);
     }
     /**
    * "Minimally ready" = this group has something visible to show under its own policy.
@@ -7240,13 +7378,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.
-   */    Xt() {
-        const e = untrack(this.sn);
-        if (e === "together") return this.En(isSlotMinimallyReady);
+   */    zt() {
+        const e = untrack(this.un);
+        if (e === "together") return this.dn(isSlotMinimallyReady);
         if (e === "natural") {
             let e = false;
             let t = false;
-            this.En(n => {
+            this.dn(n => {
                 e = true;
                 if (isSlotMinimallyReady(n)) {
                     t = true;
@@ -7257,45 +7395,45 @@ class RevealController {
         }
         // sequential: only the first owned slot matters.
                 let t = true;
-        this.En(e => {
+        this.dn(e => {
             t = isSlotMinimallyReady(e);
             return false;
         });
         return t;
     }
-    dn(e) {
-        if (this.ln.includes(e)) return;
-        this.ln.push(e);
-        const t = untrack(this.sn);
-        setSignal(e.zt, true), setSignal(e.Jt, t === "sequential" ? !!untrack(this.un) : false);
-        untrack(() => this.tn());
-    }
     Sn(e) {
-        const t = this.ln.indexOf(e);
-        if (t >= 0) this.ln.splice(t, 1);
-        untrack(() => this.tn());
-    }
-    tn(e, t) {
-        if (this.fn) return;
-        this.fn = true;
-        const n = this.an;
-        const r = this.cn;
+        if (this.an.includes(e)) return;
+        this.an.push(e);
+        const t = untrack(this.un);
+        setSignal(e.Jt, true), setSignal(e.en, t === "sequential" ? !!untrack(this.ln) : false);
+        untrack(() => this.nn());
+    }
+    Tn(e) {
+        const t = this.an.indexOf(e);
+        if (t >= 0) this.an.splice(t, 1);
+        untrack(() => this.nn());
+    }
+    nn(e, t) {
+        if (this.En) return;
+        this.En = true;
+        const n = this.cn;
+        const r = this.fn;
         try {
-            const n = e ?? read(this.zt), r = untrack(this.sn), i = r === "sequential" && !!untrack(this.un), o = t ?? i;
+            const n = e ?? read(this.Jt), r = untrack(this.un), i = r === "sequential" && !!untrack(this.ln), o = t ?? i;
             if (n) {
                 // Held by an outer group. Propagate the hold (and whatever collapsed policy
                 // the outer asked for) down the whole subtree. Inner order is ignored while
                 // held; it resumes once the outer releases us.
-                this.En(e => setSlotState(e, this, true, o));
+                this.dn(e => setSlotState(e, this, true, o));
             } else if (r === "natural") {
                 // Each child reveals based on its own readiness. A nested controller slot
                 // is released to run its own order locally — we bypass setSlotState for it
                 // so the parent backpointer survives for upward readiness notifications.
-                this.En(e => {
+                this.dn(e => {
                     if (isRevealController(e)) {
+                        setSignal(e.en, false);
                         setSignal(e.Jt, false);
-                        setSignal(e.zt, false);
-                        e.tn(false, false);
+                        e.nn(false, false);
                     } else {
                         setSlotState(e, this, !isSlotReady(e), false);
                     }
@@ -7306,11 +7444,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.En(isSlotMinimallyReady);
-                this.En(t => setSlotState(t, this, !e, false));
+                const e = this.dn(isSlotMinimallyReady);
+                this.dn(t => setSlotState(t, this, !e, false));
             } else {
                 let e = false;
-                this.En(t => {
+                this.dn(t => {
                     if (e) return setSlotState(t, this, true, i);
                     if (isSlotReady(t)) return setSlotState(t, this, false, false);
                     e = true;
@@ -7321,63 +7459,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.en, false);
                         setSignal(t.Jt, false);
-                        setSignal(t.zt, false);
-                        t.tn(false, false);
+                        t.nn(false, false);
                     } else {
                         setSlotState(t, this, true, false);
                     }
                 });
             }
         } finally {
-            this.an = this.qt();
-            this.cn = this.Xt();
-            this.fn = false;
+            this.cn = this.Bt();
+            this.fn = this.zt();
+            this.En = false;
         }
-        if (this.en && (n !== this.an || r !== this.cn)) this.en.tn();
+        if (this.tn && (n !== this.cn || r !== this.fn)) this.tn.nn();
     }
 }
 
 class CollectionQueue extends Queue {
-    Tn;
-    Bt=new Set;
     On;
-    Zt=true;
-    zt=signal(false, {
+    Zt=new Set;
+    _n;
+    Xt=true;
+    Jt=signal(false, {
         ownedWrite: true,
-        gt: true
+        bt: true
     });
     me;
-    Jt=signal(false, {
+    en=signal(false, {
         ownedWrite: true,
-        gt: true
+        bt: true
     });
-    nn;
-    rn=false;
-    _n;
-    Rn=ON_INIT;
+    rn;
+    sn=false;
+    Rn;
+    pn=ON_INIT;
     constructor(e) {
         super();
-        this.Tn = e;
+        this.On = e;
     }
     run(e) {
-        if (!e || read(this.zt) && (!_revealUsed || read(this.Jt))) return;
+        if (!e || read(this.Jt) && (!_revealUsed || read(this.en))) return;
         return super.run(e);
     }
     notify(e, t, n, r) {
-        if (!(t & this.Tn)) return super.notify(e, t, n, r);
-        if (this.rn && this._n) {
+        if (!(t & this.On)) return super.notify(e, t, n, r);
+        if (this.sn && this.Rn) {
             const e = untrack(() => {
                 try {
-                    return this._n();
+                    return this.Rn();
                 } catch {
                     return ON_INIT;
                 }
             });
-            if (e !== this.Rn) {
-                this.Rn = e;
-                this.rn = false;
-                this.Bt.clear();
+            if (e !== this.pn) {
+                this.pn = e;
+                this.sn = false;
+                this.Zt.clear();
             }
         }
         // Routing is dimension-independent: each boundary consumes only its own
@@ -7390,47 +7528,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.Tn & STATUS_PENDING && this.rn) return super.notify(e, t, n, r);
-        if (n & this.Tn) {
-            this.Zt = true;
+                if (this.On & STATUS_PENDING && this.sn) return super.notify(e, t, n, r);
+        if (n & this.On) {
+            this.Xt = true;
             const t = r?.source || e.me?.source;
             if (t) {
-                const e = this.Bt.size === 0;
-                this.Bt.add(t);
-                if (e) setSignal(this.zt, true);
-                if (this.Tn & STATUS_ERROR) {
+                const e = this.Zt.size === 0;
+                this.Zt.add(t);
+                if (e) setSignal(this.Jt, true);
+                if (this.On & STATUS_ERROR) {
                     setSignal(this.me, unwrapStatusError(t.me));
                 }
             }
         }
-        t &= ~this.Tn;
+        t &= ~this.On;
         return t ? super.notify(e, t, n, r) : true;
     }
-    $e() {
-        for (const e of this.Bt) {
+    je() {
+        for (const e of this.Zt) {
             // 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.D & REACTIVE_DISPOSED || !e.W && !(e.xe & this.Tn) && !(this.Tn & STATUS_ERROR && e.xe & STATUS_PENDING)) this.Bt.delete(e);
+            if (e.D & REACTIVE_DISPOSED || !e.W && !(e.He & this.On) && !(this.On & STATUS_ERROR && e.He & STATUS_PENDING)) this.Zt.delete(e);
         }
-        if (!this.Bt.size) {
-            if (this.Tn & STATUS_PENDING && this.Zt && !this.rn && this.On) {
-                this.Zt = !!(this.On.xe & this.Tn);
+        if (!this.Zt.size) {
+            if (this.On & STATUS_PENDING && this.Xt && !this.sn && this._n) {
+                this.Xt = !!(this._n.He & this.On);
             } else {
-                this.Zt = false;
+                this.Xt = false;
             }
-            if (!this.Zt) {
-                setSignal(this.zt, false);
-                if (this._n) {
+            if (!this.Xt) {
+                setSignal(this.Jt, false);
+                if (this.Rn) {
                     try {
-                        this.Rn = untrack(() => this._n());
+                        this.pn = untrack(() => this.Rn());
                     } catch {
                         /* value not yet committed — _prevOn stays stale, next notify will reset */}
                 }
             }
         }
-        if (_revealUsed) this.nn?.tn();
+        if (_revealUsed) this.rn?.nn();
     }
 }
 
@@ -7440,10 +7578,10 @@ function createCollectionBoundary(e, t, n, r) {
     const o = new CollectionQueue(e);
     if (e === STATUS_ERROR) o.me = signal(undefined, {
         ownedWrite: true,
-        gt: true
+        bt: true
     });
-    if (r) o._n = r;
-    const s = o.On = createBoundChildren(i, t, o, e);
+    if (r) o.Rn = r;
+    const s = o._n = createBoundChildren(i, t, o, e);
     // Prime source tracking so reveal registration sees pending sources.
         untrack(() => {
         let t = false;
@@ -7452,23 +7590,23 @@ function createCollectionBoundary(e, t, n, r) {
         } catch (e) {
             if (e instanceof NotReadyError) t = true; else throw e;
         }
-        o.Zt = t || !!(s.xe & e) || s.me instanceof NotReadyError;
+        o.Xt = t || !!(s.He & e) || s.me instanceof NotReadyError;
     });
     const u = _revealUsed && e === STATUS_PENDING ? getContext(RevealControllerContext) : null;
     if (u) {
-        o.nn = u;
-        u.dn(o);
-        cleanup(() => u.Sn(o));
+        o.rn = u;
+        u.Sn(o);
+        cleanup(() => u.Tn(o));
     }
     return accessor(computed(() => {
-        if (!read(o.zt)) {
+        if (!read(o.Jt)) {
             const e = read(s);
-            if (!untrack(() => read(o.zt))) return o.rn = true, e;
+            if (!untrack(() => read(o.Jt))) return o.sn = 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.Jt)) return undefined;
+                if (_revealUsed && read(o.en)) return undefined;
         return n(o);
     }, 
     // Boundary structure, not a user source: its value is fallback-or-content and
@@ -7476,7 +7614,7 @@ function createCollectionBoundary(e, t, n, r) {
     // by snapshot capture. The tree no longer carries foreign status flags, so
     // capture can't rely on PENDING to skip this node the way it used to.
     {
-        gt: true
+        bt: true
     }));
 }
 
@@ -7530,7 +7668,7 @@ function createCollectionBoundary(e, t, n, r) {
  * ```
  */ function createErrorBoundary(e, t) {
     return createCollectionBoundary(STATUS_ERROR, e, e => t(accessor(e.me), () => {
-        for (const t of e.Bt) recompute(t);
+        for (const t of e.Zt) recompute(t);
         schedule();
     }));
 }
@@ -7587,12 +7725,12 @@ function createCollectionBoundary(e, t, n, r) {
         computed(() => {
             i();
             o();
-            s.tn();
+            s.nn();
         });
         if (r) {
-            s.en = r;
-            r.dn(s);
-            cleanup(() => r.Sn(s));
+            s.tn = r;
+            r.Sn(s);
+            cleanup(() => r.Tn(s));
         }
         return t;
     });