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

package/dist/observe/store/next/store.js

@@ -208,6 +208,8 @@ r = -1) {
         //    committed is the held view `hv[key]`, staged is `v[key]`.
         const l = heldFoldTransition(e);
         let s = heldAdoptionTransition(e);
+        // A key the adoption left unchanged is not born holding (#3706).
+                if (s !== null && !heldKey(e, t)) s = null;
         if (s !== null) n = e.hv[t]; else if ((s = l) !== null) n = e.v[t];
         // Create-floor diet: slotSignal bakes the whole node into one literal —
         // no options object, no equals/unobserved closures, no NodeExtension,
@@ -315,6 +317,33 @@ r = -1) {
     return true;
 }
 
+// #3706: the keys an adoption under a live hold changed against the held
+// view — the adoption twin of `wk` (#3688), keyed on the target. adoptPB
+// records `[adopted object]`; the keys are diffed against IT, once, on the
+// first held read (its children are re-pointed by then), and replace the
+// entry. Never against the live backing — a mainline write during the hold
+// replaces that, and its key is not the adoption's. WK_ALL holds the whole
+// container.
+const heldKeys = new WeakMap;
+
+function heldKey(e, t) {
+    let n = heldKeys.get(e);
+    if (Array.isArray(n)) heldKeys.set(e, n = adoptionChangedKeys(e, n[0]));
+    return n === WK_ALL || n.has(t);
+}
+
+function adoptionChangedKeys(e, t) {
+    const n = e.hv;
+    // A chained backing, an optimistic family, a chained held view, a swapped
+    // or non-plain prototype (inherited accessors read through `this`): whole.
+        if (t[$TARGET] !== undefined || e.fam?.opt === true || n[$TARGET] !== undefined || Object.getPrototypeOf(n) !== Object.getPrototypeOf(t) || !plainProto(t)) return WK_ALL;
+    const r = new Set;
+    // Accessors are never invoked: they and a flipped enumerability are changes.
+        for (const i of Reflect.ownKeys(n)) if (!hasOwn.call(t, i) || isOwnAccessor(n, i) || isOwnAccessor(t, i) || propertyIsEnumerable.call(n, i) !== propertyIsEnumerable.call(t, i) || !(isEqual(n[i], t[i]) || sameLogicalSlot(e, n[i], t[i]))) r.add(i);
+    for (const e of Reflect.ownKeys(t)) if (!hasOwn.call(n, e)) r.add(e);
+    return r;
+}
+
 function stageHeldKey(e, t, n) {
     if (slotNodeEquals.call(e, e.ce, t)) return;
     e._e = t;
@@ -508,6 +537,23 @@ let hookInstalled = false;
     return r;
 }
 
+/** Shallow copy of a WIDE plain-data (sc 2) backing for the overlay rebuild
+ * (#3689). Own keys land on a null-prototype object — V8 creates those in
+ * dictionary mode, so the copy is O(keys) hash inserts — and the prototype
+ * is attached after. A spread builds a fast-mode object one map transition
+ * per key; from a source in dictionary mode (a backing that took deletes)
+ * whose key order differs from the last copy's, every transition is a fresh
+ * map with an O(keys) descriptor copy: measured 270 µs vs 28 µs at 400 keys,
+ * 1.3 ms vs 75 µs at 1000. Narrow, stable-shaped backings keep the spread
+ * (cloneRaw): there the clone IC copies the property store at once and is
+ * 3–8× cheaper than any per-key loop. */ function wideClone(e, t) {
+    const n = Object.create(null);
+    for (const t of Reflect.ownKeys(e)) n[t] = e[t];
+    Object.setPrototypeOf(n, Object.prototype);
+    n[$OWNER] = t;
+    return n;
+}
+
 /** Copy own `key` from `from` onto `to`. A plain data slot (enumerable,
  * writable, configurable, no accessor) is a bare assignment — the common case
  * and the cheap one; anything else goes through defineProperty so accessors
@@ -544,21 +590,67 @@ let hookInstalled = false;
  * backing into a prototype, and every later flatten writes into that
  * prototype); above it the clone's O(keys) copy dominates (#3044). */ const OVERLAY_MIN_KEYS = 32;
 
+/** Overlay commit choice (#3689): flatten in place, or rebuild the backing
+ * (materializePB, then the clone path's swap)? Measured on V8 (Node 26): a
+ * committed backing that has served as an overlay prototype is kept as a
+ * FAST-MODE prototype object up to V8's descriptor limit (1020 own
+ * properties), and there every in-place DELETE is O(keys) — normalize to
+ * dictionary plus re-optimize as a prototype, ~0.08 µs × keys — and every
+ * in-place ADD is a map transition copying the descriptors, ~0.006 µs ×
+ * keys. Detaching the overlay first does not help: prototype-ness is a
+ * property of the object's map. One rebuild (wideClone, deletes, writes) is
+ * ~0.07–0.09 µs × keys — the price of ONE in-place delete. So a fold that
+ * deleted anything, or added more than ~16 keys, commits cheaper rebuilt (a
+ * 400-key record churning 100 keys per commit, 10,000 membership readers:
+ * 4.7 ms → 0.22 ms per step); a pure rewrite of existing keys — the
+ * overlay's home case — stays in place at O(written).
+ * Past the descriptor limit V8 keeps the backing in dictionary mode where
+ * every in-place op is O(1), and a rebuild would be a pure O(keys) loss on
+ * exactly the growing-record pattern the overlay exists for (#3044) — the
+ * count gate keeps those in place. The gate reads `kc`, which the set trap
+ * counts up for keys new to the container and the delete commit counts down. */ const OVERLAY_REBUILD_MAX_KEYS = 1024;
+
+const OVERLAY_REBUILD_MIN_ADDS = 16;
+
+function overlayRebuilds(e, t) {
+    if (e.kc > OVERLAY_REBUILD_MAX_KEYS) return false;
+    if (e.del !== null && e.del.size !== 0) return true;
+    // Every trap write records its key, so the written-key count bounds the
+    // adds — the common few-key fold (#3044's growing record) answers here
+    // without enumerating the overlay.
+        const n = e.wk;
+    if (n !== null && n !== WK_ALL && n.size <= OVERLAY_REBUILD_MIN_ADDS) return false;
+    const r = e.v;
+    let i = 0;
+    for (const e of Reflect.ownKeys(t)) if (!hasOwn.call(r, e) && ++i > OVERLAY_REBUILD_MIN_ADDS) return true;
+    return false;
+}
+
 /** Downgrade a prototype-overlay pending backing to the clone path: builds
  * the real container (committed + overlay writes − deletes) that fold will
  * SWAP in as the committed backing, exactly as if the draft had started on
  * the clone path. Consumers that need a complete container (reconcile's
- * diff walks, drafts escaping into other storage) call this. */ function materializePB(e) {
-    if (!e.ovl) return;
+ * diff walks, drafts escaping into other storage) call this, and so does the
+ * commit itself when the fold changed the key set (overlayRebuilds). Returns
+ * the pending backing (the clone, or the pb as-is when not an overlay). */ function materializePB(e) {
     const t = e.pb;
-    const n = cloneRaw(e.v, e);
-    for (const e of Reflect.ownKeys(t)) copyOwn(n, t, e);
-    if (e.del !== null) {
+    if (!e.ovl) return t;
+    const n = e.sc === 2 ? wideClone(e.v, e) : cloneRaw(e.v, e);
+    // Deletes before writes (#3689): on a fast-mode clone (the descriptor
+    // path) the first delete normalizes it once, and the writes then land as
+    // O(1) dictionary adds instead of O(keys) map transitions each. Order is
+    // free semantically — a rewritten key left `del` at write time, so no
+    // write targets a deleted key.
+        if (e.del !== null) {
         for (const t of e.del) delete n[t];
+        e.kc -= e.del.size;
         e.del = null;
     }
+    // Plain-data grade (sc 2): bare assignment, as flattenOverlay does.
+        for (const r of Reflect.ownKeys(t)) e.sc === 2 ? n[r] = t[r] : copyOwn(n, t, r);
     e.pb = n;
     e.ovl = false;
+    return n;
 }
 
 function ensurePB(e) {
@@ -698,6 +790,7 @@ function ensurePB(e) {
         if (heldMaskView(e) === null) e.hv = e.v;
         e.ht = activeTransition ?? PLAIN_HOLD;
         if (!n && activeTransition !== null) heldAdoptions.add(e);
+        heldKeys.set(e, [ t ]);
     }
     e.pb = null;
     // Overlay and accessor-scan state describe the OUTGOING backing — a
@@ -829,6 +922,7 @@ function queueFold(e) {
         for (const r of Reflect.ownKeys(t)) e.sc === 2 ? n[r] = t[r] : copyOwn(n, t, r);
     if (e.del !== null) {
         for (const t of e.del) delete n[t];
+        e.kc -= e.del.size;
         e.del = null;
     }
     e.pb = null;
@@ -887,11 +981,13 @@ function drainFolds() {
  // re-queue: commit happens when the hold settles
                                 continue;
             }
-            if (t.ovl) {
+            if (t.ovl && (t.v !== n || !overlayRebuilds(t, i))) {
                 // Overlay flatten (#3044): the backing keeps its identity, so the
                 // `t.v === old` gate below skips path copying (the parent slot
                 // already points here) and the adopted-notify (setter notifications
-                // happened at write time).
+                // happened at write time). A backing privatized mid-batch is a fresh
+                // clone, never a prototype — in-place writes into it are cheap, and
+                // the merge branch below is what a materialized pb would need anyway.
                 flattenOverlay(t, i);
             } else if (t.v !== n) {
                 // Privatized mid-batch (#3271): an earlier fold in this drain
@@ -932,7 +1028,10 @@ function drainFolds() {
                 t.wk = null;
  // written-keys window closes with the fold commit
                         } else {
-                t.v = i;
+                // An overlay whose fold changed the key set rebuilds (#3689) and
+                // takes the swap like a clone-path draft: the parent slot re-points
+                // in the path copy below.
+                t.v = t.ovl ? materializePB(t) : i;
                 t.ch = false;
  // pb is always a plain clone
                                 t.pb = null;
@@ -1162,8 +1261,12 @@ function sameLeaf(e, t) {
         if (e.ht !== null) e.ht = e.hv = null;
         // Overlay landing (#3352): flatten in place — identity-stable, and
         // privatizeCommitted re-slots the parent itself when it has to clone an
-        // unowned seed, so no path copy is needed.
-                if (e.ovl) return flattenOverlay(e, t);
+        // unowned seed, so no path copy is needed. A landing that changed the
+        // key set rebuilds instead (#3689) and swaps like a clone-path landing.
+                if (e.ovl) {
+            if (!overlayRebuilds(e, t)) return flattenOverlay(e, t);
+            t = materializePB(e);
+        }
         const n = e.v;
         e.pb = null;
         e.v = t;
@@ -1405,21 +1508,25 @@ const UNSAFE_KEYS = new Set([ "__proto__", "prototype", "constructor" ]);
     return false;
 }
 
-function readSource(e) {
+/** The backing a reader is served. `key` (the get/has/descriptor traps)
+ * scopes a fold hold to the keys the fold touched — see pendingBackingVisible —
+ * and an adoption hold to the keys the adoption changed (heldKey). */ function readSource(e, t) {
     // Adoption hold first (#3074): an adoption staged under a live transaction
     // (or a latest()-pull, PLAIN_HOLD) serves the pre-hold committed view to
     // committed-visibility readers — context-free and children-forbidden ones,
     // and stale passes off a foreign hold. Drafts, write-override and latest()
     // see the adopted backing.
-    const t = e.ht;
-    if (t !== null && !latestReadActive && !inDraft(e) && !getWriteOverride()) {
-        const n = heldMaskView(e);
-        if (n !== null) {
+    const n = e.ht;
+    if (n !== null && !latestReadActive && !inDraft(e) && !getWriteOverride()) {
+        const r = heldMaskView(e);
+        // A key the adoption left unchanged derives nothing from the hold, for
+        // any reader (#3706): the backing serves it.
+                if (r !== null && (t === undefined || heldKey(e, t))) {
             const e = readerContext();
-            if (e === null || e.C & CONFIG_CHILDREN_FORBIDDEN || !holdVisible(t === PLAIN_HOLD ? null : currentTransition(t), e)) return n;
+            if (e === null || e.C & CONFIG_CHILDREN_FORBIDDEN || !holdVisible(n === PLAIN_HOLD ? null : currentTransition(n), e)) return r;
         }
     }
-    return pendingBackingVisible(e, false) ? e.pb : e.v;
+    return pendingBackingVisible(e, false, t) ? e.pb : e.v;
 }
 
 /** The single pb-vs-committed visibility decision (#3147), shared by per-key
@@ -1436,7 +1543,7 @@ function readSource(e) {
  * `speculative` is deep()/snapshot's posture: an untrack/deep PEEK that sees
  * ordinary pending staging regardless of owner context (the documented
  * divergence from context-free per-key reads) — but never through a hold:
- * held truth stays masked exactly as it is for per-key readers. */ function pendingBackingVisible(e, t) {
+ * held truth stays masked exactly as it is for per-key readers. */ function pendingBackingVisible(e, t, n) {
     if (e.pb === null) return false;
     // The writer's own channels compose on the pending backing regardless.
         if (inDraft(e) || getWriteOverride()) return true;
@@ -1447,8 +1554,8 @@ function readSource(e) {
     // hold arms below: committed for no pass, the staged backing for the
     // holding pass, stale-of-foreign or A29 for a foreign one.
         if (heldTruthMasked(e)) return false;
-    const n = readerContext();
-    if (n === null || n.C & CONFIG_CHILDREN_FORBIDDEN) {
+    const r = readerContext();
+    if (r === null || r.C & CONFIG_CHILDREN_FORBIDDEN) {
         // No pass, or a children-forbidden one: the committed frame (A32) —
         // except the speculative peek (deep()/snapshot()), which sees ordinary
         // pending staging but never through a live foreign hold, and a
@@ -1456,11 +1563,30 @@ function readSource(e) {
         // readers UNLESS a transition holds the node commits (downstream async
         // hold — stale committed is the contract; the write-time stamp covers
         // keys with no node, #3336) or the scope is children-forbidden (#3082).
-        const r = liveFoldTransition(e);
-        if (t) return r === null || ownsHold(r);
-        return e.fam !== null && n === null && !foldHeld(e) && r === null;
+        const n = liveFoldTransition(e);
+        if (t) return n === null || ownsHold(n);
+        return e.fam !== null && r === null && !foldHeld(e) && n === null;
+    }
+    const i = liveFoldTransition(e);
+    // A hold changes what a reader of ONE key sees only through the fold's
+    // writes to that key. A key the fold left alone reads the same from either
+    // backing, so a pass reading it derives nothing from the hold: serve
+    // committed, with no transaction entry and no stale replay (#3688 — a memo
+    // reading an unchanged key beside an independent signal was held with
+    // someone else's action). Per-node reads already have this precision (a
+    // node with nothing staged enters nothing; stageHeldKey skips an equal
+    // value); this is the same rule at the container gate. `wk` is the trap's
+    // record of every write and delete this batch (deletes included, on the
+    // overlay and clone paths alike); null (a fold with no trap writes) or
+    // WK_ALL (an array length write) leaves the whole container held. Same
+    // exclusions as heldFoldTransition: an optimistic family's draft is seeded
+    // from node overrides the trap never saw, and a chained backing's
+    // committed layer is a live proxy, not a frozen twin of the clone.
+        if (i !== null && n !== undefined && !e.ch && e.fam?.opt !== true) {
+        const t = e.wk;
+        if (t != null && t !== WK_ALL && !t.has(n)) return false;
     }
-    return holdVisible(liveFoldTransition(e), n);
+    return holdVisible(i, r);
 }
 
 /** #3164 fold: HELD truth on an optimistic family — a pending backing
@@ -1756,7 +1882,7 @@ const traps = {
         // observer, so bring the projection computed up to date here — signal/
         // memo parity for latest() reads through a projection.
                 if (e.fam !== null && latestReadActive && !inDraft(e) && !getWriteOverride()) pullProjectionForLatest(e);
-        const r = readSource(e);
+        const r = readSource(e, t);
         // Overlay delete (#3044): a prototype overlay cannot shadow a delete, so
         // deleted keys are tracked aside and read as absent in the pending view.
                 if (e.del !== null && r === e.pb && e.del.has(t)) {
@@ -1866,7 +1992,7 @@ const traps = {
         if (t === $OWNER || t === $RECORD) return false;
         if (pendingCheckActive) witnessAffectsMark(e, t);
         if (e.fam !== null && getObserver() === null && !inDraft(e)) firewallGate(e);
-        const n = readSource(e);
+        const n = readSource(e, t);
         let r = t in n;
         // Overlay deletes read as absent in the pending view (#3044).
                 if (r && e.del !== null && n === e.pb && e.del.has(t)) r = false;
@@ -1922,7 +2048,7 @@ const traps = {
                 if (pendingCheckActive) witnessAffectsMark(e, t);
         const n = getObserver();
         if (e.fam !== null && n === null && !inDraft(e)) firewallGate(e);
-        const r = readSource(e);
+        const r = readSource(e, t);
         const i = visibleDescriptor(e, r, t);
         if (!inDraft(e) && n !== null && !observerHoldsKeySet(e, n)) {
             // The node is born from the source's presence (as `has` births it),
@@ -1967,10 +2093,12 @@ const traps = {
             }
         } else {
             if (e.wk !== WK_ALL) (e.wk ??= new Set).add(t);
-            // Live own-key estimate for the overlay/clone choice (#3360): `in`
-            // sees through an overlay to the committed keys, so this counts keys
-            // NEW to the container. Deletes are not un-counted (a stale high
-            // count only picks the overlay a little early).
+            // Live own-key estimate for the overlay/clone choice (#3360) and the
+            // overlay's commit choice (#3689): `in` sees through an overlay to the
+            // committed keys, so this counts keys NEW to the container. Overlay
+            // deletes are counted down when they commit (`del` is exact); clone-
+            // path deletes are not (a stale high count on a narrow container only
+            // picks the overlay a little early).
                         if (!(t in l)) e.kc++;
         }
         // Own data keys literally named "prototype"/"constructor" land as data —

package/dist/prod/core/constants.js

@@ -180,20 +180,29 @@ const CONFIG_HAS_LANE = 1 << 10;
  * transaction. A parked node (status propagation stamps `_transition`
  * without recomputing) recomputed when its source lands otherwise disposed
  * its committed children mid-hold, running their cleanups before the
- * transaction's atomic reveal. Cleared by `commitPendingNode`. */ const CONFIG_HELD_CHILDREN = 1 << 20;
+ * transaction's atomic reveal. Cleared by `commitPendingNode`. Transaction
+ * work only (A15 lane work and transaction work, #3698): zombies are parked
+ * by a pass under a held transaction; a pass over a lane parks a LANE frame
+ * instead (`CONFIG_LANE_FRAME`), whatever the node's kind. */ const CONFIG_HELD_CHILDREN = 1 << 20;
 
 /** The frame parked in `_pendingFirstChild` / `_pendingDisposal` is a LANE
- * frame (#3662, A15 lanes corollary): an effect's lane pass direct-commits,
- * so the frame it replaces leaves the screen when the lane's queue applies
- * the run (A30) — not at the action's commit like #3404's transaction
- * zombies, and not at the pass (a held lane defers the run). Drained by the
- * lane's render entry the parking site pushed ahead of the new frame's
- * effects (cleanups before side effects), by `commitPendingNode` if a hold
- * commits the node first, or with the owner's death. While set the parked
- * frame is not a hold (the node is not queued or stamped for it), a
- * superseding pass disposes the never-shown live children on the spot, and a
- * lane-channel dirty on a member is cancelled (`laneZombie`). Effects only: a
- * memo's lane pass publishes an override (A17, #3479). */ const CONFIG_LANE_FRAME = 1 << 26;
+ * frame (#3662, #3698; A15 lane work and transaction work): a lane pass —
+ * on an effect or a memo alike — publishes into the lane's frame (an
+ * effect's run; a memo's derived override, A17), so the frame it replaces
+ * leaves the screen when the lane applies (A30) — not at the action's
+ * commit like #3404's transaction zombies, and not at the pass (a held lane
+ * defers the apply with the frame still displayed). Drained by the lane's
+ * render entry the parking site pushed ahead of the new frame's effects
+ * (cleanups before side effects), by `commitPendingNode` if a hold commits
+ * the node first, or with the owner's death. While set the parked frame is
+ * not a hold (the node is not queued or stamped for it — lane work never
+ * makes its node transaction work), a superseding pass disposes the
+ * never-shown live children on the spot, and a lane-channel dirty on a
+ * member is cancelled (`laneZombie`). Ruled 2026-09-28 (#3698): a pass is
+ * lane work or transaction work by its owner, never by node kind. #3662
+ * flagged effects only, and a memo's lane pass parked a transaction zombie
+ * that queued and stamped the memo as the action's pending node, so its
+ * next mainline recompute re-entered the hold. */ const CONFIG_LANE_FRAME = 1 << 26;
 
 /** In-flight async node whose inputs were PUBLISHED while it was pending: a
  * batch or transaction committed with the node still `STATUS_PENDING` (an

package/dist/prod/core/core.js

@@ -146,8 +146,8 @@ function recompute(e, n = false) {
     bumpNotifyEpoch();
     const t = e.je;
     // 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 i = !!(e.oe & REACTIVE_OPTIMISTIC_DIRTY);
     let u = null;
@@ -195,20 +195,30 @@ function recompute(e, n = 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.
+        // 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 (t === EFFECT_TRACKED || e.C & (CONFIG_HELD_CHILDREN | CONFIG_LANE_FRAME)) disposeChildren(e); else if (e.tn !== null || e.qe !== null) {
             markDisposal(e);
             const n = ext(e);
@@ -217,7 +227,7 @@ function recompute(e, n = false) {
             e.qe = null;
             e.tn = null;
             e.En = 0;
-            if (t && u) {
+            if (u) {
                 e.C |= CONFIG_LANE_FRAME;
                 findLane(u).dn[0].push(() => {
                     e.C &= ~CONFIG_LANE_FRAME;

package/dist/prod/core/optimistic.js

@@ -1,6 +1,6 @@
 import { NOT_PENDING, unwrapOverride, STATUS_UNINITIALIZED, REACTIVE_DIRTY, REACTIVE_CHECK, CONFIG_HAS_LANE, OVERRIDE_UNDEFINED, STATUS_PENDING, CONFIG_DERIVED_OVERRIDE, CONFIG_OPTIMISTIC, CONFIG_OVERRIDE_SUPERSEDED, EFFECT_RENDER, CONFIG_AUTHORITATIVE_OBSERVED, REACTIVE_MANUAL_WRITE, REACTIVE_OPTIMISTIC_DIRTY, LANE_RUN, EFFECT_USER } from "./constants.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";
 
@@ -25,17 +25,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?.Fe !== NOT_PENDING;
-    const t = i ? unwrapOverride(e.o?.Fe) : e.ce;
-    if (typeof n === "function") n = n(t);
-    const r = !!(e.h & STATUS_UNINITIALIZED) || 
+    const r = i ? unwrapOverride(e.o?.Fe) : e.ce;
+    if (typeof n === "function") n = n(r);
+    const t = !!(e.h & 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.xe || !e.xe(t, n);
-    if (!r) {
+    !!((e.oe ?? 0) & (REACTIVE_DIRTY | REACTIVE_CHECK)) || !e.xe || !e.xe(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
@@ -162,7 +162,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.h & STATUS_PENDING)) n.h &= ~STATUS_UNINITIALIZED;
-        const t = n.o?.Fe;
+        const r = n.o?.Fe;
         // 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
@@ -172,15 +172,15 @@ 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).Fe = r && !(n.C & CONFIG_OPTIMISTIC) ? undefined : NOT_PENDING;
+                const t = n.C & CONFIG_DERIVED_OVERRIDE;
+        ext(n).Fe = 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 {
                 insertSubs(n, true);
             }
         }
@@ -192,9 +192,9 @@ function resolveOptimisticNodes(e) {
     // transition that produced them (A19 — pending is a property of the data).
         for (let i = 0; i < n; i++) {
         const n = e[i];
-        if (n.o?.Ze || n.o?.He) GlobalQueue.ti(n);
-        const t = n.o?.kn;
-        if (t && (t.o?.Ze === n || t.o?.He === n)) GlobalQueue.ti(t);
+        if (n.o?.Ze || n.o?.He) GlobalQueue.ri(n);
+        const r = n.o?.kn;
+        if (r && (r.o?.Ze === n || r.o?.He === n)) GlobalQueue.ri(r);
     }
     e.splice(0, n);
 }
@@ -248,14 +248,14 @@ function resolveOptimisticNodes(e) {
         const n = e.o?.me;
         if (n) {
             const i = findLane(n);
-            const t = [ e ];
-            while (t.length) {
-                const e = t.pop();
+            const r = [ e ];
+            while (r.length) {
+                const e = r.pop();
                 const n = e.o?.me;
                 if (!n || findLane(n) !== i) continue;
                 e.o.me = undefined;
                 i.Qe.delete(e);
-                for (let n = e.u; n !== null; n = n.Ae) t.push(n.ge);
+                for (let n = e.u; n !== null; n = n.Ae) r.push(n.ge);
             }
         }
     }
@@ -297,7 +297,7 @@ function resolveOptimisticNodes(e) {
  * the optimistic path so it flushes ahead of the hold — but they answer for
  * their owner and snap at settlement (`_snapCompanions`), not here.
  */ function endOptimism(e) {
-    if (!e.Te || e.pe.length || !e.cn.length || e.ri.size || transitionBlocked(e)) return false;
+    if (!e.Te || e.pe.length || !e.cn.length || e.ti.size || transitionBlocked(e)) return false;
     for (const n of e.le.keys()) if (sourceObserved(e, n, e) && n.o?.ue?.has(n) && !resolveLane(n)) return false;
     let n = false;
     for (const i of e.cn) {
@@ -393,7 +393,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.xe || !e.xe(hasActiveOverride(e) ? unwrapOverride(e.o.Fe) : 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 (e._e === NOT_PENDING) queuePendingNode(e);
@@ -583,7 +625,7 @@ function cleanupCompletedLanes(e) {
 
 function trackOptimisticStore(e) {
     // After initTransition, globalQueue._batch IS activeTransition (same reference)
-    globalQueue.m.ri.add(e);
+    globalQueue.m.ti.add(e);
     schedule();
 }
 

package/dist/prod/core/owner.js

@@ -58,13 +58,13 @@ function disposeChildren(e, n = false, t) {
         // edge). Snap runs after the DISPOSED flag is set so the oracle reads
         // false, and notifies subscribers still watching the companion.
                 const n = e;
-        if (n.o?.Ze || n.o?.He) GlobalQueue.ti(n);
+        if (n.o?.Ze || n.o?.He) GlobalQueue.ri(n);
         // A firewall's leaves have no lifecycle of their own, so a companion on
         // one of them outlives its source the same way (INV-9's rationale). The
         // firewall knows which leaves carry companions (CONFIG_CHILD_COMPANIONS,
         // #3038): snap them with it — the snap retires a shadow whose firewall is
         // disposed (spec O5).
-                if (n.C & CONFIG_CHILD_COMPANIONS) n.o.Un.forEach(GlobalQueue.ti);
+                if (n.C & CONFIG_CHILD_COMPANIONS) n.o.Un.forEach(GlobalQueue.ri);
         // A pending reader parked in a transaction may be the only thing holding
         // it (#3372): its death is a completion event the transaction must be
         // re-judged for, and nothing else re-enters a parked transaction.