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

package/dist/prod/store/store.js

@@ -10,9 +10,9 @@ import { getObserver } from "../core/owner.js";
 
 import { insertIntoHeap } from "../core/heap.js";
 
-import { txOf, flushTransaction, holdNode, joinFuture, insertSubs, schedule, passLane, globalQueue, queuePendingNode, GlobalQueue, installStoreHooks, joinPassTx, dirtyQueue } from "../core/scheduler.js";
+import { txOf, flushTransaction, holdNode, joinFuture, insertSubs, schedule, passLane, globalQueue, queuePendingNode, resolveTx, GlobalQueue, installStoreHooks, joinPassTx, dirtyQueue } from "../core/scheduler.js";
 
-import { lookupTarget, setLookup, $OWNER, isOwned, markDescendants, devAssertNeverUserMutation } from "./target.js";
+import { lookupTarget, setLookup, $OWNER, isOwned, markDescendants } from "./target.js";
 
 import { optHooks, affectsHooks } from "./hooks.js";
 
@@ -134,7 +134,7 @@ function wrap(e, n = null, t = null, r = n?.fam ?? null) {
     const i = lookupTarget(e, r);
     if (i !== undefined) return i.px;
     const o = e[$TARGET];
-    if (o !== undefined && o.px === e) {
+    if (o?.px === e) {
         // Foreign-family proxies re-wrap into THIS family (writes stay isolated);
         // same-family and plain-store proxies pass through.
         if (r === null || o.fam === r) return e;
@@ -206,7 +206,7 @@ function sameKey(e, n) {
 /** The container node's comparator: a staging is a backing (identity — a
  * pending backing is never "equal" to the committed one); a lane value is
  * an arrangement (`LaneView`), judged by the optimistic machinery. */ const containerEquals = function(e, n) {
-    return e === n || optHooks !== null && optHooks.arrangement(this.O, e, n);
+    return e === n || !!optHooks?.arrangement(this.O, e, n);
 };
 
 function sameLogicalSlot(e, n, t) {
@@ -225,10 +225,10 @@ function releaseSlot(e) {
         if (n.k === e) n.k = null;
     } else if (t === $DEEP) {
         if (n.dk === e) n.dk = null;
-    } else if (n.n !== null && n.n[t] === e) {
+    } else if (n.n?.[t] === e) {
         delete n.n[t];
         n.nc--;
-    } else if (n.h !== null && n.h[t] === e) delete n.h[t];
+    } else if (n.h?.[t] === e) delete n.h[t];
     // The family's index keeps only targets that still carry a node.
         if (n.fam !== null && n.nc === 0 && n.k === null && n.dk === null && (n.h === null || Reflect.ownKeys(n.h).length === 0)) n.fam.live.delete(n);
 }
@@ -247,7 +247,7 @@ function releaseSlot(e) {
 // holds: its release waits for the commit that resolves it. So does a leaf of
 // a held container (#4146): a mainline write it carried is in the held
 // staging too, where it would read as the hold's until the landing.
-const slotKept = e => e.se !== NOT_PENDING || e.l & CONFIG_OVERRIDE || e.O.k?.l & CONFIG_HELD;
+const slotKept = e => e.ue !== NOT_PENDING || e.l & CONFIG_OVERRIDE || e.O.k?.l & CONFIG_HELD;
 
 setSlotUnobserved(e => {
     if (slotKept(e)) deferredReleases.add(e); else releaseSlot(e);
@@ -260,14 +260,19 @@ setSlotUnobserved(e => {
  * unchanged stages nothing and holds no one). */ function bornStaged(e, n, t, r) {
     if (n.xe && n.xe(n.Ie, t)) return;
     queuePendingNode(n);
-    n.se = t;
+    n.ue = t;
     const i = e.k;
     if (i === null) return;
  // a node-less staging holds nothing (`stageOn`)
     // Held by the container's transaction only for a key the HELD staging
     // changed — a mainline layer's change above it stages mainline. (A
-    // container carrying a guess is a lane's: the flush's park decides.)
-        if ((i.l & (CONFIG_HELD | CONFIG_OVERRIDE)) === CONFIG_HELD && heldKeyChanged(e, r)) holdNode(n, txOf(i));
+    // container carrying a guess is a lane's: the flush's park decides —
+    // unless a correction folded under the guess, D-34: the key is that
+    // correction's hold's.)
+        if (i.l & CONFIG_HELD && heldKeyChanged(e, r)) {
+        const e = txOf(i);
+        if (!(i.l & CONFIG_OVERRIDE) || e.folded) holdNode(n, resolveTx(e._parent ?? e));
+    }
     // A28 (4): a batch written inside a creation-time pass is promoted — its
     // late-materialized leaf with it.
         if (i.l & CONFIG_PROMOTED) notePromotedWrite(n);
@@ -287,7 +292,7 @@ t = -1) {
         // receiver.
         const o = e.pb;
         const l = i = slotSignal(committed(e)[n], slotNodeEquals, e, n, t === -1 ? isOwnAccessor(o ?? e.v, n) : t === 1);
-        if (o !== null && !l.acc) bornStaged(e, l, e.del !== null && e.del.has(n) ? undefined : o[n], n);
+        if (o !== null && !l.acc) bornStaged(e, l, e.del?.has(n) ? undefined : o[n], n);
         r[n] = i;
         e.nc++;
         noteNode(e, l, n);
@@ -301,7 +306,7 @@ function getHasNode(e, n) {
     if (r === undefined) {
         const i = r = slotSignal(n in committed(e), isEqual, e, n, false);
         const o = e.pb;
-        if (o !== null) bornStaged(e, i, n in o && !(e.del !== null && e.del.has(n)), n);
+        if (o !== null) bornStaged(e, i, n in o && !e.del?.has(n), n);
         t[n] = r;
         noteNode(e, i, n);
     }
@@ -321,7 +326,7 @@ function getHasNode(e, n) {
         // would have read had the node been there from the write.
                 if (e.pb !== null && !directCommit) {
             n.Ie = preBatch(e);
-            n.se = e.pb;
+            n.ue = e.pb;
             queuePendingNode(n);
         }
     }
@@ -340,8 +345,8 @@ function getHasNode(e, n) {
  * (`storeParkHook`) — the one case the staging home exists for. */ function stageOn(e, n) {
     if (e.k === null && passLane === null && (context === null || globalQueue.q) && !deriveHolds(e)) return;
     const t = getContainerNode(e);
-    if (t.se === NOT_PENDING) queuePendingNode(t);
-    t.se = n;
+    if (t.ue === NOT_PENDING) queuePendingNode(t);
+    t.ue = n;
     // A28 (4): a write issued inside a pass outside a flush (a creation-time
     // derive) is promoted at the pass's end — the batch with it.
         if (context !== null) notePromotedWrite(t);
@@ -444,7 +449,7 @@ function copyOwn(e, n, t) {
     const t = Reflect.ownKeys(n);
     let r = Object.getPrototypeOf(n) === Object.prototype;
     for (const i of t) {
-        if (lookupGetter.call(n, i) !== undefined || lookupSetter.call(n, i) !== undefined) {
+        if (isOwnAccessor(n, i)) {
             e.a = true;
             r = false;
             break;
@@ -474,7 +479,7 @@ const plainProto = e => {
 /** An overlay with many adds (or any delete) rebuilds the committed
  * container at flatten so its shape stays fast (#3689). */ function overlayRebuilds(e, n) {
     if (e.kc > OVERLAY_REBUILD_MAX_KEYS) return false;
-    if (e.del !== null && e.del.size !== 0) return true;
+    if (e.del?.size) return true;
     const t = e.wk;
     if (t !== null && t !== WK_ALL && t.u === undefined && t.size <= OVERLAY_REBUILD_MIN_ADDS) return false;
     const r = e.v;
@@ -486,17 +491,10 @@ const plainProto = e => {
 /** Downgrade an overlay to a real clone (a consumer needs a container). */ function materializePB(e) {
     const n = e.pb;
     if (!e.ovl) return n;
-    const t = e.sc === 2 ? wideClone(e.v, e) : cloneRaw(e.v, e);
-    if (e.del !== null) {
-        for (const n of e.del) delete t[n];
-        e.kc -= e.del.size;
-        e.del = null;
-    }
-    for (const r of Reflect.ownKeys(n)) e.sc === 2 ? t[r] = n[r] : copyOwn(t, n, r);
+    const t = overlayOnto(e, e.sc === 2 ? wideClone(e.v, e) : cloneRaw(e.v, e), n);
     e.pb = t;
-    e.ovl = false;
     // The staging IS the pending backing: re-point the container node.
-        if (e.k !== null && e.k.se === n) e.k.se = t;
+        if (e.k?.ue === n) e.k.ue = t;
     return t;
 }
 
@@ -517,7 +515,7 @@ const plainProto = e => {
         // mainline setter mid-hold publishes mainline; the held keys stay held).
         n = e.pb = cloneRaw(n, e);
         const t = e.k;
-        if (t !== null && !(t.l & CONFIG_HELD)) t.se = n;
+        if (t !== null && !(t.l & CONFIG_HELD)) t.ue = n;
     } else if (n === null) {
         const t = e.v;
         if (!directCommit) queueFold(e);
@@ -541,7 +539,6 @@ const plainProto = e => {
     e.ch = false;
     if (e.u) {
         privatizeCommitted(e.u);
-        devAssertNeverUserMutation(e.u.v);
         const t = e.u.v;
         const r = parentSlotKey(e, n);
         if (t[r] === n) t[r] = e.v;
@@ -565,17 +562,20 @@ const plainProto = e => {
 /** Overlay flatten (#3044): own keys onto the owned committed backing in
  * place — the backing keeps its identity. */ function flattenOverlay(e, n) {
     privatizeCommitted(e);
-    const t = e.v;
-    for (const r of Reflect.ownKeys(n)) e.sc === 2 ? t[r] = n[r] : copyOwn(t, n, r);
+    overlayOnto(e, e.v, n);
+ // the caller (`foldTarget`) closes the staging
+}
+
+/** An overlay's own keys and deletions onto `to` (the two are disjoint: a
+ * write un-deletes its key); the overlay is closed. */ function overlayOnto(e, n, t) {
+    for (const r of Reflect.ownKeys(t)) e.sc === 2 ? n[r] = t[r] : copyOwn(n, t, r);
     if (e.del !== null) {
-        for (const n of e.del) delete t[n];
+        for (const t of e.del) delete n[t];
         e.kc -= e.del.size;
         e.del = null;
     }
-    e.pb = null;
     e.ovl = false;
-    e.wk = null;
- // written-keys window closes with the commit
+    return n;
 }
 
 /** Adoption (a setter's returned replacement; reconcile and projection
@@ -615,7 +615,7 @@ const plainProto = e => {
     e.wk = null;
  // adoption supersedes staged trap writes
         const i = n[$OWNER];
-    if (i !== undefined && i.fam === e.fam) n[$OWNER] = e; else setLookup(n, e);
+    if (i?.fam === e.fam) n[$OWNER] = e; else setLookup(n, e);
     if (t && r !== n) notifyFold(e, r, n);
 }
 
@@ -692,7 +692,7 @@ let foldIndex = null;
             if (r.pb === null) continue;
  // folded already (a direct commit)
                         const i = r.k;
-            if (i !== null && i.se !== NOT_PENDING) {
+            if (i !== null && i.ue !== NOT_PENDING) {
                 // held: commits with its hold
                 foldList.push(r);
                 foldOlds.push(n[t]);
@@ -716,7 +716,7 @@ let foldIndex = null;
  * marks (an ambient `affects()` over a declared reload lives to the
  * landing) read it. */ GlobalQueue.k = e => {
     const n = e.O?.fam;
-    return n != null && n.node !== null && (n.node.m & STATUS_PENDING) !== 0;
+    return (n?.node?.m & STATUS_PENDING) !== 0;
 };
 
 /** Core asks (lanes.ts `covered`): the value a slot node's guess covered.
@@ -727,7 +727,7 @@ let foldIndex = null;
     if (n.ch) {
         const t = e.ze;
         const r = n.v;
-        if (n.h !== null && n.h[t] === e) e.Ie = untrack(() => t in r); else if (n.n !== null && n.n[t] === e) e.Ie = untrack(() => unwrapValue(r[t]));
+        if (n.h?.[t] === e) e.Ie = untrack(() => t in r); else if (n.n?.[t] === e) e.Ie = untrack(() => unwrapValue(r[t]));
     }
     return e.Ie;
 };
@@ -763,12 +763,7 @@ function runDirect(e) {
             const t = e.k;
             const r = e.pb;
             if (r !== null) {
-                if (r === e.v) {
-                    // An eager adoption nothing wrote after: the backing is already
-                    // the adopted object (shared ownership — never cloned).
-                    e.pb = null;
-                    e.wk = null;
-                } else if (e.ovl && (e.v !== n || !overlayRebuilds(e, r) && t?.T?.Pe !== n)) {
+                if (r === e.v) ; else if (e.ovl && (e.v !== n || !overlayRebuilds(e, r) && t?.T?.Pe !== n)) {
                     // Overlay flatten (#3044): the backing keeps its identity, so the
                     // `t.v === old` gate below skips path copying (the parent slot
                     // already points here) and the adopted-notify (setter
@@ -786,25 +781,21 @@ function runDirect(e) {
                             if (hasOwn.call(r, n)) copyOwn(t, r, n); else delete t[n];
                         }
                     } else {
-                        for (const e of Reflect.ownKeys(r)) {
-                            const i = Object.getOwnPropertyDescriptor(r, e);
-                            if (i.get || i.set || !i.enumerable || !i.writable || !i.configurable) Object.defineProperty(t, e, i); else if (i.value !== n[e] || !hasOwn.call(n, e)) t[e] = i.value;
-                        }
+                        for (const e of Reflect.ownKeys(r)) copyOwn(t, r, e);
                         for (const e of Reflect.ownKeys(n)) {
                             if (!hasOwn.call(r, e)) delete t[e];
                         }
                     }
-                    e.pb = null;
-                    e.wk = null;
                 } else {
                     // The clone (or adopted object) becomes the committed backing
                     // (path copy below).
                     e.v = e.ovl ? materializePB(e) : r;
                     e.ch = e.v[$TARGET] !== undefined;
-                    e.pb = null;
-                    e.wk = null;
                 }
-            }
+                e.pb = null;
+                e.wk = null;
+ // the written-keys window closes with the commit
+                        }
             if (t !== null) {
                 // The node's committed value is the backing. A container nobody
                 // subscribes to was a transient staging home (INTERNALS §5: an
@@ -816,7 +807,6 @@ function runDirect(e) {
                 const t = parentSlotKey(e, n);
                 if (e.u.v[t] === n) {
                     privatizeCommitted(e.u);
-                    devAssertNeverUserMutation(e.u.v);
                     e.u.v[t] = e.v;
                 }
             }
@@ -901,7 +891,7 @@ function heldDerivation(e, n, t) {
                 if (e?.get || e?.set || !isEqual(e?.value, r.value)) setSignal(i, () => r.value);
                 continue;
             }
-            const l = e.del !== null && e.del.has(o) ? undefined : n[o];
+            const l = e.del?.has(o) ? undefined : n[o];
             setSignal(i, () => l);
             if (e.fam !== null) {
                 // The derive's write is a derivation; a user setter's is a proposal
@@ -919,13 +909,13 @@ function heldDerivation(e, n, t) {
         for (const r of t) {
             const t = l[r];
             if (t !== undefined) {
-                setSignal(t, r in n && !(e.del !== null && e.del.has(r)));
+                setSignal(t, r in n && !e.del?.has(r));
                 if (e.fam !== null) holdWithDerive(e, t);
             }
         }
     }
     if (e.dk !== null) {
-        if (e.del !== null && e.del.size !== 0) bumpDeep(e); else for (const r of o ?? Reflect.ownKeys(n)) {
+        if (e.del?.size) bumpDeep(e); else for (const r of o ?? Reflect.ownKeys(n)) {
             if (r === $OWNER) continue;
             const i = n[r];
             const o = t[r];
@@ -943,7 +933,7 @@ function heldDerivation(e, n, t) {
     if (u !== null && (u.o !== null || u.l & CONFIG_OVERRIDE)) {
         let r;
         if (e.ovl) {
-            r = e.del !== null && e.del.size !== 0;
+            r = !!e.del?.size;
             if (!r) {
                 for (const e of Reflect.ownKeys(n)) {
                     if (!hasOwn.call(t, e)) {
@@ -1089,7 +1079,7 @@ function inDraft(e) {
 /** A child proxy served to a draft joins the draft's scope. */ function draftServe(e, n) {
     if (writeScopes !== null && inDraft(e)) {
         const e = n?.[$TARGET];
-        if (e !== undefined && e.v !== undefined) writeScopes.add(scopeKey(e));
+        if (e?.v !== undefined) writeScopes.add(scopeKey(e));
     }
     return n;
 }
@@ -1099,7 +1089,7 @@ function inDraft(e) {
  * "adoption is eager by contract" — and the node keeps the frame committed
  * readers under a hold still see), `t.v` otherwise. */ function committed(e) {
     const n = e.k;
-    if (n !== null) return n.se !== NOT_PENDING ? asBacking(n.Ie) : e.v;
+    if (n !== null) return n.ue !== NOT_PENDING ? asBacking(n.Ie) : e.v;
     // A node-less staging (`stageOn`): the fold queue remembers the frame.
         return e.pb !== null ? preBatch(e) : e.v;
 }
@@ -1111,7 +1101,7 @@ function inDraft(e) {
  * committed frame. */ function stagingReader() {
     let e = context;
     if (e === null) return null;
-    if (e.je) e = e.Ye ?? null;
+    if (e.Qe) e = e.Ye ?? null;
     return e === null || e.l & CONFIG_CHILDREN_FORBIDDEN ? null : e;
 }
 
@@ -1132,7 +1122,7 @@ function inDraft(e) {
     // sees — the lanes' values and the tick's own guesses over the truth
     // (#3665), never a staging awaiting its fold: the draft is born on the
     // read (and notified at the setter's exit like any).
-    if (userWrite && e.fam !== null && e.fam.opt === true && !pendingNotify.has(e) && inDraft(e)) {
+    if (userWrite && e.fam?.opt === true && !pendingNotify.has(e) && inDraft(e)) {
         const n = ensurePB(e);
         pendingNotify.add(e);
         return n;
@@ -1165,7 +1155,7 @@ function inDraft(e) {
     // it).
         if (n !== undefined) {
         const t = e.n?.[n];
-        if (t !== undefined && t.l & CONFIG_OVERRIDE) return committed(e);
+        if (t?.l & CONFIG_OVERRIDE) return committed(e);
     }
     const o = i !== null && (i.l & CONFIG_HELD) !== 0;
     // A held container: the hold's unit is the key (#3706). A key the HELD
@@ -1218,7 +1208,7 @@ function inDraft(e) {
 
 /** Did the HELD staging (the container node's, not a mainline layer above
  * it) change `key`? */ function heldKeyChanged(e, n, t = true) {
-    return changedBetween(e, e.k.Ie, e.k.se, n, t) && !adoptChild(e, n);
+    return changedBetween(e, e.k.Ie, e.k.ue, n, t) && !adoptChild(e, n);
 }
 
 /** The values of a held frame, built once per frame: neither the committed
@@ -1247,23 +1237,23 @@ function rawsOf(e) {
     const t = e.k;
     const r = asBacking(t.Ie);
     const i = r[n];
-    const o = t.se[n];
+    const o = t.ue[n];
     const l = Array.isArray(r) ? e.fam?.key : null;
     if (e.s || l === undefined || !sameRow(i, o, l) || !isWrappable(i) || !isWrappable(o) || Array.isArray(i) !== Array.isArray(o) || lookupTarget(i, e.fam) !== undefined || lookupTarget(o, e.fam) !== undefined || 
     // A raw in both frames (the same objects swapped or reordered) is its
     // own row: pairing it with another would alias the two after the commit.
-    rawsOf(r).has(o) || rawsOf(t.se).has(i)) return false;
+    rawsOf(r).has(o) || rawsOf(t.ue).has(i)) return false;
     // A raw-marked value wraps to itself, a proxy to its own target: neither
     // is a fresh target around `ov`.
         const u = wrap(i, e, n)[$TARGET];
-    if (u === undefined || u.v !== i) return false;
+    if (u?.v !== i) return false;
     adoptPB(u, o, false);
     holdNode(getContainerNode(u), txOf(t));
     return true;
 }
 
 /** A family target's unheld staging, read with no pass (a handler). */ function familyAhead(e) {
-    return e.fam !== null && context === null && !(e.k !== null && e.k.l & CONFIG_HELD);
+    return e.fam !== null && context === null && !(e.k?.l & CONFIG_HELD);
 }
 
 /** Did this batch change `key` — value (slot equality), presence, and (for
@@ -1283,7 +1273,7 @@ function rawsOf(e) {
 
 function changedBetween(e, n, t, r, i) {
     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;
+    if (e.del?.has(r)) return r in n;
     const o = hasOwn.call(t, r) || e.ovl && hasOwn.call(e.v, r);
     if (o !== hasOwn.call(n, r)) return true;
     if (!o) return false;
@@ -1297,7 +1287,7 @@ function changedBetween(e, n, t, r, i) {
  * tracked or not, applies the hold and A28 rules a signal's read does. A
  * projection's unheld staging is ahead for a handler (`familyAhead`). */ function nodeValue(e, n, t) {
     let r = read(e);
-    if (e.se !== NOT_PENDING && !(e.l & CONFIG_HELD) && context === null && t.fam !== null) r = e.se;
+    if (e.ue !== NOT_PENDING && !(e.l & CONFIG_HELD) && context === null && t.fam !== null) r = e.ue;
     return r === FORCE ? n : r;
 }
 
@@ -1390,7 +1380,7 @@ function changedBetween(e, n, t, r, i) {
  * classification, as core reads it — `heldNotFinal`). */ function holdWithDerive(e, n) {
     const t = e.fam?.node;
     if (t !== undefined && t !== null && !userWrite && // the derive's own write (its draft or landing), not a user setter's
-    t.l & CONFIG_HELD && n.se !== NOT_PENDING && 
+    t.l & CONFIG_HELD && n.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))) {
@@ -1431,7 +1421,7 @@ function changedBetween(e, n, t, r, i) {
 /** 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" ]);
@@ -1514,7 +1504,7 @@ const traps = {
         const i = readSource(e, n);
         // Overlay delete (#3044): a prototype overlay cannot shadow a delete, so
         // deleted keys are tracked aside and read as absent in the pending view.
-                if (e.del !== null && i === e.pb && e.del.has(n)) {
+                if (i === e.pb && e.del?.has(n)) {
             if (!inDraft(e) && getObserver() !== null) read(getNode(e, n));
             return undefined;
         }
@@ -1601,7 +1591,7 @@ const traps = {
                 if (t !== undefined) return t;
             }
         }
-        return n in t && !(e.del !== null && t === e.pb && e.del.has(n));
+        return n in t && !(t === e.pb && e.del?.has(n));
     },
     ownKeys(e) {
         if (verdict !== null && affectsHooks !== null && getObserver() === null) affectsHooks.ro(e, undefined);
@@ -1644,12 +1634,13 @@ const traps = {
     },
     set(e, n, t) {
         const r = inDraft(e);
-        const i = !r && writeOverride;
-        if (!r && !i) return true;
+        if (!r && !writeOverride) {
+            return true;
+        }
         if (n === "__proto__") return true;
  // pollution guard (core R30)
-                const o = e.s ? t : unwrapValue(t);
-        const l = ensurePB(e);
+                const i = e.s ? t : unwrapValue(t);
+        const o = 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
@@ -1661,59 +1652,55 @@ const traps = {
         // A34) — as it would with a reader's leaf. Kept while the container is
         // held (`deferredReleases`).
                 if (userWrite && e.k?.l & CONFIG_HELD) deferredReleases.add(getNode(e, n));
-        if (Array.isArray(l)) {
+        if (Array.isArray(o)) {
             touch(e, n);
             if (n === "length") e.wk = WK_ALL; else touch(e, "length");
         } else {
             touch(e, n);
-            if (!(n in l)) e.kc++;
-        }
-        if (UNSAFE_KEYS.has(n)) {
-            Object.defineProperty(l, n, {
-                value: o,
-                writable: true,
-                enumerable: true,
-                configurable: true
-            });
-            if (e.del !== null) e.del.delete(n);
-            return true;
+            if (!(n in o)) e.kc++;
         }
-        if (e.ovl && e.sc !== 2 && !hasOwn.call(l, n)) {
-            Object.defineProperty(l, n, {
-                value: o,
+        const l = UNSAFE_KEYS.has(n);
+        if (l || e.ovl && e.sc !== 2 && !hasOwn.call(o, n)) {
+            Object.defineProperty(o, n, {
+                value: i,
                 writable: true,
                 enumerable: true,
                 configurable: true
             });
-        } else l[n] = o;
-        if (e.del !== null) e.del.delete(n);
-        if (e.s && o !== null && typeof o === "object") markRawOne(o);
-        if (i) notifyWrites(e);
-        return true;
+        } else o[n] = i;
+        e.del?.delete(n);
+        if (l) return true;
+        if (e.s && i !== null && typeof i === "object") markRawOne(i);
+        if (!r) notifyWrites(e);
+ // a write-override write
+                return true;
     },
     defineProperty(e, n, t) {
         const r = inDraft(e);
-        const i = !r && writeOverride;
-        if (!r && !i) return true;
+        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)
         };
-        const o = ensurePB(e);
+        const i = ensurePB(e);
         if (e.a || !(t.enumerable && t.writable && t.configurable)) e.sc = 1;
         touch(e, n);
-        Object.defineProperty(o, n, t);
-        if (e.del !== null) e.del.delete(n);
-        if (i) notifyWrites(e);
-        return true;
+        Object.defineProperty(i, n, t);
+        e.del?.delete(n);
+        if (!r) notifyWrites(e);
+ // a write-override write
+                return true;
     },
     deleteProperty(e, n) {
         const t = inDraft(e);
-        const r = !t && writeOverride;
-        if (!t && !r) return true;
-        const i = ensurePB(e);
+        if (!t && !writeOverride) {
+            return true;
+        }
+        const r = ensurePB(e);
         touch(e, n);
         // The key count (`kc`, the overlay gate and the rebuild cap) follows a
         // delete the way it follows an add: an own key of the draft leaving — a
@@ -1724,14 +1711,15 @@ 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 o = e.ovl && hasOwn.call(e.v, n);
-        if (hasOwn.call(i, n)) {
-            delete i[n];
-            o || e.kc--;
+                const i = e.ovl && hasOwn.call(e.v, n);
+        if (hasOwn.call(r, n)) {
+            delete r[n];
+            i || e.kc--;
         }
-        if (o) (e.del ??= new Set).add(n);
-        if (r) notifyWrites(e);
-        return true;
+        if (i) (e.del ??= new Set).add(n);
+        if (!t) notifyWrites(e);
+ // a write-override write
+                return true;
     }
 };
 
@@ -1813,17 +1801,17 @@ function createStore(e, n) {
  * replaced by reference — #2932). The list driver uses this to choose the
  * slot-patch channel (collected row bodies) over per-record registration. */ function storeIsShallow(e) {
     const n = e?.[$TARGET];
-    return n !== undefined && n.s === true;
+    return n?.s === true;
 }
 
 /** True when `proxy` belongs to a projection family (S3). */ function storeHasFamily(e) {
     const n = e?.[$TARGET];
-    return n !== undefined && n.fam !== null;
+    return n?.fam != null;
 }
 
 /** True when `proxy` belongs to an OPTIMISTIC family (S4). */ function storeHasOptimisticFamily(e) {
     const n = e?.[$TARGET];
-    return n !== undefined && n.fam?.opt === true;
+    return n?.fam?.opt === true;
 }
 
 // ---------------------------------------------------------------------------
@@ -1833,7 +1821,7 @@ function visibleKeys(e, n) {
     if (e.ovl && n === e.pb) {
         t = Reflect.ownKeys(e.v);
         const r = e.del;
-        if (r !== null && r.size !== 0) t = t.filter(e => !r.has(e));
+        if (r?.size) t = t.filter(e => !r.has(e));
         for (const r of Reflect.ownKeys(n)) {
             if (!hasOwn.call(e.v, r)) t.push(r);
         }
@@ -1851,7 +1839,7 @@ function visibleKeys(e, n) {
 function visibleDescriptor(e, n, t) {
     let r = Object.getOwnPropertyDescriptor(n, t);
     if (e.ovl && n === e.pb) {
-        if (e.del !== null && e.del.has(t)) return undefined;
+        if (e.del?.has(t)) return undefined;
         if (r === undefined) r = Object.getOwnPropertyDescriptor(e.v, t);
     }
     return r;
@@ -1862,7 +1850,7 @@ function visibleDescriptor(e, n, t) {
 /** Tracking snapshot: subscribes every reachable record's container and deep
  * witness (one node per record, not one per path), then snapshots. */ function deep(e) {
     const n = e?.[$TARGET];
-    if (n === undefined || n.px !== e) return e;
+    if (n?.px !== e) return e;
     const t = new Set;
     const childTarget = (e, n, t) => {
         let r = lookupTarget(n, e.fam);

package/dist/prod/store/target.js

@@ -17,31 +17,27 @@ const $OWNER = Symbol(0);
 /** raw → target for plain (family-less) stores. Family stores use their own
  * map so one raw can wrap once per family (§7b). */ const storeLookup = new WeakMap;
 
-function setLookup(e, o) {
-    (o.fam?.map ?? storeLookup).set(e, o);
+function setLookup(o, e) {
+    (e.fam?.map ?? storeLookup).set(o, e);
 }
 
-function isOwned(e) {
-    return e[$OWNER] !== undefined;
+function isOwned(o) {
+    return o[$OWNER] !== undefined;
 }
 
 /** The target wrapping `raw` in `fam` (or the plain lookup). An owned raw
- * answers from its stamp; a user raw from the map. */ function lookupTarget(e, o) {
-    const t = e[$OWNER];
-    return t !== undefined && t.fam === o ? t : (o?.map ?? storeLookup).get(e);
-}
-
-function devAssertNeverUserMutation(e) {
-    return;
+ * answers from its stamp; a user raw from the map. */ function lookupTarget(o, e) {
+    const n = o[$OWNER];
+    return n !== undefined && n.fam === e ? n : (e?.map ?? storeLookup).get(o);
 }
 
 /** Sticky descendants flag up the parent chain (§6d): adoption descends
- * into a changed child pair only where a target with nodes exists below. */ function markDescendants(e) {
-    let o = e;
-    while (o && !o.d) {
-        o.d = true;
-        o = o.u;
+ * into a changed child pair only where a target with nodes exists below. */ function markDescendants(o) {
+    let e = o;
+    while (e && !e.d) {
+        e.d = true;
+        e = e.u;
     }
 }
 
-export { $OWNER, devAssertNeverUserMutation, isOwned, lookupTarget, markDescendants, setLookup, storeLookup };
+export { $OWNER, isOwned, lookupTarget, markDescendants, setLookup, storeLookup };