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

package/dist/prod/core/scheduler.js

@@ -1,16 +1,16 @@
-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 { EFFECT_RENDER, EFFECT_USER, STATUS_PENDING, CONFIG_ADOPTED_UNFLUSHED, NOT_PENDING, REACTIVE_MANUAL_WRITE, STATUS_UNINITIALIZED, REACTIVE_OPTIMISTIC_DIRTY, REACTIVE_IN_HEAP_HEIGHT, REACTIVE_DISPOSED, CONFIG_HELD_TRUTH, CONFIG_HAS_COMPANIONS, EFFECT_TRACKED, CONFIG_INPUTS_PUBLISHED, REACTIVE_ZOMBIE, CONFIG_HAS_LANE, CONFIG_HAS_SNAPSHOT, REACTIVE_RECOMPUTING_DEPS, REACTIVE_MISSED_WAKE, CONFIG_IN_SNAPSHOT_SCOPE, REACTIVE_SNAPSHOT_STALE, CONFIG_SLOT_NODE, CONFIG_HELD_CHILDREN, REACTIVE_REASK, CONFIG_AUTHORITATIVE_READ } from "./constants.js";
 
-import { currentOptimisticLane, slotUnobservedHook } from "./core.js";
+import { resyncUnflushedCompanions, currentOptimisticLane, slotUnobservedHook, markUnflushedStaged, hasActiveOverride } from "./core.js";
 
 import { DEV } from "./dev.js";
 
 import { NotReadyError } from "./error.js";
 
-import { sweepDormant } from "./graph.js";
+import { sweepDormant, trimStaleDeps } from "./graph.js";
 
 import { runHeap, deleteFromHeap, enqueueSub } from "./heap.js";
 
-import { activeLanes, assignOrMergeLane, findLane, hasActiveOverride } from "./lanes.js";
+import { activeLanes, assignOrMergeLane, findLane } from "./lanes.js";
 
 export { getOrCreateLane, mergeLanes, resolveLane } from "./lanes.js";
 
@@ -21,23 +21,31 @@ const transitions = new Set;
 const dirtyQueue = {
     eE: new Array(2e3).fill(undefined),
     tE: false,
-    Ke: 0,
+    et: 0,
     EE: 0
 };
 
 const zombieQueue = {
     eE: new Array(2e3).fill(undefined),
     tE: false,
-    Ke: 0,
+    et: 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.ie & REACTIVE_IN_HEAP_HEIGHT) e.ie &= -12; else {
+ * height-adjust entries so their height work still happens. A zombie dirtied
+ * through the lane channel (OPTIMISTIC_DIRTY — an override or a `latest()`
+ * companion) runs instead (#3444): a zombie renders mainline until the commit
+ * disposes it, and the lane's values ARE the mainline frame — the still-visible
+ * branch a held `Show` is removing showed the old `latest(count)` beside the
+ * new one outside. Its pass runs under the lane and its run lands on the
+ * lane's effect queue, so a held lane defers it exactly as it defers every
+ * other reader's. */ function cancelZombieRecompute(e) {
+    if (e.ue & REACTIVE_OPTIMISTIC_DIRTY) return GlobalQueue.We(e);
+    if (e.ue & REACTIVE_IN_HEAP_HEIGHT) e.ue &= -12; else {
         deleteFromHeap(e, zombieQueue);
-        e.ie &= -4;
+        e.ue &= -4;
     }
 }
 
@@ -66,15 +74,23 @@ 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,
-// releasing the slot in the parent store's node map.
+// Store property nodes whose last subscriber left while they carried state
+// the backing cannot reconstruct — an optimistic override (overrides live on
+// nodes, over a clone the setter discards) or a staged write. Releasing the
+// slot then would drop the override: an optimistic store key read `0` the
+// moment its only reader gated away while the action was live (S7). Swept
+// after each flush — a node still without subs whose override and staging
+// have resolved is released through the slot hook; one that regained a
+// subscriber leaves the set.
 const transientStoreNodes = new Set;
 
+/** Slot hook's deferral: release this node when its carried state resolves. */ function deferSlotRelease(e) {
+    transientStoreNodes.add(e);
+}
+
 function canUseSimpleSyncFlush(e) {
     const t = e.m;
-    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;
+    return transitions.size === 0 && activeLanes.size === 0 && e.hn.length === 0 && t.rt.length === 0 && t.A.length === 0 && t.dn.size === 0 && transientStoreNodes.size === 0;
 }
 
 function sweepTransientStoreNodes() {
@@ -84,14 +100,14 @@ function sweepTransientStoreNodes() {
             transientStoreNodes.delete(e);
             continue;
         }
-        if (e.Ge !== NOT_PENDING) continue;
-        if (e.o?.be !== undefined && e.o?.be !== NOT_PENDING) continue;
+        if (e.ve !== NOT_PENDING) continue;
+        if (e.o?.Ce !== undefined && e.o?.Ce !== 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);
-        if (e.T & CONFIG_SLOT_NODE) slotUnobservedHook(e); else e.o?.Ct?.();
+        if (e.T & CONFIG_SLOT_NODE) slotUnobservedHook(e); else e.o?.Pt?.();
     }
 }
 
@@ -118,33 +134,34 @@ function setProjectionWriteActive(e) {
  * land there directly — no per-field aliasing.
  */ function createBatch() {
     return {
-        _e: clock,
-        $t: [],
-        Re: new Map,
-        it: [],
+        Pe: clock,
+        Ot: [],
+        oe: new Map,
+        rt: [],
         A: [],
-        En: new Set,
-        ue: [],
-        ei: {
-            ti: [ [], [] ],
-            Xt: []
+        dn: new Set,
+        pe: [],
+        Sn: {
+            mn: [ [], [] ],
+            hn: []
         },
-        ft: false,
-        lt: new Set,
-        Et: null
+        Tt: false,
+        ct: new Set,
+        St: null
     };
 }
 
 function mergeTransitionState(e, t) {
-    t.ft = e;
-    e.ue.push(...t.ue);
-    for (const i of activeLanes) if (i.ge === t) i.ge = e;
-    if (t.it.length) {
+    t.Tt = e;
+    e.pe.push(...t.pe);
+    e.he ||= t.he;
+    for (const n of activeLanes) if (n.Ge === t) n.Ge = e;
+    if (t.rt.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.it.push(...t.it);
-        t.it.length = 0;
+        e.rt.push(...t.rt);
+        t.rt.length = 0;
     }
     if (t.A.length) {
         // Move (don't copy): the global queue's batch may still be the outgoing
@@ -153,14 +170,14 @@ function mergeTransitionState(e, t) {
         e.A.push(...t.A);
         t.A.length = 0;
     }
-    for (const i of t.En) e.En.add(i);
-    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 n of t.dn) e.dn.add(n);
+    for (const [n, i] of t.oe) {
+        let t = e.oe.get(n);
+        if (!t) e.oe.set(n, t = new Set);
+        for (const e of i) t.add(e);
     }
-    for (const i of t.lt) e.lt.add(i);
-    if (t.Et) (e.Et ??= []).push(...t.Et);
+    for (const n of t.ct) e.ct.add(n);
+    if (t.St) (e.St ??= []).push(...t.St);
 }
 
 /**
@@ -181,7 +198,7 @@ function mergeTransitionState(e, t) {
  * `until()` retain this.
  */ function entangleConfirmingTransitions(e, t) {
     t = currentTransition(t);
-    if (t.ft === true) return;
+    if (t.Tt === 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
@@ -193,22 +210,22 @@ function mergeTransitionState(e, t) {
     // and stashes are its own future (a live stream's flight must not chain
     // the awaiting transaction to landings that haven't happened; a merged
     // reporter deadlocked exactly that way).
-        let i = false;
-    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;
+        let n = false;
+    for (let i = e.Se; i !== null; i = i.de) {
+        const s = i.Ee;
+        if (s.ve !== NOT_PENDING) {
+            const e = s.Ge;
+            const i = 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
             // reveal already correct) and dead carriers. Ambient-batch staging
             // (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.$t : n !== t && n.ft !== true ? n.$t : null;
-            if (s !== null) i = stealEntangledCargo(s, t) || i;
+                        const r = i === null ? currentBatch.Ot : i !== t && i.Tt !== true ? i.Ot : null;
+            if (r !== null) n = stealEntangledCargo(r, t) || n;
         }
-        if (n === e.et) break;
+        if (i === e.ot) break;
     }
     // The steal never activates the awaiting transaction: the predicate can
     // flip inside another transaction's finalize heap, and adopting the queue
@@ -237,20 +254,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.$t || e.length === 0) return false;
-    for (let i = 0; i < e.length; i++) {
-        const n = e[i];
-        n.ge = t;
-        t.$t.push(n);
+    if (e === t.Ot || e.length === 0) return false;
+    for (let n = 0; n < e.length; n++) {
+        const i = e[n];
+        i.Ge = t;
+        t.Ot.push(i);
         // 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.Te) {
-                const t = e.Ie;
-                if (t.Ce && !(t.T & CONFIG_AUTHORITATIVE_READ)) enqueueSub(t);
+                if (!hasActiveOverride(i)) {
+            i.T |= CONFIG_HELD_TRUTH;
+            for (let e = i.u; e !== null; e = e.Ne) {
+                const t = e._e;
+                if (t.Le && !(t.T & CONFIG_AUTHORITATIVE_READ)) enqueueSub(t);
             }
         }
     }
@@ -266,14 +283,51 @@ function schedule() {
     }
     if (scheduled) return;
     scheduled = true;
-    if (!syncDepth && !globalQueue.sn && !projectionWriteActive) queueMicrotask(flush);
+    if (!syncDepth && !globalQueue.Kt && !projectionWriteActive) queueMicrotask(flush);
+}
+
+/**
+ * Parked transactions whose reporter set changed without a write. A
+ * transaction completes when nothing live reports a flight it waits on, but
+ * the flush only judges the ACTIVE transaction: a parked one is re-entered by
+ * a stamped node's landing or an action's resume. A reporter that stops
+ * counting for another reason — its loading boundary flipped to the fallback
+ * (#3375), or it was disposed by ambient work (#3372) — is neither: the
+ * pruning in `reporterBlocksSource` would drop it at the next check, but no
+ * check comes, and the writes held with it stay staged. Such sites record the
+ * transaction here (deduped: one idle pass per transaction, however many
+ * reporters changed); the flush re-enters it on an otherwise idle pass, so
+ * the re-evaluation adopts no unrelated ambient work.
+ */ const wokenTransitions = [];
+
+/** Wake every parked transaction — for a site that knows a reporter stopped
+ * counting but not whose (a boundary reset). */ function wakeParked() {
+    for (const e of transitions) wokenTransitions.includes(e) || wokenTransitions.push(e);
+    schedule();
 }
 
+/** Transactions a mainline tick has PROPOSED against (A34, #3494): a write to a
+ * node one of them holds — the same value or another — is a second proposal
+ * on a contested node, and the tick reveals with the hold ("both are
+ * suggesting a value; if one finished before the other that would be odd").
+ * Entered at the next flush's start, where the ambient batch is adopted;
+ * never from the write itself, which left `activeTransition` set across the
+ * caller's block and made creation after the write the transaction's (A29). */ const batchJoins = [];
+
 /**
  * Permanently halts the reactive system. Called when a user error escapes
  * every boundary — app state is undefined at that point, so scheduling stops
  * entirely rather than limping along with a half-applied update.
- */ function haltReactivity(e) {
+ */
+/**
+ * The key a root owner carries its client error hook under (`render`'s
+ * `onError`) — registered, so a runtime writes it with no import of the hook
+ * module (core/error-hooks.ts) and no property mangling in the way. Defined
+ * HERE, not there: a runtime that only writes the key must not retain the
+ * hook machinery (pay-for-use).
+ */ const ROOT_ERROR_HOOK = Symbol.for("solid-js/root-error-hook");
+
+function haltReactivity(e) {
     if (halted) return;
     halted = true;
     let t = "[REACTIVITY_HALTED]";
@@ -286,9 +340,9 @@ function schedule() {
     // 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);
+        const n = e !== undefined && globalThis.reportError;
+    n || e === undefined ? console.error(t) : console.error(t, e);
+    n && n(e);
 }
 
 // Logs on the first write after a halt so a frozen interaction is traceable.
@@ -308,30 +362,30 @@ function notifyHalted() {
 let queueRunToken = 0;
 
 class Queue {
-    qe=null;
-    ti=[ [], [] ];
-    Xt=[];
-    ii=0;
+    _parent=null;
+    mn=[ [], [] ];
+    hn=[];
+    An=0;
     created=clock;
     addChild(e) {
-        this.Xt.push(e);
-        e.qe = this;
+        this.hn.push(e);
+        e._parent = this;
     }
     removeChild(e) {
-        const t = this.Xt.indexOf(e);
+        const t = this.hn.indexOf(e);
         if (t >= 0) {
-            this.Xt.splice(t, 1);
-            e.qe = null;
+            this.hn.splice(t, 1);
+            e._parent = null;
         }
     }
-    notify(e, t, i, n) {
-        if (this.qe) return this.qe.notify(e, t, i, n);
+    notify(e, t, n, i) {
+        if (this._parent) return this._parent.notify(e, t, n, i);
         return false;
     }
     run(e) {
-        if (this.ti[e - 1].length) {
-            const t = this.ti[e - 1];
-            this.ti[e - 1] = [];
+        if (this.mn[e - 1].length) {
+            const t = this.mn[e - 1];
+            this.mn[e - 1] = [];
             runQueue(t, e);
         }
         // Effects run here can dispose owners, and disposal removes queues from
@@ -341,70 +395,70 @@ 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.Xt;
-        const i = ++queueRunToken;
-        for (let n = 0; n < t.length; ) {
-            const r = t[n];
-            if (r.ii !== i) {
-                r.ii = i;
-                r.run?.(e);
-                if (t[n] !== r) {
-                    n = 0;
+                const t = this.hn;
+        const n = ++queueRunToken;
+        for (let i = 0; i < t.length; ) {
+            const s = t[i];
+            if (s.An !== n) {
+                s.An = n;
+                s.run?.(e);
+                if (t[i] !== s) {
+                    i = 0;
                     continue;
                 }
             }
-            n++;
+            i++;
         }
     }
     enqueue(e, t) {
         if (e) {
             // Route to lane's effect queue if we're in an optimistic recomputation
             if (currentOptimisticLane) {
-                const i = findLane(currentOptimisticLane);
-                i.tn[e - 1].push(t);
+                const n = findLane(currentOptimisticLane);
+                n.fn[e - 1].push(t);
             } else {
-                this.ti[e - 1].push(t);
+                this.mn[e - 1].push(t);
             }
         }
         schedule();
     }
     stashQueues(e) {
-        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 = {
-                    ti: [ [], [] ],
-                    Xt: []
+        e.mn[0].push(...this.mn[0]);
+        e.mn[1].push(...this.mn[1]);
+        this.mn = [ [], [] ];
+        for (let t = 0; t < this.hn.length; t++) {
+            let n = this.hn[t];
+            let i = e.hn[t];
+            if (!i) {
+                i = {
+                    mn: [ [], [] ],
+                    hn: []
                 };
-                e.Xt[t] = n;
+                e.hn[t] = i;
             }
-            i.stashQueues(n);
+            n.stashQueues(i);
         }
     }
     restoreQueues(e) {
-        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);
+        this.mn[0].push(...e.mn[0]);
+        this.mn[1].push(...e.mn[1]);
+        for (let t = 0; t < e.hn.length; t++) {
+            const n = e.hn[t];
+            let i = this.hn[t];
+            if (i) i.restoreQueues(n);
         }
     }
 }
 
 class GlobalQueue extends Queue {
-    sn=false;
+    Kt=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 We;
-    static ct;
-    static ni=null;
+    static Be;
+    static Et;
+    static Cn=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).
@@ -418,27 +472,27 @@ class GlobalQueue extends Queue {
     static N=null;
     // External-source bridge (wired by enableExternalSource(); null while no
     // config is active — including after _resetExternalSourceConfig()).
-    static kt=null;
-    static Lt=null;
+    static wt=null;
+    static Yt=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 Ne=null;
-    static ke=null;
-    static un=null;
-    static wt=null;
-    static Wt=null;
-    static jt=null;
-    static st=null;
+    static me=null;
+    static Oe=null;
+    static Me=null;
+    static En=null;
+    static zt=null;
+    static Jt=null;
+    static nn=null;
+    static Nt=null;
     static k=null;
-    static ri=null;
+    static pn=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 si=null;
+    static vn=null;
     // Optimistic-engine hooks (wired by core/optimistic.ts via
     // installOptimisticEngine(), called from verdict.ts / createOptimistic /
     // createOptimisticStore — every module that can create optimistic state).
@@ -446,31 +500,31 @@ 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 Bt=null;
-    static fn=null;
-    static cn=null;
-    static dn=null;
-    static In=null;
+    static ln=null;
+    static On=null;
+    static Nn=null;
+    static Rn=null;
+    static _n=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 Zt=null;
-    static qt=null;
+    static In=null;
+    static tn=null;
+    static $t=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;
+    static Xt=null;
+    static Bt=null;
+    static st=null;
+    static _t=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;
+    static Zt=null;
+    static ft=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
@@ -478,54 +532,92 @@ class GlobalQueue extends Queue {
      * 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;
+    static we=null;
+    /** The flush's pre-verdict step (#3427): once the transaction's action
+     * bodies have all ended and nothing authoritative is left in flight, the
+     * engine supersedes every override still in force with the truth it
+     * reverts to, so the graph re-derives from it now, as the transaction's
+     * held work, instead of after the flights the overrides fed have landed.
+     * True when it superseded something: the caller re-runs the heap ahead of
+     * the verdict. The engine owns every gate (acted, actions drained, has
+     * overrides, no store edits, no authoritative flight); null without it. */
+    static Tn=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;
+    /** A tracked read of an active override: the lane outside-view rule
+     * (#3460) and the A18 supersession selection (#3331) — see optimistic.ts. */
+    static en=null;
+    /** A lane pass's publish for a memo (#3479, lanes stage): the speculative
+     * result becomes a DERIVED override, `_value` stays committed — see
+     * optimistic.ts laneOverride. Set with the engine, which a lane implies. */
+    static Ve=null;
+    /** Verdict-layer recompute in progress (companion creation, latest()/
+     * isPending() pulls): never born held — see core.ts enterStagedRead. */
+    static jt=false;
     /** 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;
+    static un=null;
+    static Dn=null;
     flush() {
-        if (this.sn) return;
+        if (this.Kt) 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.Ke && this.ti[0].length === 0 && this.ti[1].length === 0 && this.Xt.length === 0 && canUseSimpleSyncFlush(this)) {
-            this.sn = true;
+                if (activeTransition === null && dirtyQueue.EE < dirtyQueue.et && this.mn[0].length === 0 && this.mn[1].length === 0 && this.hn.length === 0 && !wokenTransitions.length && !batchJoins.length && // a join must drain in its own tick (#3519 review)
+        canUseSimpleSyncFlush(this)) {
+            this.Kt = true;
             try {
+                // A28: companions of nodes written since the last flush mirror the
+                // flushed world — re-synced inside the running window (the write is
+                // "flushed" from here on).
+                resyncUnflushedCompanions();
                 // Sweep first: unobserved() pulls swept nodes out of the dirty heap,
                 // so a dormant memo dirtied in the same tick is reclaimed instead of
                 // recomputed (matching the old inline dispose-on-read counts).
-                sweepDormant();
+                                sweepDormant();
                 commitPendingNodes();
             } finally {
-                this.sn = false;
+                this.Kt = false;
             }
             clock++;
-            scheduled = dirtyQueue.EE >= dirtyQueue.Ke || this.ti[0].length !== 0 || this.ti[1].length !== 0 || this.m.$t.length !== 0;
+            scheduled = dirtyQueue.EE >= dirtyQueue.et || this.mn[0].length !== 0 || this.mn[1].length !== 0 || this.m.Ot.length !== 0;
             return;
         }
-        this.sn = true;
-        try {
+        this.Kt = true;
+        resyncUnflushedCompanions();
+ // A28, see above
+                try {
+            // The tick proposed against a hold (#3494): adopt its batch into it.
+            // Inside the try: the adoption runs user comparators (the no-proposal
+            // drop), and a throw there must not leave `_running` set.
+            while (batchJoins.length) this.initTransition(batchJoins.pop());
             if (false) ;
             // Before runHeap for the same reason as the fast drain above; late
             // subscribers (an effect reading a swept memo this flush) revive it,
             // which is the pay-for-use contract.
                         sweepDormant();
-            runHeap(dirtyQueue, GlobalQueue.Fe);
+            runHeap(dirtyQueue, GlobalQueue.We);
             if (activeTransition) {
+                // The action bodies are over: the overrides they leave in force
+                // revert at this settle, and the correction is this transaction's
+                // held work — re-derived here, under it, ahead of the verdict — not a
+                // waterfall after the flights the overrides fed (#3427). After the
+                // heap, not before: a synchronous body's own writes (a refresh that
+                // puts an override node's source in flight) are judged applied.
+                if (GlobalQueue.Tn?.(activeTransition)) runHeap(dirtyQueue, GlobalQueue.We);
                 const e = transitionComplete(activeTransition);
                 if (!e) {
                     const e = activeTransition;
+                    // Parked: the unchanged passes' inputs are held; their tails stay (A30).
+                                        heldTrims.length = 0;
                     // When the parking batch IS the transition, all of its writes commit
                     // only with it — every zombie recompute they queued would run against
                     // a world the zombie never displays (zombies render mainline until
@@ -534,7 +626,7 @@ 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.Fe);
+                                        runHeap(zombieQueue, this.m === e ? cancelZombieRecompute : GlobalQueue.We);
                     // 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
@@ -544,48 +636,48 @@ 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.In(EFFECT_RENDER);
-                        GlobalQueue.In(EFFECT_USER);
+                        GlobalQueue._n(EFFECT_RENDER);
+                        GlobalQueue._n(EFFECT_USER);
                     }
-                    this.stashQueues(e.ei);
+                    this.stashQueues(e.Sn);
                     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.Ke || this.m.$t.length > 0;
-                    reassignPendingTransition(e.$t);
+                                        scheduled = dirtyQueue.EE >= dirtyQueue.et || this.m.Ot.length > 0;
+                    reassignPendingTransition(e.Ot);
                     activeTransition = null;
                     finalizePureQueue(null, true);
                     return;
                 }
                 const t = activeTransition;
-                const i = this.m;
-                i !== t && i.$t.push(...t.$t);
-                this.restoreQueues(t.ei);
+                const n = this.m;
+                n !== t && n.Ot.push(...t.Ot);
+                this.restoreQueues(t.Sn);
                 transitions.delete(t);
                 activeTransition = null;
-                reassignPendingTransition(i.$t);
+                reassignPendingTransition(n.Ot);
                 finalizePureQueue(t);
-                if (i === t) {
+                if (n === 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.$t = i.$t;
-                    e.it = i.it;
-                    e.A = i.A;
-                    e.En = i.En;
+                    e.Ot = n.Ot;
+                    e.rt = n.rt;
+                    e.A = n.A;
+                    e.dn = n.dn;
                     currentBatch = this.m = e;
                 }
             } else {
                 if (canUseSimpleSyncFlush(this)) {
                     commitPendingNodes();
-                    if (dirtyQueue.EE >= dirtyQueue.Ke) {
-                        runHeap(dirtyQueue, GlobalQueue.Fe);
+                    if (dirtyQueue.EE >= dirtyQueue.et) {
+                        runHeap(dirtyQueue, GlobalQueue.We);
                         commitPendingNodes();
                     }
                 } else {
-                    if (transitions.size) runHeap(zombieQueue, GlobalQueue.Fe);
+                    if (transitions.size) runHeap(zombieQueue, GlobalQueue.We);
                     finalizePureQueue();
                 }
             }
@@ -596,26 +688,36 @@ class GlobalQueue extends Queue {
             // 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;
+                        scheduled = dirtyQueue.EE >= dirtyQueue.et || activeTransition !== null;
             // Run lane effects first (for ready lanes), then regular effects
-                        activeLanes.size && GlobalQueue.In(EFFECT_RENDER);
+                        activeLanes.size && GlobalQueue._n(EFFECT_RENDER);
             this.run(EFFECT_RENDER);
-            activeLanes.size && GlobalQueue.In(EFFECT_USER);
+            activeLanes.size && GlobalQueue._n(EFFECT_USER);
             this.run(EFFECT_USER);
             if (false) ;
             if (false && !scheduled && !activeTransition && transitions.size === 0 && activeLanes.size === 0) ;
             if (false) ;
         } finally {
-            this.sn = false;
+            // Re-enter a woken transaction (see wokenTransitions) only from an
+            // idle pass: entering adopts the ambient batch, and staged or dirty
+            // ambient work would be held behind flights it never read. `scheduled`
+            // is that test here — after the park exit as well as the normal one:
+            // it was recomputed from the heap this pass, every write since re-armed
+            // it, and optimistic ambient nodes reverted with the finalize — so a
+            // wake in a pass with work simply falls to the next. Entering re-arms
+            // it itself; a dead (completed) wake is a bare return in
+            // initTransition, and the loop moves on to the next.
+            while (!scheduled && !activeTransition && wokenTransitions.length) this.initTransition(wokenTransitions.pop());
+            this.Kt = false;
         }
     }
-    notify(e, t, i, n) {
+    notify(e, t, n, i) {
         // Only track async if the boundary is propagating STATUS_PENDING (not caught by boundary)
         if (t & STATUS_PENDING) {
-            if (i & STATUS_PENDING) {
+            if (n & STATUS_PENDING) {
                 // 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?._;
+                const t = i ?? 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
@@ -627,16 +729,16 @@ class GlobalQueue extends Queue {
                     // 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 && !e.Ge && currentBatch.Ot.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) {
+                        const n = t.source;
+                        let i = activeTransition.oe.get(n);
+                        if (!i) activeTransition.oe.set(n, i = new Set);
+                        const s = i.size;
+                        i.add(e);
+                        if (i.size !== s) {
                             schedule();
-                            GlobalQueue.si?.(activeTransition);
+                            GlobalQueue.vn?.(activeTransition);
                         }
                     }
                 }
@@ -655,9 +757,9 @@ 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.ft === true || e === activeTransition) return;
+                        if (e.Tt === true || e === activeTransition) return;
         }
-        if (!e && activeTransition && activeTransition._e === clock) return;
+        if (!e && activeTransition && activeTransition.Pe === clock) return;
         if (!activeTransition) {
             activeTransition = e ?? createBatch();
         } else if (e) {
@@ -667,12 +769,12 @@ class GlobalQueue extends Queue {
             // 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);
+                        this.restoreQueues(t.Sn);
             transitions.delete(t);
             activeTransition = e;
         }
         transitions.add(activeTransition);
-        activeTransition._e = clock;
+        activeTransition.Pe = clock;
         const t = this.m;
         if (t !== activeTransition) {
             // Adopt the ambient batch into the transaction, then make the
@@ -682,28 +784,57 @@ 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.$t.length; e++) {
-                const i = t.$t[e];
-                i.ge = activeTransition;
-                activeTransition.$t.push(i);
+            // Adopted outside a flush: the staging is still unflushed — the stamp
+            // must not make it read as held-and-carried (CONFIG_ADOPTED_UNFLUSHED;
+            // the carrying flush clears it in reassignPendingTransition).
+            const e = this.Kt ? 0 : CONFIG_ADOPTED_UNFLUSHED;
+            for (let n = 0; n < t.Ot.length; n++) {
+                const i = t.Ot[n];
+                // A tick that nets to the committed value proposed nothing (A34, #3494):
+                // `setShow(false); setShow(true)` beside a write that opens a hold
+                // left `show` staged at its own value, stamped, pending to the
+                // verdict, and its next mainline write held by a flight it never
+                // derived from. Unstage it here — its subscribers were walked at the
+                // write and re-derive the same value. Writes only: a signal's staging
+                // is always one, a computed's only under REACTIVE_MANUAL_WRITE
+                // (`createSignal(fn)`'s setter, #3519 review) — otherwise it is its
+                // pass's result, which may equal an uninitialized `undefined` (a
+                // born-held first pass). `_equals: false` opts out. The unstaging is
+                // the commit's own path (commitPendingNode with nothing staged): the
+                // manual-write flag, companions and the rest are cleaned up as a
+                // commit would, and the node is stamped nowhere. Unstamped
+                // only: a node already a transaction's — arriving here as a parked
+                // batch folds into a merge — carries a FLUSHED proposal a later
+                // rewrite brought back to the committed value; it is held, not
+                // proposal-free. Dropped, it kept the dead stamp, and the next write
+                // to it queued under the merged transaction a value the commit then
+                // skipped as another's (fuzzer latest-2 #1470, S3).
+                                if (i.Ge === null && i.ve !== NOT_PENDING && (!i.ce || i.ue & REACTIVE_MANUAL_WRITE && !(i.S & STATUS_UNINITIALIZED)) && i.Fe && i.Fe(i.Qe, i.ve)) {
+                    i.ve = NOT_PENDING;
+                    commitPendingNode(i);
+                    continue;
+                }
+                i.Ge = activeTransition;
+                i.T |= e;
+                activeTransition.Ot.push(i);
             }
-            for (let e = 0; e < t.it.length; e++) {
-                const i = t.it[e];
-                i.ge = activeTransition;
-                activeTransition.it.push(i);
+            for (let e = 0; e < t.rt.length; e++) {
+                const n = t.rt[e];
+                n.Ge = activeTransition;
+                activeTransition.rt.push(n);
             }
             if (t.A.length) activeTransition.A.push(...t.A);
-            for (const e of t.En) activeTransition.En.add(e);
+            for (const e of t.dn) activeTransition.dn.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.lt.size) {
-                for (const e of t.lt) activeTransition.lt.add(e);
-                t.lt.clear();
+                        if (t.ct.size) {
+                for (const e of t.ct) activeTransition.ct.add(e);
+                t.ct.clear();
             }
             currentBatch = this.m = activeTransition;
         }
         for (const e of activeLanes) {
-            if (!e.ge) e.ge = 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
@@ -718,7 +849,9 @@ class GlobalQueue extends Queue {
 }
 
 function queuePendingNode(e) {
-    currentBatch.$t.push(e);
+    currentBatch.Ot.push(e);
+    if (!globalQueue.Kt) markUnflushedStaged();
+ // A28
 }
 
 // Sticky: flips true on the first refresh() ever (the only setter of
@@ -762,22 +895,22 @@ function setOrigin(e) {
 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.At = notifyEpoch;
+    e.ht = 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
     // 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?.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.Te) {
-        const e = i.Ie;
+        const n = e.T;
+    const i = (n & CONFIG_HAS_LANE ? e.o?.Ue : undefined) || currentOptimisticLane;
+    const s = (n & CONFIG_HAS_SNAPSHOT) !== 0 && e.o?.nt !== undefined;
+    const r = reaskArmed;
+    for (let n = e.u; n !== null; n = n.Ne) {
+        const e = n._e;
         // 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;
+                if (r) e.ue &= ~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
@@ -786,18 +919,18 @@ 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.yt === e.tt && i !== e.et) e.ie |= REACTIVE_MISSED_WAKE;
-        if (r && e.T & CONFIG_IN_SNAPSHOT_SCOPE) {
-            e.ie |= REACTIVE_SNAPSHOT_STALE;
+                if (e.ue & REACTIVE_RECOMPUTING_DEPS && n.qe === e.Ze && n !== e.ot) e.ue |= REACTIVE_MISSED_WAKE;
+        if (s && e.T & CONFIG_IN_SNAPSHOT_SCOPE) {
+            e.ue |= REACTIVE_SNAPSHOT_STALE;
             continue;
         }
-        if (t && n) {
-            e.ie |= REACTIVE_OPTIMISTIC_DIRTY;
-            assignOrMergeLane(e, n);
+        if (t && i) {
+            e.ue |= REACTIVE_OPTIMISTIC_DIRTY;
+            assignOrMergeLane(e, i);
         } else if (t) {
-            e.ie |= REACTIVE_OPTIMISTIC_DIRTY;
+            e.ue |= REACTIVE_OPTIMISTIC_DIRTY;
             // No source lane means reversion - clear subscriber's lane so effects go to regular queue
-                        if (e.o) e.o.Oe = undefined;
+                        if (e.o) e.o.Ue = undefined;
         }
         enqueueSub(e);
     }
@@ -805,38 +938,48 @@ function insertSubs(e, t = false) {
 
 function commitPendingNode(e) {
     const t = e;
-    if (!t.oe) {
-        if (e.Ge !== NOT_PENDING) {
-            e.me = e.Ge;
-            e.Ge = NOT_PENDING;
+    if (!t.ce) {
+        if (e.ve !== NOT_PENDING) {
+            e.Qe = e.ve;
+            e.ve = NOT_PENDING;
         }
-        if (e.T & CONFIG_HAS_COMPANIONS) GlobalQueue.un(e);
+        if (e.T & CONFIG_HAS_COMPANIONS) GlobalQueue.En(e);
         return;
     }
-    if (e.Ge !== NOT_PENDING) {
-        e.me = e.Ge;
-        e.Ge = NOT_PENDING;
+    if (e.ve !== NOT_PENDING) {
+        e.Qe = e.ve;
+        e.ve = NOT_PENDING;
+        // A node born held (recompute) initializes at this commit.
+                t.S &= ~STATUS_UNINITIALIZED;
         // Set _modified for effects, but not for tracked effects (they handle their own scheduling)
-                if (e.Ce && e.Ce !== EFFECT_TRACKED) e.He = true;
+                if (e.Le && e.Le !== EFFECT_TRACKED) e.Ye = 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.Ue = false;
+                if (e.o) e.o.be = 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.Ae = false;
-    t.ie &= ~REACTIVE_MANUAL_WRITE;
+        t.ge = false;
+    t.ue &= ~REACTIVE_MANUAL_WRITE;
+    // The children this commit publishes are the frame's now (#3404) — and so
+    // are the dependencies of the pass that produced the value: the previous
+    // frame's tail goes (A30, #3410; `recompute` left it for a staged pass). Only
+    // after a clean pass: `_error` is cleared by a clean pass or by the node's
+    // own landing (whose pass was clean), so a set `_error` means the last pass
+    // threw, kept its full list, and `_depsTail` marks where it stopped.
+        if (t.o?._ == null) trimStaleDeps(t);
+    t.T &= ~CONFIG_HELD_CHILDREN;
     if (!(t.S & STATUS_PENDING)) t.S &= ~STATUS_UNINITIALIZED;
     // 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);
+    if (t.o != null && (t.o.lt !== null || t.o.it !== null)) GlobalQueue.Be(t, false, true);
+    if (e.T & CONFIG_HAS_COMPANIONS) GlobalQueue.En(e);
 }
 
 // Store commit hook (INTERNALS-STORE-STATE.md §3): installed by the store
@@ -857,11 +1000,21 @@ function setStoreCommitHook(e) {
  * confirming truth is committed and the override still displays, a torn
  * frame no timeline contains. */ const heldRevealed = [];
 
+/** Unchanged passes with a stale dependency tail, waiting on this flush's
+ * verdict (A30, #3469). A pass that changed nothing replaced nothing either —
+ * and cannot know at its own tail whether the flush that ran it will park:
+ * parked, its inputs are held and the committed frame still derives from the
+ * tail (`b() ? b() : a()` computed `1` from the held `b`, equal to the `1` it
+ * had from `a` — with `a` trimmed, the mainline `a = 2` never reached it).
+ * Trimmed when the flush commits; dropped with a park, the tail stays linked
+ * until a committing pass trims it (one spurious recompute at most). */ const heldTrims = [];
+
 function commitPendingNodes() {
-    const e = currentBatch.$t;
+    while (heldTrims.length) trimStaleDeps(heldTrims.pop());
+    const e = currentBatch.Ot;
     for (let t = 0; t < e.length; t++) {
-        const i = e[t];
-        commitPendingNode(i);
+        const n = e[t];
+        commitPendingNode(n);
         // The stamp dies with the commit (#3143) — symmetric with
         // resolveOptimisticNodes clearing optimistic stamps. A stamp outliving
         // its transaction let any later write (even a value-equal no-op, which
@@ -873,10 +1026,10 @@ 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.ge = null;
-        if (i.T & CONFIG_HELD_TRUTH) {
-            i.T &= ~CONFIG_HELD_TRUTH;
-            heldRevealed.push(i);
+                n.Ge = null;
+        if (n.T & CONFIG_HELD_TRUTH) {
+            n.T &= ~CONFIG_HELD_TRUTH;
+            heldRevealed.push(n);
         }
     }
     e.length = 0;
@@ -886,10 +1039,10 @@ function commitPendingNodes() {
 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 = currentBatch;
-    const n = !t;
-    if (n) commitPendingNodes();
-    if (!t && globalQueue.Xt.length) checkBoundaryChildren(globalQueue);
+    const n = currentBatch;
+    const i = !t;
+    if (i) commitPendingNodes();
+    if (!t && globalQueue.hn.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
@@ -900,12 +1053,12 @@ function finalizePureQueue(e = null, t = false) {
     // _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) {
+        const s = e?.St;
+    const r = i && (e ?? n).rt.length !== 0;
+    if (s && !r) for (const e of s) if (!(e.ue & REACTIVE_DISPOSED)) enqueueSub(e);
+    const o = dirtyQueue.EE >= dirtyQueue.et;
+    if (o) runHeap(dirtyQueue, GlobalQueue.We);
+    if (i) {
         // 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
@@ -914,28 +1067,28 @@ function finalizePureQueue(e = null, t = false) {
         // 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;
+        if (currentBatch !== n) {
+            if (e === null || e === n) return;
         } else if (o) commitPendingNodes();
         // The settling batch: the completing transaction's, or the ambient one.
-                const t = e ?? i;
+                const t = e ?? n;
         // Optimistic reversion: a non-empty batch means _optimisticWrite ran,
         // which installed the engine's hooks.
-                if (t.it.length) GlobalQueue.fn(t.it);
-        if (r && s) {
-            for (const e of r) if (!(e.ie & REACTIVE_DISPOSED)) enqueueSub(e);
+                if (t.rt.length) GlobalQueue.On(t.rt);
+        if (s && r) {
+            for (const e of s) if (!(e.ue & 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.lt.size) {
-            for (const e of t.lt) {
-                if (e.ie & REACTIVE_DISPOSED) continue;
+                if (t.ct.size) {
+            for (const e of t.ct) {
+                if (e.ue & REACTIVE_DISPOSED) continue;
                 enqueueSub(e);
             }
-            t.lt.clear();
+            t.ct.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.
@@ -949,13 +1102,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.Xt.length) checkBoundaryChildren(globalQueue);
+            if (globalQueue.hn.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.ni(t.En, e);
+                if (t.dn.size) GlobalQueue.Cn(t.dn, 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
@@ -967,20 +1120,20 @@ 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.Ke) {
-                runHeap(dirtyQueue, GlobalQueue.Fe);
+            if (dirtyQueue.EE >= dirtyQueue.et) {
+                runHeap(dirtyQueue, GlobalQueue.We);
                 commitPendingNodes();
             }
         }
         sweepTransientStoreNodes();
         // Lanes only enter activeLanes through the engine's getOrCreateLane.
-                if (activeLanes.size) GlobalQueue.dn(e);
+                if (activeLanes.size) GlobalQueue.Rn(e);
     }
 }
 
 function checkBoundaryChildren(e) {
-    for (const t of e.Xt) {
-        t.se?.();
+    for (const t of e.hn) {
+        t.fe?.();
         checkBoundaryChildren(t);
     }
 }
@@ -1003,8 +1156,10 @@ function checkBoundaryChildren(e) {
 
 function reassignPendingTransition(e) {
     for (let t = 0; t < e.length; t++) {
-        e[t].ge = activeTransition;
-    }
+        e[t].Ge = activeTransition;
+        e[t].T &= ~CONFIG_ADOPTED_UNFLUSHED;
+ // this flush carried it
+        }
 }
 
 const globalQueue = new GlobalQueue;
@@ -1041,7 +1196,7 @@ function flush(e) {
             }
         }
     }
-    if (globalQueue.sn) {
+    if (globalQueue.Kt) {
         return;
     }
     if (halted) return;
@@ -1056,38 +1211,109 @@ function flush(e) {
 }
 
 function runQueue(e, t) {
-    for (let i = 0; i < e.length; i++) e[i](t);
+    for (let n = 0; n < e.length; n++) e[n](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.fe; i; i = i.ae) {
-        let e = i.Se;
+function reporterBlocksSource(e, t, n) {
+    const i = e.ue;
+    if (i & REACTIVE_DISPOSED) return false;
+    // A zombie renders until the commit that disposes it (#3463): while its
+    // removal is staged in a live transaction it is still on screen, and what
+    // it displays must stay consistent with the frame — a held `Show`'s
+    // `Details: 0` beside the lane's `Value: 1` otherwise. Its say is moot for
+    // the verdict of the transaction that stages the removal (`verdict`): done,
+    // and the commit disposes it; not done, and it stays parked regardless. A
+    // zombie whose removal commits this flush (owner's pass not held) is dead.
+    // The owner is stamped when the flush parks; held in this flush, its
+    // staging transaction is the active one.
+        if (i & REACTIVE_ZOMBIE) {
+        let t = e;
+        while (t && t.ue & REACTIVE_ZOMBIE) t = t._parent;
+        let i = t && (t.Ge || (t.T & CONFIG_HELD_CHILDREN ? activeTransition : null));
+        if (!i || (i = currentTransition(i)).Tt === true || i === n) return false;
+    }
+    // Fallback-caught async holds nothing. A collecting loading boundary
+    // consumes the notification, so a reader under a fallback never registers —
+    // but a reader registered while its boundary showed content stays
+    // registered when the boundary's `on` later changes and it flips to the
+    // fallback. The reader is behind the fallback now; if nothing outside the
+    // boundary consumes the flight, the hold is over (A33, ruled 2026-09-12, #3375).
+        for (let t = e.C; t; t = t._parent) if (t.ee & STATUS_PENDING && !t.L) return false;
+    // "Still derives from the source" is a question about THIS pass's reads:
+    // the deps up to `_depsTail`. Past it lie the committed frame's — kept
+    // linked by A30 until the commit trims them (a staged pass, an errored
+    // one). Reading them here made a reporter whose pass had stopped reading
+    // the source (a gate closed in the same flush as the write) look live, and
+    // the hold it kept was the commit that would have trimmed the dep that
+    // kept it (spec O3, same-flush form; fuzzer #3446 P1 cases 21/79). A
+    // trimmed list ends at `_depsTail`, so the bound is free there; a pass
+    // that read nothing has a null tail and derives from nothing.
+    // The registration is trusted: a pending mark rides only this pass's links
+    // (notifyStatus skips the kept tail), so a registered reporter read the
+    // source, or threw on it.
+        if (e.o?.ae?.has(t)) return true;
+    const s = e.ot;
+    for (let n = s === null ? null : e.Se; n; n = n === s ? null : n.de) {
+        let e = n.Ee;
         while (e) {
-            if (e === t || e.ce === t) return true;
-            e = e.o?.Gt;
+            // Or through a memo pending on the flight (#3494): a stale reader
+            // served a held memo's committed value never turned pending itself, so
+            // its only trace of the flight is the memo between them — `copy` of
+            // `details`. Judged dead, its transaction released `count=1` beside
+            // the `Copy: 0` it displays. `_pendingSources` is transitive, so one
+            // hop covers any depth.
+            if (e === t || e.Te === t || e.o?.ae?.has(t)) return true;
+            e = e.o?.Ht;
         }
     }
     return !!(e.S & STATUS_PENDING && e.o?._ instanceof NotReadyError && e.o?._.source === t);
 }
 
+/**
+ * Does a live reporter of `transition` still observe `source` pending? Dead
+ * reporters (disposed, behind a fallback, no longer reading the source) are
+ * pruned as they are found, and the source's entry with them. Shared by the
+ * settle verdict and the lane's hold check (`waitingTransition`): a live
+ * action parks its transaction without a verdict, so this prune is the only
+ * one an optimistic lane whose last async reader unmounted mid-action ever
+ * gets — without it the lane held on the dead reporter's registration until
+ * the flight it no longer observed landed (#3426).
+ */ function sourceObserved(e, t, n) {
+    const i = e.oe.get(t);
+    let s = false;
+    for (const e of i ?? []) {
+        if (reporterBlocksSource(e, t, n)) return true;
+        // A zombie the verdict passes over is kept, not pruned (#3463): moot for
+        // this verdict, it still holds a lane's reveal while the transaction
+        // stays parked on something else.
+                if (n && e.ue & REACTIVE_ZOMBIE) s = true; else i.delete(e);
+    }
+    if (!s) e.oe.delete(t);
+    return false;
+}
+
 function transitionComplete(e) {
-    if (e.ft) return true;
-    if (e.ue.length) {
+    if (e.Tt) return true;
+    if (e.pe.length) {
         return false;
     }
     let t = true;
-    for (const [i, n] of e.Re) {
-        let r = false;
-        for (const e of n) {
-            if (reporterBlocksSource(e, i)) {
-                r = true;
-                break;
-            }
-            n.delete(e);
-        }
-        if (!r) e.Re.delete(i); else if (i.S & STATUS_PENDING && i.o?._?.source === i) {
+    for (const n of e.oe.keys()) {
+        // The source blocks while its OWN flight is up — the self entry in its
+        // pending sources (added by notifyStatus's source path, with status;
+        // retired by the landing and the supersede sweep, so it implies
+        // STATUS_PENDING). `_error.source` is not that test: propagation from an
+        // input that went pending later overwrites it with the input (#3375 — a
+        // boundary-consumed load re-asked under a held derivation), and the
+        // still-flying source read as settled, committing the writes it was
+        // asked with ahead of its answer.
+        // Not the self entry alone: a source whose own flight an upstream re-ask
+        // superseded is still pending — on that re-ask (#3462). Its reader cannot
+        // render until the chain lands, and the landing folds this transaction in
+        // (enterWaiting). Judged complete instead, a re-entry between the two (a
+        // repeated write to a held signal) committed the held writes beside the
+        // reader's stale frame.
+        if (sourceObserved(e, n, e) && n.o?.ae?.size) {
             t = false;
             break;
         }
@@ -1095,8 +1321,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.cn?.(e)) t = false;
-    t && (e.ft = true);
+        if (t && GlobalQueue.Nn?.(e)) t = false;
+    t && (e.Tt = true);
     return t;
 }
 
@@ -1108,7 +1334,7 @@ function transitionComplete(e) {
 }
 
 function currentTransition(e) {
-    while (e.ft && typeof e.ft === "object") e = e.ft;
+    while (e.Tt && typeof e.Tt === "object") e = e.Tt;
     return e;
 }
 
@@ -1119,19 +1345,31 @@ function currentTransition(e) {
  * 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.
+ * observed (#3335). Null when nobody is waiting — a registration whose every
+ * reporter has since died is nobody (#3426).
  */ function waitingTransition(e) {
-    for (const t of transitions) if (t.Re.has(e)) return t;
+    for (const t of transitions) if (sourceObserved(t, e)) return t;
     return null;
 }
 
+/** A landing enters EVERY parked transaction still waiting on `source`, folding
+ * them into the active one (A15: each reveal that discovered the flight
+ * completes at its landing). The fold used to happen as the waiters' stamped
+ * readers recomputed under the landing — recompute re-entering an effect's
+ * stamp — which also folded in writes those readers merely shared a hole
+ * with (#3407); effects no longer re-enter, so the landing folds explicitly.
+ * Live iteration is safe: a merge deletes the outgoing (active) entry and
+ * re-adds the visited one. */ function enterWaiting(e) {
+    for (const t of transitions) if (sourceObserved(t, e)) globalQueue.initTransition(t);
+}
+
 function runInTransition(e, t) {
-    const i = activeTransition;
+    const n = activeTransition;
     try {
         activeTransition = currentTransition(e);
         return t();
     } finally {
-        activeTransition = i;
+        activeTransition = n;
     }
 }
 
@@ -1146,16 +1384,16 @@ function runInTransition(e, t) {
  * initTransition is the wrong tool here: it MERGES the currently ambient
  * transaction into the target, entangling whatever the interrupted window
  * belonged to. */ function runAsTransitionBatch(e, t) {
-    const i = activeTransition;
-    const n = globalQueue.m;
+    const n = activeTransition;
+    const i = globalQueue.m;
     try {
         activeTransition = currentTransition(e);
         currentBatch = globalQueue.m = activeTransition;
         return t();
     } finally {
-        activeTransition = i;
-        currentBatch = globalQueue.m = n;
+        activeTransition = n;
+        currentBatch = globalQueue.m = i;
     }
 }
 
-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 };
+export { GlobalQueue, Queue, ROOT_ERROR_HOOK, actionStepDepth, activeAffectsMarks, activeLanes, activeTransition, armReaskClear, assignOrMergeLane, batchJoins, bumpNotifyEpoch, clock, createTransition, currentTransition, deferSlotRelease, dirtyQueue, enforceLoadingBoundary, entangleConfirmingTransitions, enterActionStep, enterWaiting, exitActionStep, finalizePureQueue, findLane, flush, globalQueue, haltReactivity, hasActiveOverride, heldTrims, insertSubs, notifyEpoch, origin, projectionWriteActive, queuePendingNode, reaskArmed, resetErrorHalt, runAsTransitionBatch, runInTransition, schedule, setOrigin, setProjectionWriteActive, setStoreCommitHook, shiftAffectsMarks, sourceObserved, storeCommitHook, transitions, waitingTransition, wakeParked, wokenTransitions, zombieQueue };