@solidjs/signals 2.0.0-rc.10 → 2.0.0-rc.13

package/dist/observe/core/core.js

@@ -105,10 +105,10 @@ function releaseSnapshotScope(e) {
 }
 
 function releaseSubtree(e) {
-    let t = e._n;
+    let t = e.On;
     while (t) {
         if (t.ot) {
-            t = t.Fn;
+            t = t._n;
             continue;
         }
         if (t.Se) {
@@ -122,7 +122,7 @@ function releaseSubtree(e) {
             }
         }
         releaseSubtree(t);
-        t = t.Fn;
+        t = t._n;
     }
 }
 
@@ -155,8 +155,8 @@ function recompute(e, t = false) {
         let i = false;
     if (attrHooks !== null) attrHooks.recomputeStart(e, t);
     // Lane posture is resolved BEFORE the previous frame is parked below: a
-    // lane pass on an effect direct-commits (#3662, see the parking site), so
-    // the decision must be known there. `lane` is applied to
+    // lane pass parks a lane frame, not a transaction zombie (#3662, #3698;
+    // see the parking site), so the decision must be known there. `lane` is applied to
     // `currentOptimisticLane` further down, once the previous posture is saved.
         let l = !!(e.oe & REACTIVE_OPTIMISTIC_DIRTY);
     let u = null;
@@ -204,29 +204,39 @@ function recompute(e, t = false) {
         // Tracked effects run after finalizePureQueue, so dispose immediately
         // instead of deferring. Children built by an uncommitted recompute
         // (CONFIG_HELD_CHILDREN) die immediately too: no frame ever showed them.
-        // Everything else is the committed frame's and is deferred as zombies
-        // until this node's commit — a transaction-owned node included (#3404):
-        // a parked node's children predate the hold, and tearing them down when
-        // the source lands ran cleanups before the transaction's atomic reveal.
-        // A lane pass on an effect parks a LANE frame instead (CONFIG_LANE_FRAME,
-        // #3662; A15 lanes corollary): the frame it replaces leaves the screen
-        // when the lane's queue applies this run (A30) — not at the action's
-        // commit — and a held lane defers that with the frame still displayed.
-        // The drain is the lane's first render entry for this pass, pushed before
-        // the pass builds the new frame: cleanups before side effects — the
-        // retired frame's `onCleanup`s run ahead of every effect callback of the
-        // new frame. While the frame waits, the live children were never shown:
-        // a superseding pass disposes them here like held children, and the
-        // parked frame stays.
-                if (n === EFFECT_TRACKED || e.C & (CONFIG_HELD_CHILDREN | CONFIG_LANE_FRAME)) disposeChildren(e); else if (e._n !== null || e.Ve !== null) {
+        // Everything else is the committed frame's. Which frame retires it is
+        // decided by who owns the pass, never by the node's kind (A15 lane work
+        // and transaction work, ruled 2026-09-28, #3698). Transaction work — a
+        // pass under a held transaction — defers them as zombies until this
+        // node's commit, a transaction-owned node included (#3404): a parked
+        // node's children predate the hold, and tearing them down when the
+        // source lands ran cleanups before the transaction's atomic reveal.
+        // Lane work — a pass over a lane, effect or memo alike — parks a LANE
+        // frame instead (CONFIG_LANE_FRAME, #3662, #3698): the frame it replaces
+        // leaves the screen when the lane's queue applies this pass (A30) — not
+        // at the action's commit — and a held lane defers that with the frame
+        // still displayed. The drain is the lane's first render entry for this
+        // pass, pushed before the pass builds the new frame: cleanups before
+        // side effects — the retired frame's `onCleanup`s run ahead of every
+        // effect callback of the new frame. While the frame waits, the live
+        // children were never shown: a superseding pass disposes them here like
+        // held children, and the parked frame stays. Zombies exist for
+        // transaction work only: #3662 gated the lane frame on `isEffect`, and a
+        // memo's lane pass (its value a derived override, A17) parked a
+        // transaction zombie that made the memo a pending node of the action,
+        // stamped it, and sent its next mainline recompute through the
+        // stamped-memo arm above — a `Show` whose `when` getter owns a
+        // compiler-emitted memo held an unrelated sync write for the action's
+        // lifetime, against the #3460 ruling that a lane never holds a sync write.
+                if (n === EFFECT_TRACKED || e.C & (CONFIG_HELD_CHILDREN | CONFIG_LANE_FRAME)) disposeChildren(e); else if (e.On !== null || e.Ve !== null) {
             markDisposal(e);
             const t = ext(e);
             t.Et = e.Ve;
-            t.dt = e._n;
+            t.dt = e.On;
             e.Ve = null;
-            e._n = null;
+            e.On = null;
             e.Nt = 0;
-            if (n && u) {
+            if (u) {
                 e.C |= CONFIG_LANE_FRAME;
                 findLane(u).It[0].push(() => {
                     e.C &= ~CONFIG_LANE_FRAME;
@@ -798,9 +808,9 @@ function computed(e, t) {
         u: null,
         Ht: null,
         _parent: context,
-        Fn: null,
-        kt: null,
         _n: null,
+        kt: null,
+        On: null,
         oe: t?.lazy ? REACTIVE_LAZY : REACTIVE_NONE,
         S: i ? 0 : STATUS_UNINITIALIZED,
         Ge: clock,
@@ -880,9 +890,9 @@ function computed(e, t) {
         u: null,
         Ht: null,
         _parent: context,
-        Fn: null,
-        kt: null,
         _n: null,
+        kt: null,
+        On: null,
         oe: REACTIVE_LAZY,
         S: STATUS_UNINITIALIZED,
         Ge: clock,
@@ -1398,7 +1408,7 @@ function enterStagedRead(e, t = e.me) {
  * False means the reader derives from the staged value and enters its
  * transaction (enterStagedRead, A29).
  */ function readerSeesCommitted(e, t, n, i) {
-    return !!(!t || currentOptimisticLane !== null && GlobalQueue.On(e, n, t) || e._e === NOT_PENDING || t.C & CONFIG_CHILDREN_FORBIDDEN || stale && !i && heldFromStale(e, t) || e.C & CONFIG_HELD_TRUTH && currentOptimisticLane !== null && !latestReadActive && !(t.C & CONFIG_AUTHORITATIVE_READ));
+    return !!(!t || currentOptimisticLane !== null && GlobalQueue.An(e, n, t) || e._e === NOT_PENDING || t.C & CONFIG_CHILDREN_FORBIDDEN || stale && !i && heldFromStale(e, t) || e.C & CONFIG_HELD_TRUTH && currentOptimisticLane !== null && !latestReadActive && !(t.C & CONFIG_AUTHORITATIVE_READ));
 }
 
 /** A28 — set when a node is staged (queuePendingNode) or a held node rewritten
@@ -1522,7 +1532,7 @@ function read(e) {
     // Checked before isPending so that isPending(() => latest(x)) checks
     // the _pendingSignal of _latestValueComputed (async in flight) rather
     // than the original node (which stays "pending" while held in a transition).
-    if (latestReadActive) return GlobalQueue.An(e);
+    if (latestReadActive) return GlobalQueue.Cn(e);
     let t = context;
     if (t?.Zt) t = t.Yt;
     const n = e;
@@ -1532,7 +1542,7 @@ function read(e) {
     // Probe mode is suspended while preparing the node so nested reads during a
     // recompute don't collect into the probe.
         if (pendingCheckActive) {
-        GlobalQueue.Cn(e, t, l, i);
+        GlobalQueue.Rn(e, t, l, i);
     } else if (typeof n.Se === "function") {
         prepareComputed(e, false);
     }
@@ -1584,13 +1594,13 @@ function read(e) {
         // (firewall-backed store reads always did; plain memos since the #3043
         // port): falling through served `undefined` as if settled and stranded
         // the reader outside both transactions, so it never re-ran.
-        if (t && !(stale && !(l.S & STATUS_UNINITIALIZED) && !(l.C & CONFIG_INPUTS_PUBLISHED) && !(l.C & CONFIG_HAS_LANE && GlobalQueue.Rn(l)) && heldFromStale(l, t))) {
+        if (t && !(stale && !(l.S & STATUS_UNINITIALIZED) && !(l.C & CONFIG_INPUTS_PUBLISHED) && !(l.C & CONFIG_HAS_LANE && GlobalQueue.Gn(l)) && heldFromStale(l, t))) {
             // Per-lane suspension lives with the engine (a non-null lane implies it
             // is installed): under a lane, only same-lane pending async without an
             // active override throws — plus uninitialized sources regardless of
             // lane (#3276); that check rides laneSuspends so floor bundles don't
             // pay for it.
-            if (currentOptimisticLane === null || GlobalQueue.Gn(l)) {
+            if (currentOptimisticLane === null || GlobalQueue.Dn(l)) {
                 // An untracked read of a pending node still re-runs its reader when
                 // the node settles — unless nobody is reading (`spectating`, #3528)
                 // or the reader is the node itself.
@@ -1694,7 +1704,7 @@ function read(e) {
             // a node whose own source answered with a DIFFERENT value hands a
             // tracked reader the staged truth (A18 supersession, #3331). Untracked
             // reads display the override.
-            if (t && e.C & (CONFIG_HAS_LANE | CONFIG_OVERRIDE_SUPERSEDED)) return GlobalQueue.Dn(e, t);
+            if (t && e.C & (CONFIG_HAS_LANE | CONFIG_OVERRIDE_SUPERSEDED)) return GlobalQueue.Pn(e, t);
             return unwrapOverride(e.o?.we);
         }
         e.C |= CONFIG_AUTHORITATIVE_OBSERVED;
@@ -1706,7 +1716,7 @@ function read(e) {
     // _pendingValue for correct fetching. The sub is recorded for replay at commit
     // so it re-runs with the new committed view. (Gate details live with the
     // engine — a non-null lane implies it is installed.)
-        if (currentOptimisticLane !== null && activeTransition !== null && t !== null && GlobalQueue.Pn(e, n, t)) {
+        if (currentOptimisticLane !== null && activeTransition !== null && t !== null && GlobalQueue.Fn(e, n, t)) {
         return i;
     }
     // In optimistic lane context, return _value for optimistic/lane-assigned signals

package/dist/observe/core/dev.js

@@ -68,20 +68,31 @@ function recordsChannel() {
     const e = globalThis;
     if (e[RECORDS]) return e[RECORDS];
     const n = new Map;
+    const t = new Map;
     return e[RECORDS] = {
-        subscribe(e, t) {
-            const o = n.get(e);
-            // Set semantics: one entry per function, however often it is passed.
-                        if (o === undefined) n.set(e, [ t ]); else if (!o.includes(t)) n.set(e, [ ...o, t ]);
+        subscribe(e, o, r) {
+            const i = n.get(e);
+            // Set semantics: one entry per function, however often it is passed —
+            // the first subscription's options stand for it.
+                        if (i === undefined || !i.includes(o)) {
+                n.set(e, i === undefined ? [ o ] : [ ...i, o ]);
+                if (r !== undefined && r.bodies) {
+                    let n = t.get(e);
+                    if (n === undefined) t.set(e, n = new Set);
+                    n.add(o);
+                }
+            }
             return () => {
-                const o = n.get(e);
-                if (o === undefined) return;
-                const r = o.filter(e => e !== t);
-                if (r.length > 0) n.set(e, r); else n.delete(e);
+                const r = n.get(e);
+                if (r === undefined || !r.includes(o)) return;
+                const i = r.filter(e => e !== o);
+                if (i.length > 0) n.set(e, i); else n.delete(e);
+                const s = t.get(e);
+                if (s !== undefined && s.delete(o) && s.size === 0) t.delete(e);
             };
         },
-        observed(e) {
-            return n.has(e);
+        observed(e, o) {
+            return o === "bodies" ? t.has(e) : n.has(e);
         },
         emit(e, t, o) {
             const r = n.get(e);
@@ -108,9 +119,14 @@ const OBSERVE = {
     // empty HERE and gains its members by augmentation downstream.
     server: {},
     exclude(e) {
-        excludedOwners.add(e);
+        markedOwners.set(e, true);
         hasExclusions = true;
     },
+    include(e) {
+        // No flag flip: with nothing excluded there is nothing to re-admit,
+        // and the walk stays short-circuited.
+        markedOwners.set(e, false);
+    },
     isExcluded: isExcluded,
     ownerPath: ownerPath
 };
@@ -119,9 +135,13 @@ const OBSERVE = {
 
 // An observer that lives inside the observed app (an adapter's panel,
 // devtools) marks its root; both channels check the subject's owner chain —
-// the same walk `ownerPath` already makes — and stay silent under it. The
-// flag short-circuits the walk for the common case of no exclusions.
-const excludedOwners = new WeakSet;
+// the same walk `ownerPath` already makes — and stay silent under it. An
+// observer that WRAPS the app (a toolbar around it) excludes its own root
+// and includes the app's back: one map, `true` excluded / `false` included,
+// and the nearest marker up the chain decides. The flag short-circuits the
+// walk for the common case of no exclusions (an include with nothing
+// excluded changes no verdict, so it does not flip it).
+const markedOwners = new WeakMap;
 
 let hasExclusions = false;
 
@@ -130,7 +150,10 @@ let hasExclusions = false;
 function isExcluded(e) {
     if (!hasExclusions || !e) return false;
     let n = "_parent" in e ? e : e.ie ?? null;
-    for (;n !== null; n = n._parent) if (excludedOwners.has(n)) return true;
+    for (;n !== null; n = n._parent) {
+        const e = markedOwners.get(n);
+        if (e !== undefined) return e;
+    }
     return false;
 }
 

package/dist/observe/core/optimistic.js

@@ -2,7 +2,7 @@ import { NOT_PENDING, unwrapOverride, STATUS_UNINITIALIZED, REACTIVE_DIRTY, REAC
 
 import { attrHooks } from "./attribution-hooks.js";
 
-import { ext, hasActiveOverride, stale, currentOptimisticLane, enterStagedRead, latestReadActive } from "./core.js";
+import { ext, hasActiveOverride, stale, currentOptimisticLane, enterStagedRead, setSignal, latestReadActive } from "./core.js";
 
 import { NotReadyError } from "./error.js";
 
@@ -27,17 +27,17 @@ import { GlobalQueue, activeTransition, globalQueue, origin, clock, insertSubs,
  */
 /** The optimistic half of setSignal, fired when `_overrideValue !== undefined`. */ function optimisticWrite(e, n) {
     const i = e.o?.we !== NOT_PENDING;
-    const t = i ? unwrapOverride(e.o?.we) : e.ce;
-    if (typeof n === "function") n = n(t);
-    const r = !!(e.S & STATUS_UNINITIALIZED) || 
+    const r = i ? unwrapOverride(e.o?.we) : e.ce;
+    if (typeof n === "function") n = n(r);
+    const t = !!(e.S & STATUS_UNINITIALIZED) || 
     // A dirty node's _value is stale (its queued recompute hasn't run — e.g.
     // a latest() shadow marked by the previous landing's companion snap), so
     // equality against it must not swallow the write. Without this, a sync
     // push returning the shadow to that stale value was dropped, the snap
     // recompute then committed the parent's old value, and the banner showed
     // the previous transition's target (#3041 follow-up).
-    !!((e.oe ?? 0) & (REACTIVE_DIRTY | REACTIVE_CHECK)) || !e.Fe || !e.Fe(t, n);
-    if (!r) {
+    !!((e.oe ?? 0) & (REACTIVE_DIRTY | REACTIVE_CHECK)) || !e.Fe || !e.Fe(r, n);
+    if (!t) {
         // Same-value write with an active override still entangles the current
         // action's transition — the hold must outlast all overlapping actions —
         // and renews the override's PROVENANCE: the newer action re-asks the
@@ -164,7 +164,7 @@ function resolveOptimisticNodes(e) {
         // override-covered authoritative values hold in _pendingValue and
         // elevate on their OWN transition's schedule (A18 as re-ruled 2026-07-07).
                 if (!(n.S & STATUS_PENDING)) n.S &= ~STATUS_UNINITIALIZED;
-        const t = n.o?.we;
+        const r = n.o?.we;
         // A derived override (lanes stage, #3479) has no truth of its own: the
         // slot disarms — the memo is plain again — and the override PROMOTES to
         // `_value`. Not superseded, nothing it derives from told it otherwise
@@ -174,18 +174,18 @@ function resolveOptimisticNodes(e) {
         // the override IS what a recompute from the truth yields. Re-deriving
         // instead re-asked an async member's flight and held the transaction on
         // it — a waterfall after the reveal.
-                const r = n.C & CONFIG_DERIVED_OVERRIDE;
-        ext(n).we = r && !(n.C & CONFIG_OPTIMISTIC) ? undefined : NOT_PENDING;
+                const t = n.C & CONFIG_DERIVED_OVERRIDE;
+        ext(n).we = t && !(n.C & CONFIG_OPTIMISTIC) ? undefined : NOT_PENDING;
         // A superseded override's subscribers already re-derived from the truth
         // when it arrived (#3331) — the drop changes nothing they read. Everyone
         // else learns of the correction here: this drop IS their notification.
                 const u = (n.C & CONFIG_OVERRIDE_SUPERSEDED) !== 0;
         n.C &= -8912897;
-        if (!u && t !== NOT_PENDING && n.ce !== unwrapOverride(t)) {
-            if (r) n.ce = unwrapOverride(t); else {
+        if (!u && r !== NOT_PENDING && n.ce !== unwrapOverride(r)) {
+            if (t) n.ce = unwrapOverride(r); else {
                 // The guess lifts and what was beneath it differs: the screen
                 // changes from the override to the committed value.
-                if (attrHooks !== null) attrHooks.optimisticReverted(n, unwrapOverride(t), n.ce, "reverted");
+                if (attrHooks !== null) attrHooks.optimisticReverted(n, unwrapOverride(r), n.ce, "reverted");
                 insertSubs(n, true);
             }
         }
@@ -198,8 +198,8 @@ function resolveOptimisticNodes(e) {
         for (let i = 0; i < n; i++) {
         const n = e[i];
         if (n.o?.xe || n.o?.Me) GlobalQueue.Qn(n);
-        const t = n.o?.$n;
-        if (t && (t.o?.xe === n || t.o?.Me === n)) GlobalQueue.Qn(t);
+        const r = n.o?.$n;
+        if (r && (r.o?.xe === n || r.o?.Me === n)) GlobalQueue.Qn(r);
     }
     e.splice(0, n);
 }
@@ -257,14 +257,14 @@ function resolveOptimisticNodes(e) {
         const i = e.o?.Ce;
         if (i) {
             const n = findLane(i);
-            const t = [ e ];
-            while (t.length) {
-                const e = t.pop();
+            const r = [ e ];
+            while (r.length) {
+                const e = r.pop();
                 const i = e.o?.Ce;
                 if (!i || findLane(i) !== n) continue;
                 e.o.Ce = undefined;
                 n.ke.delete(e);
-                for (let n = e.u; n !== null; n = n.Pe) t.push(n.Ae);
+                for (let n = e.u; n !== null; n = n.Pe) r.push(n.Ae);
             }
         }
     }
@@ -403,7 +403,49 @@ function resolveOptimisticNodes(e) {
  * action provenance, or an A17-silent confirmation (#3331). Before this the
  * landing took setSignal's plain path: a differing truth staged silently
  * under the override and the graph never moved until the commit.
+ *
+ * Slot arm (list-matrix F1): `mapArray`'s writes to its per-slot signals —
+ * the row accessors of index mode, the index accessors of keyed mode; never
+ * CONFIG_OPTIMISTIC, which is how the arm tells them from the store landings
+ * above — once a lane pass has run over the map. The list's frame lives in
+ * these writes as much as in the computed's result. Under a LANE pass the
+ * write is the lane's frame, as the computed's result is (lanes stage,
+ * `laneOverride`): the slot joins the lane carrying a DERIVED override —
+ * `_value` stays the committed row, the lane's readers and untracked reads
+ * see the override (A17), an off-lane render effect sees the committed frame
+ * (#3460), the revert promotes or drops it with the lane's transaction. The
+ * gate compares against the slot the pass publishes to (INV-11): the override
+ * when armed, the committed row otherwise. A plain `setSignal` here staged
+ * the write into the ACTION's transaction: `<For>` without `keyed` showed the
+ * pre-action list for the whole action while the keyed modes showed the
+ * optimistic one. A PLAIN pass over a slot still carrying the lane's frame —
+ * the landing, the reversion, a mainline re-pass — is the truth arriving
+ * under an override and takes the landing path below: a differing truth
+ * supersedes, an equal one confirms and the revert promotes. Every pass
+ * rewrites every slot whose value differs from the previous frame's (index
+ * mode rewrites every surviving slot), so a slot the landing does NOT write
+ * holds, by construction, what the truth yields. A slot with neither a lane
+ * nor an override is the plain write.
  */ function landOnOverride(e, n) {
+    if (!(e.C & CONFIG_OPTIMISTIC)) {
+        const i = currentOptimisticLane;
+        if (i === null) {
+            if (!hasActiveOverride(e)) return setSignal(e, n);
+        } else {
+            // INV-11: the gate compares against the slot this pass publishes to —
+            // the override when one is armed, the committed row otherwise.
+            if (!e.Fe || !e.Fe(hasActiveOverride(e) ? unwrapOverride(e.o.we) : e.ce, n)) {
+                // Membership before the publish: `laneOverride` files the slot under
+                // the lane's transaction, and the read path routes a tracked reader
+                // of a lane member through `overrideRead` (CONFIG_HAS_LANE).
+                assignOrMergeLane(e, i);
+                laneOverride(e, n, i);
+                insertSubs(e, true);
+                schedule();
+            }
+            return n;
+        }
+    }
     const i = e._e === NOT_PENDING ? e.ce : e._e;
     if (typeof n === "function") n = n(i);
     if (attrHooks !== null) attrHooks.write(e, i, n);
@@ -611,13 +653,13 @@ function trackOptimisticStore(e) {
     GlobalQueue.Kn = runLaneEffects;
     GlobalQueue.Qe = supersedeOverride;
     GlobalQueue.zn = endOptimism;
-    GlobalQueue.Dn = overrideRead;
+    GlobalQueue.Pn = overrideRead;
     GlobalQueue.je = laneOverride;
     GlobalQueue.Vn = landOnOverride;
-    GlobalQueue.Pn = gatedRead;
-    GlobalQueue.Gn = laneSuspends;
-    GlobalQueue.Rn = laneLive;
-    GlobalQueue.On = laneReadsCommitted;
+    GlobalQueue.Fn = gatedRead;
+    GlobalQueue.Dn = laneSuspends;
+    GlobalQueue.Gn = laneLive;
+    GlobalQueue.An = laneReadsCommitted;
     GlobalQueue._t = recomputeLane;
     GlobalQueue.Ot = laneAsyncPending;
     GlobalQueue.St = laneAsyncSettled;

package/dist/observe/core/owner.js

@@ -14,7 +14,7 @@ const PENDING_OWNER = {};
 
  // Dummy owner to trigger store's read() path
 function markDisposal(e) {
-    let n = e._n;
+    let n = e.On;
     while (n) {
         const e = n.oe;
         n.oe = e | REACTIVE_ZOMBIE;
@@ -28,7 +28,7 @@ function markDisposal(e) {
             if (e & REACTIVE_IN_HEAP) insertIntoHeap(n, zombieQueue); else insertIntoHeapHeight(n, zombieQueue);
         }
         markDisposal(n);
-        n = n.Fn;
+        n = n._n;
     }
 }
 
@@ -76,8 +76,8 @@ function disposeChildren(e, n = false, t) {
         schedule();
     }
     if (n && e.Se && e.o !== null) e.o.pe = null;
-    let o = t ? e.o?.dt ?? null : e._n;
-    if (!t) e._n = null;
+    let o = t ? e.o?.dt ?? null : e.On;
+    if (!t) e.On = null;
     while (o) {
         const e = o;
         // Owner teardown is death regardless of the child's own lifecycle
@@ -107,7 +107,7 @@ function disposeChildren(e, n = false, t) {
         // itself out of the detached chain, and a cleanup may then have linked
         // it at the fresh head, which rewrote the `_nextSibling` a pre-read
         // would still be holding.
-                o = o.Fn;
+                o = o._n;
     }
     if (t) {
         if (e.o !== null) e.o.dt = null;
@@ -118,8 +118,8 @@ function disposeChildren(e, n = false, t) {
     // walks that already advanced past us still reach later siblings.
         if (n && !t && !(i & REACTIVE_ZOMBIE) && e._parent !== null && !(e._parent.oe & REACTIVE_DISPOSED)) {
         const n = e.kt;
-        const t = e.Fn;
-        if (n !== null) n.Fn = t; else e._parent._n = t;
+        const t = e._n;
+        if (n !== null) n._n = t; else e._parent.On = t;
         if (t !== null) t.kt = n;
         e.kt = null;
     }
@@ -134,11 +134,11 @@ function disposeChildren(e, n = false, t) {
 }
 
 function linkChild(e, n) {
-    const t = e._n;
+    const t = e.On;
     n.kt = null;
-    n.Fn = t;
+    n._n = t;
     if (t !== null) t.kt = n;
-    e._n = n;
+    e.On = n;
 }
 
 function runDisposal(e, n) {
@@ -295,8 +295,8 @@ function disposeRootSelf(e = true) {
         C: t ? CONFIG_TRANSPARENT : 0,
         Zt: true,
         Yt: n?.Zt ? n.Yt : n,
+        On: null,
         _n: null,
-        Fn: null,
         kt: null,
         Ve: null,
         T: n?.T ?? globalQueue,

package/dist/observe/core/scheduler.js

@@ -554,8 +554,8 @@ class GlobalQueue extends Queue {
     static Ue=null;
     static qe=null;
     static Qn=null;
-    static An=null;
     static Cn=null;
+    static Rn=null;
     static Hn=null;
     static At=null;
     static k=null;
@@ -579,14 +579,14 @@ class GlobalQueue extends Queue {
      * apply at lane-effect timing — visible in flight, unlike the regular
      * effect queues an action stashes. Injected; null when unused. */
     static Zn=null;
-    static Pn=null;
-    static Gn=null;
+    static Fn=null;
+    static Dn=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 Rn=null;
-    static On=null;
+    static Gn=null;
+    static An=null;
     static _t=null;
     static Ot=null;
     /** Authoritative-view reader wakeup: installed by until() and refresh() before
@@ -618,7 +618,7 @@ class GlobalQueue extends Queue {
      * transaction's committed value over its staged write. */
     /** A tracked read of an active override: the lane outside-view rule
      * (#3460) and the A18 supersession selection (#3331) — see optimistic.ts. */
-    static Dn=null;
+    static Pn=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. */
@@ -631,7 +631,11 @@ class GlobalQueue extends Queue {
      * 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. */
+     * that has an override — or, from `mapArray` once a lane pass has run over
+     * the map, on a per-slot signal (never CONFIG_OPTIMISTIC): the slot arm
+     * publishes a lane pass's write as the slot's derived override, lands a
+     * plain pass's write over one, and is the plain `setSignal` otherwise (F1,
+     * see optimistic.ts landOnOverride). */
     static Vn=null;
     static Jn=null;
     flush() {
@@ -793,8 +797,13 @@ class GlobalQueue extends Queue {
             // 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.st || activeTransition !== null;
+            // mainline applies now. A write the finalize staged in the ambient
+            // batch with no subscriber to dirty (an optimistic store settle's
+            // keyset bump under a reader that never tracks the key set) is work
+            // too — the fast drain and the park exit already count it — so the
+            // next round commits it and the woken re-entry below does not adopt
+            // it into a parked transaction it never belonged to (matrix F6).
+                        scheduled = dirtyQueue.EE >= dirtyQueue.st || activeTransition !== null || this.m.In.length !== 0;
             // Run lane effects first (for ready lanes), then regular effects
                         activeLanes.size && GlobalQueue.Kn(EFFECT_RENDER);
             this.run(EFFECT_RENDER);
@@ -808,9 +817,14 @@ class GlobalQueue extends Queue {
             // 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 was recomputed from the heap and the ambient batch's staged nodes
+            // 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. (A staged node with no subscriber — the
+            // finalize's keyset bump under a length-only reader — used to be
+            // missed here: the wake adopted it, stamped it, and a later ambient
+            // write to the same node joined the parked transaction and never
+            // reverted; matrix F6.) 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());

package/dist/observe/core/verdict.js

@@ -657,9 +657,9 @@ GlobalQueue.qe = updateChildCompanions;
 
 GlobalQueue.Qn = snapCompanionsToState;
 
-GlobalQueue.An = latestRead;
+GlobalQueue.Cn = latestRead;
 
-GlobalQueue.Cn = pendingCheckRead;
+GlobalQueue.Rn = pendingCheckRead;
 
 GlobalQueue.Hn = recordFreshRead;