@solidjs/signals 2.0.0-rc.1 → 2.0.0-rc.2

package/dist/prod/store/next/store.js

@@ -1,6 +1,6 @@
-import { unwrapOverride, $REFRESH, CONFIG_OWNED_WRITE, NOT_PENDING, STATUS_UNINITIALIZED, STATUS_ERROR, CONFIG_CHILDREN_FORBIDDEN } from "../../core/constants.js";
+import { unwrapOverride, $REFRESH, CONFIG_OWNED_WRITE, NOT_PENDING, CONFIG_OPTIMISTIC, STATUS_UNINITIALIZED, STATUS_ERROR, CONFIG_CHILDREN_FORBIDDEN } from "../../core/constants.js";
 
-import { setSignal, isEqual, read, pendingCheckActive, readNodeFast, READ_SLOW, signal } from "../../core/core.js";
+import { setSignal, isEqual, read, pendingCheckActive, readNodeFast, READ_SLOW, signal, ext } from "../../core/core.js";
 
 import { projectionWriteActive, setProjectionWriteActive, schedule, setStoreCommitHook } from "../../core/scheduler.js";
 
@@ -30,13 +30,48 @@ import { storeNextLookup, optHooks, ownedRaw, devAssertNeverUserMutation } from
  */
 // ---------------------------------------------------------------------------
 // wrap / dedupe
+/** Pre-shaped constructor for OBJECT proxy targets: V8 tips a bare `{}` into
+ * dictionary mode once ~19 named properties are assigned onto it (the #3044
+ * `ovl`/`del` fields crossed that line — every trap's field read became a
+ * hash lookup, a 15% deep-dbmon tick regression). Declaring every field in a
+ * constructor pre-allocates in-object slots so the map stays fast, with
+ * headroom for future fields. The prototype is reset to `Object.prototype`
+ * so proxy-forwarded semantics (getPrototypeOf, constructor) are exactly a
+ * plain object's. Array targets keep the bare-`[]` path — they must carry
+ * the array exotic class for `Array.isArray(proxy)`, and arrays store named
+ * fields off-object where this cliff does not apply. */
+function TargetShape() {
+    this.v = undefined;
+    this.ch = undefined;
+    this.pb = undefined;
+    this.n = undefined;
+    this.h = undefined;
+    this.k = undefined;
+    this.dk = undefined;
+    this.u = undefined;
+    this.pk = undefined;
+    this.px = undefined;
+    this.d = undefined;
+    this.a = undefined;
+    this.sc = undefined;
+    this.nc = undefined;
+    this.adopted = undefined;
+    this.fam = undefined;
+    this.s = undefined;
+    this.ovl = undefined;
+    this.del = undefined;
+    this.wk = undefined;
+}
+
+TargetShape.prototype = Object.prototype;
+
 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
     // copy): every target shares a hidden-class transition chain — createTarget
     // was the #2 store cost in the uibench creation profile.
-    const i = Array.isArray(e) ? [] : {};
+    const i = Array.isArray(e) ? [] : new TargetShape;
     i.v = e;
     // Chained-backing flag (backing IS another store's proxy, §7b) — cached so
     // the hot read path never does a per-read symbol lookup on the backing.
@@ -56,6 +91,9 @@ function createTarget(e, t, n, r = t?.fam ?? null) {
     i.adopted = false;
     i.fam = r;
     i.s = false;
+    i.ovl = false;
+    i.del = null;
+    i.wk = null;
     i.px = new Proxy(i, traps);
     // Legacy interop: shared machinery (affects walks, wrap dedupe) reads the
     // proxy off looked-up targets as a field.
@@ -83,7 +121,13 @@ function wrapNext(e, t = null, n = null, r = t?.fam ?? null) {
 /** Unwrap our own proxies to their current backing; leave everything else. */ function unwrapValue(e) {
     if (e == null || typeof e !== "object") return e;
     const t = e[$TARGET];
-    if (t !== undefined && t.px === e && t.v !== undefined) return t.pb ?? t.v;
+    if (t !== undefined && t.px === e && 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 (t.ovl) materializePB(t);
+        return t.pb ?? t.v;
+    }
     return e;
 }
 
@@ -100,7 +144,7 @@ function getNode(e, t, n) {
             equals: (t, n) => isEqual(t, n) || sameLogicalSlot(e, t, n),
             unobserved() {
                 // A live affects() mark keeps the node addressable (sweep parity).
-                if (o.t) return;
+                if (o.o?.t) return;
                 if (e.n && e.n[t] === o) {
                     delete e.n[t];
                     e.nc--;
@@ -126,7 +170,10 @@ function getNode(e, t, n) {
         o.pxv = undefined;
         // Optimistic families: arm the override slot — setSignal routes armed
         // nodes through the core engine (lanes, ownership, reverts all native).
-                if (e.fam?.opt) o.De = NOT_PENDING;
+                if (e.fam?.opt) {
+            ext(o).De = NOT_PENDING;
+            o.T |= CONFIG_OPTIMISTIC;
+        }
         // A node born inside a live mark's identity scope inherits the mark
         // (the declaration walk could only cover nodes existing then).
                 if (t !== $AFFECTS && affectsScopesLive()) inheritAffectsMarks(o, e.v, t);
@@ -151,12 +198,15 @@ function getHasNode(e, t, n) {
         const o = i = signal(n, {
             equals: isEqual,
             unobserved() {
-                if (o.t) return;
+                if (o.o?.t) return;
                 if (e.h && e.h[t] === o) delete e.h[t];
             }
         }, e.fam?.node ?? undefined);
         o.T |= CONFIG_OWNED_WRITE;
-        if (e.fam?.opt) o.De = NOT_PENDING;
+        if (e.fam?.opt) {
+            ext(o).De = NOT_PENDING;
+            o.T |= CONFIG_OPTIMISTIC;
+        }
         if (affectsScopesLive()) inheritAffectsMarks(o, e.v, t);
         r[t] = i;
         markDescendants(e);
@@ -174,7 +224,10 @@ function getKeySetNode(e) {
             }
         }, e.fam?.node ?? undefined);
         n.T |= CONFIG_OWNED_WRITE;
-        if (e.fam?.opt) n.De = NOT_PENDING;
+        if (e.fam?.opt) {
+            ext(n).De = NOT_PENDING;
+            n.T |= CONFIG_OPTIMISTIC;
+        }
         e.k = t;
         markDescendants(e);
     }
@@ -191,7 +244,10 @@ function getDeepNode(e) {
             }
         }, e.fam?.node ?? undefined);
         n.T |= CONFIG_OWNED_WRITE;
-        if (e.fam?.opt) n.De = NOT_PENDING;
+        if (e.fam?.opt) {
+            ext(n).De = NOT_PENDING;
+            n.T |= CONFIG_OPTIMISTIC;
+        }
         if (affectsScopesLive()) inheritAffectsMarks(n, e.v, $TRACK);
         e.dk = t;
         markDescendants(e);
@@ -235,10 +291,56 @@ function cloneRaw(e, t) {
     return Array.isArray(e) ? Object.defineProperties([], n) : Object.create(Object.getPrototypeOf(e), n);
 }
 
+/** One-time own-accessor scan (Annex-B probes, no descriptor allocation);
+ * returns true when the container is plain data (overlay-safe). */ function scanAccessorsOnce(e) {
+    const t = e.v;
+    for (const n of Reflect.ownKeys(t)) {
+        // Own keys shadow prototype accessors, so the lookups are exact here.
+        if (lookupGetter.call(t, n) !== undefined || lookupSetter.call(t, n) !== undefined) {
+            e.a = true;
+            break;
+        }
+    }
+    e.sc = true;
+    return !e.a;
+}
+
+/** Downgrade a prototype-overlay pending backing to the clone path: builds
+ * the real container (committed + overlay writes − deletes) that fold will
+ * SWAP in as the committed backing, exactly as if the draft had started on
+ * the clone path. Consumers that need a complete container (reconcile's
+ * diff walks, drafts escaping into other storage) call this. */ function materializePB(e) {
+    if (!e.ovl) return;
+    const t = e.pb;
+    const n = cloneRaw(e.v, e);
+    for (const e of Reflect.ownKeys(t)) {
+        const r = Object.getOwnPropertyDescriptor(t, e);
+        if (r.get || r.set || !r.enumerable || !r.writable || !r.configurable) Object.defineProperty(n, e, r); else n[e] = r.value;
+    }
+    if (e.del !== null) {
+        for (const t of e.del) delete n[t];
+        e.del = null;
+    }
+    const r = e.fam?.map ?? storeNextLookup;
+    r.delete(t);
+    ownedRaw.add(n);
+    r.set(n, e);
+    e.pb = n;
+    e.ovl = false;
+}
+
 function ensurePB(e) {
     let t = e.pb;
     if (t === null) {
-        t = e.pb = cloneRaw(e.v, e);
+        // Prototype-chain overlay (#3044): plain-data non-array containers
+        // outside projection/optimistic families open drafts in O(1) — own keys
+        // are the writes, reads fall through to committed. Everything else
+        // (arrays: splice/length semantics; families: seeding/revert machinery;
+        // accessor containers: live getters) keeps the descriptor clone.
+        if (e.fam === null && !Array.isArray(e.v) && (e.sc ? !e.a : scanAccessorsOnce(e))) {
+            t = e.pb = Object.create(e.v);
+            e.ovl = true;
+        } else t = e.pb = cloneRaw(e.v, e);
         // Optimistic families: seed USER drafts from the OPTIMISTIC VIEW
         // (committed + active node overrides), so follow-up writes compose on
         // optimism instead of clobbering from base (#2951's compose half).
@@ -250,14 +352,14 @@ function ensurePB(e) {
             if (n !== null) {
                 for (const e of Reflect.ownKeys(n)) {
                     const r = n[e];
-                    if (hasActiveOverride(r)) t[e] = unwrapOverride(r.De);
+                    if (hasActiveOverride(r)) t[e] = unwrapOverride(r.o?.De);
                 }
             }
             const r = e.h;
             if (r !== null) {
                 for (const e of Reflect.ownKeys(r)) {
                     const n = r[e];
-                    if (hasActiveOverride(n) && !unwrapOverride(n.De)) delete t[e];
+                    if (hasActiveOverride(n) && !unwrapOverride(n.o?.De)) delete t[e];
                 }
             }
         }
@@ -285,6 +387,19 @@ function ensurePB(e) {
                 e.adopted = true;
     }
     e.pb = null;
+    // Overlay and accessor-scan state describe the OUTGOING backing — a
+    // swapped container must not inherit them: a stale `ovl` beside a nulled
+    // pb crashes materializePB (unwrapValue consults ovl before the
+    // null-coalesce), a stale `del` would read the adoptee's keys as deleted
+    // in the next draft, and a stale plain-data verdict (`sc`/`a`) could
+    // admit an accessor-bearing adoptee to the overlay path. Reset; the next
+    // draft rescans once (#3044 audit follow-up).
+        e.ovl = false;
+    e.del = null;
+    e.wk = null;
+ // adoption supersedes any staged trap writes
+        e.sc = false;
+    e.a = false;
     e.v = t;
     e.ch = t[$TARGET] !== undefined;
     (e.fam?.map ?? storeNextLookup).set(t, e);
@@ -331,9 +446,14 @@ function drainFolds() {
             const r = t.pb;
             const i = t.n;
             if (i !== null) {
-                for (const t of Reflect.ownKeys(i)) {
+                // Only written keys can hold (their nodes took the setSignal); the
+                // wk bound keeps this O(written) — see notifyWrites. Same fallback
+                // rules as the notify (WK_ALL / accessors / non-plain prototypes).
+                const n = t.wk;
+                const o = n === null || n === WK_ALL || t.a === true || !plainProto(t.ovl ? t.v : r) ? Reflect.ownKeys(i) : n;
+                for (const t of o) {
                     const n = i[t];
-                    if (n._e !== NOT_PENDING) {
+                    if (n !== undefined && n.Pe !== NOT_PENDING) {
                         e = true;
                         break;
                     }
@@ -344,10 +464,37 @@ function drainFolds() {
  // re-queue: commit happens when the hold settles
                                 continue;
             }
-            t.v = r;
-            t.ch = false;
+            if (t.ovl) {
+                // Overlay flatten (#3044): apply this batch's writes onto an OWNED
+                // committed backing in place — O(written), not O(container). 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).
+                // Unowned backings privatize first (clone once, parents re-slotted)
+                // — the never-mutate-user-data contract holds.
+                privatizeCommitted(t);
+                const e = t.v;
+                for (const t of Reflect.ownKeys(r)) {
+                    const n = Object.getOwnPropertyDescriptor(r, t);
+                    if (n.get || n.set || !n.enumerable || !n.writable || !n.configurable) Object.defineProperty(e, t, n); else e[t] = n.value;
+                }
+                if (t.del !== null) {
+                    for (const n of t.del) delete e[n];
+                    t.del = null;
+                }
+                (t.fam?.map ?? storeNextLookup).delete(r);
+                t.pb = null;
+                t.ovl = false;
+                t.wk = null;
+ // written-keys window closes with the fold commit
+                        } else {
+                t.v = r;
+                t.ch = false;
  // pb is always a plain clone
-                        t.pb = null;
+                                t.pb = null;
+                t.wk = null;
+ // written-keys window closes with the fold commit
+                        }
         }
         if (t.v === n) continue;
  // adopted then re-adopted back, or no-op
@@ -371,8 +518,20 @@ function drainFolds() {
  * isPending, affects, and lane machinery ride the core natively (§3's
  * "pending home = the node when a node exists"). Unobserved keys stay in the
  * pending backing and fold directly at commit.
- */ function notifyWrites(e) {
-    const t = e.pb;
+ */
+/** Sentinel for `t.wk`: the written-keys bound is unusable this batch (an
+ * array length write implicitly deleted indices) — consumers full-scan. */ const WK_ALL = new Set;
+
+/** Plain-prototype check for the written-keys bound: prototype getters on
+ * class instances can derive from ANY field, so only plain-data containers
+ * may bound the notify to written keys. Overlay pbs chain to the COMMITTED
+ * object (#3044), so overlay plainness is judged on the committed proto. */ const plainProto = e => {
+    const t = Object.getPrototypeOf(e);
+    return t === Object.prototype || t === Array.prototype || t === null;
+};
+
+function notifyWrites(e) {
+    let t = e.pb;
     if (t === null) return;
     // Optimistic channel: user writes on an optimistic family become node-level
     // engine writes (armed nodes route setSignal through optimisticWrite) — the
@@ -402,40 +561,51 @@ function drainFolds() {
     }
     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
+    // map with thousands of per-key subscribers pays two visits per select,
+    // not a full scan). Falls back to the full node scan when the bound can't
+    // hold: no trap granularity (wk null), an array length write (WK_ALL —
+    // implicit index deletes), accessors on the record (t.a — a getter node's
+    // value can change when ANY key is written), or a non-plain prototype.
+        const i = e.wk;
+    const o = i === WK_ALL || e.a === true || !plainProto(e.ovl ? e.v : t) ? null : i;
     if (r !== null) {
-        for (const e of Reflect.ownKeys(r)) {
-            const i = r[e];
+        const i = o ?? Reflect.ownKeys(r);
+        for (const o of i) {
+            const i = r[o];
+            if (i === undefined) continue;
             // Per-key accessor handling: the node's cached flag plus ONE getter
             // probe on the incoming side (getters arriving via merge/adoption).
             // Setter-only props read as data (value undefined) so lookupSetter is
             // not consulted on this hot path; prototype getters never own nodes.
-                        if (i.acc === true || hasOwn.call(t, e) && lookupGetter.call(t, e) !== undefined) {
-                i.acc = isOwnAccessor(t, e);
-                const r = Object.getOwnPropertyDescriptor(n, e);
-                const o = Object.getOwnPropertyDescriptor(t, e);
-                if (r && (r.get || r.set) || o && (o.get || o.set)) {
-                    if (r?.get !== o?.get || r?.set !== o?.set || r?.value !== o?.value) setSignal(i, () => FORCE);
+                        if (i.acc === true || hasOwn.call(t, o) && lookupGetter.call(t, o) !== undefined) {
+                i.acc = isOwnAccessor(t, o);
+                const e = Object.getOwnPropertyDescriptor(n, o);
+                const r = Object.getOwnPropertyDescriptor(t, o);
+                if (e && (e.get || e.set) || r && (r.get || r.set)) {
+                    if (e?.get !== r?.get || e?.set !== r?.set || e?.value !== r?.value) setSignal(i, () => FORCE);
                     continue;
                 }
-                if (!isEqual(r?.value, o?.value)) setSignal(i, () => o?.value);
+                if (!isEqual(e?.value, r?.value)) setSignal(i, () => r?.value);
                 continue;
             }
             // No old-side pre-compare: t.v lags across multi-batch windows (a
             // projection recompute can run before the prior fold commits) — the
             // node's OWN current value is the true old side, and setSignal's
             // internal equality already checks exactly that.
-                        const o = t[e];
-            setSignal(i, () => o);
+                        const f = e.del !== null && e.del.has(o) ? undefined : t[o];
+            setSignal(i, () => f);
         }
     }
-    const i = e.h;
-    if (i !== null) {
-        for (const e of Reflect.ownKeys(i)) setSignal(i[e], e in t);
+    const f = e.h;
+    if (f !== null) {
+        for (const n of Reflect.ownKeys(f)) setSignal(f[n], n in t && !(e.del !== null && e.del.has(n)));
     }
     // Deep-witness (dk): setter writes must notify a deep() subscriber even on
     // keys with no node. O(pb keys) equality only when a witness exists.
         if (e.dk !== null) {
-        for (const r of Reflect.ownKeys(t)) {
+        if (e.del !== null && e.del.size !== 0) bumpDeep(e); else for (const r of Reflect.ownKeys(t)) {
             const i = t[r];
             const o = n[r];
             if (i !== null && typeof i === "object" ? !targetsEqual(o, i) : !isEqual(o, i)) {
@@ -445,7 +615,21 @@ function drainFolds() {
         }
     }
     if (e.k !== null) {
-        const r = Array.isArray(t) && Array.isArray(n) ? arrayStructureChanged(n, t) : membershipChanged(n, t);
+        let r;
+        if (e.ovl) {
+            // Overlay membership: only NEW own keys or deletes can change it.
+            r = e.del !== null && e.del.size !== 0;
+            if (!r) {
+                for (const e of Reflect.ownKeys(t)) {
+                    if (!hasOwn.call(n, e)) {
+                        r = true;
+                        break;
+                    }
+                }
+            }
+        } else {
+            r = Array.isArray(t) && Array.isArray(n) ? arrayStructureChanged(n, t) : membershipChanged(n, t);
+        }
         if (r) setSignal(e.k, e => e + 1);
     }
     // Projection backing folds split by channel (two pinned contracts):
@@ -461,7 +645,9 @@ function drainFolds() {
         if (e.fam !== null && e.pb !== null && getWriteOverride()) {
         const n = e.v;
         e.pb = null;
-        e.v = t;
+        e.wk = null;
+ // written-keys window closes with the eager fold
+                e.v = t;
         e.ch = false;
         if (e.u && e.u.v[e.pk] === n) {
             privatizeCommitted(e.u);
@@ -650,7 +836,7 @@ const UNSAFE_KEYS = new Set([ "__proto__", "prototype", "constructor" ]);
  * / onSettled callbacks) get COMMITTED visibility (#3006), same as core. */ function inOwnerContext() {
     const e = getOwner();
     if (e === null) return false;
-    const t = e.Tt ? e.It : e;
+    const t = e.Ct ? e.Ot : e;
     return t != null && !(t.T & CONFIG_CHILDREN_FORBIDDEN);
 }
 
@@ -661,7 +847,7 @@ const UNSAFE_KEYS = new Set([ "__proto__", "prototype", "constructor" ]);
     if (t === null) return false;
     for (const e of Reflect.ownKeys(t)) {
         const n = t[e];
-        if (n._e !== NOT_PENDING && n.Ne != null && n.Ne.fn !== true) return true;
+        if (n.Pe !== NOT_PENDING && n._e != null && n._e.an !== true) return true;
     }
     return false;
 }
@@ -710,7 +896,7 @@ function isOwnAccessor(e, t) {
 
 /** Active optimistic override on an armed node (armed slot idles at
  * NOT_PENDING; undefined = unarmed plain node). */ function hasActiveOverride(e) {
-    return e.De !== undefined && e.De !== NOT_PENDING;
+    return e.o?.De !== undefined && e.o?.De !== NOT_PENDING;
 }
 
 /** Context-aware node view for reads outside tracking: active override >
@@ -720,7 +906,7 @@ function isOwnAccessor(e, t) {
  * reader that forced it (backing commits eagerly; node values fold at flush).
  * FORCE sentinels never surface (they only bump subscribers of accessor
  * keys, which are served by the trap, not the node). */ function nodeValue(e, t) {
-    const n = hasActiveOverride(e) ? unwrapOverride(e.De) : e._e !== NOT_PENDING && inOwnerContext() ? e._e : t;
+    const n = hasActiveOverride(e) ? unwrapOverride(e.o?.De) : e.Pe !== NOT_PENDING && inOwnerContext() ? e.Pe : t;
     return n === FORCE ? t : n;
 }
 
@@ -753,7 +939,7 @@ function isOwnAccessor(e, t) {
         // #2951). Once ensurePB runs, the seeded clone carries the view.
         if (e.fam?.opt && e.pb === null) {
             const n = e.n?.[t];
-            if (n !== undefined && hasActiveOverride(n)) f = unwrapOverride(n.De);
+            if (n !== undefined && hasActiveOverride(n)) f = unwrapOverride(n.o?.De);
         }
     } else {
         if (i !== undefined) {
@@ -796,6 +982,15 @@ function isOwnAccessor(e, t) {
  * read() links the node and throws the firewall's error itself (the node
  * link is what wakes async-memo readers when the landing writes values;
  * the firewall link rides the same read). */ function firewallGate(e) {
+    // Own-draft ops are exempt: an async derive's continuation (generator body
+    // after an `await`/`yield`) runs OUTSIDE the sync write scope (inDraft is
+    // already false), but its draft-proxy traps mark every op with the write
+    // override. Those reads are the derive working its own draft (state.push
+    // reading .length) — gating them throws NotReadyError back into the derive
+    // itself, which the post-await read diagnostic (#2987) then escalates to a
+    // reactivity halt. The gate exists for EXTERNAL readers (seed invisibility,
+    // proj R23); the derive is the author.
+    if (projectionWriteActive || getWriteOverride()) return;
     const t = e.fam?.node;
     if (t != null && t.S & (STATUS_UNINITIALIZED | STATUS_ERROR)) read(t);
 }
@@ -828,6 +1023,12 @@ const traps = {
         if (pendingCheckActive) witnessAffectsMark(e, t);
         if (e.fam !== null && getObserver() === null && !inDraft(e)) firewallGate(e);
         const r = readSource(e);
+        // 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 && r === e.pb && e.del.has(t)) {
+            if (!inDraft(e) && getObserver() !== null) read(getNode(e, t, undefined));
+            return undefined;
+        }
         // Hot inline case: existing PLAIN node (non-accessor), unchained backing,
         // tracked read of a present data key — the dbmon/uibench effect re-read
         // shape. Skips serveDataKey's frame, the FORCE compare (only accessor
@@ -855,11 +1056,17 @@ const traps = {
         // the node's cached flag; the first TRACKED read (which creates the
         // node) probes once — untracked node-less reads take the plain path,
         // where a raw-receiver getter still returns correct committed values.
+        // Tracking suppression is PER-TARGET (inDraft), never global: `writing`
+        // counts every open setter anywhere, and a projection derive runs its
+        // whole body inside one — a global gate silently swallowed EXTERNAL
+        // absent-key/accessor subscriptions for every store read during any
+        // derive, leaving nested projections permanently dependency-less when
+        // their sources hadn't materialized yet (#3037).
                 const i = e.n?.[t];
         {
-            const o = i !== undefined ? i.acc === true : !writing && getObserver() !== null && isOwnAccessor(r, t);
+            const o = i !== undefined ? i.acc === true : !inDraft(e) && getObserver() !== null && isOwnAccessor(r, t);
             if (o) {
-                if (!writing && getObserver() !== null) read(i ?? getNode(e, t, undefined));
+                if (!inDraft(e) && getObserver() !== null) read(i ?? getNode(e, t, undefined));
                 const o = Reflect.get(r, t, n);
                 if (e.s) return serveShallow(e, t, o);
                 return isWrappable(o) ? draftServe(e, wrapNext(o, e, t)) : o;
@@ -868,16 +1075,21 @@ const traps = {
         // Plain-data fast path: no descriptor allocation per read.
         // Inherited pollution keys are never served (core R30) — checked before
         // the proto-function branch can leak `constructor`. Interned-string
-        // compares beat a Set hash on this per-read path.
-                if ((t === "constructor" || t === "__proto__" || t === "prototype") && !hasOwn.call(r, t)) return undefined;
-        let o = r[t];
-        if (o === undefined ? !hasOwn.call(r, t) : false) {
+        // compares beat a Set hash on this per-read path. Overlay pending
+        // backings chain to the committed backing, so "own in the view" means
+        // own on either layer (ownInView) — a genuine prototype method is one
+        // that is own on NEITHER.
+                const o = e.ovl && r === e.pb;
+        if ((t === "constructor" || t === "__proto__" || t === "prototype") && !hasOwn.call(r, t) && !(o && hasOwn.call(e.v, t))) return undefined;
+        let f = r[t];
+        if (f === undefined ? !hasOwn.call(r, t) && !(o && hasOwn.call(e.v, t)) : false) {
             // Inherited: prototype getters/methods run with the proxy receiver.
-            o = Reflect.get(r, t, n);
-            if (typeof o === "function") return o;
+            f = Reflect.get(r, t, n);
+            if (typeof f === "function") return f;
  // proto methods untracked
-            // Reading a currently-absent own key subscribes to it (R12).
-                        if (o === undefined && !writing) {
+            // Reading a currently-absent own key subscribes to it (R12) — for any
+            // target OUTSIDE its own draft scope, even mid-setter (#3037, above).
+                        if (f === undefined && !inDraft(e)) {
                 if (getObserver() !== null) read(getNode(e, t, undefined));
                 const n = e.n?.[t];
                 if (n) {
@@ -885,16 +1097,16 @@ const traps = {
                     if (e.s) return serveShallow(e, t, r);
                     return isWrappable(r) ? draftServe(e, wrapNext(r, e, t)) : r;
                 }
-            } else if (o === undefined && inDraft(e) && e.fam?.opt && e.pb === null) {
+            } else if (f === undefined && inDraft(e) && e.fam?.opt && e.pb === null) {
                 const n = e.n?.[t];
-                if (n !== undefined && hasActiveOverride(n)) o = unwrapOverride(n.De);
+                if (n !== undefined && hasActiveOverride(n)) f = unwrapOverride(n.o?.De);
             }
-            if (e.s) return serveShallow(e, t, o);
-            return isWrappable(o) ? draftServe(e, wrapNext(o, e, t)) : o;
+            if (e.s) return serveShallow(e, t, f);
+            return isWrappable(f) ? draftServe(e, wrapNext(f, e, t)) : f;
         }
-        if (typeof o === "function" && !hasOwn.call(r, t)) return o;
+        if (typeof f === "function" && !hasOwn.call(r, t) && !(o && hasOwn.call(e.v, t))) return f;
  // proto method
-                return serveDataKey(e, t, o, r, i);
+                return serveDataKey(e, t, f, r, i);
     },
     has(e, t) {
         if (t === $TARGET || t === $PROXY || t === $TRACK) return true;
@@ -902,6 +1114,8 @@ const traps = {
         if (e.fam !== null && getObserver() === null && !inDraft(e)) firewallGate(e);
         const n = readSource(e);
         let r = t in n;
+        // Overlay deletes read as absent in the pending view (#3044).
+                if (r && e.del !== null && n === e.pb && e.del.has(t)) r = false;
         if (!inDraft(e)) {
             if (getObserver() !== null) {
                 const n = getHasNode(e, t, r);
@@ -909,11 +1123,11 @@ const traps = {
                 if (hasActiveOverride(n)) r = !!i;
             } else {
                 const n = e.h?.[t];
-                if (n !== undefined && hasActiveOverride(n)) r = !!unwrapOverride(n.De);
+                if (n !== undefined && hasActiveOverride(n)) r = !!unwrapOverride(n.o?.De);
             }
         } else if (e.fam?.opt && e.pb === null) {
             const n = e.h?.[t];
-            if (n !== undefined && hasActiveOverride(n)) r = !!unwrapOverride(n.De);
+            if (n !== undefined && hasActiveOverride(n)) r = !!unwrapOverride(n.o?.De);
         }
         return r;
     },
@@ -921,31 +1135,49 @@ const traps = {
         if (pendingCheckActive) witnessAffectsMark(e);
         if (e.fam !== null && getObserver() === null && !inDraft(e)) firewallGate(e);
         if (!inDraft(e) && getObserver() !== null) read(getKeySetNode(e));
-        const t = Reflect.ownKeys(readSource(e));
+        const t = readSource(e);
+        let n;
+        if (e.ovl && t === e.pb) {
+            // Overlay merge (#3044): committed keys in their order, then this
+            // batch's NEW keys, minus deletes.
+            n = Reflect.ownKeys(e.v);
+            const r = e.del;
+            if (r !== null && r.size !== 0) n = n.filter(e => !r.has(e));
+            for (const r of Reflect.ownKeys(t)) {
+                if (!hasOwn.call(e.v, r)) n.push(r);
+            }
+        } else n = Reflect.ownKeys(t);
         // Optimistic membership overlay: presence-node overrides add/remove keys
         // (per-transaction lifecycle rides the nodes — §6, FINDING-2's fix).
         // Draft reads before the first write overlay too (pb, once created, is
         // seeded with the view).
                 if (e.fam?.opt && e.h !== null && (!inDraft(e) || e.pb === null)) {
-            let n = null;
+            let t = null;
             for (const r of Reflect.ownKeys(e.h)) {
                 const i = e.h[r];
                 if (!hasActiveOverride(i)) continue;
-                n ??= new Set(t);
-                if (unwrapOverride(i.De)) n.add(r); else n.delete(r);
+                t ??= new Set(n);
+                if (unwrapOverride(i.o?.De)) t.add(r); else t.delete(r);
             }
-            if (n !== null) return [ ...n ];
+            if (t !== null) return [ ...t ];
         }
-        return t;
+        return n;
     },
     getOwnPropertyDescriptor(e, t) {
-        const n = Object.getOwnPropertyDescriptor(readSource(e), t);
+        const n = readSource(e);
+        let r = Object.getOwnPropertyDescriptor(n, t);
+        // Overlay (#3044): unwritten keys live on the committed backing;
+        // deleted keys are absent from the pending view.
+                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);
+        }
         if (e.fam?.opt && !inDraft(e)) {
-            const r = e.h?.[t];
-            if (r !== undefined && hasActiveOverride(r)) {
-                if (!unwrapOverride(r.De)) return undefined;
+            const n = e.h?.[t];
+            if (n !== undefined && hasActiveOverride(n)) {
+                if (!unwrapOverride(n.o?.De)) return undefined;
  // opt delete
-                                if (n === undefined) {
+                                if (r === undefined) {
                     const n = e.n?.[t];
                     return {
                         value: n !== undefined ? nodeValue(n, undefined) : undefined,
@@ -956,12 +1188,12 @@ const traps = {
                 }
             }
         }
-        if (n === undefined) return undefined;
+        if (r === undefined) return undefined;
         // Array targets carry a real non-configurable `length` the proxy
         // invariant forces us to report faithfully; everything else reports
         // configurable via target indirection (core R51).
-                if (!(t === "length" && Array.isArray(e))) n.configurable = true;
-        return n;
+                if (!(t === "length" && Array.isArray(e))) r.configurable = true;
+        return r;
     },
     set(e, t, n) {
         // Writes require the target's draft scope OR the projection write
@@ -972,27 +1204,52 @@ const traps = {
         if (!r && !i) return true;
         if (t === "__proto__") return true;
  // pollution guard (core R30)
-                const o = ensurePB(e);
+        // Unwrap BEFORE ensurePB: unwrapValue materializes a self-referencing
+        // draft's overlay (replacing target.pb), so a pb local captured earlier
+        // would be the abandoned overlay and the write would vanish.
+        // Shallow slots store what was written VERBATIM — another store's proxy
+        // passes through by reference (#2932; markRawOne skips proxies), while
+        // deep stores unwrap to raw backings.
+                const o = e.s ? n : unwrapValue(n);
+        const f = ensurePB(e);
         pendingNotify.add(e);
+        // Array length writes implicitly delete indices — the written-keys bound
+        // can't see them, so poison to the full scan for this batch. Index
+        // writes implicitly GROW length, so arrays always record it alongside.
+                if (Array.isArray(f)) {
+            if (t === "length") e.wk = WK_ALL; else if (e.wk !== WK_ALL) {
+                const n = e.wk ??= new Set;
+                n.add(t);
+                n.add("length");
+            }
+        } else if (e.wk !== WK_ALL) (e.wk ??= new Set).add(t);
         // Own data keys literally named "prototype"/"constructor" land as data —
         // defineProperty sidesteps a proto-chain setter named the same.
                 if (UNSAFE_KEYS.has(t)) {
-            Object.defineProperty(o, t, {
-                value: unwrapValue(n),
+            Object.defineProperty(f, t, {
+                value: o,
                 writable: true,
                 enumerable: true,
                 configurable: true
             });
+            if (e.del !== null) e.del.delete(t);
             return true;
         }
-        // Shallow slots store what was written VERBATIM — another store's proxy
-        // passes through by reference (#2932; markRawOne skips proxies), while
-        // deep stores unwrap to raw backings.
-                const f = e.s ? n : unwrapValue(n);
-        o[t] = f;
+        // Overlay first-write DEFINES the own key: assignment through the proto
+        // chain would reject on a non-writable committed property (the clone
+        // path normalized descriptors for exactly this — R51 parity).
+                if (e.ovl && !hasOwn.call(f, t)) {
+            Object.defineProperty(f, t, {
+                value: o,
+                writable: true,
+                enumerable: true,
+                configurable: true
+            });
+        } else f[t] = o;
+        if (e.del !== null) e.del.delete(t);
         // Shallow ingest: written records are sticky raw-marked (one entity is
         // never both deep-wrapped and raw — R41/#2932, shared invariant).
-                if (e.s && f !== null && typeof f === "object") markRawOne(f);
+                if (e.s && o !== null && typeof o === "object") markRawOne(o);
         // Override-mode (post-await draft) writes have no setter exit — notify
         // per-op (setSignal equality-gates repeats).
                 if (i) notifyWrites(e);
@@ -1004,13 +1261,16 @@ const traps = {
         if (!r && !i) return true;
         if (t === "__proto__") return true;
         if (n.get || n.set) e.a = true;
-        const o = ensurePB(e);
-        pendingNotify.add(e);
-        if ("value" in n) n = {
+        // Unwrap before ensurePB (see the set trap: self-reference materializes).
+                if ("value" in n) n = {
             ...n,
             value: unwrapValue(n.value)
         };
+        const o = ensurePB(e);
+        pendingNotify.add(e);
+        if (e.wk !== WK_ALL) (e.wk ??= new Set).add(t);
         Object.defineProperty(o, t, n);
+        if (e.del !== null) e.del.delete(t);
         if (i) notifyWrites(e);
         return true;
     },
@@ -1020,7 +1280,11 @@ const traps = {
         if (!n && !r) return true;
         const i = ensurePB(e);
         pendingNotify.add(e);
+        if (e.wk !== WK_ALL) (e.wk ??= new Set).add(t);
         delete i[t];
+        // A prototype overlay cannot shadow a delete of a committed key —
+        // record it aside (#3044); reads/has/ownKeys/commit consult the set.
+                if (e.ovl && hasOwn.call(e.v, t)) (e.del ??= new Set).add(t);
         if (r) notifyWrites(e);
         return true;
     }
@@ -1155,6 +1419,9 @@ function snapshotWalk(e, t, n) {
         if (e === undefined) break;
         if (e.fam !== null) n = e.fam;
         if (e.fam?.opt === true) (i ??= []).push(e);
+        // Snapshot runs mid-flush (tracked memos execute before commit), so a
+        // pending prototype overlay must present as a REAL merged container.
+                if (e.ovl) materializePB(e);
         const t = e.pb ?? e.v;
         if (t === r) break;
         r = t;
@@ -1199,10 +1466,10 @@ function snapshotWalk(e, t, n) {
                 continue;
             }
             const u = f.value;
-            const s = u !== null && typeof u === "object" ? snapshotWalk(u, t, n) : u;
-            if (f.enumerable && f.writable && f.configurable) i[o] = s; else Object.defineProperty(i, o, {
+            const l = u !== null && typeof u === "object" ? snapshotWalk(u, t, n) : u;
+            if (f.enumerable && f.writable && f.configurable) i[o] = l; else Object.defineProperty(i, o, {
                 ...f,
-                value: s
+                value: l
             });
         }
         if (e && i.length !== r.length) i.length = r.length;
@@ -1229,4 +1496,4 @@ function snapshotWalk(e, t, n) {
     return f ?? r;
 }
 
-export { adoptPB, bumpDeep, createStoreNext, deepNext, getHasNode, getKeySetNode, getNode, hasAccessorFlag, hasActiveOverride, notifyFold, notifyFoldTail, notifyKeyDiff, notifyKeyValue, runAuthoritative, snapshotNext, storeSetterNext, targetsEqual, unwrapValue, wrapNext };
+export { adoptPB, bumpDeep, createStoreNext, deepNext, getHasNode, getKeySetNode, getNode, hasAccessorFlag, hasActiveOverride, materializePB, notifyFold, notifyFoldTail, notifyKeyDiff, notifyKeyValue, runAuthoritative, snapshotNext, storeSetterNext, targetsEqual, unwrapValue, wrapNext };