@solidjs/signals 2.0.0-rc.7 → 2.0.0-rc.9

package/dist/prod/core/verdict.js

@@ -1,20 +1,22 @@
-import { NOT_PENDING, REACTIVE_DISPOSED, REACTIVE_DIRTY, REACTIVE_CHECK, unwrapOverride, REACTIVE_ZOMBIE, STATUS_UNINITIALIZED, STATUS_PENDING, REACTIVE_OPTIMISTIC_DIRTY, REACTIVE_MANUAL_WRITE, CONFIG_HAS_COMPANIONS, CONFIG_CHILD_COMPANIONS, STATUS_ERROR, REACTIVE_RECOMPUTING_DEPS } from "./constants.js";
+import { NOT_PENDING, REACTIVE_DISPOSED, REACTIVE_DIRTY, REACTIVE_CHECK, unwrapOverride, REACTIVE_RECOMPUTING_DEPS, STATUS_PENDING, STATUS_UNINITIALIZED, REACTIVE_OPTIMISTIC_DIRTY, REACTIVE_MANUAL_WRITE, CONFIG_OVERRIDE_SUPERSEDED, CONFIG_HAS_COMPANIONS, CONFIG_ADOPTED_UNFLUSHED, CONFIG_CHILD_COMPANIONS, STATUS_ERROR } from "./constants.js";
 
-import { setSignal, pendingCheckActive, setPendingCheckActive, prepareComputed, read, context, stale, currentOptimisticLane, tracking, ext, setLatestReadActive, setContextInternal, optimisticComputed, latestReadActive, optimisticSignal } from "./core.js";
+import { setSignal, visibleOverride, unflushedValue, context, markLateLinker, read, stale, hasActiveOverride, prepareComputed, tracking, ext, setLatestReadActive, setContextInternal, optimisticComputed, unflushed, unflushedCompanions, setPendingCheckActive, latestReadActive, optimisticSignal, pendingCheckActive } from "./core.js";
 
 import { NotReadyError } from "./error.js";
 
 import { link } from "./graph.js";
 
-import { insertIntoHeap, queueFor, markHeap, enqueueSub } from "./heap.js";
+import { dispose } from "./owner.js";
+
+import { insertIntoHeap, queueFor, enqueueSub } from "./heap.js";
 
 import "./invariants.js";
 
-import { findLane, laneHeld, hasActiveOverride, assignOrMergeLane } from "./lanes.js";
+import { readsHeldCommitted, assignOrMergeLane } from "./lanes.js";
 
 import { installOptimisticEngine } from "./optimistic.js";
 
-import { GlobalQueue, insertSubs, schedule, activeTransition, currentTransition, activeAffectsMarks } from "./scheduler.js";
+import { GlobalQueue, insertSubs, schedule, activeTransition, currentTransition, runAsTransitionBatch, activeAffectsMarks } from "./scheduler.js";
 
 /**
  * The isPending()/latest() verdict layer, moved out of core.ts. Importing this
@@ -44,35 +46,76 @@ let pendingProbe = null;
  * the one-load gate at the call sites). The snap then iterates exactly the
  * children someone asked verdicts of — O(companions) — never the full
  * `_child` chain, which carries one node per materialized leaf (the
- * O(all-leaves-ever-read)-per-update pathology). Entries are permanent like
- * the companions themselves; a store with no leaf-level isPending()/latest()
- * reads never allocates the set or pays the walk. */ function markFirewallChildCompanions(e) {
-    const t = e.rt;
+ * O(all-leaves-ever-read)-per-update pathology). Entries live as long as the
+ * store addresses the leaf — the unobserved sweep's `unlinkFirewallChild`
+ * drops them (#3503); a store with no leaf-level isPending()/latest() reads
+ * never allocates the set or pays the walk. */ function markFirewallChildCompanions(e) {
+    const t = e.Te;
     if (!t) return;
     t.T |= CONFIG_CHILD_COMPANIONS;
-    (ext(t).dt ??= new Set).add(e);
+    (ext(t).bt ??= new Set).add(e);
 }
 
 function getPendingSignal(e) {
-    let t = e.o?.ye;
+    let t = e.o?.je;
     if (!t) {
         // Start false, write true if pending - ensures reversion returns to false
         t = optimisticSignal(false, {
             ownedWrite: true
         });
-        ext(e).ye = t;
+        ext(e).je = t;
         e.T |= CONFIG_HAS_COMPANIONS;
         markFirewallChildCompanions(e);
-        ext(t).St = e;
-        if (computePendingState(e)) setSignal(t, true);
+        ext(t).Ht = e;
+        if (computePendingState(e)) backfillCompanion(e, t, true);
+        joinUnflushedResync(e);
     }
     return t;
 }
 
+/**
+ * A lazily created companion's first write mirrors state the owner already
+ * carries — a held write, a pending verdict. The companion is created wherever
+ * the first latest()/isPending() read happens to run, but the write belongs
+ * to whatever HOLDS that state: written in the ambient window, the override
+ * would register in the ambient batch and revert when that flush's round ends
+ * — the shadow re-derived from the committed view, the verdict flipped false —
+ * while the owner's hold was still on (#3336: A and B differing only in
+ * whether a companion existed before the hold). A companion created lazily
+ * answers as if it had always existed: its backfill is registered with the
+ * owner's transaction and lives and reverts with it. A hold with no
+ * transaction (a pending async, a same-flush staged write) is ambient and the
+ * write stays ambient. (A28 (3), lifted from #3337.)
+ */ function backfillCompanion(e, t, n) {
+    const i = e.Ge;
+    if (i) runAsTransitionBatch(i, () => setSignal(t, n)); else setSignal(t, n);
+}
+
+/** A28: a companion created while its source carries an UNFLUSHED write joins
+ * the flush-start re-sync like a companion that existed at the write —
+ * syncCompanions only reaches companions that exist at write time. Without
+ * this the flush brings it current by a plain recompute instead of the
+ * optimistic write: its readers are then staged under whatever transaction
+ * the round entered (a memo over latest() of a held source was held with the
+ * source, and its untracked reads answered the previous value until the hold
+ * committed) rather than direct-committed as the optimistic view they are. */ function joinUnflushedResync(e) {
+    if (unflushed(e)) unflushedCompanions.push(e);
+}
+
+/** The staged value the verdict channels answer for (A28): while a node
+ * carries an unflushed write its `_pendingValue` is not yet part of any
+ * flushed world, so the channels answer for the value the last flush left
+ * staged (a held node's stash) or for nothing (NOT_PENDING). */ function flushedStaged(e) {
+    if (!unflushed(e)) return e.ve;
+    // Ambient, or adopted before any flush (CONFIG_ADOPTED_UNFLUSHED): nothing
+    // a flush carried is staged for it. A held rewrite: the stash.
+        return e.Ge === null || e.T & CONFIG_ADOPTED_UNFLUSHED ? NOT_PENDING : e.o.gt;
+}
+
 function collectPendingSources(e) {
     if (!pendingProbe) return;
     pendingProbe.sources.add(e);
-    const t = e.rt || e;
+    const t = e.Te || e;
     if (t !== e) pendingProbe.sources.add(t);
 }
 
@@ -105,17 +148,17 @@ function collectPendingSources(e) {
         if (e.S & STATUS_ERROR) return false;
     if (t.has(e)) return false;
     t.add(e);
-    const n = e.rt;
+    const n = e.Te;
     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 i = e;
-    const r = i.ie & REACTIVE_RECOMPUTING_DEPS ? i.Be : undefined;
+    const r = i.ue & REACTIVE_RECOMPUTING_DEPS ? i.ot : undefined;
     if (r !== null) {
-        for (let e = i.lt ?? null; e !== null; e = e.ot) {
-            if (!e.ve && markWalk(e.st, t)) return true;
+        for (let e = i.Se ?? null; e !== null; e = e.de) {
+            if (!e.He && markWalk(e.Ee, t)) return true;
             if (e === r) break;
         }
     }
@@ -123,11 +166,11 @@ function collectPendingSources(e) {
 }
 
 function quietPending(e) {
-    if (e.o?.le) {
-        for (const t of e.o.le) if (!t.o?.De) return false;
+    if (e.o?.ae) {
+        for (const t of e.o.ae) if (!t.o?.be) return false;
         return true;
     }
-    return e.o?.De ?? false;
+    return e.o?.be ?? false;
 }
 
 // NOTE: a loadingValue node's open loading window (_loading) is verdict-quiet
@@ -143,50 +186,68 @@ function newQuestionInFlight(e) {
 
 function computePendingState(e) {
     const t = e;
-    if (t.ie & REACTIVE_DISPOSED) return false;
+    if (t.ue & REACTIVE_DISPOSED) return false;
     // Mark coverage is transitive by dep-graph reachability: a latest() shadow
     // reaches its owner (and a store leaf its firewall) through its own deps,
     // so the one walk covers direct marks, derivation, and companion chains.
     // Gated: apps with no live mark pay one integer compare.
         if (activeAffectsMarks !== 0 && markWalk(e, new Set)) return true;
-    const n = e.rt;
-    if (e.o?.St) {
-        const t = e.o?.St;
-        const n = t.rt || t;
+    const n = e.Te;
+    if (e.o?.Ht) {
+        const t = e.o?.Ht;
+        const n = t.Te || t;
         return newQuestionInFlight(n);
     }
-    if (n && e.Re !== NOT_PENDING && !hasActiveOverride(e)) {
-        return !!(n.ie & REACTIVE_MANUAL_WRITE) || !n.o?.Ie && !(n.S & STATUS_PENDING) || !!(n.S & STATUS_PENDING) && quietPending(n);
+    const i = flushedStaged(e);
+    if (n && i !== NOT_PENDING && !hasActiveOverride(e)) {
+        return !!(n.ue & REACTIVE_MANUAL_WRITE) || !n.o?.Re && !(n.S & STATUS_PENDING) || !!(n.S & 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.Re !== NOT_PENDING && !(t.S & STATUS_UNINITIALIZED) && !t.Ne) {
-        if (hasActiveOverride(e)) return !e.pe || !e.pe(e.Re, unwrapOverride(e.o?.Pe));
+    // A18 (d) for a body-end supersession (#3427): the truth at hand is the
+    // COMMITTED value — nothing staged — yet the display still shows the
+    // override; pending iff they differ, as for a staged arrival below.
+        if (e.T & CONFIG_OVERRIDE_SUPERSEDED && e.ve === NOT_PENDING && visibleOverride(e)) return !e.Fe || !e.Fe(e.Qe, unwrapOverride(e.o?.Ce));
+    // A28 (2): an unflushed write is not yet observable — the verdict answers
+    // for the flushed staged value.
+        if (i !== NOT_PENDING && !t.ge) {
+        // A18 (d): under a displayed override the observable value is the
+        // override, so the verdict is "the arrived truth differs from it" —
+        // even before the node's first commit. The UNINITIALIZED suppression
+        // below is A19 exception (1), "no observable value exists to be
+        // non-final"; an override is one (a node whose first landing was held
+        // by a reveal it never got to commit, then superseded under its
+        // override, read false here).
+        if (visibleOverride(e)) return !e.Fe || !e.Fe(i, unwrapOverride(e.o?.Ce));
         // A quiet re-ask's held landing still answers the same question: the
         // classification survives the landing (asyncWrite) and dies with the
         // commit (commitPendingNode) — verdict-quiet through the reveal, like
         // the loading window above (#3178).
-                if (!t.o?.De) return true;
+        // A staged value equal to the committed one is no proposal (A34, #3494): the
+        // observable value IS final (A19). The coalesced `setShow(false);
+        // setShow(true)` read pending through the flush that carried it — and,
+        // stamped into a hold that flush opened, until the hold settled.
+                if (!(t.S & STATUS_UNINITIALIZED) && !t.o?.be && (!e.Fe || !e.Fe(e.Qe, i))) return true;
     }
     return newQuestionInFlight(t);
 }
 
 function syncCompanions(e, t) {
-    if (e.o?.ye) updatePendingSignal(e);
-    if (e.o?.Ce) setSignal(e.o?.Ce, t);
+    if (e.o?.je) updatePendingSignal(e);
+    if (e.o?.xe) setSignal(e.o?.xe, t);
 }
 
 function updatePendingSignal(e) {
-    if (e.o?.ye) {
-        setSignal(e.o?.ye, computePendingState(e));
+    if (e.o?.je) {
+        setSignal(e.o?.je, computePendingState(e));
     }
-    if (e.o?.Ce) updatePendingSignal(e.o?.Ce);
+    if (e.o?.xe) updatePendingSignal(e.o?.xe);
 }
 
 function updateChildCompanions(e) {
-    const t = e.o?.dt;
+    const t = e.o?.bt;
     if (t === undefined) return;
     for (const e of t) updatePendingSignal(e);
 }
@@ -205,9 +266,9 @@ function updateChildCompanions(e) {
     const visit = e => {
         if (i.has(e)) return;
         i.add(e);
-        if (e.o?.ye || e.o?.Ce) n(e);
-        for (let t = e.u; t !== null; t = t.ae) visit(t.ce);
-        for (let t = e.o?.i ?? null; t !== null; t = t.Se) {
+        if (e.o?.je || e.o?.xe) n(e);
+        for (let t = e.u; t !== null; t = t.Ne) visit(t._e);
+        for (let t = e.o?.i ?? null; t !== null; t = t.De) {
             visit(t);
         }
     };
@@ -228,7 +289,7 @@ function updateChildCompanions(e) {
     if (suppressedProbes.size === 0) return;
     let t = false;
     for (const [n, i] of suppressedProbes) {
-        const r = n.Ae;
+        const r = n.Ge;
         const s = r ? currentTransition(r) : null;
         if (!s) {
             suppressedProbes.delete(n);
@@ -236,11 +297,11 @@ function updateChildCompanions(e) {
         }
         if (s !== e) continue;
         suppressedProbes.delete(n);
-        const o = n.o?.ye?.o?.$e;
+        const o = n.o?.je?.o?.Ue;
         for (const e of i) {
-            if (e.ie & REACTIVE_DISPOSED) continue;
-            e.ie |= REACTIVE_OPTIMISTIC_DIRTY;
-            if (o) assignOrMergeLane(e, o); else if (e.o !== null) e.o.$e = undefined;
+            if (e.ue & REACTIVE_DISPOSED) continue;
+            e.ue |= REACTIVE_OPTIMISTIC_DIRTY;
+            if (o) assignOrMergeLane(e, o); else if (e.o !== null) e.o.Ue = undefined;
             enqueueSub(e);
             t = true;
         }
@@ -250,20 +311,32 @@ function updateChildCompanions(e) {
 
 function snapCompanionsToState(e) {
     suppressedProbes.size !== 0 && suppressedProbes.delete(e);
-    const t = e.o?.ye;
-    if (t && (t.o?.Pe === undefined || t.o?.Pe === NOT_PENDING)) {
+    const t = e.o?.je;
+    if (t && (t.o?.Ce === undefined || t.o?.Ce === NOT_PENDING)) {
         const n = computePendingState(e);
-        if (t.be !== n || t.Re !== NOT_PENDING) {
-            t.be = n;
-            t.Re = NOT_PENDING;
+        if (t.Qe !== n || t.ve !== NOT_PENDING) {
+            t.Qe = n;
+            t.ve = NOT_PENDING;
             insertSubs(t);
             schedule();
         }
     }
-    const n = e.o?.Ce;
-    if (n && !(n.ie & REACTIVE_DISPOSED)) {
-        if ((n.o?.Pe === undefined || n.o?.Pe === NOT_PENDING) && n.Re === NOT_PENDING && !Object.is(n.be, e.be) && !(n.ie & (REACTIVE_DIRTY | REACTIVE_CHECK))) {
-            n.ie |= REACTIVE_DIRTY;
+    const n = e.o?.xe;
+    if (n && !(n.ue & REACTIVE_DISPOSED)) {
+        // A leaf whose firewall is disposed (the projection's teardown snaps its
+        // companion-bearing leaves): the shadow's compute reads through a
+        // disposed, possibly still-pending projection and would sit
+        // NotReady/uninitialized forever — never derived, its backfilled override
+        // dropped at the settle — against a leaf whose committed value differs
+        // (INV-4 at the next quiescence; spec O5). It dies with its source;
+        // getLatestValueComputed treats a disposed shadow as absent, so a later
+        // read recreates it from the committed view.
+        if (e.Te?.ue & REACTIVE_DISPOSED) {
+            dispose(n);
+            return;
+        }
+        if ((n.o?.Ce === undefined || n.o?.Ce === NOT_PENDING) && n.ve === NOT_PENDING && !Object.is(n.Qe, e.Qe) && !(n.ue & (REACTIVE_DIRTY | REACTIVE_CHECK))) {
+            n.ue |= REACTIVE_DIRTY;
             insertIntoHeap(n, queueFor(n));
             insertSubs(n);
             schedule();
@@ -273,14 +346,14 @@ function snapCompanionsToState(e) {
 }
 
 function getLatestValueComputed(e) {
-    let t = e.o?.Ce;
+    let t = e.o?.xe;
     // A shadow disposed while unobserved (its gated reader unmounted at a
     // landing) is a corpse: sync writes into it equality-swallow against its
     // frozen _value, and a later read revives it via recompute — clearing
     // DISPOSED and re-deriving from the committed view, so the banner showed
     // the previous transition's target (#3041 follow-up). Treat it as absent;
     // recreation backfills from the in-flight write below.
-        if (t && t.ie & REACTIVE_DISPOSED) t = undefined;
+        if (t && t.ue & REACTIVE_DISPOSED) t = undefined;
     if (!t) {
         const n = latestReadActive;
         setLatestReadActive(false);
@@ -289,17 +362,26 @@ function getLatestValueComputed(e) {
         const r = context;
         setContextInternal(null);
  // Detach from owner so it isn't disposed with effects
-                t = optimisticComputed(() => read(e));
-        ext(e).Ce = t;
+                GlobalQueue.jt = true;
+        try {
+            t = optimisticComputed(() => read(e), {
+                ownedWrite: true
+            });
+        } finally {
+            GlobalQueue.jt = false;
+        }
+        ext(e).xe = t;
         e.T |= CONFIG_HAS_COMPANIONS;
         markFirewallChildCompanions(e);
-        ext(t).St = e;
+        ext(t).Ht = e;
  // Parent-child lane relationship
         // Backfill an in-flight write (mirrors getPendingSignal): the companion is
         // created lazily, possibly after the write was processed — syncCompanions
         // only pushes into companions that already exist, so the first latest()
         // read inside a held transition showed the committed value (#3041).
-                if (e.Re !== NOT_PENDING && !hasActiveOverride(e)) setSignal(t, e.Re);
+                const s = flushedStaged(e);
+        if (s !== NOT_PENDING && !hasActiveOverride(e)) backfillCompanion(e, t, s);
+        joinUnflushedResync(e);
         setContextInternal(r);
         setPendingCheckActive(i);
         setLatestReadActive(n);
@@ -307,59 +389,83 @@ function getLatestValueComputed(e) {
     return t;
 }
 
-/** The latest()-mode read path, installed as GlobalQueue._latestRead. */ function latestRead(e) {
+/** The latest()-mode read path, installed as GlobalQueue._latestRead. */
+/** A7: the source has no visible value yet — judged on the OWNER, as read()
+ * does: a store leaf behind a projection's firewall is a plain signal whose
+ * `_value` is the seed (A25: a draft, never a value), and read() routes a
+ * latest() read here before its own firewall/status logic. An override
+ * displays a value even before the first commit (A17). */ function uninitializedSource(e) {
+    const t = e.Te || e;
+    return !!(t.S & STATUS_UNINITIALIZED) && !hasActiveOverride(e);
+}
+
+function latestRead(e) {
+    // A leaf of a DISPOSED projection has no flushed world left to mirror: a
+    // shadow created for it now would read through the dead firewall, sit
+    // NotReady/uninitialized forever, and no teardown would ever retire it (the
+    // firewall's already ran — spec O5). Serve the committed value; create
+    // nothing. (A read of a disposed node freezes at its last commit, #3024.)
+    if (e.Te?.ue & REACTIVE_DISPOSED) return e.Qe;
     const t = getLatestValueComputed(e);
     const n = latestReadActive;
     setLatestReadActive(false);
-    const i = e.o?.Pe !== undefined && e.o?.Pe !== NOT_PENDING ? unwrapOverride(e.o?.Pe) : e.be;
-    let r;
-    try {
-        // An untracked latest() read has no reading context, so read() never
-        // performs its mid-tick pull — a plain write queued between two latest()
-        // calls left a still-subscribed shadow at its previous speculative value
-        // until the flush (#2922). Mirror the tracked-read pull here: mark the
-        // queued staleness through the graph, then bring the shadow up to date.
-        const e = queueFor(t);
-        if (t.qe >= e.Me && !(t.ie & (REACTIVE_DISPOSED | REACTIVE_ZOMBIE))) {
-            markHeap(e);
-            // Suspend probe collection during the pull (mirrors pendingCheckRead's
-            // prepare): a probe through latest() answers for the SHADOW — the
-            // read() dispatch collects it deliberately, so the verdict reflects
-            // async still in flight for the latest view, not the parent's held
-            // write. A stale shadow recomputing HERE ran its `read(parent)` with
-            // the probe still live and collected the parent too, so the verdict
-            // depended on whether anything had pulled the shadow current earlier
-            // in the tick (#3104: reading latest(m) flipped a later
-            // latest(() => isPending(x)) from true to false).
-                        const n = pendingCheckActive;
-            setPendingCheckActive(false);
-            try {
-                prepareComputed(t, true);
-            } finally {
-                setPendingCheckActive(n);
-            }
+    const i = visibleOverride(e) ? unwrapOverride(e.o?.Ce) : e.Qe;
+    // A28: an unflushed write is not the staged value latest() serves. The
+    // shadow was written at the source's write to mirror it (A8) — consult it
+    // only once a flush has carried the write.
+        const r = unflushedValue(e);
+    if (r !== NOT_PENDING) {
+        // The reader derived from the flushed world because of an unflushed
+        // write: it runs again in the flush that carries it (late linker) —
+        // a pull may have cleared the mark the write's walk set.
+        if (context !== null && context.ue & REACTIVE_RECOMPUTING_DEPS) markLateLinker(context);
+        // Link the reader to the shadow so the flush that carries the write
+        // updates it (the shadow itself already mirrors the write, A8).
+                try {
+            read(t);
+        } catch {
+            /* the flushed value answers */} finally {
+            setLatestReadActive(n);
         }
-        r = read(t);
+        // An ambient write: the visible value (override or committed). A rewrite
+        // of a held node: the staged value the last flush left.
+                return e.Ge === null ? i : r;
+    }
+    let s;
+    try {
+        // No mid-tick pull: writes become visible at flush (A28), so before the
+        // flush the shadow is exactly as current as the flushed world — the read
+        // below serves it as is. (#2922's pull, which brought the shadow current
+        // against the unflushed write, is superseded: `flush()` first to read
+        // your own write.)
+        s = read(t);
     } catch (t) {
-        if (t instanceof NotReadyError && (!context || !(e.S & STATUS_UNINITIALIZED))) return i;
+        // A NotReady from the shadow of an INITIALIZED source means the shadow
+        // is mid-flight: serve the visible (committed / override) value. An
+        // uninitialized source has no visible value — latest() throws in every
+        // scope rather than fabricate `undefined` for a `T` that excludes it
+        // (A7; the unowned scope used to return undefined here).
+        if (t instanceof NotReadyError && !uninitializedSource(e)) return i;
         throw t;
     } finally {
         setLatestReadActive(n);
     }
-    if (t.S & STATUS_PENDING) return i;
-    if (stale && currentOptimisticLane && t.o?.$e) {
-        const e = findLane(t.o?.$e);
-        const n = findLane(currentOptimisticLane);
-        if (e !== n && laneHeld(e)) {
-            return i;
-        }
+    if (t.S & STATUS_PENDING) {
+        if (uninitializedSource(e)) throw new NotReadyError(e);
+        return i;
     }
+    // A render effect off the shadow's HELD lane sees the committed value and
+    // re-runs at the release (#3460; lanes mirror transitions — see
+    // readsHeldCommitted). Was: only a reader under ANOTHER lane; a mainline
+    // reader, mounted or re-run by a sync write mid-hold, showed the
+    // speculative value beside the lane's deferred readers.
+        if (stale && context !== null && readsHeldCommitted(t, context)) return e.Qe;
     // A shadow recomputed by the pull above (not at creation) holds its fresh
     // speculative value in _pendingValue; a contextless read() only surfaces
     // _value. Overrides stay authoritative (A17), and stale readers keep the
     // other transition's committed view, matching read()'s own selection.
-        if (t.Re !== NOT_PENDING && !hasActiveOverride(t) && !(stale && t.Ae && activeTransition !== t.Ae)) return t.Re;
-    return r;
+        if (t.ve !== NOT_PENDING && !hasActiveOverride(t) && !(stale && t.Ge && activeTransition !== t.Ge)) return t.ve;
+    return s;
 }
 
 /**
@@ -371,16 +477,23 @@ function getLatestValueComputed(e) {
  * `_parentSource` but is a plain signal (no `_fn`) that never goes pending,
  * so the `_fn` check is belt-and-braces for this call site.
  */ function latestShadowWithInitializedParent(e) {
-    if (typeof e.oe !== "function") return false;
-    const t = e.o?.St;
+    if (typeof e.ce !== "function") return false;
+    const t = e.o?.Ht;
     if (t === undefined) return false;
-    const n = t.rt || t;
+    const n = t.Te || t;
     return !(n.S & STATUS_UNINITIALIZED);
 }
 
 /** The isPending()-probe read path, installed as GlobalQueue._pendingCheck. */ function pendingCheckRead(e, t, n, i) {
     setPendingCheckActive(false);
-    if (typeof e.oe === "function") prepareComputed(e, true);
+    if (typeof e.ce === "function") {
+        GlobalQueue.jt = true;
+        try {
+            prepareComputed(e, true);
+        } finally {
+            GlobalQueue.jt = false;
+        }
+    }
     const r = n.S;
     if (t && r & STATUS_PENDING && r & STATUS_UNINITIALIZED && 
     // The suspend-throw is for a genuinely-first-load source: the tracked
@@ -410,9 +523,9 @@ function getLatestValueComputed(e) {
  * reader saw is an input, and pending remains the truth for every reader
  * (#3028).
  */ function heldAwaitingAsync(e) {
-    const t = e.Ae;
+    const t = e.Ge;
     const n = t ? currentTransition(t) : activeTransition;
-    if (!n || n.sn) return false;
+    if (!n || n.Tt) return false;
     // A plain staged write (a signal/store leaf — no _fn) held while an action
     // is still running is an INPUT to a computation still in flight (#3078):
     // the pairing rule must not suppress the verdict, or a memo recomputing
@@ -422,19 +535,24 @@ function getLatestValueComputed(e) {
     // awaiting reveal — where the pairing rule stands even inside an open
     // action (#2831: a reader that saw the new value must not also see
     // pending); still-computing answers are covered by the reporter scan.
-        if (n.ue.length && !e.oe) return true;
-    // A node not yet stamped with a transition only qualifies through the
-    // action check above; the reporter scan below is for transition-held
-    // writes whose source async is still computing.
-        if (!t) return false;
-    for (const [e, t] of n._e) {
+        if (n.pe.length && !e.ce) return true;
+    // The reporter scan runs for an unstamped node too (#3457): a node staged
+    // AFTER the transaction opened is pushed straight into the transaction's
+    // batch (queuePendingNode, once initTransition adopted it) and only gets
+    // its `_transition` stamp when the flush stashes the hold, but its staged
+    // value is already the transaction's, and `t` resolved to that very
+    // transaction above. Gating on the stamp let a memo whose recompute read
+    // a sync memo's fresh staged value mid-flush pair "not pending" with it
+    // (A10) while the transaction's async source was still computing, so a
+    // memo-wrapped isPending() read false where a direct probe read true.
+        for (const [e, t] of n.oe) {
         if (t.size && e.S & STATUS_PENDING && e.o?._?.source === e) return true;
     }
     return false;
 }
 
 function recordFreshRead(e, t) {
-    if (pendingProbe !== null && e.Re !== NOT_PENDING && t === e.Re) {
+    if (pendingProbe !== null && e.ve !== NOT_PENDING && t === e.ve) {
         if (heldAwaitingAsync(e)) return;
         pendingProbe.freshReads.add(e);
     }
@@ -442,10 +560,10 @@ function recordFreshRead(e, t) {
 
 function applyReask(e, t) {
     const n = !!(e.S & STATUS_PENDING);
-    const i = t && !(n && !e.o?.De);
-    const r = n && (e.o?.De ?? false) !== i;
+    const i = t && !(n && !e.o?.be);
+    const r = n && (e.o?.be ?? false) !== i;
     // Allocation-free for the quiet case: false is the extension default.
-        if (i) ext(e).De = true; else if (e.o !== null) e.o.De = false;
+        if (i) ext(e).be = true; else if (e.o !== null) e.o.be = false;
     return r;
 }
 
@@ -497,7 +615,7 @@ function isPending(e) {
         // this flush (a downstream async pends and holds it), the suppression was
         // wrong and the wrapper must re-ask (#3028). Remember who to wake — the
         // async registration (GlobalQueue.notify) triggers wakeSuppressedProbes.
-                if (!i.found && i.suppressed.length && context && typeof context.oe === "function") {
+                if (!i.found && i.suppressed.length && context && typeof context.ce === "function") {
             for (const e of i.suppressed) {
                 let t = suppressedProbes.get(e);
                 if (!t) suppressedProbes.set(e, t = new Set);
@@ -526,26 +644,26 @@ function isPending(e) {
 // Hook installation (same late-binding pattern as GlobalQueue._update /
 // _propagateAffects): core call sites fire these behind the same guards the
 // direct calls used, so behavior is identical once this module loads.
-GlobalQueue.Ue = syncCompanions;
+GlobalQueue.me = syncCompanions;
 
-GlobalQueue.de = updatePendingSignal;
+GlobalQueue.Oe = updatePendingSignal;
 
-GlobalQueue.me = updateChildCompanions;
+GlobalQueue.Me = updateChildCompanions;
 
-GlobalQueue.un = snapCompanionsToState;
+GlobalQueue.En = snapCompanionsToState;
 
-GlobalQueue.Vt = latestRead;
+GlobalQueue.zt = latestRead;
 
-GlobalQueue.bt = pendingCheckRead;
+GlobalQueue.Jt = pendingCheckRead;
 
-GlobalQueue.Lt = recordFreshRead;
+GlobalQueue.nn = recordFreshRead;
 
-GlobalQueue.nt = applyReask;
+GlobalQueue.Nt = applyReask;
 
 GlobalQueue.k = repollDownstreamVerdicts;
 
-GlobalQueue.zt = witnessAffects;
+GlobalQueue.pn = witnessAffects;
 
-GlobalQueue.Kt = wakeSuppressedProbes;
+GlobalQueue.vn = wakeSuppressedProbes;
 
 export { isPending, latest };