@solidjs/signals 2.0.0-rc.1 → 2.0.0-rc.2

package/dist/prod/core/scheduler.js

@@ -1,4 +1,4 @@
-import { EFFECT_RENDER, EFFECT_USER, STATUS_PENDING, REACTIVE_IN_HEAP_HEIGHT, REACTIVE_DISPOSED, REACTIVE_ZOMBIE, NOT_PENDING, EFFECT_TRACKED, CONFIG_IN_SNAPSHOT_SCOPE, REACTIVE_SNAPSHOT_STALE, REACTIVE_OPTIMISTIC_DIRTY, REACTIVE_REASK, REACTIVE_MANUAL_WRITE, STATUS_UNINITIALIZED } from "./constants.js";
+import { EFFECT_RENDER, EFFECT_USER, STATUS_PENDING, REACTIVE_IN_HEAP_HEIGHT, REACTIVE_DISPOSED, REACTIVE_ZOMBIE, NOT_PENDING, CONFIG_HAS_COMPANIONS, EFFECT_TRACKED, CONFIG_HAS_LANE, CONFIG_HAS_SNAPSHOT, REACTIVE_RECOMPUTING_DEPS, REACTIVE_MISSED_WAKE, CONFIG_IN_SNAPSHOT_SCOPE, REACTIVE_SNAPSHOT_STALE, REACTIVE_OPTIMISTIC_DIRTY, REACTIVE_REASK, REACTIVE_MANUAL_WRITE, STATUS_UNINITIALIZED } from "./constants.js";
 
 import { currentOptimisticLane } from "./core.js";
 
@@ -19,23 +19,23 @@ const transitions = new Set;
 const dirtyQueue = {
     eE: new Array(2e3).fill(undefined),
     tE: false,
-    Ve: 0,
+    xe: 0,
     EE: 0
 };
 
 const zombieQueue = {
     eE: new Array(2e3).fill(undefined),
     tE: false,
-    Ve: 0,
+    xe: 0,
     EE: 0
 };
 
 /** runHeap callback that discards a queued zombie recompute instead of running
  * it: unlink pure recompute entries; strip just the recompute bit from dirtied
  * height-adjust entries so their height work still happens. */ function cancelZombieRecompute(e) {
-    if (e.se & REACTIVE_IN_HEAP_HEIGHT) e.se &= -12; else {
+    if (e.ie & REACTIVE_IN_HEAP_HEIGHT) e.ie &= -12; else {
         deleteFromHeap(e, zombieQueue);
-        e.se &= -4;
+        e.ie &= -4;
     }
 }
 
@@ -60,25 +60,25 @@ let projectionWriteActive = false;
 const transientStoreNodes = new Set;
 
 function canUseSimpleSyncFlush(e) {
-    const t = e.m;
-    return transitions.size === 0 && activeLanes.size === 0 && e.vt.length === 0 && t.Me.length === 0 && t.A.length === 0 && t.dn.size === 0 && transientStoreNodes.size === 0;
+    const t = e.k;
+    return transitions.size === 0 && activeLanes.size === 0 && e.Qt.length === 0 && t.Ke.length === 0 && t.m.length === 0 && t.cn.size === 0 && transientStoreNodes.size === 0;
 }
 
 function sweepTransientStoreNodes() {
     if (transientStoreNodes.size === 0) return;
     for (const e of transientStoreNodes) {
-        if (e.o !== null) {
+        if (e.u !== null) {
             transientStoreNodes.delete(e);
             continue;
         }
-        if (e._e !== NOT_PENDING) continue;
-        if (e.De !== undefined && e.De !== NOT_PENDING) continue;
+        if (e.Pe !== NOT_PENDING) continue;
+        if (e.o?.De !== undefined && e.o?.De !== NOT_PENDING) continue;
         // A live affects() mark keeps the node addressable: sweeping it would
         // detach the refcount from the slot (a fresh probe would upsert a new,
         // unmarked node for the same property).
-                if (e.t) continue;
+                if (e.o?.t) continue;
         transientStoreNodes.delete(e);
-        e.ut?.();
+        e.o?.ft?.();
     }
 }
 
@@ -105,44 +105,44 @@ function setProjectionWriteActive(e) {
  * land there directly — no per-field aliasing.
  */ function createBatch() {
     return {
-        de: clock,
-        Qt: [],
-        Ie: new Map,
-        Me: [],
-        A: [],
-        dn: new Set,
-        ie: [],
-        yt: {
-            bt: [ [], [] ],
-            vt: []
+        Te: clock,
+        yt: [],
+        Ne: new Map,
+        Ke: [],
+        m: [],
+        cn: new Set,
+        oe: [],
+        bt: {
+            Lt: [ [], [] ],
+            Qt: []
         },
-        fn: false,
+        an: false,
         ln: new Set
     };
 }
 
 function mergeTransitionState(e, t) {
-    t.fn = e;
-    e.ie.push(...t.ie);
-    for (const i of activeLanes) if (i.Ne === t) i.Ne = e;
-    if (t.Me.length) {
+    t.an = e;
+    e.oe.push(...t.oe);
+    for (const i of activeLanes) if (i._e === t) i._e = e;
+    if (t.Ke.length) {
         // Move (don't copy): the global queue's batch may still be the outgoing
         // transition, and the adoption pass in initTransition would re-push its
         // contents into the target — duplicating every entry.
-        e.Me.push(...t.Me);
-        t.Me.length = 0;
+        e.Ke.push(...t.Ke);
+        t.Ke.length = 0;
     }
-    if (t.A.length) {
+    if (t.m.length) {
         // Move (don't copy): the global queue's batch may still be the outgoing
         // transition, and the adoption pass in initTransition would re-push its
         // contents into the target — double-releasing every mark.
-        e.A.push(...t.A);
-        t.A.length = 0;
+        e.m.push(...t.m);
+        t.m.length = 0;
     }
-    for (const i of t.dn) e.dn.add(i);
-    for (const [i, n] of t.Ie) {
-        let t = e.Ie.get(i);
-        if (!t) e.Ie.set(i, t = new Set);
+    for (const i of t.cn) e.cn.add(i);
+    for (const [i, n] of t.Ne) {
+        let t = e.Ne.get(i);
+        if (!t) e.Ne.set(i, t = new Set);
         for (const e of n) t.add(e);
     }
     for (const i of t.ln) e.ln.add(i);
@@ -155,7 +155,7 @@ function schedule() {
     }
     if (scheduled) return;
     scheduled = true;
-    if (!syncDepth && !globalQueue.cn && !projectionWriteActive) queueMicrotask(flush);
+    if (!syncDepth && !globalQueue.sn && !projectionWriteActive) queueMicrotask(flush);
 }
 
 /**
@@ -189,30 +189,30 @@ function notifyHalted() {
 let queueRunToken = 0;
 
 class Queue {
-    Fe=null;
-    bt=[ [], [] ];
-    vt=[];
-    kt=0;
+    ve=null;
+    Lt=[ [], [] ];
+    Qt=[];
+    Mt=0;
     created=clock;
     addChild(e) {
-        this.vt.push(e);
-        e.Fe = this;
+        this.Qt.push(e);
+        e.ve = this;
     }
     removeChild(e) {
-        const t = this.vt.indexOf(e);
+        const t = this.Qt.indexOf(e);
         if (t >= 0) {
-            this.vt.splice(t, 1);
-            e.Fe = null;
+            this.Qt.splice(t, 1);
+            e.ve = null;
         }
     }
     notify(e, t, i, n) {
-        if (this.Fe) return this.Fe.notify(e, t, i, n);
+        if (this.ve) return this.ve.notify(e, t, i, n);
         return false;
     }
     run(e) {
-        if (this.bt[e - 1].length) {
-            const t = this.bt[e - 1];
-            this.bt[e - 1] = [];
+        if (this.Lt[e - 1].length) {
+            const t = this.Lt[e - 1];
+            this.Lt[e - 1] = [];
             runQueue(t, e);
         }
         // Effects run here can dispose owners, and disposal removes queues from
@@ -222,12 +222,12 @@ class Queue {
         // can be recovered by rescanning from the front and every child still runs
         // exactly once. Children appended mid-pass carry a stale stamp and run,
         // matching the previous live-array behaviour.
-                const t = this.vt;
+                const t = this.Qt;
         const i = ++queueRunToken;
         for (let n = 0; n < t.length; ) {
             const s = t[n];
-            if (s.kt !== i) {
-                s.kt = i;
+            if (s.Mt !== i) {
+                s.Mt = i;
                 s.run?.(e);
                 if (t[n] !== s) {
                     n = 0;
@@ -242,81 +242,84 @@ class Queue {
             // Route to lane's effect queue if we're in an optimistic recomputation
             if (currentOptimisticLane) {
                 const i = findLane(currentOptimisticLane);
-                i.rn[e - 1].push(t);
+                i.en[e - 1].push(t);
             } else {
-                this.bt[e - 1].push(t);
+                this.Lt[e - 1].push(t);
             }
         }
         schedule();
     }
     stashQueues(e) {
-        e.bt[0].push(...this.bt[0]);
-        e.bt[1].push(...this.bt[1]);
-        this.bt = [ [], [] ];
-        for (let t = 0; t < this.vt.length; t++) {
-            let i = this.vt[t];
-            let n = e.vt[t];
+        e.Lt[0].push(...this.Lt[0]);
+        e.Lt[1].push(...this.Lt[1]);
+        this.Lt = [ [], [] ];
+        for (let t = 0; t < this.Qt.length; t++) {
+            let i = this.Qt[t];
+            let n = e.Qt[t];
             if (!n) {
                 n = {
-                    bt: [ [], [] ],
-                    vt: []
+                    Lt: [ [], [] ],
+                    Qt: []
                 };
-                e.vt[t] = n;
+                e.Qt[t] = n;
             }
             i.stashQueues(n);
         }
     }
     restoreQueues(e) {
-        this.bt[0].push(...e.bt[0]);
-        this.bt[1].push(...e.bt[1]);
-        for (let t = 0; t < e.vt.length; t++) {
-            const i = e.vt[t];
-            let n = this.vt[t];
+        this.Lt[0].push(...e.Lt[0]);
+        this.Lt[1].push(...e.Lt[1]);
+        for (let t = 0; t < e.Qt.length; t++) {
+            const i = e.Qt[t];
+            let n = this.Qt[t];
             if (n) n.restoreQueues(i);
         }
     }
 }
 
 class GlobalQueue extends Queue {
-    cn=false;
+    sn=false;
     // The current transaction-shaped batch: a plain ambient batch while no
     // transition is active, the active transition itself after initTransition.
-    m=createBatch();
+    k=createBatch();
     static Ce;
-    static me;
-    static et;
-    static gt=null;
+    static Fe;
+    static tt;
+    static Vt=null;
     // Store-side hook: drops a keyless affects() mark's identity scope when the
     // carrier node's last registration releases (wired by store.ts, mirroring
     // _clearOptimisticStore).
-    static p=null;
+    static G=null;
     // affects()-side hooks (wired by affects.ts, mirroring _update): the mark
     // engine — count/register/release — lives with the feature. Every call site
     // is gated by state only that module creates, so `!` invocations are safe
     // once the gate holds.
-    static G=null;
     static M=null;
     static h=null;
+    static j=null;
     // External-source bridge (wired by enableExternalSource(); null while no
     // config is active — including after _resetExternalSourceConfig()).
-    static dt=null;
-    static St=null;
+    static Rt=null;
+    static Gt=null;
     // Verdict-layer hooks (wired by verdict.ts when isPending()/latest() are
     // imported; null in apps that never use them). Call sites either guard for
     // null or sit behind state only the verdict layer can create (`!` is safe
     // there: `_pendingSignal`/`_latestValueComputed` are only ever assigned by
     // verdict.ts, and `pendingCheckActive`/`latestReadActive` only flip inside
     // isPending()/latest()).
-    static Pe=null;
-    static Se=null;
-    static Ge=null;
+    static Oe=null;
+    static de=null;
+    static ye=null;
     static un=null;
-    static At=null;
-    static Ct=null;
     static Pt=null;
-    static $e=null;
-    static k=null;
-    static Lt=null;
+    static Dt=null;
+    static Ht=null;
+    static Je=null;
+    static p=null;
+    static Bt=null;
+    // Re-asks probes whose verdict was provisionally suppressed by a fresh read
+    // of a held value, once the transaction gains an async blocker (#3028).
+    static wt=null;
     // Optimistic-engine hooks (wired by core/optimistic.ts via
     // installOptimisticEngine(), called from verdict.ts / createOptimistic /
     // createOptimisticStore — every module that can create optimistic state).
@@ -324,21 +327,37 @@ class GlobalQueue extends Queue {
     // `_overrideValue` slot, a lane in `activeLanes`, an `_optimisticNodes`
     // entry, or a non-null `currentOptimisticLane`, so `!` invocations are safe
     // once the gate holds.
-    static Gt=null;
+    static vt=null;
+    static fn=null;
+    static dn=null;
     static En=null;
     static Tn=null;
-    static In=null;
-    static Nn=null;
-    static Rt=null;
-    static Ot=null;
-    static Dt=null;
+    static Ft=null;
+    static ht=null;
+    static gt=null;
     static je=null;
+    static $e=null;
     static ze=null;
-    static Be=null;
-    static Qn=null;
+    static Nn=null;
     flush() {
-        if (this.cn) return;
-        this.cn = true;
+        if (this.sn) return;
+        // Fast drain: nothing in flight but plain pending commits — no dirty
+        // computeds, no queued effects, no child queues, no transitions/lanes/
+        // optimistic state. Commit and go; anything a commit hook schedules
+        // (companion snaps, store folds notifying subs) re-arms `scheduled`
+        // below and the outer drain loop takes the full spine next round.
+                if (activeTransition === null && dirtyQueue.EE < dirtyQueue.xe && this.Lt[0].length === 0 && this.Lt[1].length === 0 && this.Qt.length === 0 && canUseSimpleSyncFlush(this)) {
+            this.sn = true;
+            try {
+                commitPendingNodes();
+            } finally {
+                this.sn = false;
+            }
+            clock++;
+            scheduled = dirtyQueue.EE >= dirtyQueue.xe || this.Lt[0].length !== 0 || this.Lt[1].length !== 0 || this.k.yt.length !== 0;
+            return;
+        }
+        this.sn = true;
         try {
             if (false) ;
             runHeap(dirtyQueue, GlobalQueue.Ce);
@@ -354,53 +373,53 @@ class GlobalQueue extends Queue {
                     // zombies here. Height-adjust entries still process normally: a
                     // dirtied one keeps its height flag and falls through to runHeap's
                     // adjustHeight path on the next pass of the bucket.
-                                        runHeap(zombieQueue, this.m === e ? cancelZombieRecompute : GlobalQueue.Ce);
+                                        runHeap(zombieQueue, this.k === e ? cancelZombieRecompute : GlobalQueue.Ce);
                     // Detach: the stashed transition keeps its batch; ambient work that
                     // follows lands in a fresh one. If the batch is already a separate
                     // ambient one — action done() restored activeTransition without
                     // adopting the batch, and an ordinary write landed there before
                     // the scheduled flush (#2916) — keep it: replacing it would strand
                     // its queued pending nodes with held _pendingValues forever.
-                                        if (this.m === e) currentBatch = this.m = createBatch();
+                                        if (this.k === e) currentBatch = this.k = createBatch();
                     // Run lane effects immediately (before stashing) - lanes with no pending async
                                         if (activeLanes.size) {
-                        GlobalQueue.Nn(EFFECT_RENDER);
-                        GlobalQueue.Nn(EFFECT_USER);
+                        GlobalQueue.Tn(EFFECT_RENDER);
+                        GlobalQueue.Tn(EFFECT_USER);
                     }
-                    this.stashQueues(e.yt);
+                    this.stashQueues(e.bt);
                     clock++;
                     // A kept ambient batch may hold pending nodes (#2916): stay
                     // scheduled so the outer drain loop commits them via the plain
                     // flush path instead of leaving them until the next natural flush.
-                                        scheduled = dirtyQueue.EE >= dirtyQueue.Ve || this.m.Qt.length > 0;
-                    reassignPendingTransition(e.Qt);
+                                        scheduled = dirtyQueue.EE >= dirtyQueue.xe || this.k.yt.length > 0;
+                    reassignPendingTransition(e.yt);
                     activeTransition = null;
                     finalizePureQueue(null, true);
                     return;
                 }
                 const t = activeTransition;
-                const i = this.m;
-                i !== t && i.Qt.push(...t.Qt);
-                this.restoreQueues(t.yt);
+                const i = this.k;
+                i !== t && i.yt.push(...t.yt);
+                this.restoreQueues(t.bt);
                 transitions.delete(t);
                 activeTransition = null;
-                reassignPendingTransition(i.Qt);
+                reassignPendingTransition(i.yt);
                 finalizePureQueue(t);
                 if (i === t) {
                     // Drop the dead Transition wrapper but keep its (drained) containers
                     // as the ambient batch — late registrations during finalization live
                     // there and must survive to the next flush.
                     const e = createBatch();
-                    e.Qt = i.Qt;
-                    e.Me = i.Me;
-                    e.A = i.A;
-                    e.dn = i.dn;
-                    currentBatch = this.m = e;
+                    e.yt = i.yt;
+                    e.Ke = i.Ke;
+                    e.m = i.m;
+                    e.cn = i.cn;
+                    currentBatch = this.k = e;
                 }
             } else {
                 if (canUseSimpleSyncFlush(this)) {
                     commitPendingNodes();
-                    if (dirtyQueue.EE >= dirtyQueue.Ve) {
+                    if (dirtyQueue.EE >= dirtyQueue.xe) {
                         runHeap(dirtyQueue, GlobalQueue.Ce);
                         commitPendingNodes();
                     }
@@ -411,36 +430,39 @@ class GlobalQueue extends Queue {
             }
             clock++;
             // Check if finalization added items to the heap (from optimistic reversion)
-                        scheduled = dirtyQueue.EE >= dirtyQueue.Ve;
+                        scheduled = dirtyQueue.EE >= dirtyQueue.xe;
             // Run lane effects first (for ready lanes), then regular effects
-                        activeLanes.size && GlobalQueue.Nn(EFFECT_RENDER);
+                        activeLanes.size && GlobalQueue.Tn(EFFECT_RENDER);
             this.run(EFFECT_RENDER);
-            activeLanes.size && GlobalQueue.Nn(EFFECT_USER);
+            activeLanes.size && GlobalQueue.Tn(EFFECT_USER);
             this.run(EFFECT_USER);
             if (false) ;
             if (false && !scheduled && !activeTransition && transitions.size === 0 && activeLanes.size === 0) ;
             if (false) ;
         } finally {
-            this.cn = false;
+            this.sn = false;
         }
     }
     notify(e, t, i, n) {
         // Only track async if the boundary is propagating STATUS_PENDING (not caught by boundary)
         if (t & STATUS_PENDING) {
             if (i & STATUS_PENDING) {
-                const t = n !== undefined ? n : e._;
+                const t = n !== undefined ? n : e.o?._;
                 // A visibility-only mark notification (the affects() boundary
                 // channel) updates display state on its way up but must be invisible
                 // to completion accounting BY CONSTRUCTION: it never registers a
                 // reporter and never counts toward the loading-boundary diagnostic.
-                                if (t?.l) return true;
+                                if (t?.i) return true;
                 if (activeTransition && t) {
                     const i = t.source;
-                    let n = activeTransition.Ie.get(i);
-                    if (!n) activeTransition.Ie.set(i, n = new Set);
+                    let n = activeTransition.Ne.get(i);
+                    if (!n) activeTransition.Ne.set(i, n = new Set);
                     const s = n.size;
                     n.add(e);
-                    if (n.size !== s) schedule();
+                    if (n.size !== s) {
+                        schedule();
+                        GlobalQueue.wt?.(activeTransition);
+                    }
                 }
             }
             return true;
@@ -450,7 +472,7 @@ class GlobalQueue extends Queue {
     initTransition(e) {
         if (e) e = currentTransition(e);
         if (e && e === activeTransition) return;
-        if (!e && activeTransition && activeTransition.de === clock) return;
+        if (!e && activeTransition && activeTransition.Te === clock) return;
         if (!activeTransition) {
             activeTransition = e ?? createBatch();
         } else if (e) {
@@ -460,8 +482,8 @@ class GlobalQueue extends Queue {
             activeTransition = e;
         }
         transitions.add(activeTransition);
-        activeTransition.de = clock;
-        const t = this.m;
+        activeTransition.Te = clock;
+        const t = this.k;
         if (t !== activeTransition) {
             // Adopt the ambient batch into the transaction, then make the
             // transaction the batch so later registrations land there directly.
@@ -470,34 +492,34 @@ class GlobalQueue extends Queue {
             // must not entangle unrelated writes to it; the same rule holds one hop
             // downstream: propagation never queues pended subscribers as pending
             // nodes, see propagateAffectsMark, #2893.
-            for (let e = 0; e < t.Qt.length; e++) {
-                const i = t.Qt[e];
-                i.Ne = activeTransition;
-                activeTransition.Qt.push(i);
+            for (let e = 0; e < t.yt.length; e++) {
+                const i = t.yt[e];
+                i._e = activeTransition;
+                activeTransition.yt.push(i);
             }
-            for (let e = 0; e < t.Me.length; e++) {
-                const i = t.Me[e];
-                i.Ne = activeTransition;
-                activeTransition.Me.push(i);
+            for (let e = 0; e < t.Ke.length; e++) {
+                const i = t.Ke[e];
+                i._e = activeTransition;
+                activeTransition.Ke.push(i);
             }
-            if (t.A.length) activeTransition.A.push(...t.A);
-            for (const e of t.dn) activeTransition.dn.add(e);
+            if (t.m.length) activeTransition.m.push(...t.m);
+            for (const e of t.cn) activeTransition.cn.add(e);
             // Gated readers recorded against the ambient batch move with it: their
             // replay-at-commit now happens at the transaction's completion.
                         if (t.ln.size) {
                 for (const e of t.ln) activeTransition.ln.add(e);
                 t.ln.clear();
             }
-            currentBatch = this.m = activeTransition;
+            currentBatch = this.k = activeTransition;
         }
         for (const e of activeLanes) {
-            if (!e.Ne) e.Ne = activeTransition;
+            if (!e._e) e._e = activeTransition;
         }
     }
 }
 
 function queuePendingNode(e) {
-    currentBatch.Qt.push(e);
+    currentBatch.yt.push(e);
 }
 
 // Sticky: flips true on the first refresh() ever (the only setter of
@@ -505,60 +527,87 @@ function queuePendingNode(e) {
 // clear entirely in apps that never refresh.
 let reaskArmed = false;
 
+/** §12d: bumped by every recompute and every new subscriber edge. A node's
+ * staged-rewrite skip is sound only while NOTHING recomputed or linked since
+ * its last notify — a mid-batch pull can clean a marked subscriber, and a
+ * skipped re-write would leave it stale. */ let notifyEpoch = 0;
+
+function bumpNotifyEpoch() {
+    notifyEpoch++;
+}
+
 function armReaskClear() {
     reaskArmed = true;
 }
 
 function insertSubs(e, t = false) {
+    // §12d: stamp before walking — setSignal's staged-rewrite fast path skips
+    // the next walk for this node while the epoch holds (marking is idempotent).
+    e._t = notifyEpoch;
     // Get source lane: prefer node's own lane over current context
     // This is important for isPending signals which need their own lane to flush immediately
-    const i = e.Ke || currentOptimisticLane;
-    const n = e.xe !== undefined;
-    const s = reaskArmed;
-    for (let r = e.o; r !== null; r = r.ue) {
+    // Presence bits gate the optional-slot probes (see constants.ts): one
+    // masked read of the always-present _config instead of missing-property
+    // lookups in the hottest notify loop. Bits are sticky — the field read
+    // stays authoritative when a bit is set.
+        const i = e.T;
+    const n = (i & CONFIG_HAS_LANE ? e.o?.Be : undefined) || currentOptimisticLane;
+    const s = (i & CONFIG_HAS_SNAPSHOT) !== 0 && e.o?.Qe !== undefined;
+    const o = reaskArmed;
+    for (let i = e.u; i !== null; i = i.fe) {
+        const e = i.ae;
         // A value-change notification is a new question for the subscriber: any
         // pending re-ask mark (refresh) it carried is superseded.
-        if (s) r.fe.se &= ~REACTIVE_REASK;
-        if (n && r.fe.T & CONFIG_IN_SNAPSHOT_SCOPE) {
-            r.fe.se |= REACTIVE_SNAPSHOT_STALE;
+                if (o) e.ie &= ~REACTIVE_REASK;
+        // Missed-wake latch (#3037): this write is landing while the subscriber
+        // is mid-recompute (a nested pull committing beneath its reads), and the
+        // heap refuses RECOMPUTING nodes. A gen-current link means the pass
+        // already validated this dep — the value it read is now stale — so latch
+        // for recompute's tail to reschedule. Untouched links need no latch (the
+        // pass either re-reads them fresh or trims them), and neither does the
+        // tail link: it is the read IN FLIGHT — read() links before it pulls, so
+        // this very commit is what that read returns.
+                if (e.ie & REACTIVE_RECOMPUTING_DEPS && i.ll === e.Ze && i !== e.Ye) e.ie |= REACTIVE_MISSED_WAKE;
+        if (s && e.T & CONFIG_IN_SNAPSHOT_SCOPE) {
+            e.ie |= REACTIVE_SNAPSHOT_STALE;
             continue;
         }
-        if (t && i) {
-            r.fe.se |= REACTIVE_OPTIMISTIC_DIRTY;
-            assignOrMergeLane(r.fe, i);
+        if (t && n) {
+            e.ie |= REACTIVE_OPTIMISTIC_DIRTY;
+            assignOrMergeLane(e, n);
         } else if (t) {
-            r.fe.se |= REACTIVE_OPTIMISTIC_DIRTY;
+            e.ie |= REACTIVE_OPTIMISTIC_DIRTY;
             // No source lane means reversion - clear subscriber's lane so effects go to regular queue
-                        r.fe.Ke = undefined;
+                        if (e.o) e.o.Be = undefined;
         }
-        enqueueSub(r.fe);
+        enqueueSub(e);
     }
 }
 
 function commitPendingNode(e) {
     const t = e;
-    if (!t.ce) {
-        if (e._e !== NOT_PENDING) {
-            e.be = e._e;
-            e._e = NOT_PENDING;
+    if (!t.Se) {
+        if (e.Pe !== NOT_PENDING) {
+            e.be = e.Pe;
+            e.Pe = NOT_PENDING;
         }
-        if (e.Oe || e.ge) GlobalQueue.un(e);
+        if (e.T & CONFIG_HAS_COMPANIONS) GlobalQueue.un(e);
         return;
     }
-    if (e._e !== NOT_PENDING) {
-        e.be = e._e;
-        e._e = NOT_PENDING;
+    if (e.Pe !== NOT_PENDING) {
+        e.be = e.Pe;
+        e.Pe = NOT_PENDING;
         // Set _modified for effects, but not for tracked effects (they handle their own scheduling)
-                if (e.Re && e.Re !== EFFECT_TRACKED) e.Je = true;
+                if (e.Re && e.Re !== EFFECT_TRACKED) e.Xe = 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.Ee = false;
-    t.se &= ~REACTIVE_MANUAL_WRITE;
+        t.Ie = false;
+    t.ie &= ~REACTIVE_MANUAL_WRITE;
     if (!(t.S & STATUS_PENDING)) t.S &= ~STATUS_UNINITIALIZED;
-    if (t.We !== null || t.Qe !== null) GlobalQueue.me(t, false, true);
-    if (e.Oe || e.ge) GlobalQueue.un(e);
+    if (t.o != null && (t.o.qe !== null || t.o.We !== null)) GlobalQueue.Fe(t, false, true);
+    if (e.T & CONFIG_HAS_COMPANIONS) GlobalQueue.un(e);
 }
 
 // Store commit hook (INTERNALS-STORE-STATE.md §3): installed by the store
@@ -573,7 +622,7 @@ function setStoreCommitHook(e) {
 }
 
 function commitPendingNodes() {
-    const e = currentBatch.Qt;
+    const e = currentBatch.yt;
     for (let t = 0; t < e.length; t++) {
         commitPendingNode(e[t]);
     }
@@ -586,23 +635,23 @@ function finalizePureQueue(e = null, t = false) {
     // For completing transitions or no-transition, resolve pending and revert optimistic
     const i = !t;
     if (i) commitPendingNodes();
-    if (!t && globalQueue.vt.length) checkBoundaryChildren(globalQueue);
-    const n = dirtyQueue.EE >= dirtyQueue.Ve;
+    if (!t && globalQueue.Qt.length) checkBoundaryChildren(globalQueue);
+    const n = dirtyQueue.EE >= dirtyQueue.xe;
     if (n) runHeap(dirtyQueue, GlobalQueue.Ce);
     if (i) {
         if (n) commitPendingNodes();
         // The settling batch: the completing transaction's, or the ambient one.
-                const t = e ?? globalQueue.m;
+                const t = e ?? globalQueue.k;
         // Optimistic reversion: a non-empty batch means _optimisticWrite ran,
         // which installed the engine's hooks.
-                if (t.Me.length) GlobalQueue.En(t.Me);
+                if (t.Ke.length) GlobalQueue.fn(t.Ke);
         // Replay entanglement: subs recorded by the read-time gate get rescheduled
         // so they re-run with the now-committed values visible. The ambient batch
         // replays too — laneReadsCommitted records readers whose committed-view
         // read hid a same-tick plain write that just committed above (#2963).
                 if (t.ln.size) {
             for (const e of t.ln) {
-                if (e.se & REACTIVE_DISPOSED) continue;
+                if (e.ie & REACTIVE_DISPOSED) continue;
                 enqueueSub(e);
             }
             t.ln.clear();
@@ -617,24 +666,24 @@ function finalizePureQueue(e = null, t = false) {
         // held boundary display state through the visual channel, and their
         // release is the display-state update point — re-run the boundary sweep
         // (the earlier sweep above ran while the marks were still live).
-                if (t.A.length) {
-            GlobalQueue.G(t.A);
-            if (globalQueue.vt.length) checkBoundaryChildren(globalQueue);
+                if (t.m.length) {
+            GlobalQueue.M(t.m);
+            if (globalQueue.Qt.length) checkBoundaryChildren(globalQueue);
         }
         // A non-empty set means trackOptimisticStore ran, which installed the
         // hook; the hook iterates, clears, and schedules (keeping the loop out of
         // core lets esbuild shake it — rollup already folds the null guard). The
         // completing transition scopes the clear to its own layer keys (#2899).
-                if (t.dn.size) GlobalQueue.gt(t.dn, e);
+                if (t.cn.size) GlobalQueue.Vt(t.cn, e);
         sweepTransientStoreNodes();
         // Lanes only enter activeLanes through the engine's getOrCreateLane.
-                if (activeLanes.size) GlobalQueue.In(e);
+                if (activeLanes.size) GlobalQueue.En(e);
     }
 }
 
 function checkBoundaryChildren(e) {
-    for (const t of e.vt) {
-        t.ne?.();
+    for (const t of e.Qt) {
+        t.se?.();
         checkBoundaryChildren(t);
     }
 }
@@ -657,7 +706,7 @@ function checkBoundaryChildren(e) {
 
 function reassignPendingTransition(e) {
     for (let t = 0; t < e.length; t++) {
-        e[t].Ne = activeTransition;
+        e[t]._e = activeTransition;
     }
 }
 
@@ -668,7 +717,7 @@ const globalQueue = new GlobalQueue;
 // property hop through `_batch` was a measured instruction-count regression
 // (CodSpeed update1to1, PR #2905). The field stays authoritative for
 // cross-module readers; every `_batch` assignment updates both.
-let currentBatch = globalQueue.m;
+let currentBatch = globalQueue.k;
 
 function flush(e) {
     if (e) {
@@ -685,7 +734,7 @@ function flush(e) {
             }
         }
     }
-    if (globalQueue.cn) {
+    if (globalQueue.sn) {
         return;
     }
     if (halted) return;
@@ -701,23 +750,23 @@ function runQueue(e, t) {
 }
 
 function reporterBlocksSource(e, t) {
-    if (e.se & (REACTIVE_ZOMBIE | REACTIVE_DISPOSED)) return false;
-    if (e.oe?.has(t)) return true;
-    for (let i = e.tt; i; i = i.nt) {
-        let e = i.it;
+    if (e.ie & (REACTIVE_ZOMBIE | REACTIVE_DISPOSED)) return false;
+    if (e.o?.le?.has(t)) return true;
+    for (let i = e.nt; i; i = i.it) {
+        let e = i.ut;
         while (e) {
             if (e === t || e.lt === t) return true;
-            e = e.nn;
+            e = e.o?.It;
         }
     }
-    return !!(e.S & STATUS_PENDING && e._ instanceof NotReadyError && e._.source === t);
+    return !!(e.S & STATUS_PENDING && e.o?._ instanceof NotReadyError && e.o?._.source === t);
 }
 
 function transitionComplete(e) {
-    if (e.fn) return true;
-    if (e.ie.length) return false;
+    if (e.an) return true;
+    if (e.oe.length) return false;
     let t = true;
-    for (const [i, n] of e.Ie) {
+    for (const [i, n] of e.Ne) {
         let s = false;
         for (const e of n) {
             if (reporterBlocksSource(e, i)) {
@@ -726,7 +775,7 @@ function transitionComplete(e) {
             }
             n.delete(e);
         }
-        if (!s) e.Ie.delete(i); else if (i.S & STATUS_PENDING && i._?.source === i) {
+        if (!s) e.Ne.delete(i); else if (i.S & STATUS_PENDING && i.o?._?.source === i) {
             t = false;
             break;
         }
@@ -734,13 +783,13 @@ function transitionComplete(e) {
     // Override blockage lives with the engine (absent hook = "no optimistic
     // blockage"); the hook's loops over _optimisticNodes/_optimisticStores are
     // no-ops when the transition holds neither, so no pre-check is needed.
-        if (t && GlobalQueue.Tn?.(e)) t = false;
-    t && (e.fn = true);
+        if (t && GlobalQueue.dn?.(e)) t = false;
+    t && (e.an = true);
     return t;
 }
 
 function currentTransition(e) {
-    while (e.fn && typeof e.fn === "object") e = e.fn;
+    while (e.an && typeof e.an === "object") e = e.an;
     return e;
 }
 
@@ -754,4 +803,4 @@ function runInTransition(e, t) {
     }
 }
 
-export { GlobalQueue, Queue, activeAffectsMarks, activeLanes, activeTransition, armReaskClear, assignOrMergeLane, clock, currentTransition, dirtyQueue, enforceLoadingBoundary, finalizePureQueue, findLane, flush, globalQueue, haltReactivity, insertSubs, projectionWriteActive, queuePendingNode, resetErrorHalt, runInTransition, schedule, setProjectionWriteActive, setStoreCommitHook, shiftAffectsMarks, storeCommitHook, zombieQueue };
+export { GlobalQueue, Queue, activeAffectsMarks, activeLanes, activeTransition, armReaskClear, assignOrMergeLane, bumpNotifyEpoch, clock, currentTransition, dirtyQueue, enforceLoadingBoundary, finalizePureQueue, findLane, flush, globalQueue, haltReactivity, insertSubs, notifyEpoch, projectionWriteActive, queuePendingNode, reaskArmed, resetErrorHalt, runInTransition, schedule, setProjectionWriteActive, setStoreCommitHook, shiftAffectsMarks, storeCommitHook, zombieQueue };