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

package/dist/observe/store/store.js

@@ -2,7 +2,7 @@ import { attrHooks } from "../core/attribution-hooks.js";
 
 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, context, notePromotedWrite, untrack, slotSignal, stagedScreen, stagedRead } from "../core/core.js";
+import { setSignal, isEqual, read, verdict, snapshotCaptureActive, captureWriteSnapshot, context, notePromotedWrite, untrack, slotSignal, stagedScreen, stagedRead } from "../core/core.js";
 
 import { registerGraph } from "../core/dev.js";
 
@@ -16,6 +16,8 @@ import { txOf, flushTransaction, holdNode, joinFuture, insertSubs, schedule, pas
 
 import { lookupTarget, storeOwners, setLookup, $OWNER, isOwned, markDescendants, devAssertNeverUserMutation } from "./target.js";
 
+import { optHooks, affectsHooks } from "./hooks.js";
+
 import { $TARGET, rawValuesUsed, isRawValue, isWrappable, markRawIngest, writeOverride, markRawOne, $RECORD, $PROXY, $TRACK } from "./types.js";
 
 export { markRaw } from "./types.js";
@@ -49,18 +51,7 @@ export { markRaw } from "./types.js";
  * Perf contracts (plan sec. 31.4): lazy nodes; one literal per node; O(written) per
  * setter (`wk`); overlay drafts for large plain records; no new named
  * fields on array targets; zero allocation for adopted-but-unread objects.
- */ let optHooks = null;
-
-function installOptHooks(e) {
-    optHooks = e;
-}
-
-let affectsHooks = null;
-
-function installAffectsHooks(e) {
-    affectsHooks = e;
-}
-
+ */
 /** Key of the deep-witness slot node (never a user key). */ const $DEEP = Symbol(0);
 
 // ---------------------------------------------------------------------------
@@ -247,7 +238,7 @@ function releaseSlot(e) {
 /** A node was born on `target`: a family target enters the live index. */ function noteNode(e, n, t) {
     if (e.fam !== null) e.fam.live.add(e);
     markDescendants(e);
-    if (affectsHooks !== null) affectsHooks.born(e, n, t);
+    if (affectsHooks !== null) affectsHooks.fo(e, n, t);
 }
 
 // Shared slot-node release handler: registered once; the core sweep
@@ -257,7 +248,7 @@ function releaseSlot(e) {
 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.Ae !== NOT_PENDING || e.u & CONFIG_OVERRIDE) deferredReleases.add(e); else releaseSlot(e);
+    if (e.Oe !== NOT_PENDING || e.i & CONFIG_OVERRIDE) deferredReleases.add(e); else releaseSlot(e);
 });
 
 /** A node born while its container has a staging is born from the two
@@ -265,19 +256,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.tn && n.tn(n.pe, t)) return;
+    if (n.en && n.en(n.Ae, t)) return;
     queuePendingNode(n);
-    n.Ae = t;
+    n.Oe = t;
     const o = e.k;
     if (o === 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 ((o.u & (CONFIG_HELD | CONFIG_OVERRIDE)) === CONFIG_HELD && heldKeyChanged(e, r)) holdNode(n, txOf(o));
+        if ((o.i & (CONFIG_HELD | CONFIG_OVERRIDE)) === CONFIG_HELD && heldKeyChanged(e, r)) holdNode(n, txOf(o));
     // A28 (4): a batch written inside a creation-time pass is promoted — its
     // late-materialized leaf with it.
-        if (o.u & CONFIG_PROMOTED) notePromotedWrite(n);
+        if (o.i & CONFIG_PROMOTED) notePromotedWrite(n);
 }
 
 function getNode(e, n, 
@@ -339,8 +330,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.pe = preBatch(e);
-            n.Ae = e.pb;
+            n.Ae = preBatch(e);
+            n.Oe = e.pb;
             queuePendingNode(n);
         }
     }
@@ -357,10 +348,10 @@ function getHasNode(e, n) {
  * 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.ee) && !deriveHolds(e)) return;
+    if (e.k === null && passLane === null && (context === null || globalQueue.X) && !deriveHolds(e)) return;
     const t = getContainerNode(e);
-    if (t.Ae === NOT_PENDING) queuePendingNode(t);
-    t.Ae = n;
+    if (t.Oe === NOT_PENDING) queuePendingNode(t);
+    t.Oe = 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);
@@ -370,10 +361,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.u & CONFIG_HELD) !== 0;
+    return n != null && !userWrite && (n.i & CONFIG_HELD) !== 0;
 }
 
-GlobalQueue.hn = e => {
+GlobalQueue.An = e => {
     for (let n = 0; n < foldList.length; n++) {
         const t = foldList[n];
         if (t.k === null && t.pb !== null) holdNode(getContainerNode(t), e);
@@ -402,8 +393,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.u & CONFIG_OVERRIDE) setSignal(e, n); else {
-        if (e.u & CONFIG_HELD) joinFuture(txOf(e));
+    if (e.i & CONFIG_OVERRIDE) setSignal(e, n); else {
+        if (e.i & CONFIG_HELD) joinFuture(txOf(e));
+        if (snapshotCaptureActive) captureWriteSnapshot(e, e.Ae);
         insertSubs(e);
         schedule();
     }
@@ -421,7 +413,7 @@ function storeRootOwner(e) {
 }
 
 function stampNodeOwner(e, n) {
-    e.H = storeRootOwner(n) ?? null;
+    e.L = storeRootOwner(n) ?? null;
 }
 
 const storeNames = new WeakMap;
@@ -540,7 +532,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.Ae === n) e.k.Ae = t;
+        if (e.k !== null && e.k.Oe === n) e.k.Oe = t;
     return t;
 }
 
@@ -561,7 +553,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.u & CONFIG_HELD)) t.Ae = n;
+        if (t !== null && !(t.i & CONFIG_HELD)) t.Oe = n;
     } else if (n === null) {
         const t = e.v;
         if (!directCommit) queueFold(e);
@@ -640,7 +632,7 @@ const plainProto = e => {
     } else r = e.v;
     if (directCommit) {
         e.pb = null;
-        if (e.k !== null) e.k.pe = n;
+        if (e.k !== null) e.k.Ae = n;
     } else {
         // Eager (INTERNALS §3): the backing swaps now — handlers read the
         // adopted object before the flush — while the container node, when
@@ -736,7 +728,7 @@ let foldIndex = null;
             if (r.pb === null) continue;
  // folded already (a direct commit)
                         const o = r.k;
-            if (o !== null && o.Ae !== NOT_PENDING) {
+            if (o !== null && o.Oe !== NOT_PENDING) {
                 // held: commits with its hold
                 foldList.push(r);
                 foldOlds.push(n[t]);
@@ -747,7 +739,7 @@ let foldIndex = null;
     }
     if (deferredReleases.size !== 0) {
         for (const e of deferredReleases) {
-            if (e.Ae === NOT_PENDING && !(e.u & CONFIG_OVERRIDE) && e.t === null) {
+            if (e.Oe === NOT_PENDING && !(e.i & CONFIG_OVERRIDE) && e.t === null) {
                 deferredReleases.delete(e);
                 releaseSlot(e);
             }
@@ -758,29 +750,34 @@ 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.F = e => {
+ * landing) read it. */ GlobalQueue.C = e => {
     const n = e.yt?.fam;
-    return n != null && n.node !== null && (n.node.G & STATUS_PENDING) !== 0;
+    return n != null && n.node !== null && (n.node.S & 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 => {
+ * (#3672: the revert compares against the base's live value). */ GlobalQueue.In = e => {
     const n = e.yt;
     if (n.ch) {
         const t = e.bt;
         const r = n.v;
-        if (n.h !== null && n.h[t] === e) e.pe = untrack(() => t in r); else if (n.n !== null && n.n[t] === e) e.pe = untrack(() => unwrapValue(r[t]));
+        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]));
     }
-    return e.pe;
+    return e.Ae;
 };
 
-GlobalQueue.Sn = () => {
+GlobalQueue.Rn = () => {
     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;
+
+GlobalQueue.so = isWrappable;
+
 /** A projection's creation run commits directly (a memo's first value is
  * its `_value`, not a staging): the draft still writes a clone of the seed,
  * nothing is staged on the nodes, and the setter's exit folds the touched
@@ -807,7 +804,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))) {
+                } else if (e.ovl && (e.v !== n || !overlayRebuilds(e, r) && t?.m?.ot !== 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
@@ -849,7 +846,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.pe instanceof LaneView) t.pe.base = e.v; else t.pe = e.v;
+                if (t.t === null) e.k = null; else if (t.Ae instanceof LaneView) t.Ae.base = e.v; else t.Ae = e.v;
             }
             if (e.v !== n && e.u) {
                 const t = parentSlotKey(e, n);
@@ -922,9 +919,9 @@ function reportReplacedContainers(e, n, t, r) {
 
 function heldDerivation(e, n, t) {
     if (e.fam === null || !userWrite) return false;
-    if (n !== undefined) return (n.u & (CONFIG_HELD | CONFIG_MANUAL_WRITE)) === CONFIG_HELD && txOf(n) !== flushTransaction;
+    if (n !== undefined) return (n.i & (CONFIG_HELD | CONFIG_MANUAL_WRITE)) === CONFIG_HELD && txOf(n) !== flushTransaction;
     const r = e.k;
-    return r !== null && (r.u & CONFIG_HELD) !== 0 && txOf(r) !== flushTransaction && heldKeyChanged(e, t);
+    return r !== null && (r.i & CONFIG_HELD) !== 0 && txOf(r) !== flushTransaction && heldKeyChanged(e, t);
 }
 
 /** Setter exit: one node write per changed observed key (the leaves stage
@@ -970,15 +967,18 @@ function heldDerivation(e, n, t) {
             if (o.acc === true || hasOwn.call(n, i) && lookupGetter.call(n, i) !== undefined) {
                 // Accessor keys: the node is linked for shape-change notification,
                 // its value is never served (the getter runs with the proxy
-                // receiver on read) — FORCE wakes the readers.
+                // receiver on read) — FORCE wakes the readers. A data descriptor
+                // falls through so the cleared-acc hot read serves it (#3949);
+                // an own getter's descriptor has no `value`, so the compare below
+                // would otherwise keep the getter's result (or FORCE) for `undefined`.
                 o.acc = isOwnAccessor(n, i);
                 const e = Object.getOwnPropertyDescriptor(t, i);
                 const r = Object.getOwnPropertyDescriptor(n, i);
-                if (e && (e.get || e.set) || r && (r.get || r.set)) {
+                if (!r || r.get || r.set) {
                     if (e?.get !== r?.get || e?.set !== r?.set || e?.value !== r?.value) setSignal(o, () => FORCE);
                     continue;
                 }
-                if (!isEqual(e?.value, r?.value)) setSignal(o, () => r?.value);
+                if (e?.get || e?.set || !isEqual(e?.value, r.value)) setSignal(o, () => r.value);
                 continue;
             }
             const l = e.del !== null && e.del.has(i) ? undefined : n[i];
@@ -987,9 +987,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) {
-                    o.u &= ~CONFIG_MANUAL_WRITE;
+                    o.i &= ~CONFIG_MANUAL_WRITE;
                     holdWithDerive(e, o);
-                } else o.u |= CONFIG_MANUAL_WRITE;
+                } else o.i |= CONFIG_MANUAL_WRITE;
             }
         }
     }
@@ -1020,7 +1020,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.u & CONFIG_OVERRIDE)) {
+    if (u !== null && (u.t !== null || u.i & CONFIG_OVERRIDE)) {
         let r;
         if (e.ovl) {
             r = e.del !== null && e.del.size !== 0;
@@ -1069,13 +1069,14 @@ function membershipChanged(e, n) {
         e.acc = isOwnAccessor(r, n);
         const o = Object.getOwnPropertyDescriptor(t, n);
         const i = Object.getOwnPropertyDescriptor(r, n);
-        if (o && (o.get || o.set) || i && (i.get || i.set)) {
+        // Data descriptors fall through, as in notifyWrites (#3949).
+                if (!i || i.get || i.set) {
             if (o?.get !== i?.get || o?.set !== i?.set || o?.value !== i?.value) setSignal(e, () => FORCE);
             return;
         }
         const l = o?.value;
         const u = i?.value;
-        if (!isEqual(l, u) && !targetsEqual(l, u)) setSignal(e, typeof u === "function" ? () => u : u);
+        if (o?.get || o?.set || !isEqual(l, u) && !targetsEqual(l, u)) setSignal(e, typeof u === "function" ? () => u : u);
     } else {
         const o = t[n];
         const i = r[n];
@@ -1121,7 +1122,7 @@ function hasAccessorFlag(e) {
         for (const o of Reflect.ownKeys(r)) if (e || o in n !== o in t) setSignal(r[o], o in t);
     }
     const o = e.k;
-    if (o !== null && (o.t !== null || o.u & CONFIG_OVERRIDE)) {
+    if (o !== null && (o.t !== null || o.i & CONFIG_OVERRIDE)) {
         const e = Array.isArray(t) && Array.isArray(n) ? arrayStructureChanged(n, t) : membershipChanged(n, t);
         if (e) notifyContainer(o, t);
     }
@@ -1178,7 +1179,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.Ae !== NOT_PENDING ? asBacking(n.pe) : e.v;
+    if (n !== null) return n.Oe !== NOT_PENDING ? asBacking(n.Ae) : e.v;
     // A node-less staging (`stageOn`): the fold queue remembers the frame.
         return e.pb !== null ? preBatch(e) : e.v;
 }
@@ -1191,7 +1192,7 @@ function inDraft(e) {
     let e = context;
     if (e === null) return null;
     if (e.Ht) e = e.gt ?? null;
-    return e === null || e.u & CONFIG_CHILDREN_FORBIDDEN ? null : e;
+    return e === null || e.i & CONFIG_CHILDREN_FORBIDDEN ? null : e;
 }
 
 /** The backing a read serves (RUL-1, signal parity): the draft and the write
@@ -1229,10 +1230,10 @@ function inDraft(e) {
         if (writeOverride && !userWrite) {
             const t = n !== undefined ? e.n?.[n] : undefined;
             if (t !== undefined) {
-                if ((t.u & (CONFIG_HELD | CONFIG_OVERRIDE)) === CONFIG_HELD) joinPassTx(txOf(t));
+                if ((t.i & (CONFIG_HELD | CONFIG_OVERRIDE)) === CONFIG_HELD) joinPassTx(txOf(t));
             } else {
                 const t = e.k;
-                if (t !== null && (t.u & (CONFIG_HELD | CONFIG_OVERRIDE)) === CONFIG_HELD && (n === undefined || heldKeyChanged(e, n))) joinPassTx(txOf(t));
+                if (t !== null && (t.i & (CONFIG_HELD | CONFIG_OVERRIDE)) === CONFIG_HELD && (n === undefined || heldKeyChanged(e, n))) joinPassTx(txOf(t));
             }
         }
         return r;
@@ -1244,9 +1245,9 @@ function inDraft(e) {
     // it).
         if (n !== undefined) {
         const t = e.n?.[n];
-        if (t !== undefined && t.u & CONFIG_OVERRIDE) return committed(e);
+        if (t !== undefined && t.i & CONFIG_OVERRIDE) return committed(e);
     }
-    const i = o !== null && (o.u & CONFIG_HELD) !== 0;
+    const i = o !== null && (o.i & 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
@@ -1264,7 +1265,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 || !i && n !== undefined && !keyChanged(e, n, t)) return i ? asBacking(o.pe) : e.v;
+                if (verdict === null || !i && n !== undefined && !keyChanged(e, n, t)) return i ? asBacking(o.Ae) : e.v;
         return o === null ? committed(e) : asBacking(read(o));
     }
     // A pass reading a key the batch left unchanged: the same value in both
@@ -1281,13 +1282,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.u & (CONFIG_VERDICT | CONFIG_CHILDREN_FORBIDDEN))) return r;
+        if (l.R & REACTIVE_STAGED_READ && !(l.i & (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 (o === null) {
-            if (l.u & CONFIG_VERDICT && stagedScreen(l)) return committed(e);
+            if (l.i & CONFIG_VERDICT && stagedScreen(l)) return committed(e);
             stagedRead(l);
             return r;
         }
@@ -1297,11 +1298,52 @@ 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.pe, e.k.Ae, n, t);
+    return changedBetween(e, e.k.Ae, e.k.Oe, n, t) && !adoptChild(e, n);
+}
+
+/** The values of a held frame, built once per frame: neither the committed
+ * frame nor the held staging changes while the hold stands (a draft writes a
+ * clone), so the set stays true for every first read of the hold. */ const frameRaws = new WeakMap;
+
+function rawsOf(e) {
+    let n = frameRaws.get(e);
+    if (n === undefined) frameRaws.set(e, n = new Set(Object.values(e)));
+    return n;
+}
+
+/** The same row at a slot, as the adoption pairs rows (reconcile.ts): two
+ * objects whose keys agree — positionally for an unkeyed family. */ function sameRow(e, n, t) {
+    return e !== null && typeof e === "object" && n !== null && typeof n === "object" && (t === null || sameKey(t(e), t(n)));
+}
+
+/** A key of a held adoption whose old and new values are the same row that
+ * nothing had proxied when the adoption ran, so `descend` never paired
+ * them: paired now, as it would have been (#3712) — one target, the old
+ * raw its committed frame, the new raw its staging, held by the same
+ * transaction. Both raws resolve to it, so the slot reads as unchanged and
+ * the row's own leaves decide: `id` the same in both frames holds no one,
+ * `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 o = r[n];
+    const i = t.Oe[n];
+    const l = Array.isArray(r) ? e.fam?.key : null;
+    if (e.s || l === undefined || !sameRow(o, i, l) || !isWrappable(o) || !isWrappable(i) || Array.isArray(o) !== Array.isArray(i) || lookupTarget(o, e.fam) !== undefined || lookupTarget(i, 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(i) || rawsOf(t.Oe).has(o)) 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(o, e, n)[$TARGET];
+    if (u === undefined || u.v !== o) return false;
+    adoptPB(u, i, false);
+    holdNode(getContainerNode(u), txOf(t));
+    return true;
 }
 
 /** 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.u & CONFIG_HELD);
+    return e.fam !== null && context === null && !(e.k !== null && e.k.i & CONFIG_HELD);
 }
 
 /** Did this batch change `key` — value (slot equality), presence, and (for
@@ -1335,7 +1377,7 @@ function changedBetween(e, n, t, r, o) {
  * 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.Ae !== NOT_PENDING && !(e.u & CONFIG_HELD) && context === null && t.fam !== null) r = e.Ae;
+    if (e.Oe !== NOT_PENDING && !(e.i & CONFIG_HELD) && context === null && t.fam !== null) r = e.Oe;
     return r === FORCE ? n : r;
 }
 
@@ -1355,8 +1397,8 @@ function changedBetween(e, n, t, r, o) {
             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).
-                o.pe = t;
-                if (o.u & CONFIG_OVERRIDE) u = n;
+                o.Ae = t;
+                if (o.i & CONFIG_OVERRIDE) u = n;
             } else u = n;
         }
     }
@@ -1377,7 +1419,7 @@ function changedBetween(e, n, t, r, o) {
 }
 
 /** Is `n` among `c`'s dependencies (any pass's — a kept tail included)? */ function linkedTo(e, n) {
-    for (let t = e._; t !== null; t = t.p) if (t.I === n) return true;
+    for (let t = e.G; t !== null; t = t._) if (t.I === n) return true;
     return false;
 }
 
@@ -1396,7 +1438,7 @@ function changedBetween(e, n, t, r, o) {
     // 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.G & (STATUS_PENDING | STATUS_ERROR)) {
+        if (n.S & (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
@@ -1404,9 +1446,10 @@ function changedBetween(e, n, t, r, o) {
         // One that already observes the flight (linked by the pass that saw it
         // go up — the frame's hold, `blocked`) keeps observing it: a re-run for
         // another reason (a guess it read, the seam) that dropped the link would
-        // release the hold with the flight still up.
+        // 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.i === EFFECT_RENDER && n.u & CONFIG_HELD && flushTransaction !== txOf(n) && !linkedTo(t, n)) return;
+        if (t !== null && t.u === EFFECT_RENDER && !(n.S & STATUS_ERROR) && n.i & 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
@@ -1414,7 +1457,7 @@ function changedBetween(e, n, t, r, o) {
         // 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.G & STATUS_PENDING && r !== undefined && r.size !== 0) return;
+        if (verdict === null && n.S & STATUS_PENDING && r !== undefined && r.size !== 0) return;
         read(n);
     } else untrack(() => read(n));
 }
@@ -1427,10 +1470,10 @@ function changedBetween(e, n, t, r, o) {
  * 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.u & CONFIG_HELD && n.Ae !== NOT_PENDING && 
+    t.i & CONFIG_HELD && n.Oe !== 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.u & (CONFIG_HELD | CONFIG_OVERRIDE))) {
+    !(n.i & (CONFIG_HELD | CONFIG_OVERRIDE))) {
         holdNode(n, txOf(t));
         n.m.It = t.m.It;
     }
@@ -1503,7 +1546,7 @@ const traps = {
                 }
         // (The witness before the pull: a mark on an uninitialized derived
         // store is witnessed, then the pull throws — loading, declared pending.)
-                if (verdict !== null && affectsHooks !== null && getObserver() === null) affectsHooks.witness(e, n);
+                if (verdict !== null && affectsHooks !== null && getObserver() === null) affectsHooks.ro(e, n);
         if (e.fam !== null) pullFamily(e);
         // Hot inline case: existing PLAIN node (non-accessor) read outside any
         // draft — the dbmon/uibench effect re-read shape. Core's `read()` serves
@@ -1518,7 +1561,7 @@ const traps = {
                 const r = e.n?.[n];
         if (writeScopes === null && !writeOverride) {
             const t = r;
-            if (t !== undefined && t.acc !== true && (!e.ch || t.u & CONFIG_OVERRIDE)) {
+            if (t !== undefined && t.acc !== true && (!e.ch || t.i & CONFIG_OVERRIDE)) {
                 const r = nodeValue(t, undefined, e);
                 if (r === null || typeof r !== "object") return r;
                 if (e.s) return serveShallow(e, n, r);
@@ -1600,7 +1643,7 @@ const traps = {
         if (n === $OWNER || n === $RECORD) return false;
         // (The witness before the pull: a mark on an uninitialized derived
         // store is witnessed, then the pull throws — loading, declared pending.)
-                if (verdict !== null && affectsHooks !== null && getObserver() === null) affectsHooks.witness(e, n);
+                if (verdict !== null && affectsHooks !== null && getObserver() === null) affectsHooks.ro(e, n);
         if (e.fam !== null) pullFamily(e);
         const t = readSource(e, n);
         // A tracked reader's presence node answers (born from the two frames;
@@ -1613,9 +1656,9 @@ const traps = {
                 const o = read(r);
                 if (!e.ch || t !== e.v) return !!o;
                 const i = n in t;
-                r.pe = i;
+                r.Ae = i;
  // the link follows the inner store (S4)
-                                if (r.u & CONFIG_OVERRIDE) return !!o;
+                                if (r.i & CONFIG_OVERRIDE) return !!o;
                 return i;
             } else if (optRead(e)) {
                 const t = optHooks.has(e, n);
@@ -1625,14 +1668,14 @@ const traps = {
         return n in t && !(e.del !== null && t === e.pb && e.del.has(n));
     },
     ownKeys(e) {
-        if (verdict !== null && affectsHooks !== null && getObserver() === null) affectsHooks.witness(e, undefined);
+        if (verdict !== null && affectsHooks !== null && getObserver() === null) affectsHooks.ro(e, undefined);
         if (e.fam !== null) pullFamily(e);
         return visibleKeys(e, enumerationSource(e));
     },
     getOwnPropertyDescriptor(e, n) {
         if (n === $OWNER || n === $RECORD) return undefined;
         const t = getObserver();
-        if (verdict !== null && affectsHooks !== null && t === null) affectsHooks.witness(e, n);
+        if (verdict !== null && affectsHooks !== null && t === null) affectsHooks.ro(e, n);
         if (e.fam !== null) pullFamily(e);
         // An enumerator (spread, Object.entries) already holds the container
         // node and reads its frame; a descriptor read on its own tracks
@@ -1650,7 +1693,7 @@ const traps = {
             const t = getHasNode(e, n);
             const r = read(t);
             i = readSource(e, n, true);
-            if (!r && (!e.ch || t.u & CONFIG_OVERRIDE || !(n in i))) return undefined;
+            if (!r && (!e.ch || t.i & CONFIG_OVERRIDE || !(n in i))) return undefined;
         } else i = readSource(e, n, true);
         let l;
         if (!o && optRead(e)) {
@@ -1744,7 +1787,7 @@ const traps = {
     const t = e.k;
     if (t === null) return false;
     const r = t.Dt;
-    return r !== null && r.o === n && (!(n.R & REACTIVE_RECOMPUTING_DEPS) || r.Ue === n.he);
+    return r !== null && r.l === n && (!(n.R & REACTIVE_RECOMPUTING_DEPS) || r.Pe === n.pe);
 }
 
 function storeSetter(e, n, t = true) {
@@ -1944,7 +1987,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 i = o.v;
-        if (o.pb !== null && (inDraft(o) || writeOverride || o.k === null || !(o.k.u & CONFIG_HELD))) {
+        if (o.pb !== null && (inDraft(o) || writeOverride || o.k === null || !(o.k.i & CONFIG_HELD))) {
             if (o.ovl) materializePB(o);
             i = o.pb;
         }
@@ -1996,4 +2039,4 @@ function snapshotWalk(e, n, t) {
     return i ?? r;
 }
 
-export { $PROXY, $TARGET, $TRACK, LaneView, adoptPB, affectsHooks, arrayStructureChanged, asBacking, bumpDeep, cloneRaw, committed, containerEquals, createStore, deep, getContainerNode, getHasNode, getNode, hasAccessorFlag, installAffectsHooks, installOptHooks, materializePB, membershipChanged, nameStore, notifyFold, notifyFoldTail, notifyKeyDiff, notifyKeyValue, optHooks, resolveChainedRaw, runDirect, sameKey, snapshot, storeHasFamily, storeHasOptimisticFamily, storeIsShallow, storeSetter, targetsEqual, unwrapValue, userWriting, wrap };
+export { $PROXY, $TARGET, $TRACK, LaneView, adoptPB, arrayStructureChanged, asBacking, bumpDeep, cloneRaw, committed, containerEquals, createStore, deep, getContainerNode, getHasNode, getNode, hasAccessorFlag, materializePB, membershipChanged, nameStore, notifyFold, notifyFoldTail, notifyKeyDiff, notifyKeyValue, resolveChainedRaw, runDirect, sameKey, sameRow, snapshot, storeHasFamily, storeHasOptimisticFamily, storeIsShallow, storeSetter, targetsEqual, unwrapValue, userWriting, wrap };