@solidjs/signals 2.0.0-rc.17 → 2.0.0-rc.19

package/dist/prod/store/store.js

@@ -12,7 +12,7 @@ import { insertIntoHeap } from "../core/heap.js";
 
 import { txOf, flushTransaction, holdNode, joinFuture, insertSubs, schedule, passLane, globalQueue, queuePendingNode, resolveTx, GlobalQueue, installStoreHooks, joinPassTx, dirtyQueue } from "../core/scheduler.js";
 
-import { lookupTarget, setLookup, $OWNER, isOwned, markDescendants, devAssertNeverUserMutation } from "./target.js";
+import { lookupTarget, setLookup, $OWNER, isOwned, markDescendants } from "./target.js";
 
 import { optHooks, affectsHooks } from "./hooks.js";
 
@@ -99,45 +99,45 @@ function createTarget(e, n, t, r = n?.fam ?? null) {
     // Direct field assignment in one fixed order (no Object.assign literal
     // copy): every target shares a hidden-class transition chain — createTarget
     // was the #2 store cost in the uibench creation profile.
-    const i = Array.isArray(e) ? [] : new TargetShape;
-    i.v = e;
+    const o = Array.isArray(e) ? [] : new TargetShape;
+    o.v = e;
     // Chained-backing flag (backing IS another store's proxy, §7b) — cached so
     // the hot read path never does a per-read symbol lookup on the backing.
-        i.ch = e[$TARGET] !== undefined;
-    i.pb = null;
-    i.n = null;
-    i.h = null;
-    i.k = null;
-    i.dk = null;
-    i.wk = null;
-    i.u = n;
-    i.pk = t;
-    i.px = null;
-    i.d = false;
-    i.a = false;
-    i.sc = 0;
-    i.kc = 0;
-    i.nc = 0;
-    i.fam = r;
-    i.s = false;
-    i.ovl = false;
-    i.del = null;
-    i.px = new Proxy(i, traps);
-    setLookup(e, i);
-    return i;
+        o.ch = e[$TARGET] !== undefined;
+    o.pb = null;
+    o.n = null;
+    o.h = null;
+    o.k = null;
+    o.dk = null;
+    o.wk = null;
+    o.u = n;
+    o.pk = t;
+    o.px = null;
+    o.d = false;
+    o.a = false;
+    o.sc = 0;
+    o.kc = 0;
+    o.nc = 0;
+    o.fam = r;
+    o.s = false;
+    o.ovl = false;
+    o.del = null;
+    o.px = new Proxy(o, traps);
+    setLookup(e, o);
+    return o;
 }
 
 function wrap(e, n = null, t = null, r = n?.fam ?? null) {
     // markRaw'd values never wrap through ANY store (R42; sticky raw-marking
     // is one half of the never-both-wrapped-and-raw invariant, RUL-12).
     if (rawValuesUsed && isRawValue(e)) return e;
-    const i = lookupTarget(e, r);
-    if (i !== undefined) return i.px;
-    const o = e[$TARGET];
-    if (o !== undefined && o.px === e) {
+    const o = lookupTarget(e, r);
+    if (o !== undefined) return o.px;
+    const i = e[$TARGET];
+    if (i?.px === e) {
         // Foreign-family proxies re-wrap into THIS family (writes stay isolated);
         // same-family and plain-store proxies pass through.
-        if (r === null || o.fam === r) return e;
+        if (r === null || i.fam === r) return e;
         return createTarget(e, n, t, r).px;
     }
     return createTarget(e, n, t, r).px;
@@ -206,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.O, e, n);
+    return e === n || !!optHooks?.arrangement(this.O, e, n);
 };
 
 function sameLogicalSlot(e, n, t) {
@@ -225,10 +225,10 @@ function releaseSlot(e) {
         if (n.k === e) n.k = null;
     } else if (t === $DEEP) {
         if (n.dk === e) n.dk = null;
-    } else if (n.n !== null && n.n[t] === e) {
+    } else if (n.n?.[t] === e) {
         delete n.n[t];
         n.nc--;
-    } else if (n.h !== null && n.h[t] === e) delete n.h[t];
+    } else if (n.h?.[t] === e) delete n.h[t];
     // The family's index keeps only targets that still carry a node.
         if (n.fam !== null && n.nc === 0 && n.k === null && n.dk === null && (n.h === null || Reflect.ownKeys(n.h).length === 0)) n.fam.live.delete(n);
 }
@@ -247,7 +247,7 @@ function releaseSlot(e) {
 // 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;
+const slotKept = e => e.ie !== NOT_PENDING || e.l & CONFIG_OVERRIDE || e.O.k?.l & CONFIG_HELD;
 
 setSlotUnobserved(e => {
     if (slotKept(e)) deferredReleases.add(e); else releaseSlot(e);
@@ -258,24 +258,24 @@ 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.xe && n.xe(n.Ie, t)) return;
+    if (n.xe && n.xe(n.le, t)) return;
     queuePendingNode(n);
-    n.se = t;
-    const i = e.k;
-    if (i === null) return;
+    n.ie = 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 —
     // unless a correction folded under the guess, D-34: the key is that
     // correction's hold's.)
-        if (i.l & CONFIG_HELD && heldKeyChanged(e, r)) {
-        const e = txOf(i);
-        if (!(i.l & CONFIG_OVERRIDE) || e.folded) holdNode(n, resolveTx(e._parent ?? e));
+        if (o.l & CONFIG_HELD && heldKeyChanged(e, r)) {
+        const e = txOf(o);
+        if (!(o.l & CONFIG_OVERRIDE) || e.folded) holdNode(n, resolveTx(e._parent ?? e));
     }
     // A28 (4): a batch written inside a creation-time pass is promoted — its
     // late-materialized leaf with it.
-        if (i.l & CONFIG_PROMOTED) notePromotedWrite(n);
+        if (o.l & CONFIG_PROMOTED) notePromotedWrite(n);
 }
 
 function getNode(e, n, 
@@ -285,30 +285,30 @@ function getNode(e, n,
 // callers), 0/1 = probed.
 t = -1) {
     const r = e.n ??= Object.create(null);
-    let i = r[n];
-    if (i === undefined) {
+    let o = r[n];
+    if (o === undefined) {
         // Accessor-ness resolved ONCE per node (no per-object descriptor scan
         // on reads): accessor keys serve through Reflect.get with the proxy
         // receiver.
-        const o = e.pb;
-        const l = i = slotSignal(committed(e)[n], slotNodeEquals, e, n, t === -1 ? isOwnAccessor(o ?? e.v, n) : t === 1);
-        if (o !== null && !l.acc) bornStaged(e, l, e.del !== null && e.del.has(n) ? undefined : o[n], n);
-        r[n] = i;
+        const i = e.pb;
+        const l = o = slotSignal(committed(e)[n], slotNodeEquals, e, n, t === -1 ? isOwnAccessor(i ?? e.v, n) : t === 1);
+        if (i !== null && !l.acc) bornStaged(e, l, e.del?.has(n) ? undefined : i[n], n);
+        r[n] = o;
         e.nc++;
         noteNode(e, l, n);
     }
-    return i;
+    return o;
 }
 
 function getHasNode(e, n) {
     const t = e.h ??= Object.create(null);
     let r = t[n];
     if (r === undefined) {
-        const i = r = slotSignal(n in committed(e), isEqual, e, n, false);
-        const o = e.pb;
-        if (o !== null) bornStaged(e, i, n in o && !(e.del !== null && e.del.has(n)), n);
+        const o = r = slotSignal(n in committed(e), isEqual, e, n, false);
+        const i = e.pb;
+        if (i !== null) bornStaged(e, o, n in i && !e.del?.has(n), n);
         t[n] = r;
-        noteNode(e, i, n);
+        noteNode(e, o, n);
     }
     return r;
 }
@@ -325,8 +325,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.Ie = preBatch(e);
-            n.se = e.pb;
+            n.le = preBatch(e);
+            n.ie = e.pb;
             queuePendingNode(n);
         }
     }
@@ -345,8 +345,8 @@ function getHasNode(e, n) {
  * (`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.se === NOT_PENDING) queuePendingNode(t);
-    t.se = n;
+    if (t.ie === NOT_PENDING) queuePendingNode(t);
+    t.ie = 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);
@@ -389,7 +389,7 @@ function bumpDeep(e) {
     // the node; the comparator is the store's, done).
     if (e.l & CONFIG_OVERRIDE) setSignal(e, n); else {
         if (e.l & CONFIG_HELD) joinFuture(txOf(e));
-        if (snapshotCaptureActive) captureWriteSnapshot(e, e.Ie);
+        if (snapshotCaptureActive) captureWriteSnapshot(e, e.le);
         insertSubs(e);
         schedule();
     }
@@ -421,10 +421,10 @@ function isOwnAccessor(e, n) {
     }
     const t = Object.getOwnPropertyDescriptors(e);
     for (const r of Reflect.ownKeys(t)) {
-        const i = t[r];
+        const o = t[r];
         if (r === "length" && Array.isArray(e)) continue;
-        i.configurable = true;
-        if (!i.get && !i.set) i.writable = true; else n.a = true;
+        o.configurable = true;
+        if (!o.get && !o.set) o.writable = true; else n.a = true;
     }
     const r = Array.isArray(e) ? Object.defineProperties([], t) : Object.create(Object.getPrototypeOf(e), t);
     r[$OWNER] = n;
@@ -448,13 +448,13 @@ function copyOwn(e, n, t) {
     const n = e.v;
     const t = Reflect.ownKeys(n);
     let r = Object.getPrototypeOf(n) === Object.prototype;
-    for (const i of t) {
-        if (lookupGetter.call(n, i) !== undefined || lookupSetter.call(n, i) !== undefined) {
+    for (const o of t) {
+        if (isOwnAccessor(n, o)) {
             e.a = true;
             r = false;
             break;
         }
-        if (r && !propertyIsEnumerable.call(n, i)) r = false;
+        if (r && !propertyIsEnumerable.call(n, o)) r = false;
     }
     e.sc = r ? 2 : 1;
     e.kc = t.length;
@@ -479,29 +479,22 @@ const plainProto = e => {
 /** An overlay with many adds (or any delete) rebuilds the committed
  * container at flatten so its shape stays fast (#3689). */ function overlayRebuilds(e, n) {
     if (e.kc > OVERLAY_REBUILD_MAX_KEYS) return false;
-    if (e.del !== null && e.del.size !== 0) return true;
+    if (e.del?.size) return true;
     const t = e.wk;
     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;
+    let o = 0;
+    for (const e of Reflect.ownKeys(n)) if (!hasOwn.call(r, e) && ++o > OVERLAY_REBUILD_MIN_ADDS) return true;
     return false;
 }
 
 /** Downgrade an overlay to a real clone (a consumer needs a container). */ function materializePB(e) {
     const n = e.pb;
     if (!e.ovl) return n;
-    const t = e.sc === 2 ? wideClone(e.v, e) : cloneRaw(e.v, e);
-    if (e.del !== null) {
-        for (const n of e.del) delete t[n];
-        e.kc -= e.del.size;
-        e.del = null;
-    }
-    for (const r of Reflect.ownKeys(n)) e.sc === 2 ? t[r] = n[r] : copyOwn(t, n, r);
+    const t = overlayOnto(e, e.sc === 2 ? wideClone(e.v, e) : cloneRaw(e.v, e), n);
     e.pb = t;
-    e.ovl = false;
     // The staging IS the pending backing: re-point the container node.
-        if (e.k !== null && e.k.se === n) e.k.se = t;
+        if (e.k?.ie === n) e.k.ie = t;
     return t;
 }
 
@@ -513,7 +506,7 @@ const plainProto = e => {
     // An optimistic edit composes on the view the user saw and becomes
     // guesses at the setter's exit: nothing is staged, nothing folds
     // (optimistic.ts).
-        if (userWrite && e.fam?.opt === true && !pendingNotify.has(e)) return e.pb = optHooks.draft(e);
+        if (optHooks && userWrite && e.fam?.opt === true && !pendingNotify.has(e)) return e.pb = optHooks.draft(e);
     if (n !== null && !isOwned(n)) {
         // An adopted object awaiting its fold is the user's: the draft writes a
         // clone of it. The clone is the batch's staging — unless the adoption is
@@ -522,7 +515,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.l & CONFIG_HELD)) t.se = n;
+        if (t !== null && !(t.l & CONFIG_HELD)) t.ie = n;
     } else if (n === null) {
         const t = e.v;
         if (!directCommit) queueFold(e);
@@ -546,7 +539,6 @@ const plainProto = e => {
     e.ch = false;
     if (e.u) {
         privatizeCommitted(e.u);
-        devAssertNeverUserMutation(e.u.v);
         const t = e.u.v;
         const r = parentSlotKey(e, n);
         if (t[r] === n) t[r] = e.v;
@@ -561,26 +553,29 @@ const plainProto = e => {
     const t = e.pk;
     const r = e.u.v;
     if (r[t] === n || r[t] === e.v || !Array.isArray(r)) return t;
-    const i = r.indexOf(n);
-    if (i === -1) return t;
-    e.pk = i;
-    return i;
+    const o = r.indexOf(n);
+    if (o === -1) return t;
+    e.pk = o;
+    return o;
 }
 
 /** Overlay flatten (#3044): own keys onto the owned committed backing in
  * place — the backing keeps its identity. */ function flattenOverlay(e, n) {
     privatizeCommitted(e);
-    const t = e.v;
-    for (const r of Reflect.ownKeys(n)) e.sc === 2 ? t[r] = n[r] : copyOwn(t, n, r);
+    overlayOnto(e, e.v, n);
+ // the caller (`foldTarget`) closes the staging
+}
+
+/** An overlay's own keys and deletions onto `to` (the two are disjoint: a
+ * write un-deletes its key); the overlay is closed. */ function overlayOnto(e, n, t) {
+    for (const r of Reflect.ownKeys(t)) e.sc === 2 ? n[r] = t[r] : copyOwn(n, t, r);
     if (e.del !== null) {
-        for (const n of e.del) delete t[n];
+        for (const t of e.del) delete n[t];
         e.kc -= e.del.size;
         e.del = null;
     }
-    e.pb = null;
     e.ovl = false;
-    e.wk = null;
- // written-keys window closes with the commit
+    return n;
 }
 
 /** Adoption (a setter's returned replacement; reconcile and projection
@@ -601,7 +596,7 @@ const plainProto = e => {
     } else r = e.v;
     if (directCommit) {
         e.pb = null;
-        if (e.k !== null) e.k.Ie = n;
+        if (e.k !== null) e.k.le = n;
     } else {
         // Eager (INTERNALS §3): the backing swaps now — handlers read the
         // adopted object before the flush — while the container node, when
@@ -619,8 +614,8 @@ const plainProto = e => {
     e.a = false;
     e.wk = null;
  // adoption supersedes staged trap writes
-        const i = n[$OWNER];
-    if (i !== undefined && i.fam === e.fam) n[$OWNER] = e; else setLookup(n, e);
+        const o = n[$OWNER];
+    if (o?.fam === e.fam) n[$OWNER] = e; else setLookup(n, e);
     if (t && r !== n) notifyFold(e, r, n);
 }
 
@@ -696,8 +691,8 @@ let foldIndex = null;
             const r = e[t];
             if (r.pb === null) continue;
  // folded already (a direct commit)
-                        const i = r.k;
-            if (i !== null && i.se !== NOT_PENDING) {
+                        const o = r.k;
+            if (o !== null && o.ie !== NOT_PENDING) {
                 // held: commits with its hold
                 foldList.push(r);
                 foldOlds.push(n[t]);
@@ -721,7 +716,7 @@ let foldIndex = null;
  * marks (an ambient `affects()` over a declared reload lives to the
  * landing) read it. */ GlobalQueue.k = e => {
     const n = e.O?.fam;
-    return n != null && n.node !== null && (n.node.m & STATUS_PENDING) !== 0;
+    return (n?.node?.m & STATUS_PENDING) !== 0;
 };
 
 /** Core asks (lanes.ts `covered`): the value a slot node's guess covered.
@@ -732,9 +727,9 @@ let foldIndex = null;
     if (n.ch) {
         const t = e.ze;
         const r = n.v;
-        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]));
+        if (n.h?.[t] === e) e.le = untrack(() => t in r); else if (n.n?.[t] === e) e.le = untrack(() => unwrapValue(r[t]));
     }
-    return e.Ie;
+    return e.le;
 };
 
 installStoreHooks(storePark, () => {
@@ -768,12 +763,7 @@ function runDirect(e) {
             const t = e.k;
             const r = e.pb;
             if (r !== null) {
-                if (r === e.v) {
-                    // An eager adoption nothing wrote after: the backing is already
-                    // the adopted object (shared ownership — never cloned).
-                    e.pb = null;
-                    e.wk = null;
-                } else if (e.ovl && (e.v !== n || !overlayRebuilds(e, r) && t?.T?.Pe !== n)) {
+                if (r === e.v) ; else if (e.ovl && (e.v !== n || !overlayRebuilds(e, r) && t?.T?.De !== 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
@@ -785,43 +775,38 @@ function runDirect(e) {
                     // owned backing takes the written keys.
                     privatizeCommitted(e);
                     const t = e.v;
-                    const i = e.wk;
-                    if (i !== null && i !== WK_ALL) {
-                        for (let e = i; e !== undefined; e = e.u) for (const n of e) {
+                    const o = e.wk;
+                    if (o !== null && o !== WK_ALL) {
+                        for (let e = o; 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)) {
-                            const i = Object.getOwnPropertyDescriptor(r, e);
-                            if (i.get || i.set || !i.enumerable || !i.writable || !i.configurable) Object.defineProperty(t, e, i); else if (i.value !== n[e] || !hasOwn.call(n, e)) t[e] = i.value;
-                        }
+                        for (const e of Reflect.ownKeys(r)) if (e !== $OWNER) copyOwn(t, r, e);
                         for (const e of Reflect.ownKeys(n)) {
-                            if (!hasOwn.call(r, e)) delete t[e];
+                            if (e !== $OWNER && !hasOwn.call(r, e)) delete t[e];
                         }
                     }
-                    e.pb = null;
-                    e.wk = null;
                 } else {
                     // The clone (or adopted object) becomes the committed backing
                     // (path copy below).
                     e.v = e.ovl ? materializePB(e) : r;
                     e.ch = e.v[$TARGET] !== undefined;
-                    e.pb = null;
-                    e.wk = null;
                 }
-            }
+                e.pb = null;
+                e.wk = null;
+ // the written-keys window closes with the commit
+                        }
             if (t !== null) {
                 // The node's committed value is the backing. A container nobody
                 // 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.o === null) e.k = null; else if (t.Ie instanceof LaneView) t.Ie.base = e.v; else t.Ie = e.v;
+                if (t.o === null) e.k = null; else if (t.le instanceof LaneView) t.le.base = e.v; else t.le = e.v;
             }
             if (e.v !== n && e.u) {
                 const t = parentSlotKey(e, n);
                 if (e.u.v[t] === n) {
                     privatizeCommitted(e.u);
-                    devAssertNeverUserMutation(e.u.v);
                     e.u.v[t] = e.v;
                 }
             }
@@ -855,7 +840,7 @@ function heldDerivation(e, n, t) {
     // Optimistic channel: a user's writes on an optimistic family become
     // guesses on the nodes (lanes); the draft is discarded, the committed
     // backing never touched.
-        if (userWrite && e.fam?.opt === true) {
+        if (optHooks && userWrite && e.fam?.opt === true) {
         // The draft is discarded first: the diff reads the target (its nodes
         // are born from the committed frame, not the draft).
         e.pb = null;
@@ -878,63 +863,63 @@ function heldDerivation(e, n, t) {
     // 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)) {
+        const o = e.wk;
+    const i = o === WK_ALL || e.a === true || !plainProto(e.ovl ? e.v : n) ? null : o;
+    if (e.fam !== null && !heldDerivationHit && i !== null) for (const n of i) if (heldDerivation(e, r?.[n], n)) {
         heldDerivationHit = true;
         break;
     }
     if (r !== null) {
-        const i = o ?? Reflect.ownKeys(r);
-        for (const o of i) {
-            const i = r[o];
-            if (i === undefined) continue;
-            if (i.acc === true || hasOwn.call(n, o) && lookupGetter.call(n, o) !== undefined) {
+        const o = i ?? Reflect.ownKeys(r);
+        for (const i of o) {
+            const o = r[i];
+            if (o === undefined) continue;
+            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. 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`.
-                i.acc = isOwnAccessor(n, o);
-                const e = Object.getOwnPropertyDescriptor(t, o);
-                const r = Object.getOwnPropertyDescriptor(n, o);
+                o.acc = isOwnAccessor(n, i);
+                const e = Object.getOwnPropertyDescriptor(t, i);
+                const r = Object.getOwnPropertyDescriptor(n, i);
                 if (!r || r.get || r.set) {
-                    if (e?.get !== r?.get || e?.set !== r?.set || e?.value !== r?.value) setSignal(i, () => FORCE);
+                    if (e?.get !== r?.get || e?.set !== r?.set || e?.value !== r?.value) setSignal(o, () => FORCE);
                     continue;
                 }
-                if (e?.get || e?.set || !isEqual(e?.value, r.value)) setSignal(i, () => 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(o) ? undefined : n[o];
-            setSignal(i, () => l);
+            const l = e.del?.has(i) ? undefined : n[i];
+            setSignal(o, () => l);
             if (e.fam !== null) {
                 // The derive's write is a derivation; a user setter's is a proposal
                 // (A34 (3)'s discriminator).
                 if (!userWrite) {
-                    i.l &= ~CONFIG_MANUAL_WRITE;
-                    holdWithDerive(e, i);
-                } else i.l |= CONFIG_MANUAL_WRITE;
+                    o.l &= ~CONFIG_MANUAL_WRITE;
+                    holdWithDerive(e, o);
+                } else o.l |= CONFIG_MANUAL_WRITE;
             }
         }
     }
     const l = e.h;
     if (l !== null) {
-        const t = o ?? Reflect.ownKeys(l);
+        const t = i ?? Reflect.ownKeys(l);
         for (const r of t) {
             const t = l[r];
             if (t !== undefined) {
-                setSignal(t, r in n && !(e.del !== null && e.del.has(r)));
+                setSignal(t, r in n && !e.del?.has(r));
                 if (e.fam !== null) holdWithDerive(e, t);
             }
         }
     }
     if (e.dk !== null) {
-        if (e.del !== null && e.del.size !== 0) bumpDeep(e); else for (const r of o ?? Reflect.ownKeys(n)) {
+        if (e.del?.size) bumpDeep(e); else for (const r of i ?? Reflect.ownKeys(n)) {
             if (r === $OWNER) continue;
-            const i = n[r];
-            const o = t[r];
-            if (i !== null && typeof i === "object" ? !targetsEqual(o, i) : !isEqual(o, i)) {
+            const o = n[r];
+            const i = t[r];
+            if (o !== null && typeof o === "object" ? !targetsEqual(i, o) : !isEqual(i, o)) {
                 bumpDeep(e);
                 break;
             }
@@ -948,7 +933,7 @@ function heldDerivation(e, n, t) {
     if (u !== null && (u.o !== null || u.l & CONFIG_OVERRIDE)) {
         let r;
         if (e.ovl) {
-            r = e.del !== null && e.del.size !== 0;
+            r = !!e.del?.size;
             if (!r) {
                 for (const e of Reflect.ownKeys(n)) {
                     if (!hasOwn.call(t, e)) {
@@ -976,8 +961,8 @@ function heldDerivation(e, n, t) {
     if (e.length !== n.length) return true;
     for (let t = 0; t < n.length; t++) {
         const r = e[t];
-        const i = n[t];
-        if (!isEqual(r, i) && !targetsEqual(r, i)) return true;
+        const o = n[t];
+        if (!isEqual(r, o) && !targetsEqual(r, o)) return true;
     }
     return false;
 }
@@ -989,23 +974,23 @@ function membershipChanged(e, n) {
     return false;
 }
 
-/** One leaf's notification for an adoption diff (descriptor-aware). */ function notifyKeyDiff(e, n, t, r, i = true) {
-    if (e.acc === true || i && hasOwn.call(r, n) && lookupGetter.call(r, n) !== undefined) {
+/** One leaf's notification for an adoption diff (descriptor-aware). */ function notifyKeyDiff(e, n, t, r, o = true) {
+    if (e.acc === true || o && hasOwn.call(r, n) && lookupGetter.call(r, n) !== undefined) {
         e.acc = isOwnAccessor(r, n);
-        const i = Object.getOwnPropertyDescriptor(t, n);
-        const o = Object.getOwnPropertyDescriptor(r, n);
+        const o = Object.getOwnPropertyDescriptor(t, n);
+        const i = Object.getOwnPropertyDescriptor(r, n);
         // Data descriptors fall through, as in notifyWrites (#3949).
-                if (!o || o.get || o.set) {
-            if (i?.get !== o?.get || i?.set !== o?.set || i?.value !== o?.value) setSignal(e, () => FORCE);
+                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 = i?.value;
-        const u = o?.value;
-        if (i?.get || i?.set || !isEqual(l, u) && !targetsEqual(l, u)) setSignal(e, typeof u === "function" ? () => u : u);
+        const l = o?.value;
+        const u = i?.value;
+        if (o?.get || o?.set || !isEqual(l, u) && !targetsEqual(l, u)) setSignal(e, typeof u === "function" ? () => u : u);
     } else {
-        const i = t[n];
-        const o = r[n];
-        if (!isEqual(i, o) && !targetsEqual(i, o)) setSignal(e, typeof o === "function" ? () => o : o);
+        const o = t[n];
+        const i = r[n];
+        if (!isEqual(o, i) && !targetsEqual(o, i)) setSignal(e, typeof i === "function" ? () => i : i);
     }
 }
 
@@ -1013,9 +998,9 @@ function hasAccessorFlag(e) {
     return e.acc === true;
 }
 
-/** One leaf's notification when the caller already has both values. */ function notifyKeyValue(e, n, t, r, i, o) {
+/** One leaf's notification when the caller already has both values. */ function notifyKeyValue(e, n, t, r, o, i) {
     if (e.acc === true) {
-        notifyKeyDiff(e, n, i, o, false);
+        notifyKeyDiff(e, n, o, i, false);
         return;
     }
     if (!isEqual(t, r) && !targetsEqual(t, r)) setSignal(e, typeof r === "function" ? () => r : r);
@@ -1044,12 +1029,12 @@ function hasAccessorFlag(e) {
     const r = e.h;
     if (r !== null) {
         const e = n[$TARGET];
-        for (const i of Reflect.ownKeys(r)) if (e || i in n !== i in t) setSignal(r[i], i in t);
+        for (const o of Reflect.ownKeys(r)) if (e || o in n !== o in t) setSignal(r[o], o in t);
     }
-    const i = e.k;
-    if (i !== null && (i.o !== null || i.l & CONFIG_OVERRIDE)) {
+    const o = e.k;
+    if (o !== null && (o.o !== null || o.l & CONFIG_OVERRIDE)) {
         const e = Array.isArray(t) && Array.isArray(n) ? arrayStructureChanged(n, t) : membershipChanged(n, t);
-        if (e) notifyContainer(i, t);
+        if (e) notifyContainer(o, t);
     }
 }
 
@@ -1094,7 +1079,7 @@ function inDraft(e) {
 /** A child proxy served to a draft joins the draft's scope. */ function draftServe(e, n) {
     if (writeScopes !== null && inDraft(e)) {
         const e = n?.[$TARGET];
-        if (e !== undefined && e.v !== undefined) writeScopes.add(scopeKey(e));
+        if (e?.v !== undefined) writeScopes.add(scopeKey(e));
     }
     return n;
 }
@@ -1104,7 +1089,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.se !== NOT_PENDING ? asBacking(n.Ie) : e.v;
+    if (n !== null) return n.ie !== NOT_PENDING ? asBacking(n.le) : e.v;
     // A node-less staging (`stageOn`): the fold queue remembers the frame.
         return e.pb !== null ? preBatch(e) : e.v;
 }
@@ -1137,7 +1122,7 @@ function inDraft(e) {
     // sees — the lanes' values and the tick's own guesses over the truth
     // (#3665), never a staging awaiting its fold: the draft is born on the
     // read (and notified at the setter's exit like any).
-    if (userWrite && e.fam !== null && e.fam.opt === true && !pendingNotify.has(e) && inDraft(e)) {
+    if (userWrite && e.fam?.opt === true && !pendingNotify.has(e) && inDraft(e)) {
         const n = ensurePB(e);
         pendingNotify.add(e);
         return n;
@@ -1163,21 +1148,21 @@ function inDraft(e) {
         }
         return r;
     }
-    const i = e.k;
+    const o = e.k;
     // A key whose leaf carries a lane's value (a guess, S4): the leaf serves
     // it — the container's frame is not consulted (a reader is not made a
     // stale reader of the container's hold for a key it does not see through
     // it).
         if (n !== undefined) {
         const t = e.n?.[n];
-        if (t !== undefined && t.l & CONFIG_OVERRIDE) return committed(e);
+        if (t?.l & CONFIG_OVERRIDE) return committed(e);
     }
-    const o = i !== null && (i.l & CONFIG_HELD) !== 0;
+    const i = o !== null && (o.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
     // changed reads the frame core serves this reader.
-        if (o && n !== undefined && !heldKeyChanged(e, n, t)) return r;
+        if (i && n !== undefined && !heldKeyChanged(e, n, t)) return r;
     const l = stagingReader();
     if (l === null) {
         if (getObserver() !== null) return r;
@@ -1190,8 +1175,8 @@ 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.Ie) : e.v;
-        return i === null ? committed(e) : asBacking(read(i));
+                if (verdict === null || !i && n !== undefined && !keyChanged(e, n, t)) return i ? asBacking(o.le) : e.v;
+        return o === null ? committed(e) : asBacking(read(o));
     }
     // A pass reading a key the batch left unchanged: the same value in both
     // frames — committed, holding no one. Otherwise the container's frame by
@@ -1200,7 +1185,7 @@ function inDraft(e) {
     // sees committed and re-derives at the landing, a memo joins the future,
     // a staging read is marked. The key's own leaf, when it has one, decides
     // the value the same way.
-        if (!o) {
+        if (!i) {
         // A plain pass this flush already served a staging as the screen
         // (REACTIVE_STAGED_READ — what `read()` would set again here) reads an
         // unheld staging directly: an unchanged key is the same value in both
@@ -1212,18 +1197,18 @@ function inDraft(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 (o === null) {
             if (l.l & CONFIG_VERDICT && stagedScreen(l)) return committed(e);
             stagedRead(l);
             return r;
         }
     }
-    return asBacking(untrack(() => read(i)));
+    return asBacking(untrack(() => read(o)));
 }
 
 /** 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.Ie, e.k.se, n, t) && !adoptChild(e, n);
+    return changedBetween(e, e.k.le, e.k.ie, n, t) && !adoptChild(e, n);
 }
 
 /** The values of a held frame, built once per frame: neither the committed
@@ -1250,25 +1235,25 @@ 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.Ie);
-    const i = r[n];
-    const o = t.se[n];
+    const r = asBacking(t.le);
+    const o = r[n];
+    const i = t.ie[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 || 
+    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(o) || rawsOf(t.se).has(i)) return false;
+    rawsOf(r).has(i) || rawsOf(t.ie).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(i, e, n)[$TARGET];
-    if (u === undefined || u.v !== i) return false;
-    adoptPB(u, o, false);
+        const u = wrap(o, e, n)[$TARGET];
+    if (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.l & CONFIG_HELD);
+    return e.fam !== null && context === null && !(e.k?.l & CONFIG_HELD);
 }
 
 /** Did this batch change `key` — value (slot equality), presence, and (for
@@ -1286,13 +1271,13 @@ function rawsOf(e) {
     return changedBetween(e, committed(e), e.pb, n, t);
 }
 
-function changedBetween(e, n, t, r, i) {
+function changedBetween(e, n, t, r, o) {
     if (e.ch || t[$TARGET] !== undefined || Object.getPrototypeOf(t) !== Object.getPrototypeOf(n) || !plainProto(n)) return true;
-    if (e.del !== null && e.del.has(r)) return r in n;
-    const o = hasOwn.call(t, r) || e.ovl && hasOwn.call(e.v, r);
-    if (o !== hasOwn.call(n, r)) return true;
-    if (!o) return false;
-    if ((i || e.a) && (isOwnAccessor(n, r) || isOwnAccessor(t, r) || propertyIsEnumerable.call(n, r) !== propertyIsEnumerable.call(t, r))) return true;
+    if (e.del?.has(r)) return r in n;
+    const i = hasOwn.call(t, r) || e.ovl && hasOwn.call(e.v, r);
+    if (i !== hasOwn.call(n, r)) return true;
+    if (!i) return false;
+    if ((o || e.a) && (isOwnAccessor(n, r) || isOwnAccessor(t, r) || propertyIsEnumerable.call(n, r) !== propertyIsEnumerable.call(t, r))) return true;
     const l = t[r];
     const u = n[r];
     return !isEqual(u, l) && !sameLogicalSlot(e, u, l);
@@ -1302,12 +1287,12 @@ 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.se !== NOT_PENDING && !(e.l & CONFIG_HELD) && context === null && t.fam !== null) r = e.se;
+    if (e.ie !== NOT_PENDING && !(e.l & CONFIG_HELD) && context === null && t.fam !== null) r = e.ie;
     return r === FORCE ? n : r;
 }
 
 /** Serve a present data key: link the leaf for a tracked reader (creating it
- * on first read), wrap a wrappable child through the per-node wrap cache. */ function serveDataKey(e, n, t, r, i, o = -1) {
+ * on first read), wrap a wrappable child through the per-node wrap cache. */ function serveDataKey(e, n, t, r, o, i = -1) {
     // Read-through (§7b): the inner store's node is the truth; the outer's is
     // a subscription point only — unless it carries a guess (an optimistic
     // store over a store: the guess is the outer's, shown over the inner).
@@ -1316,14 +1301,14 @@ function changedBetween(e, n, t, r, i) {
     // A write-override read (a derive's draft) serves the backing: the derive
     // composes on the truth, never on a lane's or a hold's frame.
         if (!inDraft(e) && !writeOverride) {
-        if (i === undefined && getObserver() !== null) i = getNode(e, n, o);
-        if (i !== undefined) {
-            const n = nodeValue(i, t, e);
+        if (o === undefined && getObserver() !== null) o = getNode(e, n, i);
+        if (o !== undefined) {
+            const n = nodeValue(o, t, e);
             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.Ie = t;
-                if (i.l & CONFIG_OVERRIDE) u = n;
+                o.le = t;
+                if (o.l & CONFIG_OVERRIDE) u = n;
             } else u = n;
         }
     }
@@ -1331,12 +1316,12 @@ function changedBetween(e, n, t, r, i) {
     // A derive's draft wrapper answers `$TARGET` without being a proxy: the
     // inner store's alias (#3767), resolved like a raw (#3859).
         if (e.ch && !l && u !== null && typeof u === "object" && u[$TARGET]?.px !== u) u = resolveChainedRaw(e, n, u);
-    if (i !== undefined) {
-        if (i.pxv === u && u !== undefined) return draftServe(e, i.px);
+    if (o !== undefined) {
+        if (o.pxv === u && u !== undefined) return draftServe(e, o.px);
         if (!isWrappable(u)) return u;
         const t = wrap(u, e, n);
-        i.px = t;
-        i.pxv = u;
+        o.px = t;
+        o.pxv = u;
         return draftServe(e, t);
     }
     if (!isWrappable(u)) return u;
@@ -1395,7 +1380,7 @@ 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.l & CONFIG_HELD && n.se !== NOT_PENDING && 
+    t.l & CONFIG_HELD && n.ie !== 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.l & (CONFIG_HELD | CONFIG_OVERRIDE))) {
@@ -1413,8 +1398,8 @@ function changedBetween(e, n, t, r, i) {
         const e = resolveChainedRaw(r, n, t);
         return e === t ? t : wrap(e, r, n);
     }
-    const i = lookupTarget(t, r.fam);
-    if (i !== undefined) return i.px;
+    const o = lookupTarget(t, r.fam);
+    if (o !== undefined) return o.px;
     if ((r.v[n] === t || r.pb?.[n] === t) && isWrappable(t)) return wrap(t, r, n);
     return t;
 }
@@ -1427,16 +1412,16 @@ function changedBetween(e, n, t, r, i) {
         // A container's arrangement guess is not a backing: the view composes
         // over the base it is shown over.
         const n = asBacking(read(getContainerNode(e)));
-        return e.fam?.opt === true ? optHooks.view(e, n) : n;
+        return optHooks && e.fam?.opt === true ? optHooks.view(e, n) : n;
     }
     const n = readSource(e);
-    return optRead(e) ? optHooks.view(e, n) : n;
+    return optHooks && optRead(e) ? optHooks.view(e, n) : n;
 }
 
 /** A read on an optimistic family that composes the lanes' values: not the
  * draft's (it composed already), not a derive's write-override read (the
  * derive composes on the truth). */ function optRead(e) {
-    return e.fam !== null && e.fam.opt === true && !inDraft(e) && !writeOverride;
+    return e.fam?.opt === true && !inDraft(e) && !writeOverride;
 }
 
 /** Pollution keys are never served from the prototype (core R30). */ const UNSAFE_KEYS = new Set([ "__proto__", "prototype", "constructor" ]);
@@ -1508,18 +1493,18 @@ const traps = {
                 if (e.s) return serveShallow(e, n, r);
                 if (t.pxv === r) return t.px;
                 if (isWrappable(r)) {
-                    const i = wrap(r, e, n);
-                    t.px = i;
+                    const o = wrap(r, e, n);
+                    t.px = o;
                     t.pxv = r;
-                    return i;
+                    return o;
                 }
                 return r;
             }
         }
-        const i = readSource(e, n);
+        const o = readSource(e, n);
         // 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 && i === e.pb && e.del.has(n)) {
+                if (o === e.pb && e.del?.has(n)) {
             if (!inDraft(e) && getObserver() !== null) read(getNode(e, n));
             return undefined;
         }
@@ -1530,16 +1515,16 @@ const traps = {
         // node) probes once — untracked node-less reads take the plain path,
         // where a raw-receiver getter still returns correct committed values.
         // Tracking suppression is PER-TARGET (inDraft), never global (#3037).
-                let o = -1;
+                let i = -1;
         {
             let l;
             if (r !== undefined) l = r.acc === true; else if (!inDraft(e) && getObserver() !== null) {
-                l = isOwnAccessor(i, n);
-                if (i === (e.pb ?? e.v)) o = l ? 1 : 0;
+                l = isOwnAccessor(o, n);
+                if (o === (e.pb ?? e.v)) i = l ? 1 : 0;
             } else l = false;
             if (l) {
-                if (!inDraft(e) && getObserver() !== null) read(r ?? getNode(e, n, o));
-                const l = Reflect.get(i, n, t);
+                if (!inDraft(e) && getObserver() !== null) read(r ?? getNode(e, n, i));
+                const l = Reflect.get(o, n, t);
                 if (e.s) return serveShallow(e, n, l);
                 return isWrappable(l) ? draftServe(e, wrap(l, e, n)) : l;
             }
@@ -1550,21 +1535,21 @@ const traps = {
         // chain to the committed backing, so "own in the view" means own on
         // either layer — a genuine prototype method is one that is own on
         // NEITHER.
-                const l = e.ovl && i === e.pb;
-        if ((n === "constructor" || n === "__proto__" || n === "prototype") && !hasOwn.call(i, n) && !(l && hasOwn.call(e.v, n))) return undefined;
-        let u = i[n];
-        if (u === undefined ? !hasOwn.call(i, n) && !(l && hasOwn.call(e.v, n)) : false) {
+                const l = e.ovl && o === e.pb;
+        if ((n === "constructor" || n === "__proto__" || n === "prototype") && !hasOwn.call(o, n) && !(l && hasOwn.call(e.v, n))) return undefined;
+        let u = o[n];
+        if (u === undefined ? !hasOwn.call(o, n) && !(l && hasOwn.call(e.v, n)) : false) {
             // Inherited: prototype getters/methods run with the proxy receiver.
-            u = Reflect.get(i, n, t);
+            u = Reflect.get(o, n, t);
             if (typeof u === "function") return u;
  // proto methods untracked
             // Read-through (§7b): the inner store answers an absent key too — the
             // outer's node is a subscription point unless it carries a guess.
-                        if (e.ch && i === e.v) return serveDataKey(e, n, u, i, r, o);
+                        if (e.ch && o === e.v) return serveDataKey(e, n, u, o, r, i);
             // Reading a currently-absent own key subscribes to it (R12) — for any
             // target OUTSIDE its own draft scope, even mid-setter (#3037, above).
                         if (u === undefined && !inDraft(e)) {
-                if (getObserver() !== null) read(getNode(e, n, o));
+                if (getObserver() !== null) read(getNode(e, n, i));
                 const t = e.n?.[n];
                 if (t) {
                     const r = nodeValue(t, undefined, e);
@@ -1575,9 +1560,9 @@ const traps = {
             if (e.s) return serveShallow(e, n, u);
             return isWrappable(u) ? draftServe(e, wrap(u, e, n)) : u;
         }
-        if (typeof u === "function" && !hasOwn.call(i, n) && !(l && hasOwn.call(e.v, n))) return u;
+        if (typeof u === "function" && !hasOwn.call(o, n) && !(l && hasOwn.call(e.v, n))) return u;
  // proto method
-                return serveDataKey(e, n, u, i, r, o);
+                return serveDataKey(e, n, u, o, r, i);
     },
     has(e, n) {
         if (n === $TARGET || n === $PROXY || n === $TRACK) return true;
@@ -1594,19 +1579,19 @@ const traps = {
                 if (!inDraft(e) && !writeOverride) {
             if (getObserver() !== null) {
                 const r = getHasNode(e, n);
-                const i = read(r);
-                if (!e.ch || t !== e.v) return !!i;
-                const o = n in t;
-                r.Ie = o;
+                const o = read(r);
+                if (!e.ch || t !== e.v) return !!o;
+                const i = n in t;
+                r.le = i;
  // the link follows the inner store (S4)
-                                if (r.l & CONFIG_OVERRIDE) return !!i;
-                return o;
-            } else if (optRead(e)) {
+                                if (r.l & CONFIG_OVERRIDE) return !!o;
+                return i;
+            } else if (optHooks && optRead(e)) {
                 const t = optHooks.has(e, n);
                 if (t !== undefined) return t;
             }
         }
-        return n in t && !(e.del !== null && t === e.pb && e.del.has(n));
+        return n in t && !(t === e.pb && e.del?.has(n));
     },
     ownKeys(e) {
         if (verdict !== null && affectsHooks !== null && getObserver() === null) affectsHooks.ro(e, undefined);
@@ -1622,9 +1607,9 @@ const traps = {
         // node and reads its frame; a descriptor read on its own tracks
         // presence (R13).
                 const r = t !== null && !inDraft(e) && !writeOverride;
-        const i = r && observerHoldsContainer(e, t);
-        let o;
-        if (i) o = enumerationSource(e); else if (r) {
+        const o = r && observerHoldsContainer(e, t);
+        let i;
+        if (o) i = enumerationSource(e); else if (r) {
             // The presence node's frame (core decides which) is the one described
             // (a chained target's inner store answers through the backing, §7b);
             // the descriptor itself comes from the backing the container's frame
@@ -1633,30 +1618,29 @@ const traps = {
             // the staging for a member; #3706 contrast).
             const t = getHasNode(e, n);
             const r = read(t);
-            o = readSource(e, n, true);
-            if (!r && (!e.ch || t.l & CONFIG_OVERRIDE || !(n in o))) return undefined;
-        } else o = readSource(e, n, true);
+            i = readSource(e, n, true);
+            if (!r && (!e.ch || t.l & CONFIG_OVERRIDE || !(n in i))) return undefined;
+        } else i = readSource(e, n, true);
         let l;
-        if (!i && optRead(e)) {
+        if (optHooks && !o && optRead(e)) {
             const t = optHooks.descriptor(e, n);
             if (t === null) return undefined;
             l = t;
         }
-        l ??= visibleDescriptor(e, o, n);
+        l ??= visibleDescriptor(e, i, n);
         if (l === undefined) return undefined;
         if (!(n === "length" && Array.isArray(e))) l.configurable = true;
         return l;
     },
     set(e, n, t) {
         const r = inDraft(e);
-        const i = !r && writeOverride;
-        if (!r && !i) {
+        if (!r && !writeOverride) {
             return true;
         }
         if (n === "__proto__") return true;
  // pollution guard (core R30)
                 const o = e.s ? t : unwrapValue(t);
-        const l = ensurePB(e);
+        const i = ensurePB(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
@@ -1668,40 +1652,32 @@ const traps = {
         // 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 (Array.isArray(i)) {
             touch(e, n);
             if (n === "length") e.wk = WK_ALL; else touch(e, "length");
         } else {
             touch(e, n);
-            if (!(n in l)) e.kc++;
+            if (!(n in i)) e.kc++;
         }
-        if (UNSAFE_KEYS.has(n)) {
-            Object.defineProperty(l, n, {
+        const l = UNSAFE_KEYS.has(n);
+        if (l || e.ovl && e.sc !== 2 && !hasOwn.call(i, n)) {
+            Object.defineProperty(i, n, {
                 value: o,
                 writable: true,
                 enumerable: true,
                 configurable: true
             });
-            if (e.del !== null) e.del.delete(n);
-            return true;
-        }
-        if (e.ovl && e.sc !== 2 && !hasOwn.call(l, n)) {
-            Object.defineProperty(l, n, {
-                value: o,
-                writable: true,
-                enumerable: true,
-                configurable: true
-            });
-        } else l[n] = o;
-        if (e.del !== null) e.del.delete(n);
+        } else i[n] = o;
+        e.del?.delete(n);
+        if (l) return true;
         if (e.s && o !== null && typeof o === "object") markRawOne(o);
-        if (i) notifyWrites(e);
-        return true;
+        if (!r) notifyWrites(e);
+ // a write-override write
+                return true;
     },
     defineProperty(e, n, t) {
         const r = inDraft(e);
-        const i = !r && writeOverride;
-        if (!r && !i) {
+        if (!r && !writeOverride) {
             return true;
         }
         if (n === "__proto__") return true;
@@ -1714,17 +1690,17 @@ const traps = {
         if (e.a || !(t.enumerable && t.writable && t.configurable)) e.sc = 1;
         touch(e, n);
         Object.defineProperty(o, n, t);
-        if (e.del !== null) e.del.delete(n);
-        if (i) notifyWrites(e);
-        return true;
+        e.del?.delete(n);
+        if (!r) notifyWrites(e);
+ // a write-override write
+                return true;
     },
     deleteProperty(e, n) {
         const t = inDraft(e);
-        const r = !t && writeOverride;
-        if (!t && !r) {
+        if (!t && !writeOverride) {
             return true;
         }
-        const i = ensurePB(e);
+        const r = ensurePB(e);
         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
@@ -1736,13 +1712,14 @@ const traps = {
         // 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];
+        if (hasOwn.call(r, n)) {
+            delete r[n];
             o || e.kc--;
         }
         if (o) (e.del ??= new Set).add(n);
-        if (r) notifyWrites(e);
-        return true;
+        if (!t) notifyWrites(e);
+ // a write-override write
+                return true;
     }
 };
 
@@ -1752,16 +1729,16 @@ const traps = {
     const t = e.k;
     if (t === null) return false;
     const r = t.ve;
-    return r !== null && r.u === n && (!(n.R & REACTIVE_RECOMPUTING_DEPS) || r.Te === n.Ne);
+    return r !== null && r.u === n && (!(n.R & REACTIVE_RECOMPUTING_DEPS) || r.de === n.Ne);
 }
 
 function storeSetter(e, n, t = true) {
     if (writeHook !== null) writeHook(e);
     const r = e[$TARGET];
-    const i = writeScopes;
+    const o = writeScopes;
     writeScopes = new Set;
     writeScopes.add(scopeKey(r));
-    const o = userWrite;
+    const i = userWrite;
     userWrite = t;
     writing++;
     let l;
@@ -1773,7 +1750,7 @@ function storeSetter(e, n, t = true) {
         l = n(e);
     } finally {
         writing--;
-        writeScopes = i;
+        writeScopes = o;
         // Outermost setter exit: emit write-time notifications (one node write
         // per changed observed key) so holds and lanes engage now.
                 if (writing === 0 && pendingNotify.size) {
@@ -1784,13 +1761,13 @@ function storeSetter(e, n, t = true) {
             // exit, unqueued: the backing is the pre-batch one (nothing swapped).
                         if (directCommit) for (const n of e) if (n.pb !== null) foldTarget(n, n.v);
         }
-        userWrite = o;
+        userWrite = i;
     }
     if (l !== undefined && l !== e && isWrappable(l)) {
         // A returned replacement: on an optimistic family a user's is itself an
         // optimistic edit — diffed against the view as guesses (`next` parity);
         // otherwise it is adopted as the incoming truth.
-        if (t && r.fam?.opt === true && !writeOverride) optHooks.writes(r, unwrapValue(l)); else adoptPB(r, unwrapValue(l));
+        if (optHooks && t && r.fam?.opt === true && !writeOverride) optHooks.writes(r, unwrapValue(l)); else adoptPB(r, unwrapValue(l));
     }
     // A34 (3), #3612 — the derived store's twin of `setMemo`: a user write to
     // a derivation another transaction holds is nobody's proposal; it becomes
@@ -1824,17 +1801,17 @@ function createStore(e, n) {
  * replaced by reference — #2932). The list driver uses this to choose the
  * slot-patch channel (collected row bodies) over per-record registration. */ function storeIsShallow(e) {
     const n = e?.[$TARGET];
-    return n !== undefined && n.s === true;
+    return n?.s === true;
 }
 
 /** True when `proxy` belongs to a projection family (S3). */ function storeHasFamily(e) {
     const n = e?.[$TARGET];
-    return n !== undefined && n.fam !== null;
+    return n?.fam != null;
 }
 
 /** True when `proxy` belongs to an OPTIMISTIC family (S4). */ function storeHasOptimisticFamily(e) {
     const n = e?.[$TARGET];
-    return n !== undefined && n.fam?.opt === true;
+    return n?.fam?.opt === true;
 }
 
 // ---------------------------------------------------------------------------
@@ -1844,7 +1821,7 @@ function visibleKeys(e, n) {
     if (e.ovl && n === e.pb) {
         t = Reflect.ownKeys(e.v);
         const r = e.del;
-        if (r !== null && r.size !== 0) t = t.filter(e => !r.has(e));
+        if (r?.size) t = t.filter(e => !r.has(e));
         for (const r of Reflect.ownKeys(n)) {
             if (!hasOwn.call(e.v, r)) t.push(r);
         }
@@ -1862,7 +1839,7 @@ function visibleKeys(e, n) {
 function visibleDescriptor(e, n, t) {
     let r = Object.getOwnPropertyDescriptor(n, t);
     if (e.ovl && n === e.pb) {
-        if (e.del !== null && e.del.has(t)) return undefined;
+        if (e.del?.has(t)) return undefined;
         if (r === undefined) r = Object.getOwnPropertyDescriptor(e.v, t);
     }
     return r;
@@ -1873,7 +1850,7 @@ function visibleDescriptor(e, n, t) {
 /** Tracking snapshot: subscribes every reachable record's container and deep
  * witness (one node per record, not one per path), then snapshots. */ function deep(e) {
     const n = e?.[$TARGET];
-    if (n === undefined || n.px !== e) return e;
+    if (n?.px !== e) return e;
     const t = new Set;
     const childTarget = (e, n, t) => {
         let r = lookupTarget(n, e.fam);
@@ -1905,13 +1882,13 @@ function visibleDescriptor(e, n, t) {
                 continue;
  // accessors track through their own reads when invoked
                         }
-            let i = r.value;
-            if (i === null || typeof i !== "object") continue;
-            if (e.ch && i[$TARGET] === undefined) i = resolveChainedRaw(e, t, i);
-            const o = childTarget(e, i, t);
-            if (o === undefined) continue;
+            let o = r.value;
+            if (o === null || typeof o !== "object") continue;
+            if (e.ch && o[$TARGET] === undefined) o = resolveChainedRaw(e, t, o);
+            const i = childTarget(e, o, t);
+            if (i === undefined) continue;
  // raw-marked: leaf by contract
-                        walkT(o);
+                        walkT(i);
         }
     };
     walkT(n);
@@ -1930,68 +1907,68 @@ function snapshotWalk(e, n, t) {
     let r = e;
     for (let e = true; ;e = false) {
         const n = r?.[$TARGET]?.v !== undefined;
-        let i = n ? r[$TARGET] : undefined;
-        if (i === undefined && t !== null) i = lookupTarget(r, t);
-        if (i === undefined) i = lookupTarget(r, null);
-        if (i === undefined) break;
-        if (e && !n && t !== null && i.fam !== t) {
-            const e = t.map.get(i.px);
-            if (e !== undefined) i = e;
+        let o = n ? r[$TARGET] : undefined;
+        if (o === undefined && t !== null) o = lookupTarget(r, t);
+        if (o === undefined) o = lookupTarget(r, null);
+        if (o === undefined) break;
+        if (e && !n && t !== null && o.fam !== t) {
+            const e = t.map.get(o.px);
+            if (e !== undefined) o = e;
         }
-        if (i.fam !== null) t = i.fam;
+        if (o.fam !== null) t = o.fam;
         // 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.l & CONFIG_HELD))) {
-            if (i.ovl) materializePB(i);
-            o = i.pb;
+                let i = o.v;
+        if (o.pb !== null && (inDraft(o) || writeOverride || o.k === null || !(o.k.l & CONFIG_HELD))) {
+            if (o.ovl) materializePB(o);
+            i = o.pb;
         }
-        if (optRead(i)) o = optHooks.view(i, o);
-        if (o === r) break;
-        r = o;
+        if (optHooks && optRead(o)) i = optHooks.view(o, i);
+        if (i === r) break;
+        r = i;
     }
     if (!isWrappable(r)) return r;
-    const i = n.get(r);
-    if (i !== undefined) return i;
+    const o = n.get(r);
+    if (o !== undefined) return o;
     if (isOwned(r)) {
         const e = Array.isArray(r);
-        const i = e ? [] : Object.create(Object.getPrototypeOf(r));
-        n.set(r, i);
-        for (const o of Reflect.ownKeys(r)) {
-            if (e && o === "length" || o === $OWNER) continue;
-            const l = Object.getOwnPropertyDescriptor(r, o);
-            if (typeof o === "symbol" && !l.enumerable) continue;
+        const o = e ? [] : Object.create(Object.getPrototypeOf(r));
+        n.set(r, o);
+        for (const i of Reflect.ownKeys(r)) {
+            if (e && i === "length" || i === $OWNER) continue;
+            const l = Object.getOwnPropertyDescriptor(r, i);
+            if (typeof i === "symbol" && !l.enumerable) continue;
             if (l.get || l.set) {
-                Object.defineProperty(i, o, l);
+                Object.defineProperty(o, i, l);
                 continue;
             }
             const u = l.value;
             const f = u !== null && typeof u === "object" ? snapshotWalk(u, n, t) : u;
-            if (l.enumerable && l.writable && l.configurable) i[o] = f; else Object.defineProperty(i, o, {
+            if (l.enumerable && l.writable && l.configurable) o[i] = f; else Object.defineProperty(o, i, {
                 ...l,
                 value: f
             });
         }
-        if (e && i.length !== r.length) i.length = r.length;
-        return i;
+        if (e && o.length !== r.length) o.length = r.length;
+        return o;
     }
     n.set(r, r);
-    let o = null;
+    let i = null;
     for (const e of Reflect.ownKeys(r)) {
-        const i = Object.getOwnPropertyDescriptor(r, e);
-        if (!i || i.get || i.set) continue;
-        const l = i.value;
+        const o = Object.getOwnPropertyDescriptor(r, e);
+        if (!o || o.get || o.set) continue;
+        const l = o.value;
         if (l === null || typeof l !== "object") continue;
         const u = snapshotWalk(l, n, t);
         if (u !== l) {
-            if (o === null) {
-                o = Array.isArray(r) ? [ ...r ] : Object.create(Object.getPrototypeOf(r), Object.getOwnPropertyDescriptors(r));
-                n.set(r, o);
+            if (i === null) {
+                i = Array.isArray(r) ? [ ...r ] : Object.create(Object.getPrototypeOf(r), Object.getOwnPropertyDescriptors(r));
+                n.set(r, i);
             }
-            o[e] = u;
+            i[e] = u;
         }
     }
-    return o ?? r;
+    return i ?? r;
 }
 
 export { $PROXY, $TARGET, $TRACK, LaneView, adoptPB, arrayStructureChanged, asBacking, bumpDeep, cloneRaw, committed, containerEquals, createStore, deep, getContainerNode, getHasNode, getNode, hasAccessorFlag, materializePB, membershipChanged, notifyFold, notifyFoldTail, notifyKeyDiff, notifyKeyValue, resolveChainedRaw, runDirect, sameKey, sameRow, snapshot, storeHasFamily, storeHasOptimisticFamily, storeIsShallow, storeSetter, targetsEqual, unwrapValue, userWriting, wrap };