@solidjs/signals 2.0.0-rc.7 → 2.0.0-rc.8

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

@@ -1,14 +1,16 @@
-import { unwrapOverride, $REFRESH, NOT_PENDING, CONFIG_OWNED_WRITE, CONFIG_OPTIMISTIC, CONFIG_HELD_TRUTH, STATUS_UNINITIALIZED, STATUS_ERROR, CONFIG_CHILDREN_FORBIDDEN, CONFIG_AUTHORITATIVE_READ } from "../../core/constants.js";
+import { unwrapOverride, $REFRESH, NOT_PENDING, CONFIG_OWNED_WRITE, CONFIG_OPTIMISTIC, STATUS_UNINITIALIZED, STATUS_ERROR, CONFIG_HELD_TRUTH, CONFIG_CHILDREN_FORBIDDEN, CONFIG_AUTHORITATIVE_READ } from "../../core/constants.js";
 
-import { setSlotUnobserved, setSignal, isEqual, read, pendingCheckActive, latestReadActive, readNodeFast, READ_SLOW, signal, ext, setLatestReadActive, prepareComputed, slotSignal, context } from "../../core/core.js";
+import { setSlotUnobserved, setSignal, isEqual, read, pendingCheckActive, latestReadActive, readNodeFast, READ_SLOW, signal, unlinkFirewallChild, ext, setLatestReadActive, prepareComputed, slotSignal, context } from "../../core/core.js";
 
 import { projectionWriteActive, setProjectionWriteActive, activeTransition, schedule, currentTransition, setStoreCommitHook } from "../../core/scheduler.js";
 
+import "../../core/invariants.js";
+
 import { getObserver, getOwner } from "../../core/owner.js";
 
 import { $TARGET, isWrappable, markRawIngest, $PROXY, getWriteOverride, markRawOne, witnessAffectsMark, $TRACK, affectsScopesLive, inheritAffectsMarks, $AFFECTS, rawValuesUsed, isRawValue, setNextAffectsNodeResolver } from "../store.js";
 
-import { storeNextLookup, optHooks, ownedRaw, markDescendants, devAssertNeverUserMutation } from "./target.js";
+import { lookupTarget, optHooks, storeNextLookup, $OWNER, isOwned, markDescendants, devAssertNeverUserMutation } from "./target.js";
 
 /**
  * Store rewrite — increment 2: plain deep stores with pending-backing writes.
@@ -59,6 +61,7 @@ function TargetShape() {
     this.d = undefined;
     this.a = undefined;
     this.sc = undefined;
+    this.kc = undefined;
     this.nc = undefined;
     this.ab = undefined;
     this.fam = undefined;
@@ -94,7 +97,8 @@ function createTarget(e, t, n, r = t?.fam ?? null) {
     i.px = null;
     i.d = false;
     i.a = false;
-    i.sc = false;
+    i.sc = 0;
+    i.kc = 0;
     i.nc = 0;
     i.ab = null;
     i.fam = r;
@@ -115,7 +119,7 @@ function wrapNext(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 i = (r?.map ?? storeNextLookup).get(e);
+    const i = lookupTarget(e, r);
     if (i !== undefined) return i.px;
     const o = e[$TARGET];
     if (o !== undefined && o.px === e) {
@@ -149,7 +153,7 @@ function wrapNext(e, t = null, n = null, r = t?.fam ?? null) {
 // (privatization/adoption swap raw identity without changing the logical
 // value — only changed leaves notify, R9).
 const slotNodeEquals = function(e, t) {
-    return isEqual(e, t) || sameLogicalSlot(this.ht, e, t);
+    return isEqual(e, t) || sameLogicalSlot(this.Ut, e, t);
 };
 
 // Shared slot-node unobserved handler (create-floor diet): registered once;
@@ -158,11 +162,15 @@ const slotNodeEquals = function(e, t) {
 setSlotUnobserved(e => {
     // A live affects() mark keeps the node addressable (sweep parity).
     if (e.o?.t) return;
-    const t = e.ht;
-    const n = e.Ht;
+    const t = e.Ut;
+    const n = e.xt;
     if (t.n && t.n[n] === e) {
         delete t.n[n];
         t.nc--;
+        // Projection leaves also leave the firewall child chain (#3351): a
+        // dropped node is unreachable through the store — a fresh read makes a
+        // fresh node — so the chain would only retain it and its last value.
+                unlinkFirewallChild(e);
     }
 });
 
@@ -175,6 +183,19 @@ r = -1) {
     const i = e.n ??= Object.create(null);
     let o = i[t];
     if (o === undefined) {
+        // Born holding (#3330 store twin): a key first read while a live
+        // transaction holds an ADOPTION on this target (adoptPB's `ht`) is
+        // created as if it had existed when the hold was notified — the adopted
+        // value already swapped into `v`, so committed is the held view
+        // `hv[key]` and the adopted `v[key]` is staged under the transaction
+        // (stageHeldKey). Its held-adoption notification (stageHeldAdoptions)
+        // ran before the node existed and the drain has nothing left to say.
+        // Without this the node was born from whichever view its first reader
+        // saw and never learned the other. (The held-FOLD twin — a setter's
+        // write to an unobserved key landing only in the pending backing — is
+        // #3336's, and lands with #3337.)
+        const l = heldAdoptionTransition(e);
+        if (l !== null) n = e.hv[t];
         // Create-floor diet: slotSignal bakes the whole node into one literal —
         // no options object, no equals/unobserved closures, no NodeExtension,
         // no post-construction expandos (acc + the wrap cache px/pxv are
@@ -185,7 +206,7 @@ r = -1) {
         // notification machinery. Projection nodes carry the projection
         // computed as their firewall: reads through them link the derive's
         // status/lifecycle (§7b).
-        const f = o = slotSignal(n, slotNodeEquals, e, t, 
+                const f = o = slotSignal(n, slotNodeEquals, e, t, 
         // Accessor-ness resolved ONCE per node (no per-object descriptor
         // scan on reads): accessor keys serve through Reflect.get with the
         // proxy receiver.
@@ -193,12 +214,13 @@ r = -1) {
         // Optimistic families: arm the override slot — setSignal routes armed
         // nodes through the core engine (lanes, ownership, reverts all native).
                 if (e.fam?.opt) {
-            ext(f).Pe = NOT_PENDING;
+            ext(f).be = NOT_PENDING;
             f.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(f, e.v, t);
+        if (l !== null) stageHeldKey(f, e.v[t], l);
         i[t] = o;
         e.nc++;
         markDescendants(e);
@@ -206,11 +228,37 @@ r = -1) {
     return o;
 }
 
+/** The live transaction holding an adoption on `target` (adoptPB's `ht`;
+ * a latest()-pull PLAIN_HOLD is not a transaction), else null. */ function heldAdoptionTransition(e) {
+    if (e.ht === null || e.ht === PLAIN_HOLD || heldMaskView(e) === null) return null;
+    const t = currentTransition(e.ht);
+    return t.ft === false ? t : null;
+}
+
+/**
+ * Materialization under a hold. A node created by a first tracked read while
+ * a transaction holds this target must carry the same state a node that
+ * existed when the hold was notified carries — a transaction-stamped
+ * `_pendingValue` that core read() serves by ITS rules (a stale render reader
+ * of a foreign transaction's write sees committed, an owner-context reader
+ * inside the transaction sees the write) — or the reader's answer depends on
+ * whether some OTHER reader had materialized the key before the hold. Stage
+ * `nv` (the held value for the key — see getNode for which view it comes
+ * from) as the holding transaction's write — directly, not through
+ * setSignal: it is not a new write (it staged with the adoption's batch) and
+ * it walks no subscriber (the node has none yet). Transition-stamped now, as
+ * `runFolded` does — no parked-flush pass will stamp it.
+ */ function stageHeldKey(e, t, n) {
+    if (slotNodeEquals.call(e, e.me, t)) return;
+    e.Ge = t;
+    e.ge = n;
+    n.$t.push(e);
+}
+
 function sameLogicalSlot(e, t, n) {
     if (t === null || typeof t !== "object" || n === null || typeof n !== "object") return false;
-    const r = e.fam?.map ?? storeNextLookup;
-    const i = r.get(t);
-    return i !== undefined && i === r.get(n);
+    const r = lookupTarget(t, e.fam);
+    return r !== undefined && r === lookupTarget(n, e.fam);
 }
 
 function getHasNode(e, t, n) {
@@ -221,12 +269,15 @@ function getHasNode(e, t, n) {
             equals: isEqual,
             unobserved() {
                 if (o.o?.t) return;
-                if (e.h && e.h[t] === o) delete e.h[t];
+                if (e.h && e.h[t] === o) {
+                    delete e.h[t];
+                    unlinkFirewallChild(o);
+                }
             }
         }, e.fam?.node ?? undefined);
         o.T |= CONFIG_OWNED_WRITE;
         if (e.fam?.opt) {
-            ext(o).Pe = NOT_PENDING;
+            ext(o).be = NOT_PENDING;
             o.T |= CONFIG_OPTIMISTIC;
         }
         if (affectsScopesLive()) inheritAffectsMarks(o, e.v, t);
@@ -242,12 +293,15 @@ function getKeySetNode(e) {
         const n = t = signal(0, {
             equals: false,
             unobserved() {
-                if (e.k === n) e.k = null;
+                if (e.k === n) {
+                    e.k = null;
+                    unlinkFirewallChild(n);
+                }
             }
         }, e.fam?.node ?? undefined);
         n.T |= CONFIG_OWNED_WRITE;
         if (e.fam?.opt) {
-            ext(n).Pe = NOT_PENDING;
+            ext(n).be = NOT_PENDING;
             n.T |= CONFIG_OPTIMISTIC;
         }
         e.k = t;
@@ -262,12 +316,15 @@ function getDeepNode(e) {
         const n = t = signal(0, {
             equals: false,
             unobserved() {
-                if (e.dk === n) e.dk = null;
+                if (e.dk === n) {
+                    e.dk = null;
+                    unlinkFirewallChild(n);
+                }
             }
         }, e.fam?.node ?? undefined);
         n.T |= CONFIG_OWNED_WRITE;
         if (e.fam?.opt) {
-            ext(n).Pe = NOT_PENDING;
+            ext(n).be = NOT_PENDING;
             n.T |= CONFIG_OPTIMISTIC;
         }
         if (affectsScopesLive()) inheritAffectsMarks(n, e.v, $TRACK);
@@ -288,21 +345,36 @@ function getDeepNode(e) {
 
 let hookInstalled = false;
 
-function cloneRaw(e, t) {
+/** Shallow-clone `source` as a backing OWNED by `t` (stamped `$OWNER`, see
+ * target.ts). Callers always pass their own committed backing as `source`. */ function cloneRaw(e, t) {
+    // Plain-data fast path (#3360): a scanned `Object.prototype` container
+    // whose own keys are all enumerable data clones by spread — the same
+    // result as the descriptor walk below (own enumerable string+symbol keys,
+    // normalized writable+configurable), at ~1/50th the cost.
+    t.sc || scanAccessorsOnce(t);
+    if (t.sc === 2) {
+        const n = {
+            ...e
+        };
+        n[$OWNER] = t;
+        return n;
+    }
     // Descriptor-preserving shallow clone (R29: installed getters stay live;
     // ruled 2026-08-17: frozen sources clone unfrozen — theirs stays frozen).
     // Data descriptors normalize to writable+configurable (the clone is OURS to
     // mutate — R51's "source-non-configurable is writable through the store");
     // enumerability and accessors are preserved. The scan doubles as the
     // accessor-flag detector (free — we're enumerating descriptors anyway).
-    const n = Object.getOwnPropertyDescriptors(e);
+        const n = Object.getOwnPropertyDescriptors(e);
     for (const r of Reflect.ownKeys(n)) {
         const i = n[r];
         if (r === "length" && Array.isArray(e)) continue;
         i.configurable = true;
-        if (!i.get && !i.set) i.writable = true; else if (t) t.a = true;
+        if (!i.get && !i.set) i.writable = true; else t.a = true;
     }
-    return Array.isArray(e) ? Object.defineProperties([], n) : Object.create(Object.getPrototypeOf(e), n);
+    const r = Array.isArray(e) ? Object.defineProperties([], n) : Object.create(Object.getPrototypeOf(e), n);
+    r[$OWNER] = t;
+    return r;
 }
 
 /** Copy own `key` from `from` onto `to`. A plain data slot (enumerable,
@@ -314,19 +386,33 @@ function cloneRaw(e, t) {
 }
 
 /** One-time own-accessor scan (Annex-B probes, no descriptor allocation);
- * returns true when the container is plain data (overlay-safe). */ function scanAccessorsOnce(e) {
+ * returns true when the container is plain data (overlay-safe). Also grades
+ * the container for the plain-data fast paths (`sc` = 2): `Object.prototype`
+ * and every own key an enumerable data property — what a spread copies
+ * exactly and what a bare assignment lands exactly. */ function scanAccessorsOnce(e) {
     const t = e.v;
-    for (const n of Reflect.ownKeys(t)) {
+    const n = Reflect.ownKeys(t);
+    let r = Object.getPrototypeOf(t) === Object.prototype;
+    for (const i of n) {
         // Own keys shadow prototype accessors, so the lookups are exact here.
-        if (lookupGetter.call(t, n) !== undefined || lookupSetter.call(t, n) !== undefined) {
+        if (lookupGetter.call(t, i) !== undefined || lookupSetter.call(t, i) !== undefined) {
             e.a = true;
+            r = false;
             break;
         }
+        if (r && !propertyIsEnumerable.call(t, i)) r = false;
     }
-    e.sc = true;
+    e.sc = r ? 2 : 1;
+    e.kc = n.length;
     return !e.a;
 }
 
+/** Own-key count above which a draft opens as a prototype overlay rather
+ * than a clone (#3360). Below it a spread clone of a plain container is
+ * cheaper than the overlay's `Object.create` (V8 converts the committed
+ * backing into a prototype, and every later flatten writes into that
+ * prototype); above it the clone's O(keys) copy dominates (#3044). */ const OVERLAY_MIN_KEYS = 32;
+
 /** 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
@@ -340,10 +426,6 @@ function cloneRaw(e, t) {
         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;
 }
@@ -366,15 +448,32 @@ function ensurePB(e) {
     }
     if (activeTransition !== null) foldBatches.set(e, activeTransition);
     if (t === null) {
-        // 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);
+        // Prototype-chain overlay (#3044): plain-data non-array containers open
+        // drafts in O(1) — own keys are the writes, reads fall through to
+        // committed. Projection and derived-store families take it too (#3352:
+        // a derive touching one root key of a wide keyed record paid an
+        // O(keys) clone per recompute). Everything else keeps the descriptor
+        // clone: arrays (splice/length semantics), OPTIMISTIC families (the
+        // view-seeding below writes and deletes on the draft container, and the
+        // tentative discard/truth-park hand whole backings around), chained
+        // backings (the committed layer is another store's proxy — an overlay
+        // would route every read-through into its traps), accessor containers
+        // (live getters).
+        // The overlay pays off only for a WIDE container over an OWNED committed
+        // backing (#3360). Narrow containers clone cheaper than they overlay (a
+        // spread is a fast-path copy; `Object.create` turns the backing into a
+        // V8 prototype and every later flatten writes into that prototype). An
+        // unowned backing has to be privatized (cloned) at commit anyway, so an
+        // overlay there would cost the create PLUS the clone PLUS a per-key
+        // copy — the clone path does the one clone and swaps it in. The first
+        // write on a fresh store is exactly that case.
+        const n = e.v;
+        if (!e.fam?.opt && !e.ch && !Array.isArray(n) && (e.sc !== 0 ? !e.a : scanAccessorsOnce(e)) && e.kc > OVERLAY_MIN_KEYS && isOwned(n)) {
+            // Inherits `v`'s $OWNER stamp — the overlay resolves and reads as
+            // owned without a registration of its own.
+            t = e.pb = Object.create(n);
             e.ovl = true;
-        } else t = e.pb = cloneRaw(e.v, e);
+        } else t = e.pb = cloneRaw(n, 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).
@@ -387,19 +486,17 @@ function ensurePB(e) {
             if (n !== null) {
                 for (const e of Reflect.ownKeys(n)) {
                     const r = n[e];
-                    if (hasActiveOverride(r)) t[e] = unwrapOverride(r.o?.Pe);
+                    if (hasActiveOverride(r)) t[e] = unwrapOverride(r.o?.be);
                 }
             }
             const r = e.h;
             if (r !== null) {
                 for (const e of Reflect.ownKeys(r)) {
                     const n = r[e];
-                    if (hasActiveOverride(n) && !unwrapOverride(n.o?.Pe)) delete t[e];
+                    if (hasActiveOverride(n) && !unwrapOverride(n.o?.be)) delete t[e];
                 }
             }
         }
-        ownedRaw.add(t);
-        (e.fam?.map ?? storeNextLookup).set(t, e);
         queueFold(e);
     }
     return t;
@@ -420,7 +517,7 @@ function ensurePB(e) {
  * foldHeld's node stamps). */ function heldMaskView(e) {
     const t = e.ht;
     if (t === null) return null;
-    if (t !== PLAIN_HOLD && currentTransition(t)?.sn === true) return e.ht = e.hv = null;
+    if (t !== PLAIN_HOLD && currentTransition(t)?.ft === true) return e.ht = e.hv = null;
     return e.hv;
 }
 
@@ -450,20 +547,26 @@ function ensurePB(e) {
             if (e.ovl) materializePB(e);
             e.ab = e.pb;
         } else e.ab ??= foldOlds.get(e);
-        // #3074/#3075: a projection recompute deriving from uncommitted inputs
-        // swaps the backing SPECULATIVELY — committed-visibility readers must
-        // keep the pre-hold view until the hold resolves (a source held by a
-        // live transition, or a latest()-pull ahead of the flush). Post-await
-        // landings (write-override) stay immediately visible — landed truth —
-        // and clear any hold; optimistic families ride the lane machinery.
-                if (e.fam?.opt !== true) {
-            if (getWriteOverride()) {
-                e.ht = e.hv = null;
-            } else if (activeTransition !== null || latestPullActive) {
-                if (heldMaskView(e) === null) e.hv = e.v;
-                e.ht = activeTransition ?? PLAIN_HOLD;
-            }
-        }
+    }
+    // #3074/#3075: a projection recompute deriving from uncommitted inputs
+    // swaps the backing SPECULATIVELY — committed-visibility readers must
+    // keep the pre-hold view until the hold resolves (a source held by a
+    // live transition, or a latest()-pull ahead of the flush). Post-await
+    // landings (write-override) stay immediately visible — landed truth —
+    // and clear any hold. Optimistic families hold too (#3330 store twin):
+    // their tentative edits ride the lane machinery, but a sync derive
+    // adopting under a transaction is held TRUTH like any projection's —
+    // unheld, handlers read it early and an optimistic write equal to it
+    // compared as a no-op against the swapped-in backing. A plain store's
+    // reconcile inside an action holds the same way: its nodes stage under the
+    // transaction (the inline notify), and the backing must not show handlers
+    // and stale readers what the tracked read masks (signal parity, #3336).
+        if (getWriteOverride()) {
+        e.ht = e.hv = null;
+    } else if (activeTransition !== null || !n && latestPullActive) {
+        if (heldMaskView(e) === null) e.hv = e.v;
+        e.ht = activeTransition ?? PLAIN_HOLD;
+        if (!n && activeTransition !== null) heldAdoptions.add(e);
     }
     e.pb = null;
     // Overlay and accessor-scan state describe the OUTGOING backing — a
@@ -475,13 +578,17 @@ function ensurePB(e) {
     // draft rescans once (#3044 audit follow-up).
         e.ovl = false;
     e.del = null;
-    e.sc = false;
+    e.sc = 0;
     e.a = false;
     e.wk = null;
  // adoption supersedes staged trap writes
         e.v = t;
     e.ch = t[$TARGET] !== undefined;
-    (e.fam?.map ?? storeNextLookup).set(t, e);
+    // An adoptee we own within this family (a draft aliasing one of the
+    // family's own backings) re-stamps to its new owner — the stamp is the
+    // family's registration for it; everything else registers in the map.
+        const r = t[$OWNER];
+    if (r !== undefined && r.fam === e.fam) t[$OWNER] = e; else (e.fam?.map ?? storeNextLookup).set(t, e);
 }
 
 /** Sentinel for `t.wk`: the written-keys bound is unusable this batch (an
@@ -543,22 +650,22 @@ function queueFold(e) {
 }
 
 /** Committed-time privatization for parent-chain slot updates (path copying). */ function privatizeCommitted(e) {
-    if (ownedRaw.has(e.v)) return;
+    if (isOwned(e.v)) return;
     const t = e.v;
     const n = cloneRaw(t, e);
-    ownedRaw.add(n);
-    // Register in the target's OWN registration map (#3284): family targets
-    // (derived stores, projections, optimistic) resolve children through
-    // fam.map — a clone parked only in the global lookup makes the next parent
-    // read miss, wrap a fresh target, and orphan every node (subscribers) on
-    // this one.
-        (e.fam?.map ?? storeNextLookup).set(n, e);
     e.v = n;
     e.ch = false;
     if (e.u) {
         privatizeCommitted(e.u);
         devAssertNeverUserMutation(e.u.v);
-        e.u.v[parentSlotKey(e, t)] = e.v;
+        // CAS, same as drainFolds' path copy: re-point the parent slot only
+        // while it still holds the raw we cloned. A parent that folded EARLIER
+        // in this drain may have replaced or deleted this slot (the same batch
+        // wrote the child and then `parent.row = fresh` / `parent.length = 0`)
+        // — an unconditional write resurrected the dropped child over it.
+                const n = e.u.v;
+        const r = parentSlotKey(e, t);
+        if (n[r] === t) n[r] = e.v;
     }
 }
 
@@ -577,6 +684,28 @@ function queueFold(e) {
     return i;
 }
 
+/** Overlay commit (#3044): apply the batch's writes onto an OWNED committed
+ * backing in place — O(written), not O(container). Unowned backings
+ * privatize first (clone once, parents re-slotted) — the never-mutate-user-
+ * data contract holds. Shared by the deferred fold (drainFolds) and the
+ * projection landing's immediate commit (notifyWrites). */ function flattenOverlay(e, t) {
+    privatizeCommitted(e);
+    const n = e.v;
+    // Plain-data grade (sc 2): every own key on the overlay is an enumerable
+    // writable data slot (set-trap writes; a non-plain defineProperty
+    // downgrades the grade) — a bare assignment lands it without the
+    // descriptor round trip.
+        for (const r of Reflect.ownKeys(t)) e.sc === 2 ? n[r] = t[r] : copyOwn(n, t, r);
+    if (e.del !== null) {
+        for (const t of e.del) delete n[t];
+        e.del = null;
+    }
+    e.pb = null;
+    e.ovl = false;
+    e.wk = null;
+ // written-keys window closes with the commit
+}
+
 function drainFolds() {
     if (foldOlds.size === 0) return;
     const e = [ ...foldOlds ];
@@ -592,7 +721,7 @@ function drainFolds() {
             // keys; observed keys also hit the pending-node held check below).
             const e = foldBatches.get(t);
             if (e !== undefined) {
-                if (currentTransition(e).sn === false) {
+                if (currentTransition(e).ft === false) {
                     foldOlds.set(t, n);
                     continue;
                 }
@@ -616,7 +745,7 @@ function drainFolds() {
                 !plainProto(t.ovl ? t.v : i) ? Reflect.ownKeys(o) : e;
                 for (const e of n) {
                     const t = o[e];
-                    if (t !== undefined && t.Re !== NOT_PENDING) {
+                    if (t !== undefined && t.Ge !== NOT_PENDING) {
                         r = true;
                         break;
                     }
@@ -628,26 +757,12 @@ function drainFolds() {
                                 continue;
             }
             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(i)) copyOwn(e, i, t);
-                if (t.del !== null) {
-                    for (const n of t.del) delete e[n];
-                    t.del = null;
-                }
-                (t.fam?.map ?? storeNextLookup).delete(i);
-                t.pb = null;
-                t.ovl = false;
-                t.wk = null;
- // written-keys window closes with the fold commit
-                        } else if (t.v !== 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 notifications
+                // happened at write time).
+                flattenOverlay(t, i);
+            } else if (t.v !== n) {
                 // Privatized mid-batch (#3271): an earlier fold in this drain
                 // path-copied THROUGH this target — privatizeCommitted cloned the
                 // committed backing, re-pointed the parent slot at the clone, and
@@ -682,7 +797,6 @@ function drainFolds() {
                         if (!hasOwn.call(i, t)) delete e[t];
                     }
                 }
-                (t.fam?.map ?? storeNextLookup).delete(i);
                 t.pb = null;
                 t.wk = null;
  // written-keys window closes with the fold commit
@@ -798,15 +912,15 @@ function drainFolds() {
             // 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 f = e.del !== null && e.del.has(o) ? undefined : t[o];
-            setSignal(i, () => f);
+                        const l = e.del !== null && e.del.has(o) ? undefined : t[o];
+            setSignal(i, () => l);
         }
     }
-    const f = e.h;
-    if (f !== null) {
-        const n = o ?? Reflect.ownKeys(f);
+    const l = e.h;
+    if (l !== null) {
+        const n = o ?? Reflect.ownKeys(l);
         for (const r of n) {
-            const n = f[r];
+            const n = l[r];
             if (n !== undefined) setSignal(n, r in t && !(e.del !== null && e.del.has(r)));
         }
     }
@@ -814,6 +928,7 @@ function drainFolds() {
     // keys with no node. O(written/pb keys) equality only when a witness exists.
         if (e.dk !== null) {
         if (e.del !== null && e.del.size !== 0) bumpDeep(e); else for (const r of o ?? Reflect.ownKeys(t)) {
+            if (r === $OWNER) continue;
             const i = t[r];
             const o = n[r];
             if (i !== null && typeof i === "object" ? !targetsEqual(o, i) : !isEqual(o, i)) {
@@ -860,6 +975,10 @@ function drainFolds() {
         // Landed truth (post-await write-override): immediately visible to every
         // reader — any staged held view is superseded.
         if (e.ht !== null) e.ht = e.hv = null;
+        // Overlay landing (#3352): flatten in place — identity-stable, and
+        // privatizeCommitted re-slots the parent itself when it has to clone an
+        // unowned seed, so no path copy is needed.
+                if (e.ovl) return flattenOverlay(e, t);
         const n = e.v;
         e.pb = null;
         e.v = t;
@@ -880,9 +999,9 @@ const FORCE = Symbol();
 
 /** Same logical slot: both values resolve to one (re-pointed) child target —
  * adoption preserved identity, so the slot did not change (R9). */ function targetsEqual(e, t) {
-    if (e === null || typeof e !== "object") return false;
-    const n = storeNextLookup.get(e);
-    return n !== undefined && n === storeNextLookup.get(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);
 }
 
 function arrayStructureChanged(e, t) {
@@ -897,8 +1016,9 @@ function arrayStructureChanged(e, t) {
 
 function membershipChanged(e, t) {
     const n = Reflect.ownKeys(t);
-    if (Reflect.ownKeys(e).length !== n.length) return true;
-    for (const t of n) if (!(t in e)) return true;
+    // The $OWNER stamp is not membership: an owned side counts one key more.
+        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;
 }
 
@@ -928,9 +1048,9 @@ i = true) {
             if (i?.get !== o?.get || i?.set !== o?.set || i?.value !== o?.value) setSignal(e, () => FORCE);
             return;
         }
-        const f = i?.value;
-        const l = o?.value;
-        if (!isEqual(f, l) && !targetsEqual(f, l)) setSignal(e, typeof l === "function" ? () => l : l);
+        const l = i?.value;
+        const f = o?.value;
+        if (!isEqual(l, f) && !targetsEqual(l, f)) setSignal(e, typeof f === "function" ? () => f : f);
     } else {
         const i = n[t];
         const o = r[t];
@@ -1046,6 +1166,34 @@ function inDraft(e) {
 
 /** Targets written during the current (outermost) setter — notified at exit. */ const pendingNotify = new Set;
 
+/** Targets adopted under a live transaction this setter (adoptPB set a
+ * transaction hold) — their nodes are notified at the outermost exit. */ const heldAdoptions = new Set;
+
+/**
+ * Write-time notification for a transaction-held adoption (#3330 store twin;
+ * the setter path's notifyWrites twin for adoptions). A projection's fold
+ * normally notifies its nodes at the drain — and the drain of a batch parked
+ * in a live transaction is the transaction's COMMIT, so the nodes took the
+ * adopted values as fresh writes at commit time: every subscriber was
+ * re-marked and re-ran against a frame the lane had already published (a
+ * third `v=1 d=2`), where a signal's write had staged at write time and
+ * promoted silently. Staging here, inside the transaction's batch, makes the
+ * two paths one: the nodes carry transition-stamped `_pendingValue`s, their
+ * subscribers recompute in this flush and park with the transaction, and the
+ * commit promotes without re-notifying. `ab` moves to the adopted backing —
+ * the view the nodes were last told (#3296) — so the drain has nothing left
+ * to say and only path-copies.
+ */ function stageHeldAdoptions() {
+    const e = [ ...heldAdoptions ];
+    heldAdoptions.clear();
+    for (const t of e) {
+        const e = t.ab;
+        if (e === null || e === t.v) continue;
+        notifyFold(t, e, t.v);
+        t.ab = t.v;
+    }
+}
+
 const UNSAFE_KEYS = new Set([ "__proto__", "prototype", "constructor" ]);
 
 /** Mirror of core read()'s context rule: the OWNER context (not the tracking
@@ -1055,7 +1203,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.Dt ? e.Pt : e;
+    const t = e.gt ? e.bt : e;
     return t != null && !(t.T & CONFIG_CHILDREN_FORBIDDEN);
 }
 
@@ -1066,7 +1214,7 @@ const UNSAFE_KEYS = new Set([ "__proto__", "prototype", "constructor" ]);
  * committed to them regardless of staged writes. */ function inForbiddenScope() {
     const e = getOwner();
     if (e === null) return false;
-    const t = e.Dt ? e.Pt : e;
+    const t = e.gt ? e.bt : e;
     return t != null && !!(t.T & CONFIG_CHILDREN_FORBIDDEN);
 }
 
@@ -1077,7 +1225,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.Re !== NOT_PENDING && n.Ae != null && n.Ae.sn !== true) return true;
+        if (n.Ge !== NOT_PENDING && n.ge != null && n.ge.ft !== true) return true;
     }
     return false;
 }
@@ -1149,6 +1297,8 @@ const lookupGetter = Object.prototype.__lookupGetter__;
 
 const lookupSetter = Object.prototype.__lookupSetter__;
 
+const propertyIsEnumerable = Object.prototype.propertyIsEnumerable;
+
 function isOwnAccessor(e, t) {
     return hasOwn.call(e, t) && (lookupGetter.call(e, t) !== undefined || lookupSetter.call(e, t) !== undefined);
 }
@@ -1168,7 +1318,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.o?.Pe !== undefined && e.o?.Pe !== NOT_PENDING;
+    return e.o?.be !== undefined && e.o?.be !== NOT_PENDING;
 }
 
 /** The reading computation is until()'s authoritative-view predicate — same
@@ -1203,30 +1353,53 @@ function isOwnAccessor(e, t) {
     // Authoritative-view reads (until()'s predicate) skip the override arm
     // only: staged pending values are authoritative, overrides are the
     // caller's optimism.
-    const n = !authoritativeServe() && hasActiveOverride(e) ? unwrapOverride(e.o?.Pe) : e.Re !== NOT_PENDING && (latestReadActive || 
+    const n = !authoritativeServe() && hasActiveOverride(e) ? unwrapOverride(e.o?.be) : e.Ge !== NOT_PENDING && (latestReadActive || 
     // Owner-context pending visibility — except HELD truth (#3164,
     // see CONFIG_HELD_TRUTH: fold-staged or entangle-stolen
     // confirming truth), which only authoritative/latest readers
     // see (core read()'s A17-for-held-truth twin; ordinary readers
     // keep committed until the transaction's reveal — latest() is
     // exempted by the leading arm above).
-    (inOwnerContext() || authoritativeServe()) && !(e.T & CONFIG_HELD_TRUTH && !authoritativeServe())) ? e.Re : t;
+    (inOwnerContext() || authoritativeServe()) && !(e.T & CONFIG_HELD_TRUTH && !authoritativeServe())) ? e.Ge : t;
     return n === FORCE ? t : n;
 }
 
+/** §7b: a chained target's child found as a RAW — from its pending backing
+ * (a cloneRaw of the inner proxy, whose descriptors yield the inner store's
+ * raws) or from the deep() walk's descriptor read through the chain — must
+ * resolve to the inner family's proxy for that object before this family
+ * wraps it, so the overlay serves the same chained targets as the settled
+ * state. Otherwise every row re-wrapped as a fresh non-chained target keyed
+ * by the raw: identities churned for the life of an optimistic action and
+ * snapped back at settle, and writes landed on those orphans while deep()'s
+ * witnesses sat on the chained targets (#3323). The inner family owns the
+ * raw iff it has served it or its backing holds that exact object at `key`;
+ * anything else is a draft's own replacement object — view-owned, correctly
+ * non-chained — and is returned as is. Recurses down further chains. */ function resolveChainedRaw(e, t, n) {
+    const r = e.v[$TARGET];
+    if (r.ch) {
+        const e = resolveChainedRaw(r, t, n);
+        return e === n ? n : wrapNext(e, r, t);
+    }
+    const i = lookupTarget(n, r.fam);
+    if (i !== undefined) return i.px;
+    if ((r.v[t] === n || r.pb?.[t] === n) && isWrappable(n)) return wrapNext(n, r, t);
+    return n;
+}
+
 /** Serve an own data key: node-first when a node exists (pending visibility,
  * holds, lanes ride the node); backing otherwise. Chained backings (§7b: the
  * backing IS another store's proxy) serve the read-through value — the outer
  * node is linked only for adoption-swap notification, its value never
  * shadows the live chain. */ function serveDataKey(e, t, n, r, i, o = -1) {
-    const f = e.ch && r === e.v;
-    let l = n;
+    const l = e.ch && r === e.v;
+    let f = n;
     // §6: on optimistic arrays LENGTH IS A VIEW, not a node value — one home
     // (backing ± presence overrides) for both length and indices makes torn
     // iteration impossible (a length node's value rides different visibility
     // rails than index overrides mid-settle). The node still carries
     // subscriptions; its value is never served here.
-        if (t === "length" && e.fam?.opt === true && !f && Array.isArray(r)) {
+        if (t === "length" && e.fam?.opt === true && !l && Array.isArray(r)) {
         if (!inDraft(e)) {
             const r = e.n?.length;
             if (r !== undefined) {
@@ -1248,7 +1421,7 @@ function isOwnAccessor(e, t) {
         // seeding rule, applied to the read side (#3108).
         if (e.fam?.opt && draftSeesOverrides(e) && !authoritativeServe()) {
             const n = e.n?.[t];
-            if (n !== undefined && hasActiveOverride(n)) l = unwrapOverride(n.o?.Pe);
+            if (n !== undefined && hasActiveOverride(n)) f = unwrapOverride(n.o?.be);
         }
     } else {
         if (i !== undefined) {
@@ -1260,9 +1433,9 @@ function isOwnAccessor(e, t) {
                 // parity): READ_SLOW = a global read window or non-plain node.
                 let e = readNodeFast(i);
                 if (e === READ_SLOW) e = read(i);
-                if (!f || hasActiveOverride(i)) l = e === FORCE ? n : e;
-            } else if (!f || hasActiveOverride(i)) {
-                l = nodeValue(i, n);
+                if (!l || hasActiveOverride(i)) f = e === FORCE ? n : e;
+            } else if (!l || hasActiveOverride(i)) {
+                f = nodeValue(i, n);
             }
         } else if (getObserver() !== null) {
             // First tracked read: create + link, and let the wrap-cache branch
@@ -1271,19 +1444,20 @@ function isOwnAccessor(e, t) {
         }
     }
     // Shallow stores serve data raw; store-proxy slots get boundary wrappers.
-        if (e.s) return serveShallow(e, t, l);
+        if (e.s) return serveShallow(e, t, f);
+    if (e.ch && !l && f !== null && typeof f === "object" && f[$TARGET] === undefined) f = resolveChainedRaw(e, t, f);
     if (i !== undefined) {
         // Wrap cache (see getNode): only wrappables are ever cached, so a hit
         // skips isWrappable too — pointer-compare replaces both checks.
-        if (i.pxv === l && l !== undefined) return draftServe(e, i.px);
-        if (!isWrappable(l)) return l;
-        const n = wrapNext(l, e, t);
+        if (i.pxv === f && f !== undefined) return draftServe(e, i.px);
+        if (!isWrappable(f)) return f;
+        const n = wrapNext(f, e, t);
         i.px = n;
-        i.pxv = l;
+        i.pxv = f;
         return draftServe(e, n);
     }
-    if (!isWrappable(l)) return l;
-    return draftServe(e, wrapNext(l, e, t));
+    if (!isWrappable(f)) return f;
+    return draftServe(e, wrapNext(f, e, t));
 }
 
 /** §6c store-wide status gate for reads that DON'T flow through a node:
@@ -1334,6 +1508,8 @@ const traps = {
         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
             // refresh()/isPending resolve the projection computed through $REFRESH.
                         if (t === $REFRESH) return e.fam?.node ?? undefined;
             if (t === $TRACK) {
@@ -1407,16 +1583,16 @@ const traps = {
         // scan (pb ?? v).
                 let o = -1;
         {
-            let f;
-            if (i !== undefined) f = i.acc === true; else if (!inDraft(e) && getObserver() !== null) {
-                f = isOwnAccessor(r, t);
-                if (r === (e.pb ?? e.v)) o = f ? 1 : 0;
-            } else f = false;
-            if (f) {
+            let l;
+            if (i !== undefined) l = i.acc === true; else if (!inDraft(e) && getObserver() !== null) {
+                l = isOwnAccessor(r, t);
+                if (r === (e.pb ?? e.v)) o = l ? 1 : 0;
+            } else l = false;
+            if (l) {
                 if (!inDraft(e) && getObserver() !== null) read(i ?? getNode(e, t, undefined, o));
-                const f = Reflect.get(r, t, n);
-                if (e.s) return serveShallow(e, t, f);
-                return isWrappable(f) ? draftServe(e, wrapNext(f, e, t)) : f;
+                const l = Reflect.get(r, t, n);
+                if (e.s) return serveShallow(e, t, l);
+                return isWrappable(l) ? draftServe(e, wrapNext(l, e, t)) : l;
             }
         }
         // Plain-data fast path: no descriptor allocation per read.
@@ -1426,17 +1602,17 @@ const traps = {
         // 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 f = e.ovl && r === e.pb;
-        if ((t === "constructor" || t === "__proto__" || t === "prototype") && !hasOwn.call(r, t) && !(f && hasOwn.call(e.v, t))) return undefined;
-        let l = r[t];
-        if (l === undefined ? !hasOwn.call(r, t) && !(f && hasOwn.call(e.v, t)) : false) {
+                const l = e.ovl && r === e.pb;
+        if ((t === "constructor" || t === "__proto__" || t === "prototype") && !hasOwn.call(r, t) && !(l && hasOwn.call(e.v, t))) return undefined;
+        let f = r[t];
+        if (f === undefined ? !hasOwn.call(r, t) && !(l && hasOwn.call(e.v, t)) : false) {
             // Inherited: prototype getters/methods run with the proxy receiver.
-            l = Reflect.get(r, t, n);
-            if (typeof l === "function") return l;
+            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) — for any
             // target OUTSIDE its own draft scope, even mid-setter (#3037, above).
-                        if (l === undefined && !inDraft(e)) {
+                        if (f === undefined && !inDraft(e)) {
                 if (getObserver() !== null) read(getNode(e, t, undefined, o));
                 const n = e.n?.[t];
                 if (n) {
@@ -1444,22 +1620,23 @@ const traps = {
                     if (e.s) return serveShallow(e, t, r);
                     return isWrappable(r) ? draftServe(e, wrapNext(r, e, t)) : r;
                 }
-            } else if (l === undefined && inDraft(e) && e.fam?.opt && draftSeesOverrides(e) && 
+            } else if (f === undefined && inDraft(e) && e.fam?.opt && draftSeesOverrides(e) && 
             // AUTHORITATIVE drafts (landing folds) never seed from overrides —
             // the caller's optimism is not truth (has-trap twin below).
             !authoritativeServe()) {
                 const n = e.n?.[t];
-                if (n !== undefined && hasActiveOverride(n)) l = unwrapOverride(n.o?.Pe);
+                if (n !== undefined && hasActiveOverride(n)) f = unwrapOverride(n.o?.be);
             }
-            if (e.s) return serveShallow(e, t, l);
-            return isWrappable(l) ? draftServe(e, wrapNext(l, e, t)) : l;
+            if (e.s) return serveShallow(e, t, f);
+            return isWrappable(f) ? draftServe(e, wrapNext(f, e, t)) : f;
         }
-        if (typeof l === "function" && !hasOwn.call(r, t) && !(f && hasOwn.call(e.v, t))) return l;
+        if (typeof f === "function" && !hasOwn.call(r, t) && !(l && hasOwn.call(e.v, t))) return f;
  // proto method
-                return serveDataKey(e, t, l, r, i, o);
+                return serveDataKey(e, t, f, r, i, o);
     },
     has(e, t) {
         if (t === $TARGET || t === $PROXY || t === $TRACK) return true;
+        if (t === $OWNER) return false;
         if (pendingCheckActive) witnessAffectsMark(e, t);
         if (e.fam !== null && getObserver() === null && !inDraft(e)) firewallGate(e);
         const n = readSource(e);
@@ -1475,11 +1652,11 @@ const traps = {
                 if (hasActiveOverride(n)) r = !!i;
             } else if (!authoritativeServe()) {
                 const n = e.h?.[t];
-                if (n !== undefined && hasActiveOverride(n)) r = !!unwrapOverride(n.o?.Pe);
+                if (n !== undefined && hasActiveOverride(n)) r = !!unwrapOverride(n.o?.be);
             }
         } else if (e.fam?.opt && draftSeesOverrides(e) && !authoritativeServe()) {
             const n = e.h?.[t];
-            if (n !== undefined && hasActiveOverride(n)) r = !!unwrapOverride(n.o?.Pe);
+            if (n !== undefined && hasActiveOverride(n)) r = !!unwrapOverride(n.o?.be);
         }
         return r;
     },
@@ -1487,66 +1664,17 @@ 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 = 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). Authoritative-view reads (until()'s predicate,
-        // truth-author drafts) skip the overlay.
-                if (!authoritativeServe() && e.fam?.opt && e.h !== null && (!inDraft(e) || draftSeesOverrides(e))) {
-            let t = null;
-            for (const r of Reflect.ownKeys(e.h)) {
-                const i = e.h[r];
-                if (!hasActiveOverride(i)) continue;
-                t ??= new Set(n);
-                if (unwrapOverride(i.o?.Pe)) t.add(r); else t.delete(r);
-            }
-            if (t !== null) return [ ...t ];
-        }
-        return n;
+        return visibleKeys(e, readSource(e));
     },
     getOwnPropertyDescriptor(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 (!authoritativeServe() && e.fam?.opt && !inDraft(e)) {
-            const n = e.h?.[t];
-            if (n !== undefined && hasActiveOverride(n)) {
-                if (!unwrapOverride(n.o?.Pe)) return undefined;
- // opt delete
-                                if (r === undefined) {
-                    const n = e.n?.[t];
-                    return {
-                        value: n !== undefined ? nodeValue(n, undefined) : undefined,
-                        writable: true,
-                        enumerable: true,
-                        configurable: true
-                    };
-                }
-            }
-        }
-        if (r === undefined) return undefined;
+        if (t === $OWNER) return undefined;
+        const n = visibleDescriptor(e, readSource(e), t);
+        if (n === 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))) r.configurable = true;
-        return r;
+                if (!(t === "length" && Array.isArray(e))) n.configurable = true;
+        return n;
     },
     set(e, t, n) {
         // Writes require the target's draft scope OR the projection write
@@ -1564,22 +1692,29 @@ const traps = {
         // 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);
+        const l = 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 (Array.isArray(l)) {
             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);
+        } else {
+            if (e.wk !== WK_ALL) (e.wk ??= new Set).add(t);
+            // Live own-key estimate for the overlay/clone choice (#3360): `in`
+            // sees through an overlay to the committed keys, so this counts keys
+            // NEW to the container. Deletes are not un-counted (a stale high
+            // count only picks the overlay a little early).
+                        if (!(t in l)) e.kc++;
+        }
         // 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(f, t, {
+            Object.defineProperty(l, t, {
                 value: o,
                 writable: true,
                 enumerable: true,
@@ -1590,15 +1725,17 @@ const traps = {
         }
         // 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, {
+        // path normalized descriptors for exactly this — R51 parity). A
+        // plain-data-graded backing (sc 2, owned: every slot writable) takes the
+        // bare assignment — it lands as an own key on the overlay all the same.
+                if (e.ovl && e.sc !== 2 && !hasOwn.call(l, t)) {
+            Object.defineProperty(l, t, {
                 value: o,
                 writable: true,
                 enumerable: true,
                 configurable: true
             });
-        } else f[t] = o;
+        } else l[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).
@@ -1620,6 +1757,10 @@ const traps = {
             value: unwrapValue(n.value)
         };
         const o = ensurePB(e);
+        // A non-default data descriptor (or an accessor) leaves the plain-data
+        // grade: the key reaches the committed backing as defined, so the spread
+        // clone and bare-assignment paths no longer describe it.
+                if (e.a || !(n.enumerable && n.writable && n.configurable)) e.sc = 1;
         pendingNotify.add(e);
         if (e.wk !== WK_ALL) (e.wk ??= new Set).add(t);
         Object.defineProperty(o, t, n);
@@ -1681,6 +1822,7 @@ const traps = {
             adoptPB(r, unwrapValue(o));
         }
     }
+    if (writing === 0 && heldAdoptions.size) stageHeldAdoptions();
 }
 
 // Affects integration: the legacy affects machinery reads next targets
@@ -1732,6 +1874,78 @@ function createStoreNext(e, t = false) {
     return t !== undefined && t.fam?.opt === true;
 }
 
+// ---------------------------------------------------------------------------
+// visibility: what a reader sees on a record — ONE rule for the ownKeys /
+// getOwnPropertyDescriptor traps and the deep() walk (#3323). The walk used
+// to re-derive the trap rules over raw backings and missed each new one in
+// turn (the #3044 overlay merge, then #3323's chain, then optimistic presence
+// and value overrides); sharing the body makes parity structural.
+/** Keys visible on `target` served from `src` (= readSource(target)): the
+ * pending-overlay merge (#3044) and, on optimistic families, presence-node
+ * overrides (§6, FINDING-2's fix). Draft reads before the first write overlay
+ * too (pb, once created, is seeded with the view). Authoritative-view reads
+ * (until()'s predicate, truth-author drafts) skip the overlay. */ function visibleKeys(e, t) {
+    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);
+    // Drop the $OWNER stamp (owned backings carry it as an own enumerable
+    // symbol). Symbols enumerate last, so the scan stops at the first string.
+        for (let e = n.length - 1; e >= 0 && typeof n[e] === "symbol"; e--) {
+        if (n[e] === $OWNER) {
+            n.splice(e, 1);
+            break;
+        }
+    }
+    if (!authoritativeServe() && e.fam?.opt && e.h !== null && (!inDraft(e) || draftSeesOverrides(e))) {
+        let t = null;
+        for (const r of Reflect.ownKeys(e.h)) {
+            const i = e.h[r];
+            if (!hasActiveOverride(i)) continue;
+            t ??= new Set(n);
+            if (unwrapOverride(i.o?.be)) t.add(r); else t.delete(r);
+        }
+        if (t !== null) return [ ...t ];
+    }
+    return n;
+}
+
+/** The data/accessor descriptor visible for `key` on `target` served from
+ * `src`: overlay (#3044 — unwritten keys live on the committed backing,
+ * deleted keys are absent) and optimistic presence overrides (an opt delete
+ * hides the key; an opt add synthesizes a data descriptor from the value
+ * node). `configurable` is the trap's concern (proxy invariant). */ function visibleDescriptor(e, t, n) {
+    let r = Object.getOwnPropertyDescriptor(t, n);
+    if (e.ovl && t === e.pb) {
+        if (e.del !== null && e.del.has(n)) return undefined;
+        if (r === undefined) r = Object.getOwnPropertyDescriptor(e.v, n);
+    }
+    if (!authoritativeServe() && e.fam?.opt && !inDraft(e)) {
+        const t = e.h?.[n];
+        if (t !== undefined && hasActiveOverride(t)) {
+            if (!unwrapOverride(t.o?.be)) return undefined;
+ // opt delete
+                        if (r === undefined) {
+                const t = e.n?.[n];
+                return {
+                    value: t !== undefined ? nodeValue(t, undefined) : undefined,
+                    writable: true,
+                    enumerable: true,
+                    configurable: true
+                };
+            }
+        }
+    }
+    return r;
+}
+
 /** Tracking deep snapshot (`deep()` for next targets): subscribes to the
  * key-set and deep-witness node at every reachable level, then returns the
  * plain view. Shared references and cycles handled via the visited set. */ function deepNext(e) {
@@ -1743,50 +1957,69 @@ function createStoreNext(e, t = false) {
     // in per-key nodes, and it walks TARGETS directly — no per-child proxy
     // round-trip (wrapNext → proxy → $TARGET trap) on the re-walk every
     // effect run performs.
-        const walkT = e => {
+    // Resolve `child` (a raw or a stored proxy found under `t`) to the target
+    // that `t`'s family serves for it — created on first visit, as the get trap
+    // would. Undefined = leaf (unwrappable or raw-marked).
+        const childTarget = (e, t, n) => {
+        let r = lookupTarget(t, e.fam);
+        if (r === undefined) {
+            if (!isWrappable(t)) return undefined;
+            wrapNext(t, e, n);
+            // Stored proxies (chained slots) that this family passes through
+            // resolve to their own target.
+                        r = lookupTarget(t, e.fam) ?? t[$TARGET];
+        }
+        return r;
+    };
+    const walkT = e => {
         const t = readSource(e);
         if (n.has(t)) return;
         n.add(t);
         read(getKeySetNode(e));
         read(getDeepNode(e));
-        const r = e.fam?.map ?? storeNextLookup;
-        // Overlay pending backings chain to the committed object (#3044): their
-        // OWN keys are only this batch's writes. A bare ownKeys walk mid-flush
-        // (effects recompute before the fold commits) missed every untouched
-        // child, so the re-subscribing effect dropped those records from its
-        // dependency set — later child edits never notified it (#3283). Merge
-        // committed keys, minus deletes, exactly as the ownKeys trap does.
-                let i = Reflect.ownKeys(t);
-        if (e.ovl && t === e.pb) {
-            const t = Reflect.ownKeys(e.v);
-            const n = e.del;
-            const r = n !== null && n.size !== 0 ? t.filter(e => !n.has(e)) : t;
-            for (const t of i) {
-                if (!hasOwn.call(e.v, t)) r.push(t);
-            }
-            i = r;
+        // Chained backing (§7b): the committed backing IS another store's proxy.
+        // Writes to the inner store bump the INNER record's witnesses; this
+        // target's k/dk hear only its own family's writes (optimistic overrides).
+        // Read through the whole chain — the $TRACK trap's rule (#2864 / R21)
+        // applied to deep() (#3323). From `t.v`, not `src`: a pending backing is a
+        // raw clone and would hide the chain. Non-chained targets pay one flag.
+                for (let t = e; t.ch; ) {
+            t = t.v[$TARGET];
+            read(getKeySetNode(t));
+            read(getDeepNode(t));
         }
-        for (const n of i) {
-            const i = Object.getOwnPropertyDescriptor(t, n) ?? Object.getOwnPropertyDescriptor(e.v, n);
+        // Keys and children exactly as the traps serve them — the overlay merge
+        // (#3044/#3283: a bare ownKeys over a pending backing mid-flush dropped
+        // every untouched child from the re-subscribing effect's dependencies)
+        // and optimistic presence overrides (a row added under a held action
+        // lives in `h`/`n`, not the committed backing; the walk never reached its
+        // record, so deep() was deaf to every write on it until settle).
+                const r = e.fam?.opt === true;
+        for (const n of visibleKeys(e, t)) {
+            const i = visibleDescriptor(e, t, n);
             if (i === undefined) continue;
             if (i.get || i.set) {
                 e.a = true;
                 continue;
  // accessors track through their own reads when invoked
                         }
-            const o = i.value;
+            let o = i.value;
+            // An active value override on an optimistic node shadows the backing's
+            // child (an optimistic replacement `d[i] = {...}`) — follow what reads
+            // serve, as nodeValue's leading arm does.
+                        if (r) {
+                const t = e.n?.[n];
+                if (t !== undefined && hasActiveOverride(t) && !authoritativeServe()) o = unwrapOverride(t.o.be);
+            }
             if (o === null || typeof o !== "object") continue;
-            // Stored proxies (chained slots) resolve through their own target;
-            // raw children through the family map, created on first visit.
-                        let f = o[$TARGET] ?? r.get(o);
-            if (f === undefined) {
-                if (!isWrappable(o)) continue;
-                wrapNext(o, e, n);
-                f = r.get(o);
-                if (f === undefined) continue;
+            // Through a chain the descriptor yields the INNERMOST raw: resolve it to
+            // the inner family's proxy so this level wraps the chained `view[i]` the
+            // get trap serves, never a fresh non-chained wrapper of the base raw.
+                        if (e.ch && o[$TARGET] === undefined) o = resolveChainedRaw(e, n, o);
+            const l = childTarget(e, o, n);
+            if (l === undefined) continue;
  // raw-marked: leaf by contract
-                        }
-            walkT(f);
+                        walkT(l);
         }
     };
     walkT(t);
@@ -1816,24 +2049,35 @@ function snapshotWalk(e, t, n) {
     // encountered and compose their views over the resolved base, innermost
     // outward.
         let i = null;
-    for (;;) {
-        let e = r?.[$TARGET]?.v !== undefined ? r[$TARGET] : undefined;
-        if (e === undefined && n !== null) e = n.map.get(r);
-        if (e === undefined) e = storeNextLookup.get(r);
-        if (e === undefined) break;
-        if (e.fam !== null) n = e.fam;
-        if (e.fam?.opt === true) (i ??= []).push(e);
+    for (let e = true; ;e = false) {
+        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;
+        // Entering a level from a RAW below a chained family: the raw resolves to
+        // the INNER store's target, but this family's wrapper for it — keyed by
+        // the inner proxy, §7b — is where the outer overrides live. Start from
+        // the wrapper so they compose (#3323: a nested optimistic write on a view
+        // row was served by reads but missing from deep()/snapshot()). Entry only:
+        // the descent then runs wrapper → inner → raw and terminates.
+                if (e && !t && n !== null && o.fam !== n) {
+            const e = n.map.get(o.px);
+            if (e !== undefined) o = e;
+        }
+        if (o.fam !== null) n = o.fam;
+        if (o.fam?.opt === true) (i ??= []).push(o);
         // The shared visibility decision (#3147): the speculative peek serves
         // pending staging, but a HELD landing is masked to committed exactly as
         // it is for per-key readers — the two families must answer alike while
         // a transaction holds store landings.
-                const t = pendingBackingVisible(e, true);
+                const l = pendingBackingVisible(o, true);
         // Snapshot runs mid-flush (tracked memos execute before commit), so a
         // pending prototype overlay must present as a REAL merged container.
-                if (t && e.ovl) materializePB(e);
-        const o = t ? e.pb : e.v;
-        if (o === r) break;
-        r = o;
+                if (l && o.ovl) materializePB(o);
+        const f = l ? o.pb : o.v;
+        if (f === r) break;
+        r = f;
     }
     if (!isWrappable(r)) return r;
     // Optimistic families: compose the visible view; a composed view is a fresh
@@ -1845,15 +2089,15 @@ function snapshotWalk(e, t, n) {
             const i = t.get(r);
             if (i !== undefined) return i;
             const o = Array.isArray(e);
-            const f = o ? [] : Object.create(Object.getPrototypeOf(e));
-            t.set(r, f);
+            const l = o ? [] : Object.create(Object.getPrototypeOf(e));
+            t.set(r, l);
             for (const r of Reflect.ownKeys(e)) {
-                if (o && r === "length") continue;
+                if (o && r === "length" || r === $OWNER) continue;
                 const i = e[r];
-                f[r] = i !== null && typeof i === "object" ? snapshotWalk(i, t, n) : i;
+                l[r] = i !== null && typeof i === "object" ? snapshotWalk(i, t, n) : i;
             }
-            if (o) f.length = e.length;
-            return f;
+            if (o) l.length = e.length;
+            return l;
         }
     }
     const o = t.get(r);
@@ -1862,22 +2106,22 @@ function snapshotWalk(e, t, n) {
     // subtrees "unmodified relative to source"): non-enumerable symbols are
     // excluded (recon-snap R29), and the copy registers BEFORE descent so
     // cycles keep identity (FINDING-3).
-        if (ownedRaw.has(r)) {
+        if (isOwned(r)) {
         const e = Array.isArray(r);
         const i = e ? [] : Object.create(Object.getPrototypeOf(r));
         t.set(r, i);
         for (const o of Reflect.ownKeys(r)) {
-            if (e && o === "length") continue;
-            const f = Object.getOwnPropertyDescriptor(r, o);
-            if (typeof o === "symbol" && !f.enumerable) continue;
-            if (f.get || f.set) {
-                Object.defineProperty(i, o, f);
+            if (e && o === "length" || o === $OWNER) continue;
+            const l = Object.getOwnPropertyDescriptor(r, o);
+            if (typeof o === "symbol" && !l.enumerable) continue;
+            if (l.get || l.set) {
+                Object.defineProperty(i, o, l);
                 continue;
             }
-            const l = f.value;
-            const s = l !== null && typeof l === "object" ? snapshotWalk(l, t, n) : l;
-            if (f.enumerable && f.writable && f.configurable) i[o] = s; else Object.defineProperty(i, o, {
-                ...f,
+            const f = l.value;
+            const s = f !== null && typeof f === "object" ? snapshotWalk(f, t, n) : f;
+            if (l.enumerable && l.writable && l.configurable) i[o] = s; else Object.defineProperty(i, o, {
+                ...l,
                 value: s
             });
         }
@@ -1887,22 +2131,22 @@ function snapshotWalk(e, t, n) {
     // UNOWNED (shared/user) subtrees keep identity unless a descendant
     // substituted; copy-on-substitution preserves the documented CoW contract.
         t.set(r, r);
-    let f = null;
+    let l = null;
     for (const e of Reflect.ownKeys(r)) {
         const i = Object.getOwnPropertyDescriptor(r, e);
         if (!i || i.get || i.set) continue;
         const o = i.value;
         if (o === null || typeof o !== "object") continue;
-        const l = snapshotWalk(o, t, n);
-        if (l !== o) {
-            if (f === null) {
-                f = Array.isArray(r) ? [ ...r ] : Object.create(Object.getPrototypeOf(r), Object.getOwnPropertyDescriptors(r));
-                t.set(r, f);
+        const f = snapshotWalk(o, t, n);
+        if (f !== o) {
+            if (l === null) {
+                l = Array.isArray(r) ? [ ...r ] : Object.create(Object.getPrototypeOf(r), Object.getOwnPropertyDescriptors(r));
+                t.set(r, l);
             }
-            f[e] = l;
+            l[e] = f;
         }
     }
-    return f ?? r;
+    return l ?? r;
 }
 
-export { adoptPB, arrayStructureChanged, authoritativeRead, authoritativeServe, bumpDeep, createStoreNext, deepNext, getHasNode, getKeySetNode, getNode, hasAccessorFlag, hasActiveOverride, materializePB, membershipChanged, notifyFold, notifyFoldTail, notifyKeyDiff, notifyKeyValue, runAuthoritative, snapshotNext, stagedTruthPB, storeHasFamily, storeHasOptimisticFamily, storeIsShallow, storeSetterNext, targetsEqual, unwrapValue, wrapNext };
+export { adoptPB, arrayStructureChanged, authoritativeRead, authoritativeServe, bumpDeep, createStoreNext, deepNext, getHasNode, getKeySetNode, getNode, hasAccessorFlag, hasActiveOverride, heldMaskView, materializePB, membershipChanged, notifyFold, notifyFoldTail, notifyKeyDiff, notifyKeyValue, runAuthoritative, snapshotNext, stagedTruthPB, storeHasFamily, storeHasOptimisticFamily, storeIsShallow, storeSetterNext, targetsEqual, unwrapValue, wrapNext };