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

package/dist/observe/store/store.js

@@ -16,7 +16,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, storeOwners, setLookup, $OWNER, isOwned, markDescendants, devAssertNeverUserMutation } from "./target.js";
+import { lookupTarget, storeOwners, setLookup, $OWNER, isOwned, markDescendants } from "./target.js";
 
 import { optHooks, affectsHooks } from "./hooks.js";
 
@@ -97,7 +97,7 @@ export { markRaw } from "./types.js";
 
 TargetShape.prototype = Object.prototype;
 
-function createTarget(e, n, t, r = n?.fam ?? null) {
+function createTarget(e, t, n, r = t?.fam ?? null) {
     // The proxy target carries the array exotic class when the value is an
     // array, so Array.isArray(proxy) is true; the fields live on it directly.
     // Direct field assignment in one fixed order (no Object.assign literal
@@ -114,8 +114,8 @@ function createTarget(e, n, t, r = n?.fam ?? null) {
     o.k = null;
     o.dk = null;
     o.wk = null;
-    o.u = n;
-    o.pk = t;
+    o.u = t;
+    o.pk = n;
     o.px = null;
     o.d = false;
     o.a = false;
@@ -131,20 +131,20 @@ function createTarget(e, n, t, r = n?.fam ?? null) {
     return o;
 }
 
-function wrap(e, n = null, t = null, r = n?.fam ?? null) {
+function wrap(e, t = null, n = null, r = t?.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 o = lookupTarget(e, r);
     if (o !== undefined) return o.px;
     const i = e[$TARGET];
-    if (i !== undefined && i.px === e) {
+    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 || i.fam === r) return e;
-        return createTarget(e, n, t, r).px;
+        return createTarget(e, t, n, r).px;
     }
-    return createTarget(e, n, t, r).px;
+    return createTarget(e, t, n, r).px;
 }
 
 /** Unwrap our own proxies to their current backing; leave everything else.
@@ -152,13 +152,13 @@ function wrap(e, n = null, t = null, r = n?.fam ?? null) {
  * (projection.ts `wrapDraft`) — adopted as a backing, it would forward to
  * itself (#3767). */ function unwrapValue(e) {
     if (e == null || typeof e !== "object") return e;
-    const n = e[$TARGET];
-    if (n !== undefined && (n.px === e || lookupTarget(e, n.fam) === n) && n.v !== undefined) {
+    const t = e[$TARGET];
+    if (t !== undefined && (t.px === e || lookupTarget(e, t.fam) === t) && t.v !== undefined) {
         // A draft escaping into other storage must be a REAL container that
         // becomes this target's committed backing at fold (the shared-raw
         // contract) — a prototype overlay is neither.
-        if (n.ovl) materializePB(n);
-        return n.pb ?? n.v;
+        if (t.ovl) materializePB(t);
+        return t.pb ?? t.v;
     }
     return e;
 }
@@ -171,14 +171,14 @@ function wrap(e, n = null, t = null, r = n?.fam ?? null) {
 // resolving to the same child target are the same slot (privatization/
 // adoption swap raw identity without changing the logical value — only
 // changed leaves notify, R9).
-const slotNodeEquals = function(e, n) {
-    return isEqual(e, n) || sameLogicalSlot(this.O, e, n);
+const slotNodeEquals = function(e, t) {
+    return isEqual(e, t) || sameLogicalSlot(this.O, e, t);
 };
 
 /** The deep witness: the store decides when it notifies. */ const never = false;
 
-function sameKey(e, n) {
-    return e === n || e !== e && n !== n;
+function sameKey(e, t) {
+    return e === t || e !== e && t !== t;
 }
 
 /** The container node's arrangement guess: the rows (or keys) the setter
@@ -191,14 +191,14 @@ function sameKey(e, n) {
     constructor(e, 
     /** The backing the guess is shown over: the committed one at the
      * guess, the composed arrangement after a re-base (optimistic.ts). */
-    n, 
+    t, 
     /** Keys the setter REMOVED from the view it saw (a deliberate delete,
      * not a row the truth has yet to show): a re-base does not restore
      * them. `null` when none. */
-    t = null) {
+    n = null) {
         this.rows = e;
-        this.base = n;
-        this.removed = t;
+        this.base = t;
+        this.removed = n;
     }
 }
 
@@ -209,38 +209,38 @@ 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);
+ * an arrangement (`LaneView`), judged by the optimistic machinery. */ const containerEquals = function(e, t) {
+    return e === t || !!optHooks?.arrangement(this.O, e, t);
 };
 
-function sameLogicalSlot(e, n, t) {
-    if (n === null || typeof n !== "object" || t === null || typeof t !== "object") return false;
-    const r = lookupTarget(n, e.fam);
-    return r !== undefined && r === lookupTarget(t, e.fam);
+function sameLogicalSlot(e, t, n) {
+    if (t === null || typeof t !== "object" || n === null || typeof n !== "object") return false;
+    const r = lookupTarget(t, e.fam);
+    return r !== undefined && r === lookupTarget(n, e.fam);
 }
 
 /** Slot nodes whose last subscriber left while they still held a staging:
  * released at the commit that resolves it (`drainFolds`). */ const deferredReleases = new Set;
 
 function releaseSlot(e) {
-    const n = e.O;
-    const t = e.Vt;
-    if (t === $TRACK) {
-        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) {
-        delete n.n[t];
-        n.nc--;
-    } else if (n.h !== null && n.h[t] === e) delete n.h[t];
+    const t = e.O;
+    const n = e.Vt;
+    if (n === $TRACK) {
+        if (t.k === e) t.k = null;
+    } else if (n === $DEEP) {
+        if (t.dk === e) t.dk = null;
+    } else if (t.n?.[n] === e) {
+        delete t.n[n];
+        t.nc--;
+    } else if (t.h?.[n] === e) delete t.h[n];
     // 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);
+        if (t.fam !== null && t.nc === 0 && t.k === null && t.dk === null && (t.h === null || Reflect.ownKeys(t.h).length === 0)) t.fam.live.delete(t);
 }
 
-/** A node was born on `target`: a family target enters the live index. */ function noteNode(e, n, t) {
+/** A node was born on `target`: a family target enters the live index. */ function noteNode(e, t, n) {
     if (e.fam !== null) e.fam.live.add(e);
     markDescendants(e);
-    if (affectsHooks !== null) affectsHooks.ro(e, n, t);
+    if (affectsHooks !== null) affectsHooks.ro(e, t, n);
 }
 
 // Shared slot-node release handler: registered once; the core sweep
@@ -261,10 +261,10 @@ setSlotUnobserved(e => {
  * frames (A29): committed from the committed backing, the staging from the
  * pending one — and held by the container's transaction when the container
  * is held (#3706: the unit of the hold is the key — a key the batch left
- * unchanged stages nothing and holds no one). */ function bornStaged(e, n, t, r) {
-    if (n.Ye && n.Ye(n.Ie, t)) return;
-    queuePendingNode(n);
-    n.ue = t;
+ * unchanged stages nothing and holds no one). */ function bornStaged(e, t, n, r) {
+    if (t.Ye && t.Ye(t.Ie, n)) return;
+    queuePendingNode(t);
+    t.ue = n;
     const o = e.k;
     if (o === null) return;
  // a node-less staging holds nothing (`stageOn`)
@@ -275,28 +275,28 @@ setSlotUnobserved(e => {
     // correction's hold's.)
         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));
+        if (!(o.l & CONFIG_OVERRIDE) || e.folded) holdNode(t, resolveTx(e._parent ?? e));
     }
     // A28 (4): a batch written inside a creation-time pass is promoted — its
     // late-materialized leaf with it.
-        if (o.l & CONFIG_PROMOTED) notePromotedWrite(n);
+        if (o.l & CONFIG_PROMOTED) notePromotedWrite(t);
 }
 
-function getNode(e, n, 
+function getNode(e, t, 
 // First-read dedupe (create-floor slice 2): the get trap probes
 // accessor-ness right before creating the node — pass the verdict through
 // so creation skips the second descriptor scan. -1 = unknown (other
 // callers), 0/1 = probed.
-t = -1) {
+n = -1) {
     const r = e.n ??= Object.create(null);
-    let o = r[n];
+    let o = r[t];
     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 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 !== null && e.del.has(n) ? undefined : i[n], n);
+        const l = o = slotSignal(committed(e)[t], slotNodeEquals, e, t, n === -1 ? isOwnAccessor(i ?? e.v, t) : n === 1);
+        if (i !== null && !l.acc) bornStaged(e, l, e.del?.has(t) ? undefined : i[t], t);
         // Attribution-only: name store property nodes by path segment so
         // attribution chains and wide-scope warnings read "store.todos" (or
         // "todos.title" when the store was declared with a name), not
@@ -304,28 +304,28 @@ t = -1) {
         // the hottest store path, and the disabled cost must stay one null
         // check (nodes created before enable() stay generically named).
                 if (attrHooks !== null) {
-            const t = storeRoot(e);
-            l._name = (storeNames.get(t) ?? "store") + "." + String(n);
-            l._loc = storeLocs.get(t);
+            const n = storeRoot(e);
+            l._name = (storeNames.get(n) ?? "store") + "." + String(t);
+            l._loc = storeLocs.get(n);
             stampNodeOwner(l, e);
         }
-        r[n] = o;
+        r[t] = o;
         e.nc++;
-        noteNode(e, l, n);
+        noteNode(e, l, t);
     }
     return o;
 }
 
-function getHasNode(e, n) {
-    const t = e.h ??= Object.create(null);
-    let r = t[n];
+function getHasNode(e, t) {
+    const n = e.h ??= Object.create(null);
+    let r = n[t];
     if (r === undefined) {
-        const o = r = slotSignal(n in committed(e), isEqual, e, n, false);
+        const o = r = slotSignal(t in committed(e), isEqual, e, t, false);
         const i = e.pb;
-        if (i !== null) bornStaged(e, o, n in i && !(e.del !== null && e.del.has(n)), n);
+        if (i !== null) bornStaged(e, o, t in i && !e.del?.has(t), t);
         if (attrHooks !== null) stampNodeOwner(o, e);
-        t[n] = r;
-        noteNode(e, o, n);
+        n[t] = r;
+        noteNode(e, o, t);
     }
     return r;
 }
@@ -333,22 +333,22 @@ function getHasNode(e, n) {
 /** The container node (plan sec. 31.3): created by the first structural subscription
  * or the first write that needs to stage. Its committed value is the
  * committed backing. */ function getContainerNode(e) {
-    let n = e.k;
-    if (n === null) {
-        n = e.k = slotSignal(e.v, containerEquals, e, $TRACK, false);
-        if (attrHooks !== null) stampNodeOwner(n, e);
-        noteNode(e, n, $TRACK);
+    let t = e.k;
+    if (t === null) {
+        t = e.k = slotSignal(e.v, containerEquals, e, $TRACK, false);
+        if (attrHooks !== null) stampNodeOwner(t, e);
+        noteNode(e, t, $TRACK);
         // Born while a batch is staged without a node (`stageOn`): the node
         // takes the staging as its own — the pre-batch backing committed, the
         // 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.ue = e.pb;
-            queuePendingNode(n);
+            t.Ie = preBatch(e);
+            t.ue = e.pb;
+            queuePendingNode(t);
         }
     }
-    return n;
+    return t;
 }
 
 /** Q-A's escape hatch (plan sec. 33; measured plan sec. 41.4): a staging needs the container
@@ -360,38 +360,38 @@ function getHasNode(e, n) {
  * staging: nothing allocates, nothing is swept at the commit (dbmon's tick
  * re-created, queued, swept and dropped ~7000 container nodes). If the
  * flush parks, the seam materializes and holds the node then
- * (`storeParkHook`) — the one case the staging home exists for. */ function stageOn(e, n) {
+ * (`storeParkHook`) — the one case the staging home exists for. */ function stageOn(e, t) {
     if (e.k === null && passLane === null && (context === null || globalQueue.q) && !deriveHolds(e)) return;
-    const t = getContainerNode(e);
-    if (t.ue === NOT_PENDING) queuePendingNode(t);
-    t.ue = n;
+    const n = getContainerNode(e);
+    if (n.ue === NOT_PENDING) queuePendingNode(n);
+    n.ue = t;
     // 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);
-    if (e.fam !== null) holdWithDerive(e, t);
+        if (context !== null) notePromotedWrite(n);
+    if (e.fam !== null) holdWithDerive(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.l & CONFIG_HELD) !== 0;
+    const t = e.fam?.node;
+    return t != null && !userWrite && (t.l & CONFIG_HELD) !== 0;
 }
 
 const storePark = e => {
-    for (let n = 0; n < foldList.length; n++) {
-        const t = foldList[n];
-        if (t.k === null && t.pb !== null) holdNode(getContainerNode(t), e);
+    for (let t = 0; t < foldList.length; t++) {
+        const n = foldList[t];
+        if (n.k === null && n.pb !== null) holdNode(getContainerNode(n), e);
     }
 };
 
 function getDeepNode(e) {
-    let n = e.dk;
-    if (n === null) {
-        n = e.dk = slotSignal(0, never, e, $DEEP, false);
-        if (attrHooks !== null) stampNodeOwner(n, e);
-        noteNode(e, n, $DEEP);
+    let t = e.dk;
+    if (t === null) {
+        t = e.dk = slotSignal(0, never, e, $DEEP, false);
+        if (attrHooks !== null) stampNodeOwner(t, e);
+        noteNode(e, t, $DEEP);
     }
-    return n;
+    return t;
 }
 
 function bumpDeep(e) {
@@ -401,12 +401,12 @@ function bumpDeep(e) {
 /** The structural readers' one notification: a membership/arrangement
  * change on the container (the staging is already on the node; `setSignal`
  * re-stages the same backing and walks the subscribers — and, on later
- * steps, routes a held or lane-owned container the way any node is). */ function notifyContainer(e, n) {
+ * steps, routes a held or lane-owned container the way any node is). */ function notifyContainer(e, t) {
     // A container carrying an arrangement guess takes the write as a landing
     // 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.l & CONFIG_OVERRIDE) setSignal(e, n); else {
+    if (e.l & CONFIG_OVERRIDE) setSignal(e, t); else {
         if (e.l & CONFIG_HELD) joinFuture(txOf(e));
         if (snapshotCaptureActive) captureWriteSnapshot(e, e.Ie);
         insertSubs(e);
@@ -416,17 +416,17 @@ function bumpDeep(e) {
 
 // Observe-tier labels and owners (attribution).
 function storeRoot(e) {
-    let n = e;
-    while (n.u !== null) n = n.u;
-    return n;
+    let t = e;
+    while (t.u !== null) t = t.u;
+    return t;
 }
 
 function storeRootOwner(e) {
     return storeOwners.get(storeRoot(e));
 }
 
-function stampNodeOwner(e, n) {
-    e.H = storeRootOwner(n) ?? null;
+function stampNodeOwner(e, t) {
+    e.H = storeRootOwner(t) ?? null;
 }
 
 const storeNames = new WeakMap;
@@ -436,11 +436,11 @@ const storeNames = new WeakMap;
 // neither).
 const storeLocs = new WeakMap;
 
-function nameStore(e, n, t) {
+function nameStore(e, t, n) {
     if (attrHooks !== null) {
         const r = e[$TARGET];
-        if (n) storeNames.set(r, n);
-        if (t) storeLocs.set(r, t);
+        if (t) storeNames.set(r, t);
+        if (n) storeLocs.set(r, n);
     }
 }
 
@@ -454,59 +454,59 @@ const lookupSetter = Object.prototype.__lookupSetter__;
 
 const propertyIsEnumerable = Object.prototype.propertyIsEnumerable;
 
-function isOwnAccessor(e, n) {
-    return hasOwn.call(e, n) && (lookupGetter.call(e, n) !== undefined || lookupSetter.call(e, n) !== undefined);
+function isOwnAccessor(e, t) {
+    return hasOwn.call(e, t) && (lookupGetter.call(e, t) !== undefined || lookupSetter.call(e, t) !== undefined);
 }
 
 /** Shallow clone into store ownership. Plain data (grade 2) spreads; anything
- * else copies descriptors (accessors kept, everything made configurable). */ function cloneRaw(e, n) {
-    n.sc || scanAccessorsOnce(n);
-    if (n.sc === 2) {
-        const t = {
+ * else copies descriptors (accessors kept, everything made configurable). */ function cloneRaw(e, t) {
+    t.sc || scanAccessorsOnce(t);
+    if (t.sc === 2) {
+        const n = {
             ...e
         };
-        t[$OWNER] = n;
-        return t;
+        n[$OWNER] = t;
+        return n;
     }
-    const t = Object.getOwnPropertyDescriptors(e);
-    for (const r of Reflect.ownKeys(t)) {
-        const o = t[r];
+    const n = Object.getOwnPropertyDescriptors(e);
+    for (const r of Reflect.ownKeys(n)) {
+        const o = n[r];
         if (r === "length" && Array.isArray(e)) continue;
         o.configurable = true;
-        if (!o.get && !o.set) o.writable = true; else n.a = true;
+        if (!o.get && !o.set) o.writable = true; else t.a = true;
     }
-    const r = Array.isArray(e) ? Object.defineProperties([], t) : Object.create(Object.getPrototypeOf(e), t);
-    r[$OWNER] = n;
+    const r = Array.isArray(e) ? Object.defineProperties([], n) : Object.create(Object.getPrototypeOf(e), n);
+    r[$OWNER] = t;
     return r;
 }
 
-/** Wide plain clone (many keys): null-prototype build, then reset. */ function wideClone(e, n) {
-    const t = Object.create(null);
-    for (const n of Reflect.ownKeys(e)) t[n] = e[n];
-    Object.setPrototypeOf(t, Object.prototype);
-    t[$OWNER] = n;
-    return t;
+/** Wide plain clone (many keys): null-prototype build, then reset. */ function wideClone(e, t) {
+    const n = Object.create(null);
+    for (const t of Reflect.ownKeys(e)) n[t] = e[t];
+    Object.setPrototypeOf(n, Object.prototype);
+    n[$OWNER] = t;
+    return n;
 }
 
-function copyOwn(e, n, t) {
-    const r = Object.getOwnPropertyDescriptor(n, t);
-    if (r.get || r.set || !r.enumerable || !r.writable || !r.configurable) Object.defineProperty(e, t, r); else e[t] = r.value;
+function copyOwn(e, t, n) {
+    const r = Object.getOwnPropertyDescriptor(t, n);
+    if (r.get || r.set || !r.enumerable || !r.writable || !r.configurable) Object.defineProperty(e, n, r); else e[n] = r.value;
 }
 
 /** One descriptor scan per container (grade 1/2, `a`, `kc`). */ function scanAccessorsOnce(e) {
-    const n = e.v;
-    const t = Reflect.ownKeys(n);
-    let r = Object.getPrototypeOf(n) === Object.prototype;
-    for (const o of t) {
-        if (lookupGetter.call(n, o) !== undefined || lookupSetter.call(n, o) !== undefined) {
+    const t = e.v;
+    const n = Reflect.ownKeys(t);
+    let r = Object.getPrototypeOf(t) === Object.prototype;
+    for (const o of n) {
+        if (isOwnAccessor(t, o)) {
             e.a = true;
             r = false;
             break;
         }
-        if (r && !propertyIsEnumerable.call(n, o)) r = false;
+        if (r && !propertyIsEnumerable.call(t, o)) r = false;
     }
     e.sc = r ? 2 : 1;
-    e.kc = t.length;
+    e.kc = n.length;
     return !e.a;
 }
 
@@ -521,84 +521,76 @@ const OVERLAY_REBUILD_MIN_ADDS = 16;
 const WK_ALL = new Set;
 
 const plainProto = e => {
-    const n = Object.getPrototypeOf(e);
-    return n === Object.prototype || n === Array.prototype || n === null;
+    const t = Object.getPrototypeOf(e);
+    return t === Object.prototype || t === Array.prototype || t === null;
 };
 
 /** An overlay with many adds (or any delete) rebuilds the committed
- * container at flatten so its shape stays fast (#3689). */ function overlayRebuilds(e, n) {
+ * container at flatten so its shape stays fast (#3689). */ function overlayRebuilds(e, t) {
     if (e.kc > OVERLAY_REBUILD_MAX_KEYS) return false;
-    if (e.del !== null && e.del.size !== 0) return true;
-    const t = e.wk;
-    if (t !== null && t !== WK_ALL && t.u === undefined && t.size <= OVERLAY_REBUILD_MIN_ADDS) return false;
+    if (e.del?.size) return true;
+    const n = e.wk;
+    if (n !== null && n !== WK_ALL && n.u === undefined && n.size <= OVERLAY_REBUILD_MIN_ADDS) return false;
     const r = e.v;
     let o = 0;
-    for (const e of Reflect.ownKeys(n)) if (!hasOwn.call(r, e) && ++o > OVERLAY_REBUILD_MIN_ADDS) return true;
+    for (const e of Reflect.ownKeys(t)) 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);
-    e.pb = t;
-    e.ovl = false;
+    const t = e.pb;
+    if (!e.ovl) return t;
+    const n = overlayOnto(e, e.sc === 2 ? wideClone(e.v, e) : cloneRaw(e.v, e), t);
+    e.pb = n;
     // The staging IS the pending backing: re-point the container node.
-        if (e.k !== null && e.k.ue === n) e.k.ue = t;
-    return t;
+        if (e.k?.ue === t) e.k.ue = n;
+    return n;
 }
 
 /** The batch's pending backing, created on the first draft write: an overlay
  * of an owned plain-data record above the key threshold, a clone otherwise.
  * Staged on the container node (the scheduler owns its lifetime) and queued
  * for the fold at the flush's commit. */ function ensurePB(e) {
-    let n = e.pb;
+    let t = e.pb;
     // 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 (n !== null && !isOwned(n)) {
+    if (t !== null && !isOwned(t)) {
         // 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
         // HELD (another transaction's): then the held staging stays the
         // adoption and the draft is a mainline layer above it (#3612/#3688: a
         // 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.ue = n;
-    } else if (n === null) {
-        const t = e.v;
+        t = e.pb = cloneRaw(t, e);
+        const n = e.k;
+        if (n !== null && !(n.l & CONFIG_HELD)) n.ue = t;
+    } else if (t === null) {
+        const n = e.v;
         if (!directCommit) queueFold(e);
-        if (!e.ch && !Array.isArray(t) && (e.sc !== 0 ? !e.a : scanAccessorsOnce(e)) && e.kc > OVERLAY_MIN_KEYS && isOwned(t)) {
-            n = e.pb = Object.create(t);
+        if (!e.ch && !Array.isArray(n) && (e.sc !== 0 ? !e.a : scanAccessorsOnce(e)) && e.kc > OVERLAY_MIN_KEYS && isOwned(n)) {
+            t = e.pb = Object.create(n);
             e.ovl = true;
-        } else n = e.pb = cloneRaw(t, e);
-        if (!directCommit) stageOn(e, n);
+        } else t = e.pb = cloneRaw(n, e);
+        if (!directCommit) stageOn(e, t);
     }
-    return n;
+    return t;
 }
 
 /** Privatize `target`'s committed backing (and its ancestor chain — a shared
  * parent cannot point at an owned child). Not a reactive event. */ function privatizeCommitted(e) {
     if (isOwned(e.v)) return;
-    const n = e.v;
-    const t = cloneRaw(n, e);
+    const t = e.v;
+    const n = cloneRaw(t, e);
     // Mid-batch (a staging is open on this target) the fold still sees the
     // backing the batch started from: the queue recorded it (`foldOlds`).
-        e.v = t;
+        e.v = n;
     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;
+        const n = e.u.v;
+        const r = parentSlotKey(e, t);
+        if (n[r] === t) n[r] = e.v;
     }
 }
 
@@ -606,30 +598,33 @@ const plainProto = e => {
  * when an array parent moved it (#3282). Not searched when the slot already
  * holds this target's backing (a parent adopted whole carries its children's
  * new raws before the children fold — the miss was O(rows) per changed row
- * of a keyed reconcile). */ function parentSlotKey(e, n) {
-    const t = e.pk;
+ * of a keyed reconcile). */ function parentSlotKey(e, t) {
+    const n = e.pk;
     const r = e.u.v;
-    if (r[t] === n || r[t] === e.v || !Array.isArray(r)) return t;
-    const o = r.indexOf(n);
-    if (o === -1) return t;
+    if (r[n] === t || r[n] === e.v || !Array.isArray(r)) return n;
+    const o = r.indexOf(t);
+    if (o === -1) return n;
     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) {
+ * place — the backing keeps its identity. */ function flattenOverlay(e, t) {
     privatizeCommitted(e);
-    const t = e.v;
+    overlayOnto(e, e.v, t);
+ // 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, t, n) {
     for (const r of Reflect.ownKeys(n)) e.sc === 2 ? t[r] = n[r] : copyOwn(t, n, r);
     if (e.del !== null) {
         for (const n of e.del) delete t[n];
         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 t;
 }
 
 /** Adoption (a setter's returned replacement; reconcile and projection
@@ -641,7 +636,7 @@ const plainProto = e => {
  * they were LAST told (#3296): the draft's pending backing when one
  * preceded the adoption this batch — its node writes were real, and the
  * adoption's re-stage cancels or confirms each — else the committed
- * backing. */ function adoptPB(e, n, t = true) {
+ * backing. */ function adoptPB(e, t, n = true) {
     if (!directCommit) queueFold(e);
     let r;
     if (e.pb !== null) {
@@ -650,27 +645,27 @@ 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.Ie = t;
     } else {
         // Eager (INTERNALS §3): the backing swaps now — handlers read the
         // adopted object before the flush — while the container node, when
         // there is one (`stageOn`), keeps the committed frame (`_value`) for
         // readers a hold keeps on it, and stages the adoption for the fold's
         // path copy.
-        e.pb = n;
-        stageOn(e, n);
+        e.pb = t;
+        stageOn(e, t);
     }
-    e.v = n;
-    e.ch = n[$TARGET] !== undefined;
+    e.v = t;
+    e.ch = t[$TARGET] !== undefined;
     e.ovl = false;
     e.del = null;
     e.sc = 0;
     e.a = false;
     e.wk = null;
  // adoption supersedes staged trap writes
-        const o = n[$OWNER];
-    if (o !== undefined && o.fam === e.fam) n[$OWNER] = e; else setLookup(n, e);
-    if (t && r !== n) notifyFold(e, r, n);
+        const o = t[$OWNER];
+    if (o?.fam === e.fam) t[$OWNER] = e; else setLookup(t, e);
+    if (n && r !== t) notifyFold(e, r, t);
 }
 
 // ---------------------------------------------------------------------------
@@ -724,8 +719,8 @@ let foldIndex = null;
         foldIndex = new Map;
         for (let e = 0; e < foldList.length; e++) foldIndex.set(foldList[e], e);
     }
-    const n = foldIndex.get(e);
-    return n === undefined ? e.v : foldOlds[n];
+    const t = foldIndex.get(e);
+    return t === undefined ? e.v : foldOlds[t];
 }
 
 /** The flush committed its pending nodes: fold every pending backing whose
@@ -735,25 +730,25 @@ let foldIndex = null;
  * releases. */ function drainFolds() {
     if (foldList.length !== 0) {
         const e = foldList;
-        const n = foldOlds;
+        const t = foldOlds;
         foldList = foldSpare;
         foldOlds = foldOldsSpare;
         foldSpare = e;
-        foldOldsSpare = n;
+        foldOldsSpare = t;
         foldIndex = null;
-        for (let t = 0; t < e.length; t++) {
-            const r = e[t];
+        for (let n = 0; n < e.length; n++) {
+            const r = e[n];
             if (r.pb === null) continue;
  // folded already (a direct commit)
                         const o = r.k;
             if (o !== null && o.ue !== NOT_PENDING) {
                 // held: commits with its hold
                 foldList.push(r);
-                foldOlds.push(n[t]);
-            } else foldTarget(r, n[t]);
+                foldOlds.push(t[n]);
+            } else foldTarget(r, t[n]);
         }
         e.length = 0;
-        n.length = 0;
+        t.length = 0;
     }
     if (deferredReleases.size !== 0) {
         for (const e of deferredReleases) {
@@ -769,19 +764,19 @@ let foldIndex = null;
  * 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.k = e => {
-    const n = e.O?.fam;
-    return n != null && n.node !== null && (n.node.m & STATUS_PENDING) !== 0;
+    const t = e.O?.fam;
+    return (t?.node?.m & STATUS_PENDING) !== 0;
 };
 
 /** Core asks (lanes.ts `covered`): the value a slot node's guess covered.
  * A chained link's committed value is the inner store's at the last
  * read-through — refreshed here, since a guess served the reads since
  * (#3672: the revert compares against the base's live value). */ GlobalQueue.fn = e => {
-    const n = e.O;
-    if (n.ch) {
-        const t = e.Vt;
-        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]));
+    const t = e.O;
+    if (t.ch) {
+        const n = e.Vt;
+        const r = t.v;
+        if (t.h?.[n] === e) e.Ie = untrack(() => n in r); else if (t.n?.[n] === e) e.Ie = untrack(() => unwrapValue(r[n]));
     }
     return e.Ie;
 };
@@ -802,76 +797,66 @@ GlobalQueue.fo = isWrappable;
  * containers at once. Only the synchronous first run. */ let directCommit = false;
 
 function runDirect(e) {
-    const n = directCommit;
+    const t = directCommit;
     directCommit = true;
     try {
         e();
     } finally {
-        directCommit = n;
+        directCommit = t;
     }
 }
 
-/** Fold one target's pending backing into its committed home. */ function foldTarget(e, n) {
+/** Fold one target's pending backing into its committed home. */ function foldTarget(e, t) {
     {
         {
-            const t = e.k;
+            const n = 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?.lt !== n)) {
+                if (r === e.v) ; else if (e.ovl && (e.v !== t || !overlayRebuilds(e, r) && n?.T?.lt !== t)) {
                     // Overlay flatten (#3044): the backing keeps its identity, so the
                     // `t.v === old` gate below skips path copying (the parent slot
                     // already points here) and the adopted-notify (setter
                     // notifications happened at write time). A backing privatized
                     // mid-batch is a fresh clone the parent already points at.
                     flattenOverlay(e, r);
-                } else if (e.v !== n) {
+                } else if (e.v !== t) {
                     // Privatized mid-batch (a child's path copy repointed us): the
                     // owned backing takes the written keys.
                     privatizeCommitted(e);
-                    const t = e.v;
+                    const n = e.v;
                     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];
+                        for (let e = o; e !== undefined; e = e.u) for (const t of e) {
+                            if (hasOwn.call(r, t)) copyOwn(n, r, t); else delete n[t];
                         }
                     } else {
-                        for (const e of Reflect.ownKeys(r)) {
-                            const o = Object.getOwnPropertyDescriptor(r, e);
-                            if (o.get || o.set || !o.enumerable || !o.writable || !o.configurable) Object.defineProperty(t, e, o); else if (o.value !== n[e] || !hasOwn.call(n, e)) t[e] = o.value;
-                        }
-                        for (const e of Reflect.ownKeys(n)) {
-                            if (!hasOwn.call(r, e)) delete t[e];
+                        for (const e of Reflect.ownKeys(r)) copyOwn(n, r, e);
+                        for (const e of Reflect.ownKeys(t)) {
+                            if (!hasOwn.call(r, e)) delete n[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;
                 }
-            }
-            if (t !== null) {
+                e.pb = null;
+                e.wk = null;
+ // the written-keys window closes with the commit
+                        }
+            if (n !== 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 (n.o === null) e.k = null; else if (n.Ie instanceof LaneView) n.Ie.base = e.v; else n.Ie = e.v;
             }
-            if (e.v !== n && e.u) {
-                const t = parentSlotKey(e, n);
-                if (e.u.v[t] === n) {
+            if (e.v !== t && e.u) {
+                const n = parentSlotKey(e, t);
+                if (e.u.v[n] === t) {
                     privatizeCommitted(e.u);
-                    devAssertNeverUserMutation(e.u.v);
-                    e.u.v[t] = e.v;
+                    e.u.v[n] = e.v;
                 }
             }
         }
@@ -881,28 +866,28 @@ function runDirect(e) {
 // ---------------------------------------------------------------------------
 // write-time notification (setter exit)
 /** Devtools and attribution: the containers a setter replaced wholesale. */ function storePathOf(e) {
-    let n = "";
-    for (let t = e; t !== null; t = t.u) n = t.pk === null ? "store" + n : "." + String(t.pk) + n;
-    return n;
+    let t = "";
+    for (let n = e; n !== null; n = n.u) t = n.pk === null ? "store" + t : "." + String(n.pk) + t;
+    return t;
 }
 
 const REPLACED_CENSUS_MAX = 64;
 
-function sameLeaf(e, n) {
-    if (e === n) return true;
-    if (e === null || n === null || typeof e !== "object" || typeof n !== "object") return false;
-    return unwrapValue(e) === unwrapValue(n) || targetsEqual(e, n);
+function sameLeaf(e, t) {
+    if (e === t) return true;
+    if (e === null || t === null || typeof e !== "object" || typeof t !== "object") return false;
+    return unwrapValue(e) === unwrapValue(t) || targetsEqual(e, t);
 }
 
-function reportReplacedContainers(e, n, t, r) {
-    const o = r ?? Reflect.ownKeys(t);
-    const i = Array.isArray(t);
+function reportReplacedContainers(e, t, n, r) {
+    const o = r ?? Reflect.ownKeys(n);
+    const i = Array.isArray(n);
     const l = storeRootOwner(e);
     for (const r of o) {
         if (i && r === "length" || r === $OWNER) continue;
-        if (e.del !== null && e.del.has(r)) continue;
-        const o = unwrapValue(n[r]);
-        const u = unwrapValue(t[r]);
+        if (e.del?.has(r)) continue;
+        const o = unwrapValue(t[r]);
+        const u = unwrapValue(n[r]);
         if (o === null || u === null || typeof o !== "object" || typeof u !== "object" || o === u || targetsEqual(o, u)) continue;
         const f = Array.isArray(u);
         if (f !== Array.isArray(o)) continue;
@@ -912,13 +897,13 @@ function reportReplacedContainers(e, n, t, r) {
             s = u.length;
             if (s > REPLACED_CENSUS_MAX) continue;
             const e = new Set;
-            for (const n of o) e.add(unwrapValue(n));
-            for (const n of u) if (e.has(unwrapValue(n))) a++;
+            for (const t of o) e.add(unwrapValue(t));
+            for (const t of u) if (e.has(unwrapValue(t))) a++;
         } else {
             const e = Object.keys(u);
             s = e.length;
             if (s > REPLACED_CENSUS_MAX) continue;
-            for (const n of e) if (sameLeaf(o[n], u[n])) a++;
+            for (const t of e) if (sameLeaf(o[t], u[t])) a++;
         }
         attrHooks.storeReplaced(storePathOf(e) + "." + String(r), f, s, a, f ? o.length : Object.keys(o).length, l);
     }
@@ -935,18 +920,18 @@ function reportReplacedContainers(e, n, t, r) {
     return userWrite;
 }
 
-function heldDerivation(e, n, t) {
+function heldDerivation(e, t, n) {
     if (e.fam === null || !userWrite) return false;
-    if (n !== undefined) return (n.l & (CONFIG_HELD | CONFIG_MANUAL_WRITE)) === CONFIG_HELD && txOf(n) !== flushTransaction;
+    if (t !== undefined) return (t.l & (CONFIG_HELD | CONFIG_MANUAL_WRITE)) === CONFIG_HELD && txOf(t) !== flushTransaction;
     const r = e.k;
-    return r !== null && (r.l & CONFIG_HELD) !== 0 && txOf(r) !== flushTransaction && heldKeyChanged(e, t);
+    return r !== null && (r.l & CONFIG_HELD) !== 0 && txOf(r) !== flushTransaction && heldKeyChanged(e, n);
 }
 
 /** Setter exit: one node write per changed observed key (the leaves stage
  * like signals — holds and lanes engage here on later steps), presence and
  * deep witnesses, and the container when membership changed. */ function notifyWrites(e) {
-    let n = e.pb;
-    if (n === null) return;
+    let t = e.pb;
+    if (t === null) return;
     // 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.
@@ -955,10 +940,10 @@ function heldDerivation(e, n, t) {
         // are born from the committed frame, not the draft).
         e.pb = null;
         e.wk = null;
-        e.pb = optHooks.writes(e, n);
+        e.pb = optHooks.writes(e, t);
         return;
     }
-    const t = e.v;
+    const n = e.v;
     const r = e.n;
     // Written-keys bound: trap writes record their keys, so the notify visits
     // O(written) nodes instead of every subscription on the record (a selection
@@ -974,9 +959,9 @@ function heldDerivation(e, n, t) {
     // 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 o = e.wk;
-    const i = o === WK_ALL || e.a === true || !plainProto(e.ovl ? e.v : n) ? null : o;
-    if (attrHooks !== null) reportReplacedContainers(e, t, n, i);
-    if (e.fam !== null && !heldDerivationHit && i !== null) for (const n of i) if (heldDerivation(e, r?.[n], n)) {
+    const i = o === WK_ALL || e.a === true || !plainProto(e.ovl ? e.v : t) ? null : o;
+    if (attrHooks !== null) reportReplacedContainers(e, n, t, i);
+    if (e.fam !== null && !heldDerivationHit && i !== null) for (const t of i) if (heldDerivation(e, r?.[t], t)) {
         heldDerivationHit = true;
         break;
     }
@@ -985,16 +970,16 @@ function heldDerivation(e, n, t) {
         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) {
+            if (o.acc === true || hasOwn.call(t, i) && lookupGetter.call(t, 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`.
-                o.acc = isOwnAccessor(n, i);
-                const e = Object.getOwnPropertyDescriptor(t, i);
-                const r = Object.getOwnPropertyDescriptor(n, i);
+                o.acc = isOwnAccessor(t, i);
+                const e = Object.getOwnPropertyDescriptor(n, i);
+                const r = Object.getOwnPropertyDescriptor(t, i);
                 if (!r || r.get || r.set) {
                     if (e?.get !== r?.get || e?.set !== r?.set || e?.value !== r?.value) setSignal(o, () => FORCE);
                     continue;
@@ -1002,7 +987,7 @@ function heldDerivation(e, n, t) {
                 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];
+            const l = e.del?.has(i) ? undefined : t[i];
             setSignal(o, () => l);
             if (e.fam !== null) {
                 // The derive's write is a derivation; a user setter's is a proposal
@@ -1016,20 +1001,20 @@ function heldDerivation(e, n, t) {
     }
     const l = e.h;
     if (l !== null) {
-        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)));
-                if (e.fam !== null) holdWithDerive(e, t);
+        const n = i ?? Reflect.ownKeys(l);
+        for (const r of n) {
+            const n = l[r];
+            if (n !== undefined) {
+                setSignal(n, r in t && !e.del?.has(r));
+                if (e.fam !== null) holdWithDerive(e, n);
             }
         }
     }
     if (e.dk !== null) {
-        if (e.del !== null && e.del.size !== 0) bumpDeep(e); else for (const r of i ?? Reflect.ownKeys(n)) {
+        if (e.del?.size) bumpDeep(e); else for (const r of i ?? Reflect.ownKeys(t)) {
             if (r === $OWNER) continue;
-            const o = n[r];
-            const i = t[r];
+            const o = t[r];
+            const i = n[r];
             if (o !== null && typeof o === "object" ? !targetsEqual(i, o) : !isEqual(i, o)) {
                 bumpDeep(e);
                 break;
@@ -1044,52 +1029,52 @@ 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)) {
+                for (const e of Reflect.ownKeys(t)) {
+                    if (!hasOwn.call(n, e)) {
                         r = true;
                         break;
                     }
                 }
             }
         } else {
-            r = Array.isArray(n) && Array.isArray(t) ? arrayStructureChanged(t, n) : membershipChanged(t, n);
+            r = Array.isArray(t) && Array.isArray(n) ? arrayStructureChanged(n, t) : membershipChanged(n, t);
         }
-        if (r) notifyContainer(u, n);
+        if (r) notifyContainer(u, t);
     }
 }
 
 /** Accessor-node wake sentinel: readers re-run and re-invoke the getter. */ const FORCE = Symbol();
 
-/** Two raws that wrap to the same target are the same logical value. */ function targetsEqual(e, n) {
-    if (e === null || typeof e !== "object" || n === null || typeof n !== "object") return false;
-    const t = lookupTarget(e, null);
-    return t !== undefined && t === lookupTarget(n, null);
+/** Two raws that wrap to the same target are the same logical value. */ function targetsEqual(e, t) {
+    if (e === null || typeof e !== "object" || t === null || typeof t !== "object") return false;
+    const n = lookupTarget(e, null);
+    return n !== undefined && n === lookupTarget(t, null);
 }
 
-/** Positional identity IS content for arrays (R15). */ function arrayStructureChanged(e, n) {
-    if (e.length !== n.length) return true;
-    for (let t = 0; t < n.length; t++) {
-        const r = e[t];
-        const o = n[t];
+/** Positional identity IS content for arrays (R15). */ function arrayStructureChanged(e, t) {
+    if (e.length !== t.length) return true;
+    for (let n = 0; n < t.length; n++) {
+        const r = e[n];
+        const o = t[n];
         if (!isEqual(r, o) && !targetsEqual(r, o)) return true;
     }
     return false;
 }
 
-function membershipChanged(e, n) {
-    const t = Reflect.ownKeys(n);
-    if (Reflect.ownKeys(e).length - +isOwned(e) !== t.length - +isOwned(n)) return true;
-    for (const n of t) if (n !== $OWNER && !(n in e)) return true;
+function membershipChanged(e, t) {
+    const n = Reflect.ownKeys(t);
+    if (Reflect.ownKeys(e).length - +isOwned(e) !== n.length - +isOwned(t)) return true;
+    for (const t of n) if (t !== $OWNER && !(t in e)) return true;
     return false;
 }
 
-/** 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 o = Object.getOwnPropertyDescriptor(t, n);
-        const i = Object.getOwnPropertyDescriptor(r, n);
+/** One leaf's notification for an adoption diff (descriptor-aware). */ function notifyKeyDiff(e, t, n, r, o = true) {
+    if (e.acc === true || o && hasOwn.call(r, t) && lookupGetter.call(r, t) !== undefined) {
+        e.acc = isOwnAccessor(r, t);
+        const o = Object.getOwnPropertyDescriptor(n, t);
+        const i = Object.getOwnPropertyDescriptor(r, t);
         // 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);
@@ -1099,8 +1084,8 @@ function membershipChanged(e, n) {
         const u = i?.value;
         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];
+        const o = n[t];
+        const i = r[t];
         if (!isEqual(o, i) && !targetsEqual(o, i)) setSignal(e, typeof i === "function" ? () => i : i);
     }
 }
@@ -1109,12 +1094,12 @@ function hasAccessorFlag(e) {
     return e.acc === true;
 }
 
-/** One leaf's notification when the caller already has both values. */ function notifyKeyValue(e, n, t, r, o, i) {
+/** One leaf's notification when the caller already has both values. */ function notifyKeyValue(e, t, n, r, o, i) {
     if (e.acc === true) {
-        notifyKeyDiff(e, n, o, i, false);
+        notifyKeyDiff(e, t, o, i, false);
         return;
     }
-    if (!isEqual(t, r) && !targetsEqual(t, r)) setSignal(e, typeof r === "function" ? () => r : r);
+    if (!isEqual(n, r) && !targetsEqual(n, r)) setSignal(e, typeof r === "function" ? () => r : r);
 }
 
 /** The structural half of an adoption's notifications (reconcile does the
@@ -1136,28 +1121,28 @@ function hasAccessorFlag(e) {
  * notification, and a landing whose truth changed no guessed key's value
  * or presence (a newer question's rows beneath an optimistic push) still
  * answers the arrangement — before, only the presence write reached the
- * lane, by accident of being unconditional. */ function notifyFoldTail(e, n, t) {
+ * lane, by accident of being unconditional. */ function notifyFoldTail(e, t, n) {
     const r = e.h;
     if (r !== null) {
-        const e = n[$TARGET];
-        for (const o of Reflect.ownKeys(r)) if (e || o in n !== o in t) setSignal(r[o], o in t);
+        const e = t[$TARGET];
+        for (const o of Reflect.ownKeys(r)) if (e || o in t !== o in n) setSignal(r[o], o in n);
     }
     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(o, t);
+        const e = Array.isArray(n) && Array.isArray(t) ? arrayStructureChanged(t, n) : membershipChanged(t, n);
+        if (e) notifyContainer(o, n);
     }
 }
 
 /** An adoption's notifications: every node of the target, diffed `old` →
  * `neu` (value nodes by key, presence by `in`, the container by
- * membership, the deep witness by identity). */ function notifyFold(e, n, t) {
-    if (e.dk !== null && n !== t) bumpDeep(e);
+ * membership, the deep witness by identity). */ function notifyFold(e, t, n) {
+    if (e.dk !== null && t !== n) bumpDeep(e);
     const r = e.n;
     if (r !== null) {
-        for (const e of Reflect.ownKeys(r)) notifyKeyDiff(r[e], e, n, t);
+        for (const e of Reflect.ownKeys(r)) notifyKeyDiff(r[e], e, t, n);
     }
-    notifyFoldTail(e, n, t);
+    notifyFoldTail(e, t, n);
 }
 
 // ---------------------------------------------------------------------------
@@ -1172,9 +1157,9 @@ const pendingNotify = new Set;
 
 function scopeKey(e) {
     if (e.fam !== null) return e.fam;
-    let n = e;
-    while (n.u !== null) n = n.u;
-    return n;
+    let t = e;
+    while (t.u !== null) t = t.u;
+    return t;
 }
 
 function inDraft(e) {
@@ -1182,25 +1167,25 @@ function inDraft(e) {
 }
 
 /** Shallow store: values served verbatim (a nested store proxy still wraps
- * into the family so writes stay isolated). */ function serveShallow(e, n, t) {
-    if (t !== null && typeof t === "object" && t[$TARGET] !== undefined) return draftServe(e, wrap(t, e, n));
-    return t;
+ * into the family so writes stay isolated). */ function serveShallow(e, t, n) {
+    if (n !== null && typeof n === "object" && n[$TARGET] !== undefined) return draftServe(e, wrap(n, e, t));
+    return n;
 }
 
-/** A child proxy served to a draft joins the draft's scope. */ function draftServe(e, n) {
+/** A child proxy served to a draft joins the draft's scope. */ function draftServe(e, t) {
     if (writeScopes !== null && inDraft(e)) {
-        const e = n?.[$TARGET];
-        if (e !== undefined && e.v !== undefined) writeScopes.add(scopeKey(e));
+        const e = t?.[$TARGET];
+        if (e?.v !== undefined) writeScopes.add(scopeKey(e));
     }
-    return n;
+    return t;
 }
 
 /** The committed backing: the container node's committed value while a
  * batch is staged on it (an adoption swaps `t.v` eagerly — INTERNALS §3,
  * "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.ue !== NOT_PENDING ? asBacking(n.Ie) : e.v;
+    const t = e.k;
+    if (t !== null) return t.ue !== NOT_PENDING ? asBacking(t.Ie) : e.v;
     // A node-less staging (`stageOn`): the fold queue remembers the frame.
         return e.pb !== null ? preBatch(e) : e.v;
 }
@@ -1228,15 +1213,15 @@ function inDraft(e) {
  * or the staging a pass may see). An optimistic family's lane values are
  * NOT composed here: a guessed key always has its node, and the node is
  * what serves its value (`nodeValue`); presence and enumeration compose
- * per key / per walk (`optimisticHas`, `enumerationSource`). */ function readSource(e, n, t = false) {
+ * per key / per walk (`optimisticHas`, `enumerationSource`). */ function readSource(e, t, n = false) {
     // An optimistic setter's read before its first write sees what the writer
     // 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)) {
-        const n = ensurePB(e);
+    if (userWrite && e.fam?.opt === true && !pendingNotify.has(e) && inDraft(e)) {
+        const t = ensurePB(e);
         pendingNotify.add(e);
-        return n;
+        return t;
     }
     const r = e.pb;
     if (r === null) return e.v;
@@ -1249,12 +1234,12 @@ function inDraft(e) {
         // "under the transaction and revealed with it"), not key by key. A
         // user's setter reading its draft is no pass and joins nothing here.
         if (writeOverride && !userWrite) {
-            const t = n !== undefined ? e.n?.[n] : undefined;
-            if (t !== undefined) {
-                if ((t.l & (CONFIG_HELD | CONFIG_OVERRIDE)) === CONFIG_HELD) joinPassTx(txOf(t));
+            const n = t !== undefined ? e.n?.[t] : undefined;
+            if (n !== undefined) {
+                if ((n.l & (CONFIG_HELD | CONFIG_OVERRIDE)) === CONFIG_HELD) joinPassTx(txOf(n));
             } else {
-                const t = e.k;
-                if (t !== null && (t.l & (CONFIG_HELD | CONFIG_OVERRIDE)) === CONFIG_HELD && (n === undefined || heldKeyChanged(e, n))) joinPassTx(txOf(t));
+                const n = e.k;
+                if (n !== null && (n.l & (CONFIG_HELD | CONFIG_OVERRIDE)) === CONFIG_HELD && (t === undefined || heldKeyChanged(e, t))) joinPassTx(txOf(n));
             }
         }
         return r;
@@ -1264,16 +1249,16 @@ function inDraft(e) {
     // 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 !== undefined) {
+        const n = e.n?.[t];
+        if (n?.l & CONFIG_OVERRIDE) return committed(e);
     }
     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 (i && n !== undefined && !heldKeyChanged(e, n, t)) return r;
+        if (i && t !== undefined && !heldKeyChanged(e, t, n)) return r;
     const l = stagingReader();
     if (l === null) {
         if (getObserver() !== null) return r;
@@ -1286,7 +1271,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.Ie) : e.v;
+                if (verdict === null || !i && t !== undefined && !keyChanged(e, t, n)) return i ? asBacking(o.Ie) : e.v;
         return o === null ? committed(e) : asBacking(read(o));
     }
     // A pass reading a key the batch left unchanged: the same value in both
@@ -1304,7 +1289,7 @@ function inDraft(e) {
         // 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.l & (CONFIG_VERDICT | CONFIG_CHILDREN_FORBIDDEN))) return r;
-        if (n !== undefined && !keyChanged(e, n, t)) return committed(e);
+        if (t !== undefined && !keyChanged(e, t, n)) 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.
@@ -1318,8 +1303,8 @@ 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.Ie, e.k.ue, n, t) && !adoptChild(e, n);
+ * it) change `key`? */ function heldKeyChanged(e, t, n = true) {
+    return changedBetween(e, e.k.Ie, e.k.ue, t, n) && !adoptChild(e, t);
 }
 
 /** The values of a held frame, built once per frame: neither the committed
@@ -1327,14 +1312,14 @@ function inDraft(e) {
  * 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;
+    let t = frameRaws.get(e);
+    if (t === undefined) frameRaws.set(e, t = new Set(Object.values(e)));
+    return t;
 }
 
 /** 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)));
+ * objects whose keys agree — positionally for an unkeyed family. */ function sameRow(e, t, n) {
+    return e !== null && typeof e === "object" && t !== null && typeof t === "object" && (n === null || sameKey(n(e), n(t)));
 }
 
 /** A key of a held adoption whose old and new values are the same row that
@@ -1344,27 +1329,27 @@ function rawsOf(e) {
  * 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.Ie);
-    const o = r[n];
-    const i = t.ue[n];
+ * key — without a family the pairing is not known here and the hold stands. */ function adoptChild(e, t) {
+    const n = e.k;
+    const r = asBacking(n.Ie);
+    const o = r[t];
+    const i = n.ue[t];
     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.ue).has(o)) return false;
+    rawsOf(r).has(i) || rawsOf(n.ue).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;
+        const u = wrap(o, e, t)[$TARGET];
+    if (u?.v !== o) return false;
     adoptPB(u, i, false);
-    holdNode(getContainerNode(u), txOf(t));
+    holdNode(getContainerNode(u), txOf(n));
     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
@@ -1378,69 +1363,69 @@ function rawsOf(e) {
  * twice each) are the cost of the question on a wide container read under
  * a staging (a keyed reconcile's 1k rows, read by `mapArray` in the flush
  * that staged them: ~3× the tick). A container with accessors seen (`a`)
- * keeps the full test — a getter's answer is not a slot's. */ function keyChanged(e, n, t = true) {
-    return changedBetween(e, committed(e), e.pb, n, t);
+ * keeps the full test — a getter's answer is not a slot's. */ function keyChanged(e, t, n = true) {
+    return changedBetween(e, committed(e), e.pb, t, n);
 }
 
-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 i = hasOwn.call(t, r) || e.ovl && hasOwn.call(e.v, r);
-    if (i !== hasOwn.call(n, r)) return true;
+function changedBetween(e, t, n, r, o) {
+    if (e.ch || n[$TARGET] !== undefined || Object.getPrototypeOf(n) !== Object.getPrototypeOf(t) || !plainProto(t)) return true;
+    if (e.del?.has(r)) return r in t;
+    const i = hasOwn.call(n, r) || e.ovl && hasOwn.call(e.v, r);
+    if (i !== hasOwn.call(t, 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];
+    if ((o || e.a) && (isOwnAccessor(t, r) || isOwnAccessor(n, r) || propertyIsEnumerable.call(t, r) !== propertyIsEnumerable.call(n, r))) return true;
+    const l = n[r];
+    const u = t[r];
     return !isEqual(u, l) && !sameLogicalSlot(e, u, l);
 }
 
 /** Value of a key with a leaf: core's — `read()` links a tracked reader and,
  * 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) {
+ * projection's unheld staging is ahead for a handler (`familyAhead`). */ function nodeValue(e, t, n) {
     let r = read(e);
-    if (e.ue !== NOT_PENDING && !(e.l & CONFIG_HELD) && context === null && t.fam !== null) r = e.ue;
-    return r === FORCE ? n : r;
+    if (e.ue !== NOT_PENDING && !(e.l & CONFIG_HELD) && context === null && n.fam !== null) r = e.ue;
+    return r === FORCE ? t : 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, o, i = -1) {
+ * on first read), wrap a wrappable child through the per-node wrap cache. */ function serveDataKey(e, t, n, 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).
     const l = e.ch && r === e.v;
-    let u = t;
+    let u = n;
     // 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 (o === undefined && getObserver() !== null) o = getNode(e, n, i);
+        if (o === undefined && getObserver() !== null) o = getNode(e, t, i);
         if (o !== undefined) {
-            const n = nodeValue(o, t, e);
+            const t = nodeValue(o, n, 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).
-                o.Ie = t;
-                if (o.l & CONFIG_OVERRIDE) u = n;
-            } else u = n;
+                o.Ie = n;
+                if (o.l & CONFIG_OVERRIDE) u = t;
+            } else u = t;
         }
     }
-    if (e.s) return serveShallow(e, n, u);
+    if (e.s) return serveShallow(e, t, u);
     // 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 (e.ch && !l && u !== null && typeof u === "object" && u[$TARGET]?.px !== u) u = resolveChainedRaw(e, t, u);
     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);
-        o.px = t;
+        const n = wrap(u, e, t);
+        o.px = n;
         o.pxv = u;
-        return draftServe(e, t);
+        return draftServe(e, n);
     }
     if (!isWrappable(u)) return u;
-    return draftServe(e, wrap(u, e, n));
+    return draftServe(e, wrap(u, e, t));
 }
 
-/** Is `n` among `c`'s dependencies (any pass's — a kept tail included)? */ function linkedTo(e, n) {
-    for (let t = e.C; t !== null; t = t.G) if (t.S === n) return true;
+/** Is `n` among `c`'s dependencies (any pass's — a kept tail included)? */ function linkedTo(e, t) {
+    for (let n = e.C; n !== null; n = n.G) if (n.S === t) return true;
     return false;
 }
 
@@ -1452,14 +1437,14 @@ function changedBetween(e, n, t, r, o) {
  * window judges it; a pending source registers the reader for the landing)
  * and the reader's height. The derive's own draft ops are exempt (the write
  * override): the derive is the author. */ function pullFamily(e) {
-    const n = e.fam.node;
-    if (n === null || writeOverride || inDraft(e)) return;
+    const t = e.fam.node;
+    if (t === null || writeOverride || inDraft(e)) return;
     // A settled derive: the pull alone, no link (the barrier). A derive with a
     // flight up (or errored): the reader observes the flight exactly as a
     // 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.m & (STATUS_PENDING | STATUS_ERROR)) {
+        if (t.m & (STATUS_PENDING | STATUS_ERROR)) {
         // A render effect outside the flight's own flush is the frame, not a
         // derivation: it keeps what it shows and learns of the landing from the
         // leaves the landing changes (unchanged leaves say nothing — it is not a
@@ -1469,8 +1454,8 @@ function changedBetween(e, n, t, r, o) {
         // another reason (a guess it read, the seam) that dropped the link would
         // 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.m & STATUS_ERROR) && n.l & CONFIG_HELD && flushTransaction !== txOf(n) && !linkedTo(t, n)) return;
+        const n = context;
+        if (n !== null && n.i === EFFECT_RENDER && !(t.m & STATUS_ERROR) && t.l & CONFIG_HELD && flushTransaction !== txOf(t) && !linkedTo(n, t)) 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
@@ -1478,9 +1463,9 @@ 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.m & STATUS_PENDING && r !== undefined && r.size !== 0) return;
-        read(n);
-    } else untrack(() => read(n));
+        if (verdict === null && t.m & STATUS_PENDING && r !== undefined && r.size !== 0) return;
+        read(t);
+    } else untrack(() => read(t));
 }
 
 /** A projection's writes are its derive's: a staging made while the derive
@@ -1488,31 +1473,31 @@ function changedBetween(e, n, t, r, o) {
  * callback's late write) belongs to the derive's transaction and reveals
  * with it, never drained early — and answers the derive's question: a quiet
  * re-ask's landing is quiet through its reveal (A19 exc. 2; the leaf's own
- * 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.ue !== NOT_PENDING && 
+ * classification, as core reads it — `heldNotFinal`). */ function holdWithDerive(e, t) {
+    const n = e.fam?.node;
+    if (n !== undefined && n !== null && !userWrite && // the derive's own write (its draft or landing), not a user setter's
+    n.l & CONFIG_HELD && t.ue !== 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))) {
-        holdNode(n, txOf(t));
-        n.T.ut = t.T.ut;
+    !(t.l & (CONFIG_HELD | CONFIG_OVERRIDE))) {
+        holdNode(t, txOf(n));
+        t.T.ut = n.T.ut;
     }
 }
 
 /** A chained backing's child (§7b): a raw the inner family owns, or holds
  * at this key, is served as the inner store's wrapper — never a fresh
  * raw-keyed one — so the chained targets are the same objects across
- * settled and pending views. */ function resolveChainedRaw(e, n, t) {
+ * settled and pending views. */ function resolveChainedRaw(e, t, n) {
     const r = e.v[$TARGET];
     if (r.ch) {
-        const e = resolveChainedRaw(r, n, t);
-        return e === t ? t : wrap(e, r, n);
+        const e = resolveChainedRaw(r, t, n);
+        return e === n ? n : wrap(e, r, t);
     }
-    const o = lookupTarget(t, r.fam);
+    const o = lookupTarget(n, 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;
+    if ((r.v[t] === n || r.pb?.[t] === n) && isWrappable(n)) return wrap(n, r, t);
+    return n;
 }
 
 /** The backing a structural read serves: a tracked reader subscribes to the
@@ -1522,17 +1507,17 @@ function changedBetween(e, n, t, r, o) {
     if (!inDraft(e) && !writeOverride && getObserver() !== null) {
         // 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;
+        const t = asBacking(read(getContainerNode(e)));
+        return e.fam?.opt === true ? optHooks.view(e, t) : t;
     }
-    const n = readSource(e);
-    return optRead(e) ? optHooks.view(e, n) : n;
+    const t = readSource(e);
+    return optRead(e) ? optHooks.view(e, t) : t;
 }
 
 /** 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" ]);
@@ -1542,40 +1527,40 @@ function changedBetween(e, n, t, r, o) {
 /** A trap write: the target is told at the setter's exit, the key recorded
  * in this setter's `wk`. A setter's first write to a target still staged by
  * an earlier setter of the batch opens a set of its own (the notify visits
- * it, D-8) and chains the earlier one behind for the fold's union. */ function touch(e, n) {
-    let t = e.wk;
+ * it, D-8) and chains the earlier one behind for the fold's union. */ function touch(e, t) {
+    let n = e.wk;
     if (!pendingNotify.has(e)) {
         pendingNotify.add(e);
-        if (t !== null && t !== WK_ALL) {
-            t = new Set;
-            t.u = e.wk;
-            e.wk = t;
+        if (n !== null && n !== WK_ALL) {
+            n = new Set;
+            n.u = e.wk;
+            e.wk = n;
         }
     }
-    if (t !== WK_ALL) (e.wk ??= new Set).add(n);
+    if (n !== WK_ALL) (e.wk ??= new Set).add(t);
 }
 
 const traps = {
-    get(e, n, t) {
+    get(e, t, n) {
         // One typeof gates every brand-symbol compare off the hot string path.
-        if (typeof n !== "string") {
-            if (n === $TARGET) return e;
-            if (n === $PROXY) return t;
-            if (n === $OWNER) return undefined;
+        if (typeof t !== "string") {
+            if (t === $TARGET) return e;
+            if (t === $PROXY) return n;
+            if (t === $OWNER) return undefined;
  // ownership stamp: never a user key
-                        if (n === $RECORD) return undefined;
+                        if (t === $RECORD) return undefined;
  // a store is no view (see `viewOf`)
             // refresh()/isPending resolve the projection computed through $REFRESH.
-                        if (n === $REFRESH) return e.fam?.node ?? undefined;
-            if (n === $TRACK) {
+                        if (t === $REFRESH) return e.fam?.node ?? undefined;
+            if (t === $TRACK) {
                 if (e.fam !== null) pullFamily(e);
                 if (!inDraft(e) && getObserver() !== null) {
                     read(getContainerNode(e));
                     // Structural chaining (§7b): a chained backing's $TRACK reads
                     // through to the INNER store's container — structural
                     // notifications land on the source's own node.
-                                        const n = readSource(e);
-                    if (n[$TARGET] !== undefined) n[$TRACK];
+                                        const t = readSource(e);
+                    if (t[$TARGET] !== undefined) t[$TRACK];
                 }
                 return undefined;
             }
@@ -1583,7 +1568,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.io(e, n);
+                if (verdict !== null && affectsHooks !== null && getObserver() === null) affectsHooks.io(e, t);
         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
@@ -1595,28 +1580,28 @@ const traps = {
         // a chained target's node carrying a GUESS is the value (A17 — the base
         // beneath it, and any hold there, is not this reader's concern; a link
         // without one reads through below).
-                const r = e.n?.[n];
+                const r = e.n?.[t];
         if (writeScopes === null && !writeOverride) {
-            const t = r;
-            if (t !== undefined && t.acc !== true && (!e.ch || t.l & CONFIG_OVERRIDE)) {
-                const r = nodeValue(t, undefined, e);
+            const n = r;
+            if (n !== undefined && n.acc !== true && (!e.ch || n.l & CONFIG_OVERRIDE)) {
+                const r = nodeValue(n, undefined, e);
                 if (r === null || typeof r !== "object") return r;
-                if (e.s) return serveShallow(e, n, r);
-                if (t.pxv === r) return t.px;
+                if (e.s) return serveShallow(e, t, r);
+                if (n.pxv === r) return n.px;
                 if (isWrappable(r)) {
-                    const o = wrap(r, e, n);
-                    t.px = o;
-                    t.pxv = r;
+                    const o = wrap(r, e, t);
+                    n.px = o;
+                    n.pxv = r;
                     return o;
                 }
                 return r;
             }
         }
-        const o = readSource(e, n);
+        const o = readSource(e, t);
         // Overlay delete (#3044): a prototype overlay cannot shadow a delete, so
         // deleted keys are tracked aside and read as absent in the pending view.
-                if (e.del !== null && o === e.pb && e.del.has(n)) {
-            if (!inDraft(e) && getObserver() !== null) read(getNode(e, n));
+                if (o === e.pb && e.del?.has(t)) {
+            if (!inDraft(e) && getObserver() !== null) read(getNode(e, t));
             return undefined;
         }
         // Accessor keys serve through Reflect.get with the PROXY receiver
@@ -1630,14 +1615,14 @@ const traps = {
         {
             let l;
             if (r !== undefined) l = r.acc === true; else if (!inDraft(e) && getObserver() !== null) {
-                l = isOwnAccessor(o, n);
+                l = isOwnAccessor(o, t);
                 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, 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;
+                if (!inDraft(e) && getObserver() !== null) read(r ?? getNode(e, t, i));
+                const l = Reflect.get(o, t, n);
+                if (e.s) return serveShallow(e, t, l);
+                return isWrappable(l) ? draftServe(e, wrap(l, e, t)) : l;
             }
         }
         // Plain-data fast path: no descriptor allocation per read. Inherited
@@ -1647,78 +1632,78 @@ const traps = {
         // either layer — a genuine prototype method is one that is own on
         // NEITHER.
                 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) {
+        if ((t === "constructor" || t === "__proto__" || t === "prototype") && !hasOwn.call(o, t) && !(l && hasOwn.call(e.v, t))) return undefined;
+        let u = o[t];
+        if (u === undefined ? !hasOwn.call(o, t) && !(l && hasOwn.call(e.v, t)) : false) {
             // Inherited: prototype getters/methods run with the proxy receiver.
-            u = Reflect.get(o, n, t);
+            u = Reflect.get(o, t, n);
             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 && o === e.v) return serveDataKey(e, n, u, o, r, i);
+                        if (e.ch && o === e.v) return serveDataKey(e, t, 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, i));
-                const t = e.n?.[n];
-                if (t) {
-                    const r = nodeValue(t, undefined, e);
-                    if (e.s) return serveShallow(e, n, r);
-                    return isWrappable(r) ? draftServe(e, wrap(r, e, n)) : r;
+                if (getObserver() !== null) read(getNode(e, t, i));
+                const n = e.n?.[t];
+                if (n) {
+                    const r = nodeValue(n, undefined, e);
+                    if (e.s) return serveShallow(e, t, r);
+                    return isWrappable(r) ? draftServe(e, wrap(r, e, t)) : r;
                 }
             }
-            if (e.s) return serveShallow(e, n, u);
-            return isWrappable(u) ? draftServe(e, wrap(u, e, n)) : u;
+            if (e.s) return serveShallow(e, t, u);
+            return isWrappable(u) ? draftServe(e, wrap(u, e, t)) : u;
         }
-        if (typeof u === "function" && !hasOwn.call(o, n) && !(l && hasOwn.call(e.v, n))) return u;
+        if (typeof u === "function" && !hasOwn.call(o, t) && !(l && hasOwn.call(e.v, t))) return u;
  // proto method
-                return serveDataKey(e, n, u, o, r, i);
+                return serveDataKey(e, t, u, o, r, i);
     },
-    has(e, n) {
-        if (n === $TARGET || n === $PROXY || n === $TRACK) return true;
-        if (n === $OWNER || n === $RECORD) return false;
+    has(e, t) {
+        if (t === $TARGET || t === $PROXY || t === $TRACK) return true;
+        if (t === $OWNER || t === $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.io(e, n);
+                if (verdict !== null && affectsHooks !== null && getObserver() === null) affectsHooks.io(e, t);
         if (e.fam !== null) pullFamily(e);
-        const t = readSource(e, n);
+        const n = readSource(e, t);
         // A tracked reader's presence node answers (born from the two frames;
         // core decides which it sees); everyone else reads the backing. A
         // chained target's node is a subscription point (§7b): the inner store
         // answers through the backing — unless the outer node carries a guess.
                 if (!inDraft(e) && !writeOverride) {
             if (getObserver() !== null) {
-                const r = getHasNode(e, n);
+                const r = getHasNode(e, t);
                 const o = read(r);
-                if (!e.ch || t !== e.v) return !!o;
-                const i = n in t;
+                if (!e.ch || n !== e.v) return !!o;
+                const i = t in n;
                 r.Ie = i;
  // the link follows the inner store (S4)
                                 if (r.l & CONFIG_OVERRIDE) return !!o;
                 return i;
             } else if (optRead(e)) {
-                const t = optHooks.has(e, n);
-                if (t !== undefined) return t;
+                const n = optHooks.has(e, t);
+                if (n !== undefined) return n;
             }
         }
-        return n in t && !(e.del !== null && t === e.pb && e.del.has(n));
+        return t in n && !(n === e.pb && e.del?.has(t));
     },
     ownKeys(e) {
         if (verdict !== null && affectsHooks !== null && getObserver() === null) affectsHooks.io(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.io(e, n);
+    getOwnPropertyDescriptor(e, t) {
+        if (t === $OWNER || t === $RECORD) return undefined;
+        const n = getObserver();
+        if (verdict !== null && affectsHooks !== null && n === null) affectsHooks.io(e, t);
         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
         // presence (R13).
-                const r = t !== null && !inDraft(e) && !writeOverride;
-        const o = r && observerHoldsContainer(e, t);
+                const r = n !== null && !inDraft(e) && !writeOverride;
+        const o = r && observerHoldsContainer(e, n);
         let i;
         if (o) i = enumerationSource(e); else if (r) {
             // The presence node's frame (core decides which) is the one described
@@ -1727,32 +1712,31 @@ const traps = {
             // serves this reader (`readSource`: a held container's changed key —
             // enumerability, accessor-ness — reads committed for a stale reader,
             // the staging for a member; #3706 contrast).
-            const t = getHasNode(e, n);
-            const r = read(t);
-            i = readSource(e, n, true);
-            if (!r && (!e.ch || t.l & CONFIG_OVERRIDE || !(n in i))) return undefined;
-        } else i = readSource(e, n, true);
+            const n = getHasNode(e, t);
+            const r = read(n);
+            i = readSource(e, t, true);
+            if (!r && (!e.ch || n.l & CONFIG_OVERRIDE || !(t in i))) return undefined;
+        } else i = readSource(e, t, true);
         let l;
         if (!o && optRead(e)) {
-            const t = optHooks.descriptor(e, n);
-            if (t === null) return undefined;
-            l = t;
+            const n = optHooks.descriptor(e, t);
+            if (n === null) return undefined;
+            l = n;
         }
-        l ??= visibleDescriptor(e, i, n);
+        l ??= visibleDescriptor(e, i, t);
         if (l === undefined) return undefined;
-        if (!(n === "length" && Array.isArray(e))) l.configurable = true;
+        if (!(t === "length" && Array.isArray(e))) l.configurable = true;
         return l;
     },
-    set(e, n, t) {
+    set(e, t, n) {
         const r = inDraft(e);
-        const o = !r && writeOverride;
-        if (!r && !o) {
+        if (!r && !writeOverride) {
             return true;
         }
-        if (n === "__proto__") return true;
+        if (t === "__proto__") return true;
  // pollution guard (core R30)
-                const i = e.s ? t : unwrapValue(t);
-        const l = ensurePB(e);
+                const o = e.s ? n : unwrapValue(n);
+        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
@@ -1763,65 +1747,57 @@ const traps = {
         // (1)), and the write stages on it (A28; a write by the holder joins it,
         // A34) — as it would with a reader's leaf. Kept while the container is
         // held (`deferredReleases`).
-                if (userWrite && e.k?.l & CONFIG_HELD) deferredReleases.add(getNode(e, n));
-        if (Array.isArray(l)) {
-            touch(e, n);
-            if (n === "length") e.wk = WK_ALL; else touch(e, "length");
+                if (userWrite && e.k?.l & CONFIG_HELD) deferredReleases.add(getNode(e, t));
+        if (Array.isArray(i)) {
+            touch(e, t);
+            if (t === "length") e.wk = WK_ALL; else touch(e, "length");
         } else {
-            touch(e, n);
-            if (!(n in l)) e.kc++;
+            touch(e, t);
+            if (!(t in i)) e.kc++;
         }
-        if (UNSAFE_KEYS.has(n)) {
-            Object.defineProperty(l, n, {
-                value: i,
+        const l = UNSAFE_KEYS.has(t);
+        if (l || e.ovl && e.sc !== 2 && !hasOwn.call(i, t)) {
+            Object.defineProperty(i, t, {
+                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: i,
-                writable: true,
-                enumerable: true,
-                configurable: true
-            });
-        } else l[n] = i;
-        if (e.del !== null) e.del.delete(n);
-        if (e.s && i !== null && typeof i === "object") markRawOne(i);
-        if (o) notifyWrites(e);
-        return true;
+        } else i[t] = o;
+        e.del?.delete(t);
+        if (l) return true;
+        if (e.s && o !== null && typeof o === "object") markRawOne(o);
+        if (!r) notifyWrites(e);
+ // a write-override write
+                return true;
     },
-    defineProperty(e, n, t) {
+    defineProperty(e, t, n) {
         const r = inDraft(e);
-        const o = !r && writeOverride;
-        if (!r && !o) {
+        if (!r && !writeOverride) {
             return true;
         }
-        if (n === "__proto__") return true;
-        if (t.get || t.set) e.a = true;
-        if ("value" in t) t = {
-            ...t,
-            value: unwrapValue(t.value)
+        if (t === "__proto__") return true;
+        if (n.get || n.set) e.a = true;
+        if ("value" in n) n = {
+            ...n,
+            value: unwrapValue(n.value)
         };
-        const i = ensurePB(e);
-        if (e.a || !(t.enumerable && t.writable && t.configurable)) e.sc = 1;
-        touch(e, n);
-        Object.defineProperty(i, n, t);
-        if (e.del !== null) e.del.delete(n);
-        if (o) notifyWrites(e);
-        return true;
+        const o = ensurePB(e);
+        if (e.a || !(n.enumerable && n.writable && n.configurable)) e.sc = 1;
+        touch(e, t);
+        Object.defineProperty(o, t, n);
+        e.del?.delete(t);
+        if (!r) notifyWrites(e);
+ // a write-override write
+                return true;
     },
-    deleteProperty(e, n) {
-        const t = inDraft(e);
-        const r = !t && writeOverride;
-        if (!t && !r) {
+    deleteProperty(e, t) {
+        const n = inDraft(e);
+        if (!n && !writeOverride) {
             return true;
         }
-        const o = ensurePB(e);
-        touch(e, n);
+        const r = ensurePB(e);
+        touch(e, t);
         // The key count (`kc`, the overlay gate and the rebuild cap) follows a
         // delete the way it follows an add: an own key of the draft leaving — a
         // clone's key, or an overlay's own add — is one fewer now. An overlay's
@@ -1831,34 +1807,35 @@ const traps = {
         // one" shape drifted the count up by one per write until a three-key
         // object crossed the overlay threshold and paid a rebuild on every
         // commit after.
-                const i = e.ovl && hasOwn.call(e.v, n);
-        if (hasOwn.call(o, n)) {
-            delete o[n];
-            i || e.kc--;
+                const o = e.ovl && hasOwn.call(e.v, t);
+        if (hasOwn.call(r, t)) {
+            delete r[t];
+            o || e.kc--;
         }
-        if (i) (e.del ??= new Set).add(n);
-        if (r) notifyWrites(e);
-        return true;
+        if (o) (e.del ??= new Set).add(t);
+        if (!n) notifyWrites(e);
+ // a write-override write
+                return true;
     }
 };
 
 /** Is `obs` subscribed to the container BY THIS PASS (its enumerator holds
  * it)? A link left from a previous pass is stale — the reader must subscribe
- * to the key's presence node or a later add never re-runs it. */ function observerHoldsContainer(e, n) {
-    const t = e.k;
-    if (t === null) return false;
-    const r = t.dt;
-    return r !== null && r.u === n && (!(n.R & REACTIVE_RECOMPUTING_DEPS) || r.Te === n.Ne);
+ * to the key's presence node or a later add never re-runs it. */ function observerHoldsContainer(e, t) {
+    const n = e.k;
+    if (n === null) return false;
+    const r = n.Ct;
+    return r !== null && r.u === t && (!(t.R & REACTIVE_RECOMPUTING_DEPS) || r.Te === t.Ne);
 }
 
-function storeSetter(e, n, t = true) {
+function storeSetter(e, t, n = true) {
     if (writeHook !== null) writeHook(e);
     const r = e[$TARGET];
     const o = writeScopes;
     writeScopes = new Set;
     writeScopes.add(scopeKey(r));
     const i = userWrite;
-    userWrite = t;
+    userWrite = n;
     writing++;
     let l;
     try {
@@ -1866,7 +1843,7 @@ function storeSetter(e, n, t = true) {
         // (draft reads never self-track, proj R2), while EXTERNAL reads (signals
         // inside a projection derive) must keep tracking — they are the derive's
         // dependencies.
-        l = n(e);
+        l = t(e);
     } finally {
         writing--;
         writeScopes = o;
@@ -1875,10 +1852,10 @@ function storeSetter(e, n, t = true) {
                 if (writing === 0 && pendingNotify.size) {
             const e = [ ...pendingNotify ];
             pendingNotify.clear();
-            for (const n of e) notifyWrites(n);
+            for (const t of e) notifyWrites(t);
             // A direct commit (a projection's creation run) folds at the setter's
             // 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);
+                        if (directCommit) for (const t of e) if (t.pb !== null) foldTarget(t, t.v);
         }
         userWrite = i;
     }
@@ -1886,13 +1863,13 @@ function storeSetter(e, n, t = true) {
         // 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 (n && 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
     // the draft's prior state and the hold re-derives over it (the writes
     // joined the hold through `setSignal`; the derive re-runs under it).
-        if (t && heldDerivationHit) {
+        if (n && heldDerivationHit) {
         heldDerivationHit = false;
         const e = r.fam.node;
         if (!(e.R & REACTIVE_DIRTY)) {
@@ -1903,12 +1880,12 @@ function storeSetter(e, n, t = true) {
     }
 }
 
-function createStore(e, n) {
-    const t = n?.shallow === true;
+function createStore(e, t) {
+    const n = t?.shallow === true;
     const r = wrap(e);
     // Dependency edges (store/edges.ts): the root is named like a plain signal.
         if (signalHook !== null) signalHook(r[$TARGET]);
-    if (t) {
+    if (n) {
         r[$TARGET].s = true;
         markRawIngest(e);
     }
@@ -1920,7 +1897,7 @@ function createStore(e, n) {
         // disabled, buys nothing.
                 if (attrHooks !== null) {
             storeOwners.set(r[$TARGET], e);
-            nameStore(r, n?.name, n?.loc);
+            nameStore(r, t?.name, t?.loc);
         }
     }
     const setter = e => storeSetter(r, e);
@@ -1930,47 +1907,47 @@ function createStore(e, n) {
 /** True when `proxy` is a SHALLOW store (children served verbatim, slots
  * 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;
+    const t = e?.[$TARGET];
+    return t?.s === true;
 }
 
 /** True when `proxy` belongs to a projection family (S3). */ function storeHasFamily(e) {
-    const n = e?.[$TARGET];
-    return n !== undefined && n.fam !== null;
+    const t = e?.[$TARGET];
+    return t?.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;
+    const t = e?.[$TARGET];
+    return t?.fam?.opt === true;
 }
 
 // ---------------------------------------------------------------------------
 // enumeration views (one visibility rule for the traps AND the deep walk)
-function visibleKeys(e, n) {
-    let t;
-    if (e.ovl && n === e.pb) {
-        t = Reflect.ownKeys(e.v);
+function visibleKeys(e, t) {
+    let n;
+    if (e.ovl && t === e.pb) {
+        n = Reflect.ownKeys(e.v);
         const r = e.del;
-        if (r !== null && r.size !== 0) t = t.filter(e => !r.has(e));
-        for (const r of Reflect.ownKeys(n)) {
-            if (!hasOwn.call(e.v, r)) t.push(r);
+        if (r?.size) n = n.filter(e => !r.has(e));
+        for (const r of Reflect.ownKeys(t)) {
+            if (!hasOwn.call(e.v, r)) n.push(r);
         }
-    } else t = Reflect.ownKeys(n);
+    } else n = Reflect.ownKeys(t);
     // The ownership stamp is the last symbol on an owned backing: hide it.
-        for (let e = t.length - 1; e >= 0 && typeof t[e] === "symbol"; e--) {
-        if (t[e] === $OWNER) {
-            t.splice(e, 1);
+        for (let e = n.length - 1; e >= 0 && typeof n[e] === "symbol"; e--) {
+        if (n[e] === $OWNER) {
+            n.splice(e, 1);
             break;
         }
     }
-    return t;
+    return 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 (r === undefined) r = Object.getOwnPropertyDescriptor(e.v, t);
+function visibleDescriptor(e, t, n) {
+    let r = Object.getOwnPropertyDescriptor(t, n);
+    if (e.ovl && t === e.pb) {
+        if (e.del?.has(n)) return undefined;
+        if (r === undefined) r = Object.getOwnPropertyDescriptor(e.v, n);
     }
     return r;
 }
@@ -1979,33 +1956,33 @@ function visibleDescriptor(e, n, t) {
 // deep / snapshot
 /** 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;
-    const t = new Set;
-    const childTarget = (e, n, t) => {
-        let r = lookupTarget(n, e.fam);
+    const t = e?.[$TARGET];
+    if (t?.px !== e) return e;
+    const n = new Set;
+    const childTarget = (e, t, n) => {
+        let r = lookupTarget(t, e.fam);
         if (r === undefined) {
-            if (!isWrappable(n)) return undefined;
-            wrap(n, e, t);
-            r = lookupTarget(n, e.fam) ?? n[$TARGET];
+            if (!isWrappable(t)) return undefined;
+            wrap(t, e, n);
+            r = lookupTarget(t, e.fam) ?? t[$TARGET];
         }
         return r;
     };
     const walkT = e => {
         if (e.fam !== null) pullFamily(e);
-        const n = enumerationSource(e);
-        if (t.has(n)) return;
-        t.add(n);
+        const t = enumerationSource(e);
+        if (n.has(t)) return;
+        n.add(t);
         read(getDeepNode(e));
         // Through a chain (#3323): every inner record's container AND deep
         // witness — base writes bump the inner witnesses.
-                for (let n = e; n.ch; ) {
-            n = n.v[$TARGET];
-            read(getContainerNode(n));
-            read(getDeepNode(n));
+                for (let t = e; t.ch; ) {
+            t = t.v[$TARGET];
+            read(getContainerNode(t));
+            read(getDeepNode(t));
         }
-        for (const t of visibleKeys(e, n)) {
-            const r = visibleDescriptor(e, n, t);
+        for (const n of visibleKeys(e, t)) {
+            const r = visibleDescriptor(e, t, n);
             if (r === undefined) continue;
             if (r.get || r.set) {
                 e.a = true;
@@ -2014,38 +1991,38 @@ function visibleDescriptor(e, n, t) {
                         }
             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 (e.ch && o[$TARGET] === undefined) o = resolveChainedRaw(e, n, o);
+            const i = childTarget(e, o, n);
             if (i === undefined) continue;
  // raw-marked: leaf by contract
                         walkT(i);
         }
     };
-    walkT(n);
+    walkT(t);
     return snapshot(e);
 }
 
 /** Non-tracking snapshot: source identity for unowned subtrees (zero copy),
  * a copy for owned ones (they are by definition modified relative to the
  * source). Sees the pending backing (R27). */ function snapshot(e) {
-    const n = e?.[$TARGET];
-    return snapshotWalk(e, new Map, n?.fam ?? null);
+    const t = e?.[$TARGET];
+    return snapshotWalk(e, new Map, t?.fam ?? null);
 }
 
-function snapshotWalk(e, n, t) {
+function snapshotWalk(e, t, n) {
     if (e === null || typeof e !== "object") return e;
     let r = e;
     for (let e = true; ;e = false) {
-        const n = r?.[$TARGET]?.v !== undefined;
-        let o = n ? r[$TARGET] : undefined;
-        if (o === undefined && t !== null) o = lookupTarget(r, t);
+        const t = r?.[$TARGET]?.v !== undefined;
+        let o = t ? r[$TARGET] : undefined;
+        if (o === undefined && n !== null) o = lookupTarget(r, n);
         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 && !t && n !== null && o.fam !== n) {
+            const e = n.map.get(o.px);
             if (e !== undefined) o = e;
         }
-        if (o.fam !== null) t = o.fam;
+        if (o.fam !== null) n = o.fam;
         // 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;
@@ -2058,12 +2035,12 @@ function snapshotWalk(e, n, t) {
         r = i;
     }
     if (!isWrappable(r)) return r;
-    const o = n.get(r);
+    const o = t.get(r);
     if (o !== undefined) return o;
     if (isOwned(r)) {
         const e = Array.isArray(r);
         const o = e ? [] : Object.create(Object.getPrototypeOf(r));
-        n.set(r, o);
+        t.set(r, o);
         for (const i of Reflect.ownKeys(r)) {
             if (e && i === "length" || i === $OWNER) continue;
             const l = Object.getOwnPropertyDescriptor(r, i);
@@ -2073,7 +2050,7 @@ function snapshotWalk(e, n, t) {
                 continue;
             }
             const u = l.value;
-            const f = u !== null && typeof u === "object" ? snapshotWalk(u, n, t) : u;
+            const f = u !== null && typeof u === "object" ? snapshotWalk(u, t, n) : u;
             if (l.enumerable && l.writable && l.configurable) o[i] = f; else Object.defineProperty(o, i, {
                 ...l,
                 value: f
@@ -2082,18 +2059,18 @@ function snapshotWalk(e, n, t) {
         if (e && o.length !== r.length) o.length = r.length;
         return o;
     }
-    n.set(r, r);
+    t.set(r, r);
     let i = null;
     for (const e of Reflect.ownKeys(r)) {
         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);
+        const u = snapshotWalk(l, t, n);
         if (u !== l) {
             if (i === null) {
                 i = Array.isArray(r) ? [ ...r ] : Object.create(Object.getPrototypeOf(r), Object.getOwnPropertyDescriptors(r));
-                n.set(r, i);
+                t.set(r, i);
             }
             i[e] = u;
         }