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

package/dist/prod/core/scheduler.js

@@ -1,6 +1,6 @@
-import { EFFECT_RENDER, EFFECT_USER, STATUS_PENDING, REACTIVE_IN_HEAP_HEIGHT, REACTIVE_DISPOSED, CONFIG_HELD_TRUTH, REACTIVE_ZOMBIE, CONFIG_HAS_LANE, CONFIG_HAS_SNAPSHOT, REACTIVE_RECOMPUTING_DEPS, REACTIVE_MISSED_WAKE, CONFIG_IN_SNAPSHOT_SCOPE, REACTIVE_SNAPSHOT_STALE, REACTIVE_OPTIMISTIC_DIRTY, NOT_PENDING, CONFIG_HAS_COMPANIONS, EFFECT_TRACKED, REACTIVE_REASK, REACTIVE_MANUAL_WRITE, STATUS_UNINITIALIZED, CONFIG_AUTHORITATIVE_READ } from "./constants.js";
+import { EFFECT_RENDER, EFFECT_USER, STATUS_PENDING, REACTIVE_IN_HEAP_HEIGHT, REACTIVE_DISPOSED, CONFIG_HELD_TRUTH, REACTIVE_ZOMBIE, CONFIG_HAS_LANE, CONFIG_HAS_SNAPSHOT, REACTIVE_RECOMPUTING_DEPS, REACTIVE_MISSED_WAKE, CONFIG_IN_SNAPSHOT_SCOPE, REACTIVE_SNAPSHOT_STALE, REACTIVE_OPTIMISTIC_DIRTY, NOT_PENDING, CONFIG_SLOT_NODE, CONFIG_HAS_COMPANIONS, EFFECT_TRACKED, CONFIG_INPUTS_PUBLISHED, REACTIVE_REASK, REACTIVE_MANUAL_WRITE, STATUS_UNINITIALIZED, CONFIG_AUTHORITATIVE_READ } from "./constants.js";
 
-import { currentOptimisticLane } from "./core.js";
+import { currentOptimisticLane, slotUnobservedHook } from "./core.js";
 
 import { DEV } from "./dev.js";
 
@@ -21,14 +21,14 @@ const transitions = new Set;
 const dirtyQueue = {
     eE: new Array(2e3).fill(undefined),
     tE: false,
-    Qe: 0,
+    Ke: 0,
     EE: 0
 };
 
 const zombieQueue = {
     eE: new Array(2e3).fill(undefined),
     tE: false,
-    Qe: 0,
+    Ke: 0,
     EE: 0
 };
 
@@ -55,6 +55,17 @@ let syncDepth = 0;
 
 let projectionWriteActive = false;
 
+/** > 0 while an action's generator body is on the stack (the synchronous
+ * slice between yields). Maintained by action.ts around `it.next()`. */ let actionStepDepth = 0;
+
+function enterActionStep() {
+    actionStepDepth++;
+}
+
+function exitActionStep() {
+    actionStepDepth--;
+}
+
 // Store property nodes that were created solely to carry a pending write (no
 // subscribers at write time). Swept after each flush that commits pending
 // values — any still without subs get disposed via their `_unobserved` hook,
@@ -63,7 +74,7 @@ const transientStoreNodes = new Set;
 
 function canUseSimpleSyncFlush(e) {
     const t = e.m;
-    return transitions.size === 0 && activeLanes.size === 0 && e.Qt.length === 0 && t.ze.length === 0 && t.A.length === 0 && t.En.size === 0 && transientStoreNodes.size === 0;
+    return transitions.size === 0 && activeLanes.size === 0 && e.Xt.length === 0 && t.it.length === 0 && t.A.length === 0 && t.En.size === 0 && transientStoreNodes.size === 0;
 }
 
 function sweepTransientStoreNodes() {
@@ -73,14 +84,14 @@ function sweepTransientStoreNodes() {
             transientStoreNodes.delete(e);
             continue;
         }
-        if (e.Re !== NOT_PENDING) continue;
-        if (e.o?.Pe !== undefined && e.o?.Pe !== NOT_PENDING) continue;
+        if (e.Ge !== NOT_PENDING) continue;
+        if (e.o?.be !== undefined && e.o?.be !== 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.o?.t) continue;
         transientStoreNodes.delete(e);
-        e.o?.Et?.();
+        if (e.T & CONFIG_SLOT_NODE) slotUnobservedHook(e); else e.o?.Ct?.();
     }
 }
 
@@ -107,32 +118,33 @@ function setProjectionWriteActive(e) {
  * land there directly — no per-field aliasing.
  */ function createBatch() {
     return {
-        Te: clock,
-        Lt: [],
-        _e: new Map,
-        ze: [],
+        _e: clock,
+        $t: [],
+        Re: new Map,
+        it: [],
         A: [],
         En: new Set,
         ue: [],
-        Bt: {
-            Mt: [ [], [] ],
-            Qt: []
+        ei: {
+            ti: [ [], [] ],
+            Xt: []
         },
-        sn: false,
-        cn: new Set
+        ft: false,
+        lt: new Set,
+        Et: null
     };
 }
 
 function mergeTransitionState(e, t) {
-    t.sn = e;
+    t.ft = e;
     e.ue.push(...t.ue);
-    for (const i of activeLanes) if (i.Ae === t) i.Ae = e;
-    if (t.ze.length) {
+    for (const i of activeLanes) if (i.ge === t) i.ge = e;
+    if (t.it.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.ze.push(...t.ze);
-        t.ze.length = 0;
+        e.it.push(...t.it);
+        t.it.length = 0;
     }
     if (t.A.length) {
         // Move (don't copy): the global queue's batch may still be the outgoing
@@ -142,32 +154,13 @@ function mergeTransitionState(e, t) {
         t.A.length = 0;
     }
     for (const i of t.En) e.En.add(i);
-    // Patch-channel stash (store/next/patch.ts): entries held for the outgoing
-    // transition must ride the merge like every other per-transition
-    // collection — releaseBatch only reads the COMMITTING transition's stash,
-    // so a stranded sidecar would silently drop its patches. Move (don't
-    // copy), same aliasing rule as the collections above. The field is an
-    // expando so this module stays free of patch imports (pay-for-use).
-        const i = t.wt;
-    if (i !== undefined) {
-        t.wt = undefined;
-        let n = e.wt;
-        if (n !== undefined) n.push(...i); else n = e.wt = i;
-        // Retarget the entries' coalescing stamps to the surviving stash
-        // (opaque backref contract with store/next/patch.ts): without this a
-        // post-merge emission misses the stamp and pushes a SECOND entry —
-        // the record's patch applies twice at commit (re-audit 5, P1-2).
-                for (let e = 0; e < i.length; e++) {
-            const t = i[e].pc;
-            if (t !== undefined && t.qe === i[e]) t.qa = n;
-        }
-    }
-    for (const [i, n] of t._e) {
-        let t = e._e.get(i);
-        if (!t) e._e.set(i, t = new Set);
+    for (const [i, n] of t.Re) {
+        let t = e.Re.get(i);
+        if (!t) e.Re.set(i, t = new Set);
         for (const e of n) t.add(e);
     }
-    for (const i of t.cn) e.cn.add(i);
+    for (const i of t.lt) e.lt.add(i);
+    if (t.Et) (e.Et ??= []).push(...t.Et);
 }
 
 /**
@@ -188,7 +181,7 @@ function mergeTransitionState(e, t) {
  * `until()` retain this.
  */ function entangleConfirmingTransitions(e, t) {
     t = currentTransition(t);
-    if (t.sn === true) return;
+    if (t.ft === true) return;
     // The confirming evidence is a dep whose value is STAGED (pending,
     // uncommitted) at flip evaluation — committed deps are public already and
     // carry nothing to entangle. A staged dep lives in one of two carriers: a
@@ -201,10 +194,10 @@ function mergeTransitionState(e, t) {
     // the awaiting transaction to landings that haven't happened; a merged
     // reporter deadlocked exactly that way).
         let i = false;
-    for (let n = e.ut; n !== null; n = n.lt) {
-        const r = n.ot;
-        if (r.Re !== NOT_PENDING) {
-            const e = r.Ae;
+    for (let n = e.fe; n !== null; n = n.ae) {
+        const r = n.Se;
+        if (r.Ge !== NOT_PENDING) {
+            const e = r.ge;
             const n = e != null ? currentTransition(e) : null;
             // Skip the awaiting transaction's own cargo (t === target: a
             // fold-staged landing or a write the action itself issued — hold and
@@ -212,10 +205,10 @@ function mergeTransitionState(e, t) {
             // (t === null) must leave the batch NOW — it commits at this flush's
             // end, which would reveal the confirmation under the live optimism
             // it just confirmed.
-                        const s = n === null ? currentBatch.Lt : n !== t && n.sn !== true ? n.Lt : null;
+                        const s = n === null ? currentBatch.$t : n !== t && n.ft !== true ? n.$t : null;
             if (s !== null) i = stealEntangledCargo(s, t) || i;
         }
-        if (n === e.je) break;
+        if (n === e.et) break;
     }
     // The steal never activates the awaiting transaction: the predicate can
     // flip inside another transaction's finalize heap, and adopting the queue
@@ -244,20 +237,20 @@ function mergeTransitionState(e, t) {
  * committed value — while re-running them would re-derive the OLD world
  * and re-stage it over the held truth. The reveal re-notifies
  * (commitPendingNodes), which is when they re-derive for real. */ function stealEntangledCargo(e, t) {
-    if (e === t.Lt || e.length === 0) return false;
+    if (e === t.$t || e.length === 0) return false;
     for (let i = 0; i < e.length; i++) {
         const n = e[i];
-        n.Ae = t;
-        t.Lt.push(n);
+        n.ge = t;
+        t.$t.push(n);
         // Override-covered nodes stay silent AND unmasked: the override is the
         // display (A17 — its staging never notified, its revert will), so their
         // subs saw nothing and re-running one would break the silence with a
         // duplicate fire of an unchanged view.
                 if (!hasActiveOverride(n)) {
             n.T |= CONFIG_HELD_TRUTH;
-            for (let e = n.u; e !== null; e = e.ae) {
-                const t = e.ce;
-                if (t.ge && !(t.T & CONFIG_AUTHORITATIVE_READ)) enqueueSub(t);
+            for (let e = n.u; e !== null; e = e.Te) {
+                const t = e.Ie;
+                if (t.Ce && !(t.T & CONFIG_AUTHORITATIVE_READ)) enqueueSub(t);
             }
         }
     }
@@ -273,7 +266,7 @@ function schedule() {
     }
     if (scheduled) return;
     scheduled = true;
-    if (!syncDepth && !globalQueue.fn && !projectionWriteActive) queueMicrotask(flush);
+    if (!syncDepth && !globalQueue.sn && !projectionWriteActive) queueMicrotask(flush);
 }
 
 /**
@@ -284,10 +277,18 @@ function schedule() {
     if (halted) return;
     halted = true;
     let t = "[REACTIVITY_HALTED]";
-    // Log the cause here too: callers rethrow it, but a creation-time throw
+    // Surface the cause here too: callers rethrow it, but a creation-time throw
     // unwinds through ancestor recomputes that convert it to status instead of
     // surfacing it (#2884), so the rethrow alone cannot guarantee visibility.
-        e === undefined ? console.error(t) : console.error(t, e);
+    // Where the platform has one, hand the cause to its uncaught-error channel
+    // (`reportError` → `error` event → window.onerror / error monitoring): a
+    // halt that only reaches console.error leaves a page that LOOKS alive with
+    // nothing an app or its telemetry can act on (#3338 — an uncaught throw
+    // during the hydration render). The rethrow may reach the top as well in
+    // the non-swallowed cases; a duplicate report beats a silent one.
+        const i = e !== undefined && globalThis.reportError;
+    i || e === undefined ? console.error(t) : console.error(t, e);
+    i && i(e);
 }
 
 // Logs on the first write after a halt so a frozen interaction is traceable.
@@ -307,30 +308,30 @@ function notifyHalted() {
 let queueRunToken = 0;
 
 class Queue {
-    ke=null;
-    Mt=[ [], [] ];
-    Qt=[];
-    jt=0;
+    qe=null;
+    ti=[ [], [] ];
+    Xt=[];
+    ii=0;
     created=clock;
     addChild(e) {
-        this.Qt.push(e);
-        e.ke = this;
+        this.Xt.push(e);
+        e.qe = this;
     }
     removeChild(e) {
-        const t = this.Qt.indexOf(e);
+        const t = this.Xt.indexOf(e);
         if (t >= 0) {
-            this.Qt.splice(t, 1);
-            e.ke = null;
+            this.Xt.splice(t, 1);
+            e.qe = null;
         }
     }
     notify(e, t, i, n) {
-        if (this.ke) return this.ke.notify(e, t, i, n);
+        if (this.qe) return this.qe.notify(e, t, i, n);
         return false;
     }
     run(e) {
-        if (this.Mt[e - 1].length) {
-            const t = this.Mt[e - 1];
-            this.Mt[e - 1] = [];
+        if (this.ti[e - 1].length) {
+            const t = this.ti[e - 1];
+            this.ti[e - 1] = [];
             runQueue(t, e);
         }
         // Effects run here can dispose owners, and disposal removes queues from
@@ -340,12 +341,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.Qt;
+                const t = this.Xt;
         const i = ++queueRunToken;
         for (let n = 0; n < t.length; ) {
             const r = t[n];
-            if (r.jt !== i) {
-                r.jt = i;
+            if (r.ii !== i) {
+                r.ii = i;
                 r.run?.(e);
                 if (t[n] !== r) {
                     n = 0;
@@ -362,48 +363,48 @@ class Queue {
                 const i = findLane(currentOptimisticLane);
                 i.tn[e - 1].push(t);
             } else {
-                this.Mt[e - 1].push(t);
+                this.ti[e - 1].push(t);
             }
         }
         schedule();
     }
     stashQueues(e) {
-        e.Mt[0].push(...this.Mt[0]);
-        e.Mt[1].push(...this.Mt[1]);
-        this.Mt = [ [], [] ];
-        for (let t = 0; t < this.Qt.length; t++) {
-            let i = this.Qt[t];
-            let n = e.Qt[t];
+        e.ti[0].push(...this.ti[0]);
+        e.ti[1].push(...this.ti[1]);
+        this.ti = [ [], [] ];
+        for (let t = 0; t < this.Xt.length; t++) {
+            let i = this.Xt[t];
+            let n = e.Xt[t];
             if (!n) {
                 n = {
-                    Mt: [ [], [] ],
-                    Qt: []
+                    ti: [ [], [] ],
+                    Xt: []
                 };
-                e.Qt[t] = n;
+                e.Xt[t] = n;
             }
             i.stashQueues(n);
         }
     }
     restoreQueues(e) {
-        this.Mt[0].push(...e.Mt[0]);
-        this.Mt[1].push(...e.Mt[1]);
-        for (let t = 0; t < e.Qt.length; t++) {
-            const i = e.Qt[t];
-            let n = this.Qt[t];
+        this.ti[0].push(...e.ti[0]);
+        this.ti[1].push(...e.ti[1]);
+        for (let t = 0; t < e.Xt.length; t++) {
+            const i = e.Xt[t];
+            let n = this.Xt[t];
             if (n) n.restoreQueues(i);
         }
     }
 }
 
 class GlobalQueue extends Queue {
-    fn=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();
     static Fe;
-    static He;
-    static it;
-    static qt=null;
+    static We;
+    static ct;
+    static ni=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).
@@ -417,27 +418,27 @@ class GlobalQueue extends Queue {
     static N=null;
     // External-source bridge (wired by enableExternalSource(); null while no
     // config is active — including after _resetExternalSourceConfig()).
-    static Pt=null;
-    static ht=null;
+    static kt=null;
+    static Lt=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 Ue=null;
-    static de=null;
-    static me=null;
+    static pe=null;
+    static Ne=null;
+    static ke=null;
     static un=null;
-    static gt=null;
-    static Ht=null;
-    static kt=null;
-    static et=null;
-    static k=null;
+    static wt=null;
     static Wt=null;
+    static jt=null;
+    static st=null;
+    static k=null;
+    static ri=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 zt=null;
+    static si=null;
     // Optimistic-engine hooks (wired by core/optimistic.ts via
     // installOptimisticEngine(), called from verdict.ts / createOptimistic /
     // createOptimisticStore — every module that can create optimistic state).
@@ -445,35 +446,61 @@ 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 xt=null;
-    static Tn=null;
+    static Bt=null;
+    static fn=null;
+    static cn=null;
     static dn=null;
     static In=null;
-    static Nn=null;
     /** Patch-channel optimistic drain (next/patch.ts): optimistic emissions
      * apply at lane-effect timing — visible in flight, unlike the regular
      * effect queues an action stashes. Injected; null when unused. */
     static ln=null;
-    static vt=null;
-    static Vt=null;
-    static bt=null;
-    static Be=null;
-    static $e=null;
-    /** Authoritative-view reader wakeup (until()): installed at first until() call.
-     * Call sites are gated by CONFIG_AUTHORITATIVE_OBSERVED, which only until()'s
-     * carve-out read can set, so `!` invocations are safe once the gate holds. */
-    static he=null;
-    static Xe=null;
-    static _n=null;
+    static Zt=null;
+    static qt=null;
+    /** Is the node routed through a LIVE lane (`resolveLane`)? read()'s reveal
+     * carve-out asks before showing a foreign-held pending node's committed
+     * value: a lane-derived flight's inputs are already revealed through the
+     * lane (#3334). Gated on CONFIG_HAS_LANE, which only the engine sets. */
+    static Mt=null;
+    static Kt=null;
+    static nt=null;
+    static ot=null;
+    /** Authoritative-view reader wakeup: installed by until() and refresh() before
+     * their first read. Call sites are gated by CONFIG_AUTHORITATIVE_OBSERVED, which
+     * only such a reader's carve-out read can set, so `!` invocations are safe once
+     * the gate holds (#3303). */
+    static Qt=null;
+    static ut=null;
+    /** A18 supersession (#3331): own-source truth `value` landed under an active
+     * override. The engine decides whether the graph re-derives — the value
+     * differs from the override and is not a stale (older-action) answer (mark
+     * the node, demote its lane cascade, notify), or returns to it after an
+     * earlier differing arrival (clear the mark, notify) — and owns the
+     * authoritative-observer wake for a silent confirm. Installed with the
+     * optimistic engine; only reachable on a node that has an override. */
+    static ye=null;
+    /** read()'s value for a TRACKED reader of a superseded node (#3331): the
+     * staged truth, unless the reader is a stale (render) reader of another
+     * transaction — then the displayed override, as it keeps a foreign
+     * transaction's committed value over its staged write. */
+    static Yt=null;
+    /** setSignal's authoritative (projection-write) landing on an override-
+     * covered node (#3331 store twin): stage the truth for its transaction's
+     * commit whatever its relation to the committed value — a landing equal to
+     * committed still differs from the override — then _supersedeOverride
+     * decides. Installed with the optimistic engine; only reachable on a node
+     * that has an override. */
+    static zt=null;
+    static Nn=null;
     flush() {
-        if (this.fn) return;
+        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.Qe && this.Mt[0].length === 0 && this.Mt[1].length === 0 && this.Qt.length === 0 && canUseSimpleSyncFlush(this)) {
-            this.fn = true;
+                if (activeTransition === null && dirtyQueue.EE < dirtyQueue.Ke && this.ti[0].length === 0 && this.ti[1].length === 0 && this.Xt.length === 0 && canUseSimpleSyncFlush(this)) {
+            this.sn = true;
             try {
                 // Sweep first: unobserved() pulls swept nodes out of the dirty heap,
                 // so a dormant memo dirtied in the same tick is reclaimed instead of
@@ -481,13 +508,13 @@ class GlobalQueue extends Queue {
                 sweepDormant();
                 commitPendingNodes();
             } finally {
-                this.fn = false;
+                this.sn = false;
             }
             clock++;
-            scheduled = dirtyQueue.EE >= dirtyQueue.Qe || this.Mt[0].length !== 0 || this.Mt[1].length !== 0 || this.m.Lt.length !== 0;
+            scheduled = dirtyQueue.EE >= dirtyQueue.Ke || this.ti[0].length !== 0 || this.ti[1].length !== 0 || this.m.$t.length !== 0;
             return;
         }
-        this.fn = true;
+        this.sn = true;
         try {
             if (false) ;
             // Before runHeap for the same reason as the fast drain above; late
@@ -517,35 +544,35 @@ class GlobalQueue extends Queue {
                                         if (this.m === e) currentBatch = this.m = createBatch();
                     // Run lane effects immediately (before stashing) - lanes with no pending async
                                         if (activeLanes.size) {
-                        GlobalQueue.Nn(EFFECT_RENDER);
-                        GlobalQueue.Nn(EFFECT_USER);
+                        GlobalQueue.In(EFFECT_RENDER);
+                        GlobalQueue.In(EFFECT_USER);
                     }
-                    this.stashQueues(e.Bt);
+                    this.stashQueues(e.ei);
                     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.Qe || this.m.Lt.length > 0;
-                    reassignPendingTransition(e.Lt);
+                                        scheduled = dirtyQueue.EE >= dirtyQueue.Ke || this.m.$t.length > 0;
+                    reassignPendingTransition(e.$t);
                     activeTransition = null;
                     finalizePureQueue(null, true);
                     return;
                 }
                 const t = activeTransition;
                 const i = this.m;
-                i !== t && i.Lt.push(...t.Lt);
-                this.restoreQueues(t.Bt);
+                i !== t && i.$t.push(...t.$t);
+                this.restoreQueues(t.ei);
                 transitions.delete(t);
                 activeTransition = null;
-                reassignPendingTransition(i.Lt);
+                reassignPendingTransition(i.$t);
                 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.Lt = i.Lt;
-                    e.ze = i.ze;
+                    e.$t = i.$t;
+                    e.it = i.it;
                     e.A = i.A;
                     e.En = i.En;
                     currentBatch = this.m = e;
@@ -553,7 +580,7 @@ class GlobalQueue extends Queue {
             } else {
                 if (canUseSimpleSyncFlush(this)) {
                     commitPendingNodes();
-                    if (dirtyQueue.EE >= dirtyQueue.Qe) {
+                    if (dirtyQueue.EE >= dirtyQueue.Ke) {
                         runHeap(dirtyQueue, GlobalQueue.Fe);
                         commitPendingNodes();
                     }
@@ -563,39 +590,54 @@ class GlobalQueue extends Queue {
                 }
             }
             clock++;
-            // Check if finalization added items to the heap (from optimistic reversion)
-                        scheduled = dirtyQueue.EE >= dirtyQueue.Qe;
+            // Check if finalization added items to the heap (from optimistic reversion).
+            // Finalization may also have ENTERED a transaction (a commit hook, boundary
+            // sweep or recompute wrote a node it owns): effects computed under it
+            // since are its to apply, not this flush's — runEffect leaves them queued
+            // and the next pass parks them with it (#3319). Everything computed
+            // mainline applies now.
+                        scheduled = dirtyQueue.EE >= dirtyQueue.Ke || activeTransition !== null;
             // Run lane effects first (for ready lanes), then regular effects
-                        activeLanes.size && GlobalQueue.Nn(EFFECT_RENDER);
+                        activeLanes.size && GlobalQueue.In(EFFECT_RENDER);
             this.run(EFFECT_RENDER);
-            activeLanes.size && GlobalQueue.Nn(EFFECT_USER);
+            activeLanes.size && GlobalQueue.In(EFFECT_USER);
             this.run(EFFECT_USER);
             if (false) ;
             if (false && !scheduled && !activeTransition && transitions.size === 0 && activeLanes.size === 0) ;
             if (false) ;
         } finally {
-            this.fn = 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.o?._;
+                // Callers pass either nothing or this node's own `_x._error`, so `??`
+                // is exact (a null error falls back to the same null).
+                const t = 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 (activeTransition && t) {
-                    const i = t.source;
-                    let n = activeTransition._e.get(i);
-                    if (!n) activeTransition._e.set(i, n = new Set);
-                    const r = n.size;
-                    n.add(e);
-                    if (n.size !== r) {
-                        schedule();
-                        GlobalQueue.zt?.(activeTransition);
+                if (t) {
+                    // A reveal can discover a flight started in an earlier flush. Hold
+                    // the staged writes with that reader (A15), even if the reader is
+                    // new. Fresh/reset loading boundaries consume pending before it
+                    // reaches here. A reader already parked in a transition must not
+                    // open a second one.
+                    if (!activeTransition && !e.ge && currentBatch.$t.length) this.initTransition();
+                    if (activeTransition) {
+                        const i = t.source;
+                        let n = activeTransition.Re.get(i);
+                        if (!n) activeTransition.Re.set(i, n = new Set);
+                        const r = n.size;
+                        n.add(e);
+                        if (n.size !== r) {
+                            schedule();
+                            GlobalQueue.si?.(activeTransition);
+                        }
                     }
                 }
             }
@@ -613,19 +655,24 @@ class GlobalQueue extends Queue {
             // new transaction identity each pass. Stamps are cleared at commit, so
             // this is a belt for paths that hand over a chased-dead reference
             // (merged chains, async settles racing completion).
-                        if (e.sn === true || e === activeTransition) return;
+                        if (e.ft === true || e === activeTransition) return;
         }
-        if (!e && activeTransition && activeTransition.Te === clock) return;
+        if (!e && activeTransition && activeTransition._e === clock) return;
         if (!activeTransition) {
             activeTransition = e ?? createBatch();
         } else if (e) {
             const t = activeTransition;
             mergeTransitionState(e, t);
+            // Effects the outgoing transaction parked belong to the surviving one
+            // now: back onto the live queue, where this flush parks them under
+            // `transition` or runs them at its completion. The outgoing stash is
+            // never read again — the transaction is dead (#3310).
+                        this.restoreQueues(t.ei);
             transitions.delete(t);
             activeTransition = e;
         }
         transitions.add(activeTransition);
-        activeTransition.Te = clock;
+        activeTransition._e = clock;
         const t = this.m;
         if (t !== activeTransition) {
             // Adopt the ambient batch into the transaction, then make the
@@ -635,28 +682,28 @@ 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.Lt.length; e++) {
-                const i = t.Lt[e];
-                i.Ae = activeTransition;
-                activeTransition.Lt.push(i);
+            for (let e = 0; e < t.$t.length; e++) {
+                const i = t.$t[e];
+                i.ge = activeTransition;
+                activeTransition.$t.push(i);
             }
-            for (let e = 0; e < t.ze.length; e++) {
-                const i = t.ze[e];
-                i.Ae = activeTransition;
-                activeTransition.ze.push(i);
+            for (let e = 0; e < t.it.length; e++) {
+                const i = t.it[e];
+                i.ge = activeTransition;
+                activeTransition.it.push(i);
             }
             if (t.A.length) activeTransition.A.push(...t.A);
             for (const e of t.En) activeTransition.En.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.cn.size) {
-                for (const e of t.cn) activeTransition.cn.add(e);
-                t.cn.clear();
+                        if (t.lt.size) {
+                for (const e of t.lt) activeTransition.lt.add(e);
+                t.lt.clear();
             }
             currentBatch = this.m = activeTransition;
         }
         for (const e of activeLanes) {
-            if (!e.Ae) e.Ae = activeTransition;
+            if (!e.ge) e.ge = activeTransition;
         }
         // A transaction's ambient window is one flush. Entering must therefore
         // guarantee a flush: a transaction opened with no writes (an action whose
@@ -671,7 +718,7 @@ class GlobalQueue extends Queue {
 }
 
 function queuePendingNode(e) {
-    currentBatch.Lt.push(e);
+    currentBatch.$t.push(e);
 }
 
 // Sticky: flips true on the first refresh() ever (the only setter of
@@ -692,10 +739,30 @@ function armReaskClear() {
     reaskArmed = true;
 }
 
+/** Provenance of the work currently running (A18 supersession, #3331): the
+ * invocation sequence of the action whose ambient window this is — set by
+ * action() for each slice; the flush that ends the window clears it — or,
+ * inside an async landing, the sequence captured when that flight was
+ * registered (asyncWrite sets it for the landing's synchronous propagation,
+ * so a sync recompute downstream of the landing — an optimistic wrapper over
+ * the async source — derives under the flight's provenance, and flights it
+ * registers inherit it). 0 is mainline: no action, always the current
+ * question. An override stamps this at its write (`_overrideStamp`); an
+ * answer whose flight an OLDER action issued is a stale question the user
+ * has since changed — it holds silently to commit instead of superseding. A
+ * slow source must not leak back in over a newer intent. Transactions merge,
+ * so the transition object cannot say WHICH action asked; this can. */ let origin = 0;
+
+function setOrigin(e) {
+    const t = origin;
+    origin = e;
+    return t;
+}
+
 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.It = notifyEpoch;
+    e.At = 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
     // Presence bits gate the optional-slot probes (see constants.ts): one
@@ -703,11 +770,11 @@ function insertSubs(e, t = false) {
     // 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?.Je : undefined) || currentOptimisticLane;
-    const r = (i & CONFIG_HAS_SNAPSHOT) !== 0 && e.o?.We !== undefined;
+    const n = (i & CONFIG_HAS_LANE ? e.o?.Oe : undefined) || currentOptimisticLane;
+    const r = (i & CONFIG_HAS_SNAPSHOT) !== 0 && e.o?.ze !== undefined;
     const s = reaskArmed;
-    for (let i = e.u; i !== null; i = i.ae) {
-        const e = i.ce;
+    for (let i = e.u; i !== null; i = i.Te) {
+        const e = i.Ie;
         // A value-change notification is a new question for the subscriber: any
         // pending re-ask mark (refresh) it carried is superseded.
                 if (s) e.ie &= ~REACTIVE_REASK;
@@ -719,7 +786,7 @@ function insertSubs(e, t = false) {
         // 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.Ft === e.Ke && i !== e.je) e.ie |= REACTIVE_MISSED_WAKE;
+                if (e.ie & REACTIVE_RECOMPUTING_DEPS && i.yt === e.tt && i !== e.et) e.ie |= REACTIVE_MISSED_WAKE;
         if (r && e.T & CONFIG_IN_SNAPSHOT_SCOPE) {
             e.ie |= REACTIVE_SNAPSHOT_STALE;
             continue;
@@ -730,7 +797,7 @@ function insertSubs(e, t = false) {
         } else if (t) {
             e.ie |= REACTIVE_OPTIMISTIC_DIRTY;
             // No source lane means reversion - clear subscriber's lane so effects go to regular queue
-                        if (e.o) e.o.Je = undefined;
+                        if (e.o) e.o.Oe = undefined;
         }
         enqueueSub(e);
     }
@@ -739,32 +806,36 @@ function insertSubs(e, t = false) {
 function commitPendingNode(e) {
     const t = e;
     if (!t.oe) {
-        if (e.Re !== NOT_PENDING) {
-            e.be = e.Re;
-            e.Re = NOT_PENDING;
+        if (e.Ge !== NOT_PENDING) {
+            e.me = e.Ge;
+            e.Ge = NOT_PENDING;
         }
         if (e.T & CONFIG_HAS_COMPANIONS) GlobalQueue.un(e);
         return;
     }
-    if (e.Re !== NOT_PENDING) {
-        e.be = e.Re;
-        e.Re = NOT_PENDING;
+    if (e.Ge !== NOT_PENDING) {
+        e.me = e.Ge;
+        e.Ge = NOT_PENDING;
         // Set _modified for effects, but not for tracked effects (they handle their own scheduling)
-                if (e.ge && e.ge !== EFFECT_TRACKED) e.tt = true;
+                if (e.Ce && e.Ce !== EFFECT_TRACKED) e.He = true;
         // A quiet re-ask classification preserved through a held landing dies
         // with the value commit — the commit IS the reveal (#3178). Gated on the
         // staged value: status propagation queues pending nodes whose windows
         // are still OPEN (no staged value), and their live classification must
         // survive this sweep.
-                if (e.o) e.o.De = false;
+                if (e.o) e.o.Ue = false;
     }
     // The committed hold is the first observable answer for a loading-window
     // node — the window closes here, not at compute time (#2990). Unconditional
     // store to an always-present computed slot.
-        t.Ne = false;
+        t.Ae = false;
     t.ie &= ~REACTIVE_MANUAL_WRITE;
     if (!(t.S & STATUS_PENDING)) t.S &= ~STATUS_UNINITIALIZED;
-    if (t.o != null && (t.o.Ye !== null || t.o.qe !== null)) GlobalQueue.He(t, false, true);
+    // A flight this commit leaves in the air (unobserved, or observed only by
+    // a boundary) now has PUBLISHED inputs: its committed value is stale
+    // against the frame. read()'s reveal carve-out keys on the mark (#3305).
+     else e.T |= CONFIG_INPUTS_PUBLISHED;
+    if (t.o != null && (t.o.Xe !== null || t.o.Je !== null)) GlobalQueue.We(t, false, true);
     if (e.T & CONFIG_HAS_COMPANIONS) GlobalQueue.un(e);
 }
 
@@ -779,17 +850,6 @@ function setStoreCommitHook(e) {
     storeCommitHook = e;
 }
 
-/** Patch-channel release hook (next/patch.ts): transition-stamped patch
- * emissions are released when THEIR batch commits. Transitions never
- * abort: failed actions still commit (only optimistic overrides revert),
- * and merged-away transitions hand their stash to the survivor
- * (mergeTransitionState) — every stash drains exactly once. Injected like
- * storeCommitHook to stay tree-shakeable. */ let patchCommitHook = null;
-
-function setPatchCommitHook(e) {
-    patchCommitHook = e;
-}
-
 /** Held truth committed this finalize, awaiting its post-revert wake (see
  * finalizePureQueue): the commit IS the reveal, but subscribers must not
  * re-derive until the settling transaction's optimistic overrides have
@@ -798,7 +858,7 @@ function setPatchCommitHook(e) {
  * frame no timeline contains. */ const heldRevealed = [];
 
 function commitPendingNodes() {
-    const e = currentBatch.Lt;
+    const e = currentBatch.$t;
     for (let t = 0; t < e.length; t++) {
         const i = e[t];
         commitPendingNode(i);
@@ -813,7 +873,7 @@ function commitPendingNodes() {
         // that old view and cached it), and commits are otherwise silent
         // (staging already notified), so without a wake they'd hold the old
         // world forever.
-                i.Ae = null;
+                i.ge = null;
         if (i.T & CONFIG_HELD_TRUTH) {
             i.T &= ~CONFIG_HELD_TRUTH;
             heldRevealed.push(i);
@@ -821,34 +881,61 @@ function commitPendingNodes() {
     }
     e.length = 0;
     storeCommitHook?.();
-    patchCommitHook?.(currentBatch);
 }
 
 function finalizePureQueue(e = null, t = false) {
     // For incomplete transitions, skip pending resolution and optimistic reversion
     // For completing transitions or no-transition, resolve pending and revert optimistic
-    const i = !t;
-    if (i) commitPendingNodes();
-    if (!t && globalQueue.Qt.length) checkBoundaryChildren(globalQueue);
-    const n = dirtyQueue.EE >= dirtyQueue.Qe;
-    if (n) runHeap(dirtyQueue, GlobalQueue.Fe);
-    if (i) {
-        if (n) commitPendingNodes();
+    const i = currentBatch;
+    const n = !t;
+    if (n) commitPendingNodes();
+    if (!t && globalQueue.Xt.length) checkBoundaryChildren(globalQueue);
+    // Contested effects (#3322) re-derive from the world this commit just
+    // produced. Ahead of the heap run — not the post-heap gated replay — so
+    // the recompute and the effect phase land in this same pass and the value
+    // the other transaction wrote into the slot is never published.
+    // (No clear: a completed transition is never finalized again.)
+    // A transaction whose settle reverts optimism re-derives them post-revert
+    // instead (below, with the gated replay): between commitPendingNodes and
+    // _resolveOptimistic the truth is committed but the overrides still
+    // display, and a re-derive here would compose the two — the #3164 tear,
+    // one window later. The slot meanwhile holds the frame that is on screen.
+        const r = e?.Et;
+    const s = n && (e ?? i).it.length !== 0;
+    if (r && !s) for (const e of r) if (!(e.ie & REACTIVE_DISPOSED)) enqueueSub(e);
+    const o = dirtyQueue.EE >= dirtyQueue.Ke;
+    if (o) runHeap(dirtyQueue, GlobalQueue.Fe);
+    if (n) {
+        // Boundary checks, commit hooks and recomputes can enter a transaction,
+        // which adopts the batch this finalize was settling: nothing batch-derived
+        // may be committed or reverted here — the entered transaction owns it now
+        // (#3319). A completing transaction's OWN containers are a different
+        // matter: when the ambient batch was separate from it (the #2916 shape),
+        // adoption never touched them and it must still settle them; when the
+        // batch WAS the completing transaction, adoption re-stamped its contents
+        // into the entered one and there is nothing left to settle.
+        if (currentBatch !== i) {
+            if (e === null || e === i) return;
+        } else if (o) commitPendingNodes();
         // The settling batch: the completing transaction's, or the ambient one.
-                const t = e ?? globalQueue.m;
+                const t = e ?? i;
         // Optimistic reversion: a non-empty batch means _optimisticWrite ran,
         // which installed the engine's hooks.
-                if (t.ze.length) GlobalQueue.Tn(t.ze);
+                if (t.it.length) GlobalQueue.fn(t.it);
+        if (r && s) {
+            for (const e of r) if (!(e.ie & REACTIVE_DISPOSED)) enqueueSub(e);
+            schedule();
+        }
         // 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.cn.size) {
-            for (const e of t.cn) {
+                if (t.lt.size) {
+            for (const e of t.lt) {
                 if (e.ie & REACTIVE_DISPOSED) continue;
                 enqueueSub(e);
             }
-            t.cn.clear();
+            t.lt.clear();
             // A completing transition keeps the outer flush loop alive by itself;
             // the ambient batch needs the re-arm or the replay sits in the heap
             // until the next unrelated write.
@@ -862,13 +949,13 @@ function finalizePureQueue(e = null, t = false) {
         // (the earlier sweep above ran while the marks were still live).
                 if (t.A.length) {
             GlobalQueue.G(t.A);
-            if (globalQueue.Qt.length) checkBoundaryChildren(globalQueue);
+            if (globalQueue.Xt.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.En.size) GlobalQueue.qt(t.En, e);
+                if (t.En.size) GlobalQueue.ni(t.En, e);
         // Held-truth reveal wake (#3164), post-revert by construction: this
         // finalize committed confirming truth whose subscribers were masked all
         // hold — some re-derived against the committed view (the staging, or a
@@ -880,19 +967,19 @@ function finalizePureQueue(e = null, t = false) {
         // committed but the settling transaction's overrides still display.
                 if (heldRevealed.length !== 0) {
             while (heldRevealed.length) insertSubs(heldRevealed.pop());
-            if (dirtyQueue.EE >= dirtyQueue.Qe) {
+            if (dirtyQueue.EE >= dirtyQueue.Ke) {
                 runHeap(dirtyQueue, GlobalQueue.Fe);
                 commitPendingNodes();
             }
         }
         sweepTransientStoreNodes();
         // Lanes only enter activeLanes through the engine's getOrCreateLane.
-                if (activeLanes.size) GlobalQueue.In(e);
+                if (activeLanes.size) GlobalQueue.dn(e);
     }
 }
 
 function checkBoundaryChildren(e) {
-    for (const t of e.Qt) {
+    for (const t of e.Xt) {
         t.se?.();
         checkBoundaryChildren(t);
     }
@@ -916,7 +1003,7 @@ function checkBoundaryChildren(e) {
 
 function reassignPendingTransition(e) {
     for (let t = 0; t < e.length; t++) {
-        e[t].Ae = activeTransition;
+        e[t].ge = activeTransition;
     }
 }
 
@@ -930,6 +1017,16 @@ const globalQueue = new GlobalQueue;
 let currentBatch = globalQueue.m;
 
 function flush(e) {
+    // Inside an action body the drain is incoherent (#3333): the action's
+    // writes are held by its transaction until it settles, so a drain can't
+    // reveal them — and the loop below only exits once `activeTransition` is
+    // null, so it would PARK the transaction mid-slice and every write after it
+    // in the body would land as a plain, committed write. The reporter's
+    // "leading flush()" workaround was exactly that leak. Prod: run `fn` if
+    // given (its writes stay in the transaction) and skip the drain.
+    if (actionStepDepth > 0) {
+        return e ? e() : undefined;
+    }
     if (e) {
         syncDepth++;
         try {
@@ -944,7 +1041,7 @@ function flush(e) {
             }
         }
     }
-    if (globalQueue.fn) {
+    if (globalQueue.sn) {
         return;
     }
     if (halted) return;
@@ -953,6 +1050,9 @@ function flush(e) {
         while (scheduled || activeTransition) {
         globalQueue.flush();
     }
+    // Provenance ends with the drain: every ambient window (an action's first
+    // slice, a landing's propagation) runs to this flush.
+        origin = 0;
 }
 
 function runQueue(e, t) {
@@ -962,21 +1062,23 @@ function runQueue(e, t) {
 function reporterBlocksSource(e, t) {
     if (e.ie & (REACTIVE_ZOMBIE | REACTIVE_DISPOSED)) return false;
     if (e.o?.le?.has(t)) return true;
-    for (let i = e.ut; i; i = i.lt) {
-        let e = i.ot;
+    for (let i = e.fe; i; i = i.ae) {
+        let e = i.Se;
         while (e) {
-            if (e === t || e.st === t) return true;
-            e = e.o?.Tt;
+            if (e === t || e.ce === t) return true;
+            e = e.o?.Gt;
         }
     }
     return !!(e.S & STATUS_PENDING && e.o?._ instanceof NotReadyError && e.o?._.source === t);
 }
 
 function transitionComplete(e) {
-    if (e.sn) return true;
-    if (e.ue.length) return false;
+    if (e.ft) return true;
+    if (e.ue.length) {
+        return false;
+    }
     let t = true;
-    for (const [i, n] of e._e) {
+    for (const [i, n] of e.Re) {
         let r = false;
         for (const e of n) {
             if (reporterBlocksSource(e, i)) {
@@ -985,7 +1087,7 @@ function transitionComplete(e) {
             }
             n.delete(e);
         }
-        if (!r) e._e.delete(i); else if (i.S & STATUS_PENDING && i.o?._?.source === i) {
+        if (!r) e.Re.delete(i); else if (i.S & STATUS_PENDING && i.o?._?.source === i) {
             t = false;
             break;
         }
@@ -993,8 +1095,8 @@ 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.dn?.(e)) t = false;
-    t && (e.sn = true);
+        if (t && GlobalQueue.cn?.(e)) t = false;
+    t && (e.ft = true);
     return t;
 }
 
@@ -1006,10 +1108,23 @@ function transitionComplete(e) {
 }
 
 function currentTransition(e) {
-    while (e.sn && typeof e.sn === "object") e = e.sn;
+    while (e.ft && typeof e.ft === "object") e = e.ft;
     return e;
 }
 
+/**
+ * The live transition blocked on `source` — the one whose render reader
+ * observed it pending (INV-3 records the observation in whichever transaction
+ * was active when the reader was notified). The observation is a fact about
+ * the node, so a hold check must not assume it was recorded in the transaction
+ * it happens to hold — lanes merge across transactions (#2912), and a merged
+ * root's transaction knows nothing of the async its members' transactions
+ * observed (#3335). Null when nobody is waiting.
+ */ function waitingTransition(e) {
+    for (const t of transitions) if (t.Re.has(e)) return t;
+    return null;
+}
+
 function runInTransition(e, t) {
     const i = activeTransition;
     try {
@@ -1043,4 +1158,4 @@ function runInTransition(e, t) {
     }
 }
 
-export { GlobalQueue, Queue, activeAffectsMarks, activeLanes, activeTransition, armReaskClear, assignOrMergeLane, bumpNotifyEpoch, clock, createTransition, currentTransition, dirtyQueue, enforceLoadingBoundary, entangleConfirmingTransitions, finalizePureQueue, findLane, flush, globalQueue, haltReactivity, hasActiveOverride, insertSubs, notifyEpoch, patchCommitHook, projectionWriteActive, queuePendingNode, reaskArmed, resetErrorHalt, runAsTransitionBatch, runInTransition, schedule, setPatchCommitHook, setProjectionWriteActive, setStoreCommitHook, shiftAffectsMarks, storeCommitHook, zombieQueue };
+export { GlobalQueue, Queue, actionStepDepth, activeAffectsMarks, activeLanes, activeTransition, armReaskClear, assignOrMergeLane, bumpNotifyEpoch, clock, createTransition, currentTransition, dirtyQueue, enforceLoadingBoundary, entangleConfirmingTransitions, enterActionStep, exitActionStep, finalizePureQueue, findLane, flush, globalQueue, haltReactivity, hasActiveOverride, insertSubs, notifyEpoch, origin, projectionWriteActive, queuePendingNode, reaskArmed, resetErrorHalt, runAsTransitionBatch, runInTransition, schedule, setOrigin, setProjectionWriteActive, setStoreCommitHook, shiftAffectsMarks, storeCommitHook, waitingTransition, zombieQueue };