@solidjs/signals 2.0.0-rc.15 → 2.0.0-rc.16

package/dist/prod/store/store.js

@@ -1,6 +1,8 @@
 import { CONFIG_MANUAL_WRITE, CONFIG_OVERRIDE, CONFIG_HELD, $REFRESH, NOT_PENDING, STATUS_PENDING, STATUS_ERROR, EFFECT_RENDER, REACTIVE_RECOMPUTING_DEPS, REACTIVE_STAGED_READ, CONFIG_VERDICT, CONFIG_CHILDREN_FORBIDDEN, CONFIG_PROMOTED, REACTIVE_DIRTY, REACTIVE_CHECK } from "../core/constants.js";
 
-import { setSignal, isEqual, read, verdict, snapshotCaptureActive, captureWriteSnapshot, context, notePromotedWrite, untrack, slotSignal, stagedScreen, stagedRead } from "../core/core.js";
+import { writeHook, setSignal, isEqual, read, verdict, snapshotCaptureActive, captureWriteSnapshot, context, notePromotedWrite, untrack, slotSignal, stagedScreen, stagedRead } from "../core/core.js";
+
+import { signalHook } from "../core/identities.js";
 
 import { setSlotUnobserved } from "../core/graph.js";
 
@@ -8,7 +10,7 @@ import { getObserver } from "../core/owner.js";
 
 import { insertIntoHeap } from "../core/heap.js";
 
-import { txOf, flushTransaction, holdNode, joinFuture, insertSubs, schedule, passLane, globalQueue, queuePendingNode, GlobalQueue, joinPassTx, dirtyQueue } from "../core/scheduler.js";
+import { txOf, flushTransaction, holdNode, joinFuture, insertSubs, schedule, passLane, globalQueue, queuePendingNode, GlobalQueue, installStoreHooks, joinPassTx, dirtyQueue } from "../core/scheduler.js";
 
 import { lookupTarget, setLookup, $OWNER, isOwned, markDescendants, devAssertNeverUserMutation } from "./target.js";
 
@@ -166,7 +168,7 @@ function wrap(e, n = null, t = null, r = n?.fam ?? null) {
 // adoption swap raw identity without changing the logical value — only
 // changed leaves notify, R9).
 const slotNodeEquals = function(e, n) {
-    return isEqual(e, n) || sameLogicalSlot(this.lt, e, n);
+    return isEqual(e, n) || sameLogicalSlot(this.O, e, n);
 };
 
 /** The deep witness: the store decides when it notifies. */ const never = false;
@@ -204,7 +206,7 @@ function sameKey(e, n) {
 /** The container node's comparator: a staging is a backing (identity — a
  * pending backing is never "equal" to the committed one); a lane value is
  * an arrangement (`LaneView`), judged by the optimistic machinery. */ const containerEquals = function(e, n) {
-    return e === n || optHooks !== null && optHooks.arrangement(this.lt, e, n);
+    return e === n || optHooks !== null && optHooks.arrangement(this.O, e, n);
 };
 
 function sameLogicalSlot(e, n, t) {
@@ -217,8 +219,8 @@ function sameLogicalSlot(e, n, t) {
  * released at the commit that resolves it (`drainFolds`). */ const deferredReleases = new Set;
 
 function releaseSlot(e) {
-    const n = e.lt;
-    const t = e.ot;
+    const n = e.O;
+    const t = e.ze;
     if (t === $TRACK) {
         if (n.k === e) n.k = null;
     } else if (t === $DEEP) {
@@ -241,10 +243,14 @@ function releaseSlot(e) {
 // dispatches CONFIG_SLOT_NODE nodes here (graph.ts) instead of holding a
 // per-node closure in a per-node NodeExtension. A dropped node is
 // unreachable through the store — a fresh read makes a fresh node.
+// A staged write — or a lane's value (a guess, S4) — is state only the node
+// holds: its release waits for the commit that resolves it. So does a leaf of
+// a held container (#4146): a mainline write it carried is in the held
+// staging too, where it would read as the hold's until the landing.
+const slotKept = e => e.se !== NOT_PENDING || e.l & CONFIG_OVERRIDE || e.O.k?.l & CONFIG_HELD;
+
 setSlotUnobserved(e => {
-    // A staged write — or a lane's value (a guess, S4) — is state only the
-    // node holds: defer the release to the commit that resolves it.
-    if (e.Oe !== NOT_PENDING || e.i & CONFIG_OVERRIDE) deferredReleases.add(e); else releaseSlot(e);
+    if (slotKept(e)) deferredReleases.add(e); else releaseSlot(e);
 });
 
 /** A node born while its container has a staging is born from the two
@@ -252,19 +258,19 @@ setSlotUnobserved(e => {
  * pending one — and held by the container's transaction when the container
  * is held (#3706: the unit of the hold is the key — a key the batch left
  * unchanged stages nothing and holds no one). */ function bornStaged(e, n, t, r) {
-    if (n.ye && n.ye(n.Ae, t)) return;
+    if (n.xe && n.xe(n.Ie, t)) return;
     queuePendingNode(n);
-    n.Oe = t;
+    n.se = t;
     const i = e.k;
     if (i === null) return;
  // a node-less staging holds nothing (`stageOn`)
     // Held by the container's transaction only for a key the HELD staging
     // changed — a mainline layer's change above it stages mainline. (A
     // container carrying a guess is a lane's: the flush's park decides.)
-        if ((i.i & (CONFIG_HELD | CONFIG_OVERRIDE)) === CONFIG_HELD && heldKeyChanged(e, r)) holdNode(n, txOf(i));
+        if ((i.l & (CONFIG_HELD | CONFIG_OVERRIDE)) === CONFIG_HELD && heldKeyChanged(e, r)) holdNode(n, txOf(i));
     // A28 (4): a batch written inside a creation-time pass is promoted — its
     // late-materialized leaf with it.
-        if (i.i & CONFIG_PROMOTED) notePromotedWrite(n);
+        if (i.l & CONFIG_PROMOTED) notePromotedWrite(n);
 }
 
 function getNode(e, n, 
@@ -314,8 +320,8 @@ function getHasNode(e, n) {
         // pending backing staged — so whoever asked for it reads the frame it
         // would have read had the node been there from the write.
                 if (e.pb !== null && !directCommit) {
-            n.Ae = preBatch(e);
-            n.Oe = e.pb;
+            n.Ie = preBatch(e);
+            n.se = e.pb;
             queuePendingNode(n);
         }
     }
@@ -331,11 +337,11 @@ function getHasNode(e, n) {
  * staging: nothing allocates, nothing is swept at the commit (dbmon's tick
  * re-created, queued, swept and dropped ~7000 container nodes). If the
  * flush parks, the seam materializes and holds the node then
- * (`_storePark`) — the one case the staging home exists for. */ function stageOn(e, n) {
-    if (e.k === null && passLane === null && (context === null || globalQueue.X) && !deriveHolds(e)) return;
+ * (`storeParkHook`) — the one case the staging home exists for. */ function stageOn(e, n) {
+    if (e.k === null && passLane === null && (context === null || globalQueue.q) && !deriveHolds(e)) return;
     const t = getContainerNode(e);
-    if (t.Oe === NOT_PENDING) queuePendingNode(t);
-    t.Oe = n;
+    if (t.se === NOT_PENDING) queuePendingNode(t);
+    t.se = n;
     // A28 (4): a write issued inside a pass outside a flush (a creation-time
     // derive) is promoted at the pass's end — the batch with it.
         if (context !== null) notePromotedWrite(t);
@@ -345,10 +351,10 @@ function getHasNode(e, n) {
 /** The projection's derive is held by a transaction and this is its own
  * write (not a user setter's): the staging is the derive's (`holdWithDerive`). */ function deriveHolds(e) {
     const n = e.fam?.node;
-    return n != null && !userWrite && (n.i & CONFIG_HELD) !== 0;
+    return n != null && !userWrite && (n.l & CONFIG_HELD) !== 0;
 }
 
-GlobalQueue.Tn = e => {
+const storePark = e => {
     for (let n = 0; n < foldList.length; n++) {
         const t = foldList[n];
         if (t.k === null && t.pb !== null) holdNode(getContainerNode(t), e);
@@ -376,9 +382,9 @@ function bumpDeep(e) {
     // on the guess (`laneWrite` → `supersede`, judged by `containerEquals`);
     // otherwise the structural readers are walked (the staging is already on
     // the node; the comparator is the store's, done).
-    if (e.i & CONFIG_OVERRIDE) setSignal(e, n); else {
-        if (e.i & CONFIG_HELD) joinFuture(txOf(e));
-        if (snapshotCaptureActive) captureWriteSnapshot(e, e.Ae);
+    if (e.l & CONFIG_OVERRIDE) setSignal(e, n); else {
+        if (e.l & CONFIG_HELD) joinFuture(txOf(e));
+        if (snapshotCaptureActive) captureWriteSnapshot(e, e.Ie);
         insertSubs(e);
         schedule();
     }
@@ -470,7 +476,7 @@ const plainProto = e => {
     if (e.kc > OVERLAY_REBUILD_MAX_KEYS) return false;
     if (e.del !== null && e.del.size !== 0) return true;
     const t = e.wk;
-    if (t !== null && t !== WK_ALL && t.size <= OVERLAY_REBUILD_MIN_ADDS) return false;
+    if (t !== null && t !== WK_ALL && t.u === undefined && t.size <= OVERLAY_REBUILD_MIN_ADDS) return false;
     const r = e.v;
     let i = 0;
     for (const e of Reflect.ownKeys(n)) if (!hasOwn.call(r, e) && ++i > OVERLAY_REBUILD_MIN_ADDS) return true;
@@ -490,7 +496,7 @@ const plainProto = e => {
     e.pb = t;
     e.ovl = false;
     // The staging IS the pending backing: re-point the container node.
-        if (e.k !== null && e.k.Oe === n) e.k.Oe = t;
+        if (e.k !== null && e.k.se === n) e.k.se = t;
     return t;
 }
 
@@ -511,7 +517,7 @@ const plainProto = e => {
         // mainline setter mid-hold publishes mainline; the held keys stay held).
         n = e.pb = cloneRaw(n, e);
         const t = e.k;
-        if (t !== null && !(t.i & CONFIG_HELD)) t.Oe = n;
+        if (t !== null && !(t.l & CONFIG_HELD)) t.se = n;
     } else if (n === null) {
         const t = e.v;
         if (!directCommit) queueFold(e);
@@ -590,7 +596,7 @@ const plainProto = e => {
     } else r = e.v;
     if (directCommit) {
         e.pb = null;
-        if (e.k !== null) e.k.Ae = n;
+        if (e.k !== null) e.k.Ie = n;
     } else {
         // Eager (INTERNALS §3): the backing swaps now — handlers read the
         // adopted object before the flush — while the container node, when
@@ -686,7 +692,7 @@ let foldIndex = null;
             if (r.pb === null) continue;
  // folded already (a direct commit)
                         const i = r.k;
-            if (i !== null && i.Oe !== NOT_PENDING) {
+            if (i !== null && i.se !== NOT_PENDING) {
                 // held: commits with its hold
                 foldList.push(r);
                 foldOlds.push(n[t]);
@@ -697,7 +703,7 @@ let foldIndex = null;
     }
     if (deferredReleases.size !== 0) {
         for (const e of deferredReleases) {
-            if (e.Oe === NOT_PENDING && !(e.i & CONFIG_OVERRIDE) && e.t === null) {
+            if (e.o === null && !slotKept(e)) {
                 deferredReleases.delete(e);
                 releaseSlot(e);
             }
@@ -708,28 +714,28 @@ let foldIndex = null;
 /** Core asks: is a slot node's truth in flight? Its family's derive is —
  * lanes (A17, #2864: a guess mid-refetch stands in for the flight) and
  * marks (an ambient `affects()` over a declared reload lives to the
- * landing) read it. */ GlobalQueue.C = e => {
-    const n = e.lt?.fam;
-    return n != null && n.node !== null && (n.node.S & STATUS_PENDING) !== 0;
+ * landing) read it. */ GlobalQueue.k = e => {
+    const n = e.O?.fam;
+    return n != null && n.node !== null && (n.node.m & STATUS_PENDING) !== 0;
 };
 
 /** Core asks (lanes.ts `covered`): the value a slot node's guess covered.
  * A chained link's committed value is the inner store's at the last
  * read-through — refreshed here, since a guess served the reads since
- * (#3672: the revert compares against the base's live value). */ GlobalQueue.Nn = e => {
-    const n = e.lt;
+ * (#3672: the revert compares against the base's live value). */ GlobalQueue.fn = e => {
+    const n = e.O;
     if (n.ch) {
-        const t = e.ot;
+        const t = e.ze;
         const r = n.v;
-        if (n.h !== null && n.h[t] === e) e.Ae = untrack(() => t in r); else if (n.n !== null && n.n[t] === e) e.Ae = untrack(() => unwrapValue(r[t]));
+        if (n.h !== null && n.h[t] === e) e.Ie = untrack(() => t in r); else if (n.n !== null && n.n[t] === e) e.Ie = untrack(() => unwrapValue(r[t]));
     }
-    return e.Ae;
+    return e.Ie;
 };
 
-GlobalQueue.Sn = () => {
+installStoreHooks(storePark, () => {
     drainFolds();
     optHooks?.sweep();
-};
+});
 
 /** The store half of `affects()` (store/affects.ts) makes its marks' nodes
  * and walks records through these: it never imports the engine. */ GlobalQueue.no = getNode;
@@ -762,7 +768,7 @@ function runDirect(e) {
                     // the adopted object (shared ownership — never cloned).
                     e.pb = null;
                     e.wk = null;
-                } else if (e.ovl && (e.v !== n || !overlayRebuilds(e, r) && t?.m?.Le !== n)) {
+                } else if (e.ovl && (e.v !== n || !overlayRebuilds(e, r) && t?.T?.Pe !== n)) {
                     // 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
@@ -776,8 +782,8 @@ function runDirect(e) {
                     const t = e.v;
                     const i = e.wk;
                     if (i !== null && i !== WK_ALL) {
-                        for (const e of i) {
-                            if (hasOwn.call(r, e)) copyOwn(t, r, e); else delete t[e];
+                        for (let e = i; e !== undefined; e = e.u) for (const n of e) {
+                            if (hasOwn.call(r, n)) copyOwn(t, r, n); else delete t[n];
                         }
                     } else {
                         for (const e of Reflect.ownKeys(r)) {
@@ -804,7 +810,7 @@ function runDirect(e) {
                 // subscribes to was a transient staging home (INTERNALS §5: an
                 // observer-less write holds a transient record until the fold,
                 // discarded with it) — gone with the batch.
-                if (t.t === null) e.k = null; else if (t.Ae instanceof LaneView) t.Ae.base = e.v; else t.Ae = e.v;
+                if (t.o === null) e.k = null; else if (t.Ie instanceof LaneView) t.Ie.base = e.v; else t.Ie = e.v;
             }
             if (e.v !== n && e.u) {
                 const t = parentSlotKey(e, n);
@@ -831,9 +837,9 @@ function runDirect(e) {
 
 function heldDerivation(e, n, t) {
     if (e.fam === null || !userWrite) return false;
-    if (n !== undefined) return (n.i & (CONFIG_HELD | CONFIG_MANUAL_WRITE)) === CONFIG_HELD && txOf(n) !== flushTransaction;
+    if (n !== undefined) return (n.l & (CONFIG_HELD | CONFIG_MANUAL_WRITE)) === CONFIG_HELD && txOf(n) !== flushTransaction;
     const r = e.k;
-    return r !== null && (r.i & CONFIG_HELD) !== 0 && txOf(r) !== flushTransaction && heldKeyChanged(e, t);
+    return r !== null && (r.l & CONFIG_HELD) !== 0 && txOf(r) !== flushTransaction && heldKeyChanged(e, t);
 }
 
 /** Setter exit: one node write per changed observed key (the leaves stage
@@ -863,7 +869,10 @@ function heldDerivation(e, n, t) {
     // value can change when ANY key is written), or a non-plain prototype
     // (class instances: prototype getters derive from arbitrary fields).
     // Overlay pbs chain to the COMMITTED object (#3044) — plainness is the
-    // committed container's prototype, not the overlay's.
+    // committed container's prototype, not the overlay's. THIS setter's keys
+    // only (D-8, #3743): a key an earlier setter of the batch wrote and this
+    // one did not is no second proposal — its node was told then, and telling
+    // a held node its unchanged value again would join this tick to the hold.
         const i = e.wk;
     const o = i === WK_ALL || e.a === true || !plainProto(e.ovl ? e.v : n) ? null : i;
     if (e.fam !== null && !heldDerivationHit && o !== null) for (const n of o) if (heldDerivation(e, r?.[n], n)) {
@@ -898,9 +907,9 @@ function heldDerivation(e, n, t) {
                 // The derive's write is a derivation; a user setter's is a proposal
                 // (A34 (3)'s discriminator).
                 if (!userWrite) {
-                    i.i &= ~CONFIG_MANUAL_WRITE;
+                    i.l &= ~CONFIG_MANUAL_WRITE;
                     holdWithDerive(e, i);
-                } else i.i |= CONFIG_MANUAL_WRITE;
+                } else i.l |= CONFIG_MANUAL_WRITE;
             }
         }
     }
@@ -931,7 +940,7 @@ function heldDerivation(e, n, t) {
     // container carrying an arrangement guess is told whether or not anyone
     // subscribes: the write is a landing on the guess (`notifyContainer`).
         const u = e.k;
-    if (u !== null && (u.t !== null || u.i & CONFIG_OVERRIDE)) {
+    if (u !== null && (u.o !== null || u.l & CONFIG_OVERRIDE)) {
         let r;
         if (e.ovl) {
             r = e.del !== null && e.del.size !== 0;
@@ -1033,7 +1042,7 @@ function hasAccessorFlag(e) {
         for (const i of Reflect.ownKeys(r)) if (e || i in n !== i in t) setSignal(r[i], i in t);
     }
     const i = e.k;
-    if (i !== null && (i.t !== null || i.i & CONFIG_OVERRIDE)) {
+    if (i !== null && (i.o !== null || i.l & CONFIG_OVERRIDE)) {
         const e = Array.isArray(t) && Array.isArray(n) ? arrayStructureChanged(n, t) : membershipChanged(n, t);
         if (e) notifyContainer(i, t);
     }
@@ -1090,7 +1099,7 @@ function inDraft(e) {
  * "adoption is eager by contract" — and the node keeps the frame committed
  * readers under a hold still see), `t.v` otherwise. */ function committed(e) {
     const n = e.k;
-    if (n !== null) return n.Oe !== NOT_PENDING ? asBacking(n.Ae) : e.v;
+    if (n !== null) return n.se !== NOT_PENDING ? asBacking(n.Ie) : e.v;
     // A node-less staging (`stageOn`): the fold queue remembers the frame.
         return e.pb !== null ? preBatch(e) : e.v;
 }
@@ -1102,8 +1111,8 @@ function inDraft(e) {
  * committed frame. */ function stagingReader() {
     let e = context;
     if (e === null) return null;
-    if (e.$e) e = e.et ?? null;
-    return e === null || e.i & CONFIG_CHILDREN_FORBIDDEN ? null : e;
+    if (e.je) e = e.Ye ?? null;
+    return e === null || e.l & CONFIG_CHILDREN_FORBIDDEN ? null : e;
 }
 
 /** The backing a read serves (RUL-1, signal parity): the draft and the write
@@ -1141,10 +1150,10 @@ function inDraft(e) {
         if (writeOverride && !userWrite) {
             const t = n !== undefined ? e.n?.[n] : undefined;
             if (t !== undefined) {
-                if ((t.i & (CONFIG_HELD | CONFIG_OVERRIDE)) === CONFIG_HELD) joinPassTx(txOf(t));
+                if ((t.l & (CONFIG_HELD | CONFIG_OVERRIDE)) === CONFIG_HELD) joinPassTx(txOf(t));
             } else {
                 const t = e.k;
-                if (t !== null && (t.i & (CONFIG_HELD | CONFIG_OVERRIDE)) === CONFIG_HELD && (n === undefined || heldKeyChanged(e, n))) joinPassTx(txOf(t));
+                if (t !== null && (t.l & (CONFIG_HELD | CONFIG_OVERRIDE)) === CONFIG_HELD && (n === undefined || heldKeyChanged(e, n))) joinPassTx(txOf(t));
             }
         }
         return r;
@@ -1156,9 +1165,9 @@ function inDraft(e) {
     // it).
         if (n !== undefined) {
         const t = e.n?.[n];
-        if (t !== undefined && t.i & CONFIG_OVERRIDE) return committed(e);
+        if (t !== undefined && t.l & CONFIG_OVERRIDE) return committed(e);
     }
-    const o = i !== null && (i.i & CONFIG_HELD) !== 0;
+    const o = i !== null && (i.l & CONFIG_HELD) !== 0;
     // A held container: the hold's unit is the key (#3706). A key the HELD
     // staging left unchanged reads the ambient view — a mainline layer's
     // write above the hold publishes mainline (#3688, #3612); a key it
@@ -1176,7 +1185,7 @@ function inDraft(e) {
         // probe) judges the container like any node — for a key the batch
         // changed; an unchanged key is committed and final (A22: pending is per
         // key). A held container's committed frame is the node's.
-                if (verdict === null || !o && n !== undefined && !keyChanged(e, n, t)) return o ? asBacking(i.Ae) : e.v;
+                if (verdict === null || !o && n !== undefined && !keyChanged(e, n, t)) return o ? asBacking(i.Ie) : e.v;
         return i === null ? committed(e) : asBacking(read(i));
     }
     // A pass reading a key the batch left unchanged: the same value in both
@@ -1193,13 +1202,13 @@ function inDraft(e) {
         // frames, a changed one is what the mark already stands for. The
         // per-key question is asked once per pass, not once per key (a
         // `mapArray` over 1k shifted rows asked it 1k times).
-        if (l.R & REACTIVE_STAGED_READ && !(l.i & (CONFIG_VERDICT | CONFIG_CHILDREN_FORBIDDEN))) return r;
+        if (l.R & REACTIVE_STAGED_READ && !(l.l & (CONFIG_VERDICT | CONFIG_CHILDREN_FORBIDDEN))) return r;
         if (n !== undefined && !keyChanged(e, n, t)) return committed(e);
         // A node-less staging (`stageOn`): what `read()` of its node would do
         // for this pass — a verdict reader sees the screen, any other derives
         // from the staging and is marked as having read it.
                 if (i === null) {
-            if (l.i & CONFIG_VERDICT && stagedScreen(l)) return committed(e);
+            if (l.l & CONFIG_VERDICT && stagedScreen(l)) return committed(e);
             stagedRead(l);
             return r;
         }
@@ -1209,7 +1218,7 @@ function inDraft(e) {
 
 /** Did the HELD staging (the container node's, not a mainline layer above
  * it) change `key`? */ function heldKeyChanged(e, n, t = true) {
-    return changedBetween(e, e.k.Ae, e.k.Oe, n, t) && !adoptChild(e, n);
+    return changedBetween(e, e.k.Ie, e.k.se, n, t) && !adoptChild(e, n);
 }
 
 /** The values of a held frame, built once per frame: neither the committed
@@ -1236,14 +1245,14 @@ function rawsOf(e) {
  * `version` holds. A record's keys pair by name; an array's by the family's
  * key — without a family the pairing is not known here and the hold stands. */ function adoptChild(e, n) {
     const t = e.k;
-    const r = asBacking(t.Ae);
+    const r = asBacking(t.Ie);
     const i = r[n];
-    const o = t.Oe[n];
+    const o = t.se[n];
     const l = Array.isArray(r) ? e.fam?.key : null;
     if (e.s || l === undefined || !sameRow(i, o, l) || !isWrappable(i) || !isWrappable(o) || Array.isArray(i) !== Array.isArray(o) || lookupTarget(i, e.fam) !== undefined || lookupTarget(o, e.fam) !== undefined || 
     // A raw in both frames (the same objects swapped or reordered) is its
     // own row: pairing it with another would alias the two after the commit.
-    rawsOf(r).has(o) || rawsOf(t.Oe).has(i)) return false;
+    rawsOf(r).has(o) || rawsOf(t.se).has(i)) return false;
     // A raw-marked value wraps to itself, a proxy to its own target: neither
     // is a fresh target around `ov`.
         const u = wrap(i, e, n)[$TARGET];
@@ -1254,7 +1263,7 @@ function rawsOf(e) {
 }
 
 /** A family target's unheld staging, read with no pass (a handler). */ function familyAhead(e) {
-    return e.fam !== null && context === null && !(e.k !== null && e.k.i & CONFIG_HELD);
+    return e.fam !== null && context === null && !(e.k !== null && e.k.l & CONFIG_HELD);
 }
 
 /** Did this batch change `key` — value (slot equality), presence, and (for
@@ -1288,7 +1297,7 @@ function changedBetween(e, n, t, r, i) {
  * tracked or not, applies the hold and A28 rules a signal's read does. A
  * projection's unheld staging is ahead for a handler (`familyAhead`). */ function nodeValue(e, n, t) {
     let r = read(e);
-    if (e.Oe !== NOT_PENDING && !(e.i & CONFIG_HELD) && context === null && t.fam !== null) r = e.Oe;
+    if (e.se !== NOT_PENDING && !(e.l & CONFIG_HELD) && context === null && t.fam !== null) r = e.se;
     return r === FORCE ? n : r;
 }
 
@@ -1308,8 +1317,8 @@ function changedBetween(e, n, t, r, i) {
             if (l) {
                 // The link's committed value follows the inner store's (what a lane
                 // over it covers — its reveal and revert compare against it, S4).
-                i.Ae = t;
-                if (i.i & CONFIG_OVERRIDE) u = n;
+                i.Ie = t;
+                if (i.l & CONFIG_OVERRIDE) u = n;
             } else u = n;
         }
     }
@@ -1330,7 +1339,7 @@ function changedBetween(e, n, t, r, i) {
 }
 
 /** Is `n` among `c`'s dependencies (any pass's — a kept tail included)? */ function linkedTo(e, n) {
-    for (let t = e.p; t !== null; t = t._) if (t.I === n) return true;
+    for (let t = e.C; t !== null; t = t.G) if (t.S === n) return true;
     return false;
 }
 
@@ -1349,7 +1358,7 @@ function changedBetween(e, n, t, r, i) {
     // reader of a memo would — linked, so it re-runs at the landing (the
     // next settled pass pulls without linking and the stale link trims), a
     // verdict reader registered, a tracked pass suspended.
-        if (n.S & (STATUS_PENDING | STATUS_ERROR)) {
+        if (n.m & (STATUS_PENDING | STATUS_ERROR)) {
         // A render effect outside the flight's own flush is the frame, not a
         // derivation: it keeps what it shows and learns of the landing from the
         // leaves the landing changes (unchanged leaves say nothing — it is not a
@@ -1360,7 +1369,7 @@ function changedBetween(e, n, t, r, i) {
         // release the hold with the flight still up. An errored derive has no
         // landing to learn of: the error is what the frame shows.
         const t = context;
-        if (t !== null && t.u === EFFECT_RENDER && !(n.S & STATUS_ERROR) && n.i & CONFIG_HELD && flushTransaction !== txOf(n) && !linkedTo(t, n)) return;
+        if (t !== null && t.i === EFFECT_RENDER && !(n.m & STATUS_ERROR) && n.l & CONFIG_HELD && flushTransaction !== txOf(n) && !linkedTo(t, n)) return;
         // An optimistic family carrying guesses that stand in for the flight
         // (A17): the guesses are the display — a reader is served the leaves
         // (committed plus the guesses) and does not suspend on the derive; a
@@ -1368,7 +1377,7 @@ function changedBetween(e, n, t, r, i) {
         // up). The family's, not the target's: the edit stands in for the one
         // flight the family has.
                 const r = e.fam.overlaid;
-        if (verdict === null && n.S & STATUS_PENDING && r !== undefined && r.size !== 0) return;
+        if (verdict === null && n.m & STATUS_PENDING && r !== undefined && r.size !== 0) return;
         read(n);
     } else untrack(() => read(n));
 }
@@ -1381,12 +1390,12 @@ function changedBetween(e, n, t, r, i) {
  * classification, as core reads it — `heldNotFinal`). */ function holdWithDerive(e, n) {
     const t = e.fam?.node;
     if (t !== undefined && t !== null && !userWrite && // the derive's own write (its draft or landing), not a user setter's
-    t.i & CONFIG_HELD && n.Oe !== NOT_PENDING && 
+    t.l & CONFIG_HELD && n.se !== NOT_PENDING && 
     // A node carrying a guess is the lane's: its staging is the truth beneath
     // the guess (`setSignal` → `laneWrite`), never re-homed by the store.
-    !(n.i & (CONFIG_HELD | CONFIG_OVERRIDE))) {
+    !(n.l & (CONFIG_HELD | CONFIG_OVERRIDE))) {
         holdNode(n, txOf(t));
-        n.m.ke = t.m.ke;
+        n.T.Ve = t.T.Ve;
     }
 }
 
@@ -1429,6 +1438,22 @@ function changedBetween(e, n, t, r, i) {
 
 // ---------------------------------------------------------------------------
 // traps
+/** A trap write: the target is told at the setter's exit, the key recorded
+ * in this setter's `wk`. A setter's first write to a target still staged by
+ * an earlier setter of the batch opens a set of its own (the notify visits
+ * it, D-8) and chains the earlier one behind for the fold's union. */ function touch(e, n) {
+    let t = e.wk;
+    if (!pendingNotify.has(e)) {
+        pendingNotify.add(e);
+        if (t !== null && t !== WK_ALL) {
+            t = new Set;
+            t.u = e.wk;
+            e.wk = t;
+        }
+    }
+    if (t !== WK_ALL) (e.wk ??= new Set).add(n);
+}
+
 const traps = {
     get(e, n, t) {
         // One typeof gates every brand-symbol compare off the hot string path.
@@ -1472,7 +1497,7 @@ const traps = {
                 const r = e.n?.[n];
         if (writeScopes === null && !writeOverride) {
             const t = r;
-            if (t !== undefined && t.acc !== true && (!e.ch || t.i & CONFIG_OVERRIDE)) {
+            if (t !== undefined && t.acc !== true && (!e.ch || t.l & CONFIG_OVERRIDE)) {
                 const r = nodeValue(t, undefined, e);
                 if (r === null || typeof r !== "object") return r;
                 if (e.s) return serveShallow(e, n, r);
@@ -1567,9 +1592,9 @@ const traps = {
                 const i = read(r);
                 if (!e.ch || t !== e.v) return !!i;
                 const o = n in t;
-                r.Ae = o;
+                r.Ie = o;
  // the link follows the inner store (S4)
-                                if (r.i & CONFIG_OVERRIDE) return !!i;
+                                if (r.l & CONFIG_OVERRIDE) return !!i;
                 return o;
             } else if (optRead(e)) {
                 const t = optHooks.has(e, n);
@@ -1604,7 +1629,7 @@ const traps = {
             const t = getHasNode(e, n);
             const r = read(t);
             o = readSource(e, n, true);
-            if (!r && (!e.ch || t.i & CONFIG_OVERRIDE || !(n in o))) return undefined;
+            if (!r && (!e.ch || t.l & CONFIG_OVERRIDE || !(n in o))) return undefined;
         } else o = readSource(e, n, true);
         let l;
         if (!i && optRead(e)) {
@@ -1625,15 +1650,22 @@ const traps = {
  // pollution guard (core R30)
                 const o = e.s ? t : unwrapValue(t);
         const l = ensurePB(e);
-        pendingNotify.add(e);
+        // #4146 (R1: node existence is unobservable; #3706: the hold's unit is
+        // the key): a user setter writing a key a HELD container's staging left
+        // unchanged would write it into the held staging — read as the hold's
+        // until its landing, while the same key with a leaf (a live reader)
+        // publishes at the flush. The key gets its leaf first, born from the two
+        // frames (`bornStaged`: a key the hold left unchanged — or added — is
+        // unstaged and held by no one; a key the hold changed is born held, A34
+        // (1)), and the write stages on it (A28; a write by the holder joins it,
+        // A34) — as it would with a reader's leaf. Kept while the container is
+        // held (`deferredReleases`).
+                if (userWrite && e.k?.l & CONFIG_HELD) deferredReleases.add(getNode(e, n));
         if (Array.isArray(l)) {
-            if (n === "length") e.wk = WK_ALL; else if (e.wk !== WK_ALL) {
-                const t = e.wk ??= new Set;
-                t.add(n);
-                t.add("length");
-            }
+            touch(e, n);
+            if (n === "length") e.wk = WK_ALL; else touch(e, "length");
         } else {
-            if (e.wk !== WK_ALL) (e.wk ??= new Set).add(n);
+            touch(e, n);
             if (!(n in l)) e.kc++;
         }
         if (UNSAFE_KEYS.has(n)) {
@@ -1671,8 +1703,7 @@ const traps = {
         };
         const o = ensurePB(e);
         if (e.a || !(t.enumerable && t.writable && t.configurable)) e.sc = 1;
-        pendingNotify.add(e);
-        if (e.wk !== WK_ALL) (e.wk ??= new Set).add(n);
+        touch(e, n);
         Object.defineProperty(o, n, t);
         if (e.del !== null) e.del.delete(n);
         if (i) notifyWrites(e);
@@ -1683,10 +1714,22 @@ const traps = {
         const r = !t && writeOverride;
         if (!t && !r) return true;
         const i = ensurePB(e);
-        pendingNotify.add(e);
-        if (e.wk !== WK_ALL) (e.wk ??= new Set).add(n);
-        delete i[n];
-        if (e.ovl && hasOwn.call(e.v, n)) (e.del ??= new Set).add(n);
+        touch(e, n);
+        // The key count (`kc`, the overlay gate and the rebuild cap) follows a
+        // delete the way it follows an add: an own key of the draft leaving — a
+        // clone's key, or an overlay's own add — is one fewer now. An overlay's
+        // override of a committed key is the exception: the committed key's
+        // deletion is recorded in `del` and counted at the rebuild, as before.
+        // Without the decrement the natural "delete the old key, set the new
+        // one" shape drifted the count up by one per write until a three-key
+        // object crossed the overlay threshold and paid a rebuild on every
+        // commit after.
+                const o = e.ovl && hasOwn.call(e.v, n);
+        if (hasOwn.call(i, n)) {
+            delete i[n];
+            o || e.kc--;
+        }
+        if (o) (e.del ??= new Set).add(n);
         if (r) notifyWrites(e);
         return true;
     }
@@ -1697,11 +1740,12 @@ const traps = {
  * to the key's presence node or a later add never re-runs it. */ function observerHoldsContainer(e, n) {
     const t = e.k;
     if (t === null) return false;
-    const r = t.Ye;
-    return r !== null && r.l === n && (!(n.R & REACTIVE_RECOMPUTING_DEPS) || r.Pe === n.pe);
+    const r = t.ve;
+    return r !== null && r.u === n && (!(n.R & REACTIVE_RECOMPUTING_DEPS) || r.Te === n.Ne);
 }
 
 function storeSetter(e, n, t = true) {
+    if (writeHook !== null) writeHook(e);
     const r = e[$TARGET];
     const i = writeScopes;
     writeScopes = new Set;
@@ -1755,6 +1799,8 @@ function storeSetter(e, n, t = true) {
 function createStore(e, n) {
     const t = n?.shallow === true;
     const r = wrap(e);
+    // Dependency edges (store/edges.ts): the root is named like a plain signal.
+        if (signalHook !== null) signalHook(r[$TARGET]);
     if (t) {
         r[$TARGET].s = true;
         markRawIngest(e);
@@ -1885,7 +1931,7 @@ function snapshotWalk(e, n, t) {
         // R27: a snapshot sees the batch's pending backing — a held one (another
         // transaction's future) only from its own draft.
                 let o = i.v;
-        if (i.pb !== null && (inDraft(i) || writeOverride || i.k === null || !(i.k.i & CONFIG_HELD))) {
+        if (i.pb !== null && (inDraft(i) || writeOverride || i.k === null || !(i.k.l & CONFIG_HELD))) {
             if (i.ovl) materializePB(i);
             o = i.pb;
         }

package/dist/types/affects-marks.d.ts

@@ -0,0 +1,14 @@
+import type { Computed, Signal } from "./core/types.js";
+export type Marked = Signal<any> | Computed<any>;
+/** The verdict readers downstream of `node` — through derivations, stopping
+ * at effects — re-derive: the mark's one notification (a probe's answer
+ * changed with no value notifying anyone). Truth readers (`until`, the
+ * `refresh` waiter) too, which a lagging flight parked (deferred.ts) — but
+ * not through a derived store, whose leaves change only once its derive
+ * re-runs: they re-derive at that write. */
+export declare function repoll(node: Marked, seen?: Set<Computed<any>>, readers?: number): void;
+/** One mark on `node`. The declarer repolls once its bookkeeping is done. */
+export declare function mark(node: Marked): void;
+/** Drops one mark from `node`: true when it was the last — the node's
+ * verdict readers have re-derived. */
+export declare function unmark(node: Marked): boolean;