@solidjs/signals 2.0.0-rc.0 → 2.0.0-rc.10

package/dist/prod/store/store.js

@@ -1,14 +1,6 @@
-import { $REFRESH, STORE_SNAPSHOT_PROPS, NOT_PENDING, unwrapOverride, STATUS_ERROR, STATUS_UNINITIALIZED, STATUS_PENDING, NO_SNAPSHOT } from "../core/constants.js";
+import "../core/core.js";
 
-import { suppressComputedRecompute, isEqual, signal, pendingCheckActive, untrack, setSignal, read, readNodeFast, READ_SLOW, snapshotCaptureActive, snapshotSources } from "../core/core.js";
-
-import { DEV } from "../core/dev.js";
-
-import { NotReadyError } from "../core/error.js";
-
-import { getObserver } from "../core/owner.js";
-
-import { GlobalQueue, registerTransientStoreNode, projectionWriteActive, activeTransition, globalQueue } from "../core/scheduler.js";
+import { GlobalQueue } from "../core/scheduler.js";
 
 import "../core/invariants.js";
 
@@ -16,85 +8,31 @@ import "../core/verdict.js";
 
 import "../core/effect.js";
 
-import { createProjectionInternal } from "./projection.js";
+import { $OWNER, lookupTarget as lookupTarget$1 } from "./next/target.js";
 
 /**
  * Brand symbols used internally by the store proxy / projection plumbing.
  * Cross-package wiring; not part of the user-facing API.
  *
  * @internal
- */ const $TRACK = Symbol(0), $TARGET = Symbol(0), $PROXY = Symbol(0), $DELETED = Symbol(0), 
-// Node-map slot carrying a record-level `affects()` mark: any read through
+ */ const $TRACK = Symbol(0), $TARGET = Symbol(0), $PROXY = Symbol(0), 
+// The view record behind a merge()/omit() proxy (a `MergeView` or an
+// `OmitView`, utils.ts); a store answers `undefined` on its symbol fast
+// path. One read classifies any `$PROXY`-marked object — store, view, or
+// foreign — where asking `$TARGET` first and then each view kind was two
+// to four trap hops (see `viewOf`).
+$RECORD = Symbol(0), // Node-map slot carrying a record-level `affects()` mark: any read through
 // the record witnesses it into the active isPending() probe.
 $AFFECTS = Symbol(0);
 
-const STORE_VALUE = "v", STORE_OVERRIDE = "o", STORE_OPTIMISTIC_OVERRIDE = "x", STORE_NODE = "n", STORE_HAS = "h", STORE_CUSTOM_PROTO = "c", STORE_WRAP = "w", STORE_LOOKUP = "l", STORE_FIREWALL = "f", STORE_OPTIMISTIC = "p", STORE_OPTIMISTIC_OWNERS = "t", STORE_PARENT = "u", STORE_DESC = "d", STORE_SHALLOW = "s";
-
-const STORE_SELF_PENDING = Symbol(0);
-
-// Every StoreNode field is initialized up front, in one fixed order, so all
-// targets share a single hidden class. The traps and reconcile read these
-// fields on their hottest paths; fields added lazily in varying orders made
-// those loads megamorphic across a large store graph (dictionary-mode probes
-// on every trap hit). Assignments elsewhere must never `delete` a field —
-// write `undefined` instead, or the shape degrades again.
-function initStoreFields(e) {
-    e[STORE_OVERRIDE] = undefined;
-    e[STORE_OPTIMISTIC_OVERRIDE] = undefined;
-    e[STORE_OPTIMISTIC_OWNERS] = undefined;
-    e[STORE_NODE] = undefined;
-    e[STORE_HAS] = undefined;
-    e[STORE_CUSTOM_PROTO] = undefined;
-    e[STORE_WRAP] = undefined;
-    e[STORE_LOOKUP] = undefined;
-    e[STORE_FIREWALL] = undefined;
-    e[STORE_OPTIMISTIC] = undefined;
-    e[STORE_SNAPSHOT_PROPS] = undefined;
-    e[STORE_PARENT] = undefined;
-    e[STORE_DESC] = undefined;
-    e[STORE_SHALLOW] = undefined;
-    e[$PROXY] = null;
-}
-
-function createStoreProxy(e, t = storeTraps, r) {
-    let n;
-    if (Array.isArray(e)) {
-        n = [];
-        n[STORE_VALUE] = e;
-        initStoreFields(n);
-    } else {
-        n = {
-            [STORE_VALUE]: e
-        };
-        initStoreFields(n);
-        const t = e?.[$TARGET]?.[STORE_VALUE] ?? e;
-        const r = Object.getPrototypeOf(t);
-        if (r !== null && r !== Object.prototype) {
-            n[STORE_CUSTOM_PROTO] = true;
-        }
-    }
-    r && r(n);
-    return n[$PROXY] = new Proxy(n, t);
-}
-
-// The global lookup maps raw value -> StoreNode TARGET (not proxy): reconcile
-// and the unwrap/snapshot walks resolve targets through it constantly, and a
-// target hit is a plain field read away from its proxy while a proxy hit
-// costs a trap to get back to the target. Per-family STORE_LOOKUP maps
-// (projections/optimistic) still map raw -> proxy — their wrap functions own
-// that contract — so mixed-lookup consumers resolve through lookupTarget().
-const storeLookup = new WeakMap;
-
-// Node records that hold at least one user (non-`$TRACK`) symbol-keyed node.
-// Lets reconcile enumerate symbols only for records that need it (#2851).
-const symbolKeyedRecords = new WeakSet;
+// Structural field names of store targets (StoreNextTarget aliases these, so
+// shared machinery — affects walks, tests — reads targets via the consts).
+const STORE_VALUE = "v", STORE_NODE = "n", STORE_HAS = "h";
 
 function lookupTarget(e, t) {
-    if (t !== undefined && t !== storeLookup) {
-        const r = t.get(e);
-        if (r !== undefined) return r[$TARGET];
-    }
-    return storeLookup.get(e);
+    // Family registrations (projections/optimistic) first, then the global
+    // next lookup. Proxies resolve through $TARGET directly.
+    return (t ? lookupTarget$1(e, t) : undefined) ?? lookupTarget$1(e, null);
 }
 
 // Values marked raw never acquire a proxy identity: wrap() serves them as-is
@@ -137,50 +75,12 @@ function markRawOne(e) {
 
 function markRawIngest(e) {
     if (Array.isArray(e)) {
-        for (let t = 0, r = e.length; t < r; t++) markRawOne(e[t]);
+        for (let t = 0, o = e.length; t < o; t++) markRawOne(e[t]);
     } else {
         for (const t in e) markRawOne(e[t]);
     }
 }
 
-function wrap(e, t) {
-    // Raw is raw in every family: the mark must preempt family wrapping too,
-    // or a shallow projection/optimistic store would proxy its raw records.
-    if (rawValuesUsed && rawValues.has(e)) return e;
-    if (t?.[STORE_WRAP]) {
-        const r = t[STORE_WRAP](e, t);
-        const n = r[$TARGET];
-        if (n && !n[STORE_PARENT] && n !== t) n[STORE_PARENT] = t;
-        return r;
-    }
-    const r = storeLookup.get(e);
-    if (r !== undefined) return r[$PROXY];
-    let n = e[$PROXY];
-    if (!n) {
-        n = createStoreProxy(e);
-        const r = n[$TARGET];
-        storeLookup.set(e, r);
-        if (t) r[STORE_PARENT] = t;
-    }
-    return n;
-}
-
-// Shallow store root: the target itself is fully reactive (per-key nodes,
-// membership, $TRACK); its values are served raw. Seed values are marked at
-// creation; reconcile and the set trap mark on ingest.
-function wrapShallow(e) {
-    const t = storeLookup.get(e);
-    if (t !== undefined) {
-        if (t[STORE_SHALLOW]) return t[$PROXY];
-    }
-    const r = createStoreProxy(e);
-    const n = r[$TARGET];
-    n[STORE_SHALLOW] = true;
-    storeLookup.set(e, n);
-    markRawIngest(e);
-    return r;
-}
-
 const OBJECT_PROTO = Object.prototype;
 
 // Per-prototype memo for the custom-proto branch of isWrappable: the verdict
@@ -204,16 +104,16 @@ function isWrappable(e) {
         const t = Object.getPrototypeOf(e);
     if (t === OBJECT_PROTO || t === null) return true;
     if (Array.isArray(e)) return true;
-    let r = wrappableProtos.get(t);
-    if (r === undefined) {
-        r = Object.prototype.toString.call(e) === "[object Object]" && (
+    let o = wrappableProtos.get(t);
+    if (o === undefined) {
+        o = Object.prototype.toString.call(e) === "[object Object]" && (
         // Dynamic Node check (kept dynamic so test/SSR overrides of
         // `globalThis.Node` are observed at call time): shimmed DOMs implement
         // nodes as plain user classes, which pass the tag check.
         typeof Node === "undefined" || !(e instanceof Node));
-        wrappableProtos.set(t, r);
+        wrappableProtos.set(t, o);
     }
-    return r;
+    return o;
 }
 
 let writeOverride = false;
@@ -222,33 +122,8 @@ function setWriteOverride(e) {
     writeOverride = e;
 }
 
-function writeOnly(e) {
-    return writeOverride || !!Writing?.has(e);
-}
-
-function unwrapStoreValue(e, t, r) {
-    const n = e?.[$TARGET] || lookupTarget(e, r);
-    if (!n) return e;
-    const o = n[STORE_OVERRIDE];
-    if (!o) return n[STORE_VALUE];
-    if (!t) t = new Map;
-    if (t.has(e)) return t.get(e);
-    const i = n[STORE_VALUE];
-    const O = Array.isArray(i);
-    const s = O ? [] : Object.create(Object.getPrototypeOf(i));
-    t.set(e, s);
-    r = n[STORE_LOOKUP] ?? storeLookup;
-    for (const e of getStoreKeys(i, o)) {
-        if (O && e === "length") continue;
-        const n = e in o ? o[e] : i[e];
-        if (n !== $DELETED) s[e] = unwrapStoreValue(n, t, r);
-    }
-    if (O) s.length = o.length ?? i.length;
-    return s;
-}
-
-function isPrototypePollutionKey(e) {
-    return e === "__proto__" || e === "constructor" || e === "prototype";
+function getWriteOverride() {
+    return writeOverride;
 }
 
 // Own enumerable keys including symbols (`Object.keys` drops symbol-keyed props). #2769
@@ -256,134 +131,45 @@ function ownEnumerableKeys(e) {
     return Reflect.ownKeys(e).filter(t => Object.prototype.propertyIsEnumerable.call(e, t));
 }
 
-function ownEnumerableSymbols(e) {
-    const t = Object.getOwnPropertySymbols(e);
-    const r = [];
-    for (let n = 0, o = t.length; n < o; n++) {
-        const o = t[n];
-        if (Object.prototype.propertyIsEnumerable.call(e, o)) r.push(o);
-    }
-    return r;
-}
-
-// Plain-object variant that keeps Object.keys() as the fast path and only pays
-// descriptor checks for symbols. Do not use this on store proxies: splitting
-// strings/symbols would invoke their ownKeys trap twice.
-function ownEnumerableKeysPlain(e) {
-    return Object.keys(e).concat(ownEnumerableSymbols(e));
-}
-
-/**
- * Single chokepoint for the store's layered value resolution: returns the
- * override layer (optimistic first, then regular) that shadows `property`, or
- * `undefined` when the base `STORE_VALUE` is authoritative. Every trap must
- * resolve through this — hand-inlining the layer order is how the optimistic
- * layer gets missed (#2850).
- */ function getOverlayLayer(e, t) {
-    const r = e[STORE_OPTIMISTIC_OVERRIDE];
-    if (r && t in r) return r;
-    const n = e[STORE_OVERRIDE];
-    if (n && t in n) return n;
-    return undefined;
-}
-
-/**
- * The value a store leaf's backing signal currently shows to readers: active
- * override, else held pending value, else committed value.
- */ function visibleNodeValue(e) {
-    return e._e !== undefined && e._e !== NOT_PENDING ? unwrapOverride(e._e) : e.De !== NOT_PENDING ? e.De : e.Ue;
-}
-
-function hasOwnStoreProperty(e, t) {
-    // Override layers are null-prototype objects, so `in` is an own check.
-    const r = getOverlayLayer(e, t);
-    if (r) return r[t] !== $DELETED;
-    return Object.prototype.hasOwnProperty.call(unwrapStoreValue(e[STORE_VALUE]), t);
-}
-
-function hasInheritedAccessor(e, t) {
-    let r = Object.getPrototypeOf(e);
-    while (r && r !== Object.prototype) {
-        const e = Reflect.getOwnPropertyDescriptor(r, t);
-        if (e) return !!e.get;
-        r = Object.getPrototypeOf(r);
-    }
-    return false;
-}
-
-function getNodes(e, t) {
-    let r = e[t];
-    if (!r) e[t] = r = Object.create(null);
-    return r;
-}
-
-function getNode(e, t, r, n, o = isEqual, i) {
-    if (t[r]) return t[r];
-    const O = signal(n, {
-        equals: o,
-        unobserved() {
-            if (t[r] === O) {
-                delete t[r];
-                // Drop the symbol-record mark once the last user symbol node is
-                // gone, so reconcile's fast path stops probing a now string-only
-                // record. Runs only on symbol-node cleanup (cold), never on reconcile.
-                                if (typeof r === "symbol" && r !== $TRACK && r !== $AFFECTS && symbolKeyedRecords.has(t)) {
-                    const e = Object.getOwnPropertySymbols(t);
-                    let r = false;
-                    for (let t = 0, n = e.length; t < n; t++) {
-                        if (e[t] !== $TRACK && e[t] !== $AFFECTS) {
-                            r = true;
-                            break;
-                        }
-                    }
-                    if (!r) symbolKeyedRecords.delete(t);
-                }
-            }
-        }
-    }, e[STORE_FIREWALL]);
-    if (e[STORE_OPTIMISTIC]) {
-        O._e = NOT_PENDING;
-    }
-    if (i && r in i) {
-        const e = i[r];
-        O.Le = e === undefined ? NO_SNAPSHOT : e;
-        snapshotSources?.add(O);
-    }
-    if (typeof r === "symbol" && r !== $TRACK && r !== $AFFECTS) symbolKeyedRecords.add(t);
-    // A node born inside a live mark's identity scope inherits the mark
-    // (the declaration walk could only cover nodes that existed then). The
-    // record's own $AFFECTS carrier is the mark's channel, never a member.
-        if (r !== $AFFECTS && affectsScopes.size) inheritAffectsMarks(O, e[STORE_VALUE], r);
-    // Node presence bubbles up the wrap chain (sticky), so reconcile can see
-    // "subscribers live somewhere below" through node-less intermediate
-    // records — the captured-proxy diff gate (#2902). Amortized O(1): stops at
-    // the first already-flagged ancestor.
-        let s = e;
-    while (s && !s[STORE_DESC]) {
-        s[STORE_DESC] = true;
-        s = s[STORE_PARENT];
-    }
-    return t[r] = O;
-}
-
 /**
  * Scope inheritance for late-created nodes: every live mark whose identity
  * scope contains the owning record's raw — and, for keyed marks, whose key
  * is this property — gets counted on the new node. Inherited marks live
  * exactly as long as the scope's carrier — the release hook below drops
  * them with the entry.
- */ function inheritAffectsMarks(e, t, r) {
+ */ function inheritAffectsMarks(e, t, o) {
     // A live scope exists, so affects.ts already installed the mark engine.
-    for (const [n, o] of affectsScopes) {
-        if (n.t && o.scope.has(t) && (o.key === undefined || o.key === r)) {
+    for (const [r, s] of affectsScopes) {
+        if (r.o?.t && s.scope.has(t) && (s.key === undefined || s.key === o)) {
             GlobalQueue.M(e);
-            o.inherited.push(e);
+            s.inherited.push(e);
         }
     }
 }
 
 const affectsScopes = new Map;
 
+/** Next-store node factory for affects carriers/slots: injected by the
+ * rewrite module (next targets alias the legacy field names, so everything
+ * here EXCEPT node creation works on them structurally). */ let nextAffectsNodeResolver = null;
+
+function setNextAffectsNodeResolver(e) {
+    nextAffectsNodeResolver = e;
+}
+
+/** Next-store optimistic view for the declaration walk (optimistic rows
+ * pushed before the declaration are in motion too — legacy reads its write
+ * overlays; next composes armed-node overrides). */ let nextOptimisticViewResolver = null;
+
+function setNextOptimisticViewResolver(e) {
+    nextOptimisticViewResolver = e;
+}
+
+/** @internal birth inheritance for nodes created inside a live mark window —
+ * exported for the rewrite's node factories. */ function affectsScopesLive() {
+    return affectsScopes.size > 0;
+}
+
 /**
  * Snapshots the identities reachable from `value` into `scope`, reading
  * through write overlays (an optimistic row pushed before the declaration is
@@ -393,61 +179,67 @@ const affectsScopes = new Map;
  * readers subscribed through, so the mark registers on them directly and
  * rides the status rails to everything derived. (Nodes born later inherit
  * from the scope in `getNode`.)
- */ function walkAffectsScope(e, t, r, n, 
+ */ function walkAffectsScope(e, t, o, r, 
 // Cycle guard, fresh per declaration: the scope itself can't serve — a
 // re-declaration on the same carrier unions into a scope that already
 // holds the root, and must still descend to pick up records added since.
-o) {
+s) {
     if (!isWrappable(e)) return;
-    const i = e[$TARGET] || lookupTarget(e, n);
-    const O = i ? i[STORE_VALUE] : e;
-    if (o.has(O)) return;
-    o.add(O);
-    t.scope.add(O);
-    let s;
-    if (i) {
-        collectRecordNodes(i[STORE_NODE], r);
-        collectRecordNodes(i[STORE_HAS], r);
-        s = mergedOverlay(i);
-        // Carry the effective lookup into untouched descendants. Default stores
-        // use the global lookup just like snapshotImpl; without it, nested raw
-        // objects fall back to string-only enumeration and symbol branches vanish.
-                n = i[STORE_LOOKUP] ?? n ?? storeLookup;
+    const f = e[$TARGET] || lookupTarget(e, r);
+    // Next targets: walk the pending backing when present (a draft's writes are
+    // in motion too) and cover BOTH identities in the scope.
+        let n = f ? f.pb ?? f[STORE_VALUE] : e;
+    if (s.has(n)) return;
+    s.add(n);
+    t.scope.add(n);
+    if (f && f.pb) t.scope.add(f[STORE_VALUE]);
+    // Next optimistic families: enumerate the VISIBLE view (armed-node
+    // overrides compose membership/values the raw doesn't carry).
+        if (f && f.fam?.opt && nextOptimisticViewResolver) n = nextOptimisticViewResolver(f, n);
+    if (f) {
+        collectRecordNodes(f[STORE_NODE], o);
+        collectRecordNodes(f[STORE_HAS], o);
+        // The key-set and deep-witness nodes are record-level channels: a deep()
+        // probe reads ONLY these (one pair per record), so a declared affects
+        // scope must mark them like any property node.
+                if (f.k) o.push(f.k);
+        if (f.dk) o.push(f.dk);
+        // Carry the effective family into untouched descendants (projections/
+        // optimistic stores register children under their family).
+                r = f.fam ?? r;
     }
-    if (Array.isArray(O)) {
-        const e = s?.length ?? O.length;
-        for (let i = 0; i < e; i++) {
-            const e = s && i in s ? s[i] : O[i];
-            if (e !== $DELETED) walkAffectsScope(e, t, r, n, o);
+    // Overlays are gone (next has no layer): raw enumeration; the optimistic
+    // view composition above already folded armed-node membership/values in.
+        if (Array.isArray(n)) {
+        for (let e = 0, f = n.length; e < f; e++) {
+            walkAffectsScope(n[e], t, o, r, s);
         }
-        // Arrays can also carry symbol metadata. Enumerate symbols separately to
-        // avoid scanning large index lists twice. Outside a store tree, retain the
-        // existing index-only walk.
-                const E = i || n ? getStoreSymbols(O, s) : [];
-        for (let e = 0, i = E.length; e < i; e++) {
-            const i = E[e];
-            const S = getPropertyDescriptor(O, s, i);
-            if (!S || S.get) continue;
-            walkAffectsScope(S.value, t, r, n, o);
+        const e = Object.getOwnPropertySymbols(n);
+        for (let f = 0, c = e.length; f < c; f++) {
+            if (e[f] === $OWNER) continue;
+            const c = Object.getOwnPropertyDescriptor(n, e[f]);
+            if (!c || c.get) continue;
+            walkAffectsScope(c.value, t, o, r, s);
         }
     } else {
-        const e = i || n ? getStoreKeys(O, s) : getKeys(O, s);
-        for (let i = 0, E = e.length; i < E; i++) {
-            const E = getPropertyDescriptor(O, s, e[i]);
-            if (!E || E.get) continue;
-            walkAffectsScope(E.value, t, r, n, o);
+        const e = Reflect.ownKeys(n);
+        for (let f = 0, c = e.length; f < c; f++) {
+            if (e[f] === $OWNER) continue;
+            const c = Object.getOwnPropertyDescriptor(n, e[f]);
+            if (!c || c.get) continue;
+            walkAffectsScope(c.value, t, o, r, s);
         }
     }
 }
 
 /** All live signal nodes of one record's node map (string + symbol keyed). */ function collectRecordNodes(e, t) {
     if (!e) return;
-    for (const r of Object.keys(e)) t.push(e[r]);
-    const r = Object.getOwnPropertySymbols(e);
-    for (let n = 0, o = r.length; n < o; n++) {
+    for (const o of Object.keys(e)) t.push(e[o]);
+    const o = Object.getOwnPropertySymbols(e);
+    for (let r = 0, s = o.length; r < s; r++) {
         // Another mark's carrier is its own channel — counting it here would
         // extend that sibling scope's lifetime to this declaration's.
-        if (r[n] !== $AFFECTS) t.push(e[r[n]]);
+        if (o[r] !== $AFFECTS) t.push(e[o[r]]);
     }
 }
 
@@ -463,12 +255,28 @@ o) {
  */ function witnessAffectsMark(e, t) {
     // Callers guard on `pendingCheckActive`, which only flips inside
     // isPending() — the verdict layer is loaded and its hook installed.
-    const r = e[STORE_NODE]?.[$AFFECTS];
-    if (r?.t) GlobalQueue.Lt(r);
+    const o = e[STORE_NODE]?.[$AFFECTS];
+    if (o?.o?.t) GlobalQueue.Et(o);
     if (affectsScopes.size) {
-        const n = e[STORE_VALUE];
-        for (const [e, o] of affectsScopes) {
-            if (e !== r && e.t && o.scope.has(n) && (o.key === undefined || o.key === t)) GlobalQueue.Lt(e);
+        // Chained backings (§7b): a wrapper's STORE_VALUE can be another store's
+        // proxy — marks cover by identity of the BASE raw, so resolve the chain
+        // and check every identity along it.
+        let r = e[STORE_VALUE];
+        for (const [e, s] of affectsScopes) {
+            if (e !== o && e.o?.t && (s.key === undefined || s.key === t)) {
+                let t = r;
+                for (;;) {
+                    if (s.scope.has(t)) {
+                        GlobalQueue.Et(e);
+                        break;
+                    }
+                    const o = t?.[$TARGET];
+                    if (o === undefined) break;
+                    const r = o.pb ?? o[STORE_VALUE];
+                    if (r === t) break;
+                    t = r;
+                }
+            }
         }
     }
 }
@@ -484,598 +292,38 @@ o) {
  *
  * @internal
  */ function getStoreAffectsNodes(e, t) {
-    const r = getNodes(e, STORE_NODE);
     GlobalQueue.p ||= e => {
         const t = affectsScopes.get(e);
         if (!t) return;
         affectsScopes.delete(e);
-        for (let e = 0; e < t.inherited.length; e++) GlobalQueue.h(t.inherited[e]);
+        for (let e = 0; e < t.inherited.length; e++) GlobalQueue.N(t.inherited[e]);
     };
     if (t === undefined) {
-        const t = getNode(e, r, $AFFECTS, undefined, false);
-        let n = affectsScopes.get(t);
-        if (!n) affectsScopes.set(t, n = {
+        const t = nextAffectsNodeResolver(e, $AFFECTS);
+        let o = affectsScopes.get(t);
+        if (!o) affectsScopes.set(t, o = {
             scope: new Set,
             inherited: []
         });
-        const o = [ t ];
-        walkAffectsScope(e[$PROXY], n, o, e[STORE_LOOKUP], new Set);
-        return o;
-    }
-    let n = r[t];
-    if (!n) {
-        const o = getOverlayLayer(e, t);
-        const i = o ? o[t] : e[STORE_VALUE][t];
-        n = upsertStoreNode(e, r, t, i === $DELETED ? undefined : i, e[STORE_SNAPSHOT_PROPS]);
+        const r = [ t ];
+        walkAffectsScope(e[$PROXY], o, r, e.fam, new Set);
+        return r;
     }
+    const o = e.n?.[t] ?? nextAffectsNodeResolver(e, t);
     // Keyed marks resolve by identity too (#2904): another store family's
     // proxy can share this record's raw (a derived store swaps its backing to
     // the source's raw when its projection lands), and reads through it never
     // touch this target's node map. Scope is exactly the owning record's raw,
     // narrowed to this key for witness and birth inheritance.
-        let o = affectsScopes.get(n);
-    if (!o) affectsScopes.set(n, o = {
+        let r = affectsScopes.get(o);
+    if (!r) affectsScopes.set(o, r = {
         scope: new Set,
         inherited: [],
         key: t
     });
-    o.scope.add(e[STORE_VALUE]);
-    return [ n ];
-}
-
-function trackSelf(e, t = $TRACK) {
-    if (!getObserver()) return;
-    read(getNode(e, getNodes(e, STORE_NODE), t, undefined, false));
-    // Store-in-store: structural notifications (reconcile, notifySelf) land on
-    // the wrapped source's own self-node, never on this wrapper view's. Chain
-    // the read through so enumeration/$TRACK on the wrapper observes them
-    // (#2864). Property reads already chain naturally via the inner get trap.
-    // An override layer on the view is a hold (A17) — the shown structure is
-    // the overlay's, so don't subscribe through it; clearing the layer notifies
-    // this view's own self-node and the re-run re-establishes the chain.
-        if (t === $TRACK && !e[STORE_OVERRIDE] && !e[STORE_OPTIMISTIC_OVERRIDE] && e[STORE_VALUE][$TARGET]) e[STORE_VALUE][$TRACK];
-}
-
-function notifySelf(e) {
-    const t = e[STORE_NODE]?.[$TRACK];
-    t && setSignal(t, e[STORE_OPTIMISTIC] && !projectionWriteActive ? STORE_SELF_PENDING : undefined);
-}
-
-/**
- * The write overlay a walk must read through: optimistic writes shadow
- * regular pending writes, the same resolution order as every proxy trap and
- * `reconcile` (#2850). Merging allocates only in the rare both-present case
- * (a derived optimistic store with an in-flight projection commit).
- */ function mergedOverlay(e) {
-    const t = e[STORE_OVERRIDE];
-    const r = e[STORE_OPTIMISTIC_OVERRIDE];
-    return t && r ? {
-        ...t,
-        ...r
-    } : r ?? t;
-}
-
-function getKeysImpl(e, t, r, n) {
-    // Plain objects can't trigger proxy traps — only pay for the untrack
-    // closure when the source is itself a wrapped store (store-in-store).
-    const o = e[$TARGET] ? untrack(() => r ? n ? ownEnumerableKeys(e) : Object.keys(e) : Reflect.ownKeys(e)) : r ? n ? ownEnumerableKeysPlain(e) : Object.keys(e) : Reflect.ownKeys(e);
-    return t ? mergeOverrideKeys(o, t) : o;
-}
-
-function getKeys(e, t, r = true) {
-    return getKeysImpl(e, t, r, false);
-}
-
-function getStoreKeys(e, t) {
-    return getKeysImpl(e, t, true, true);
-}
-
-function getStoreSymbols(e, t) {
-    const r = e[$TARGET] ? untrack(() => ownEnumerableSymbols(e)) : ownEnumerableSymbols(e);
-    return t ? mergeOverrideKeys(r, t, true) : r;
-}
-
-// Shared override-layer merge for key enumeration: adds live override keys,
-// drops $DELETED ones. `symbolsOnly` scopes the override scan for the
-// array-metadata passes.
-function mergeOverrideKeys(e, t, r) {
-    const n = new Set(e);
-    const o = r ? Object.getOwnPropertySymbols(t) : Reflect.ownKeys(t);
-    for (const e of o) {
-        if (t[e] !== $DELETED) n.add(e); else n.delete(e);
-    }
-    return Array.from(n);
-}
-
-function getPropertyDescriptor(e, t, r) {
-    if (t && r in t) {
-        if (t[r] === $DELETED) return void 0;
-        const n = Reflect.getOwnPropertyDescriptor(t, r);
-        if (n?.get || n?.set) return n;
-        // Plain writes live in the override while the source keeps its old value.
-        // Preserve the source descriptor flags, but report the current override
-        // value. Source accessors cannot be patched with a value, and inherited
-        // properties have no source own descriptor, so those keep their descriptor.
-                const o = Reflect.getOwnPropertyDescriptor(e, r);
-        if (!o) return n;
-        if (o.get || o.set) return o;
-        // Reflect returns a fresh descriptor, so patching in place is safe and
-        // avoids an allocation on Object.keys/spread over written stores.
-                o.value = t[r];
-        return o;
-    }
-    return Reflect.getOwnPropertyDescriptor(e, r);
-}
-
-function prepareStoreWrite(e, t, r) {
-    if (e[STORE_OPTIMISTIC]) {
-        const t = e[STORE_FIREWALL];
-        if (t?.Ne) {
-            globalQueue.initTransition(t.Ne);
-        }
-    }
-    const n = e[STORE_VALUE];
-    const o = n[r];
-    if (snapshotCaptureActive && typeof r !== "symbol" && !((e[STORE_FIREWALL]?.S ?? 0) & STATUS_PENDING)) {
-        if (!e[STORE_SNAPSHOT_PROPS]) {
-            e[STORE_SNAPSHOT_PROPS] = Object.create(null);
-            snapshotSources?.add(e);
-        }
-        if (!(r in e[STORE_SNAPSHOT_PROPS])) {
-            e[STORE_SNAPSHOT_PROPS][r] = o;
-        }
-    }
-    const i = e[STORE_OPTIMISTIC] && !projectionWriteActive;
-    const O = i ? STORE_OPTIMISTIC_OVERRIDE : STORE_OVERRIDE;
-    return {
-        base: o,
-        overrideKey: O,
-        state: n
-    };
-}
-
-/**
- * Registers the store for transition reversion. Called only once a write is
- * known to be effective — ineffective writes (same value, delete of an absent
- * property) are no-ops and must not entangle the store. Optimistic writes are
- * verdict-inert (question-scoped pending model): no mask is armed — the write
- * neither pends its own slot nor silences anyone else's.
- */ function armOptimisticStoreWrite(e, t) {
-    // STORE_OPTIMISTIC is only set by createOptimisticStore, which installs the
-    // optimistic engine before wrapping.
-    if (e[STORE_OPTIMISTIC] && !projectionWriteActive) {
-        GlobalQueue.Nn(t);
-    }
-}
-
-/**
- * Records which transition owns an optimistic layer entry (#2899), so a
- * settling action only consumes its own keys — the layer is store-wide, but
- * concurrent actions writing disjoint keys must revert independently, exactly
- * like optimistic signal nodes do via the transition's _optimisticNodes.
- * `activeTransition` is the write's transaction (action() opens it before the
- * body runs); null marks an ambient write, which clears at plain flush end —
- * unless its flush's transition is blocked on the store's own in-flight truth
- * (pending firewall, #2951), in which case it rides that transaction to
- * settle. Same-key writes across actions keep last-write-wins layer
- * semantics.
- */ function stampOptimisticOwner(e, t, r) {
-    if (t === STORE_OPTIMISTIC_OVERRIDE) (e[STORE_OPTIMISTIC_OWNERS] ??= Object.create(null))[r] = activeTransition;
-}
-
-function upsertStoreNode(e, t, r, n, o) {
-    if (t[r]) return t[r];
-    const i = isWrappable(n) ? wrap(n, e) : n;
-    const O = getNode(e, t, r, i, isEqual, o);
-    registerTransientStoreNode(O);
-    return O;
-}
-
-function notifyStoreProperty(e, t, r, n, o, i) {
-    // Cold writes upsert a transient pending node so untracked reads batch like signals.
-    // Skip for projection writes (different commit semantics) and for optimistic stores
-    // (whose whole purpose is immediate visibility via STORE_OPTIMISTIC_OVERRIDE).
-    const O = projectionWriteActive || e[STORE_OPTIMISTIC];
-    const s = r !== "delete";
-    const E = e[STORE_HAS]?.[t];
-    if (E) {
-        setSignal(E, s);
-    } else if (!O && r !== "invalidate" && i !== s) {
-        const r = upsertStoreNode(e, getNodes(e, STORE_HAS), t, i);
-        setSignal(r, s);
-    }
-    const S = getNodes(e, STORE_NODE);
-    if (r === "set") {
-        if (S[t]) {
-            setSignal(S[t], () => isWrappable(n) ? wrap(n, e) : n);
-        } else if (!O) {
-            const r = upsertStoreNode(e, S, t, o, e[STORE_SNAPSHOT_PROPS]);
-            setSignal(r, () => isWrappable(n) ? wrap(n, e) : n);
-        }
-    } else if (r === "invalidate") {
-        if (S[t]) {
-            setSignal(S[t], {});
-            delete S[t];
-        }
-    } else {
-        if (S[t]) {
-            setSignal(S[t], undefined);
-        } else if (!O) {
-            const r = upsertStoreNode(e, S, t, o, e[STORE_SNAPSHOT_PROPS]);
-            setSignal(r, undefined);
-        }
-    }
-    notifySelf(e);
-}
-
-let Writing = null;
-
-/**
- * A derived store follows async memo rules (#2897 ruling): its seed is a
- * draft for the derive function, never an observable value, and an errored
- * derive is an error state, never a silent stale/seed serve. Until the
- * firewall first resolves there is nothing to read, so every consumer path
- * throws NotReady — tracked reads through their node (core read()), and the
- * untracked fall-throughs in the traps through this guard. Returning the
- * seed leaked it; returning `undefined` would break non-nullable types.
- * Callers exempt the firewall itself (the derive function works its own
- * draft while uninitialized).
- *
- * Error rail: a firewall carrying STATUS_ERROR throws its error for every
- * late reader — memo parity, where read()'s error branch does the same for
- * plain computeds. Rejection clears STATUS_UNINITIALIZED at commit, so
- * without this check late readers silently got the seed while settle-time
- * subscribers saw the error.
- *
- * Loading rail: the veto requires the firewall to still be in flight, not
- * just flagged: STATUS_UNINITIALIZED's clear is deferred to batch commit,
- * so during the settle flush a firewall that has already recomputed — and
- * reconciled real values into STORE_VALUE — still carries the stale flag.
- * STATUS_PENDING is the live bit (it clears eagerly at settle, mirroring
- * core read()'s verdict), so gating on it stops the guard from throwing a
- * fresh NotReadyError that nothing would ever sweep. #2944: mapArray's
- * keyed diff reads items inside its internal owner (untracked by design)
- * in exactly this window, and the stale throw wedged <For> permanently.
- */ function throwIfUnreadable(e) {
-    const t = e[STORE_FIREWALL];
-    if (!t) return;
-    const r = t.S;
-    if (r & STATUS_ERROR || r & STATUS_UNINITIALIZED && r & STATUS_PENDING) throw t._ ?? new NotReadyError(t);
-}
-
-const storeTraps = {
-    get(e, t, r) {
-        if (t === $TARGET) return e;
-        if (t === $PROXY) return r;
-        if (t === $REFRESH) return e[STORE_FIREWALL];
-        if (pendingCheckActive) witnessAffectsMark(e, t);
-        if (t === $TRACK) {
-            trackSelf(e);
-            return r;
-        }
-        // Hot path: an existing node on a plain target — no firewall (so neither
-        // selfRead nor the uninitialized guard can apply), no override layers,
-        // no write scope, and a raw (non-proxy) source. This is the shape of
-        // every effect re-read of a settled store; it pays one node read and the
-        // wrap check, nothing else. Any exotic bit falls through to the full
-        // resolution below, and dev strictRead keeps its warning path.
-                if (e[STORE_FIREWALL] === undefined && e[STORE_OVERRIDE] === undefined && e[STORE_OPTIMISTIC_OVERRIDE] === undefined && !writeOverride && (Writing === null || !Writing.has(r))) {
-            const r = e[STORE_NODE];
-            const n = r && r[t];
-            if (n !== undefined && e[STORE_VALUE][$TARGET] === undefined) {
-                // readNodeFast is read()'s plain-signal fast path hoisted over the
-                // call; READ_SLOW means a global read window (latest/pending-check/
-                // transition/lane/snapshot capture) or a node layer is active, and
-                // only then does the full read() resolution have anything to do.
-                let t = readNodeFast(n);
-                if (t === READ_SLOW) t = read(n);
-                if (t === $DELETED) t = undefined;
-                // Every node-writing site wraps wrappables before setSignal (see the
-                // dev assertion below), so re-wrapping on read is redundant — except
-                // during snapshot capture, where read() can surface a raw captured
-                // value seeded from snapshot props.
-                                if (!snapshotCaptureActive) {
-                    return t;
-                }
-                return isWrappable(t) ? wrap(t, e) : t;
-            }
-        }
-        const n = getObserver() === e[STORE_FIREWALL];
-        const o = getNodes(e, STORE_NODE);
-        const i = n ? undefined : o[t];
-        const O = e[STORE_VALUE];
-        if (!i && !e[STORE_OVERRIDE] && !e[STORE_OPTIMISTIC_OVERRIDE] && !e[STORE_CUSTOM_PROTO] && !e[STORE_OPTIMISTIC] && !e[STORE_SNAPSHOT_PROPS] && !O[$TARGET] && !(t in O) && getObserver() && !n && !writeOnly(r)) {
-            return read(getNode(e, o, t, undefined));
-        }
-        const s = getOverlayLayer(e, t);
-        const E = !!s;
-        const S = !!e[STORE_VALUE][$TARGET];
-        const T = s ?? e[STORE_VALUE];
-        if (!i) {
-            const n = Object.getOwnPropertyDescriptor(T, t);
-            if (n && n.get) return n.get.call(r);
-            if (!n && !E && e[STORE_CUSTOM_PROTO]) {
-                const e = unwrapStoreValue(T);
-                if (hasInheritedAccessor(e, t)) {
-                    return Reflect.get(T, t, r);
-                }
-            }
-        }
-        if (writeOnly(r)) {
-            if (isPrototypePollutionKey(t) && !hasOwnStoreProperty(e, t)) return undefined;
-            let r = i && (E || !S) ? visibleNodeValue(i) : T[t];
-            r === $DELETED && (r = undefined);
-            if (!isWrappable(r)) return r;
-            // Shallow boundary: records are replaced, never edited in place. Reads
-            // inside a setter serve the raw so read-then-replace, filter/pop and
-            // projection derives all work; in-place mutation of a raw is inert by
-            // construction — the same contract as a markRaw child in a deep store.
-                        if (e[STORE_SHALLOW]) return r;
-            const n = wrap(r, e);
-            Writing?.add(n);
-            return n;
-        }
-        let c = i ? E || !S ? read(o[t]) : (read(o[t]), T[t]) : T[t];
-        c === $DELETED && (c = undefined);
-        if (!i) {
-            if (!E && typeof c === "function" && !Object.prototype.hasOwnProperty.call(T, t)) {
-                let t;
-                return !Array.isArray(e[STORE_VALUE]) && (t = Object.getPrototypeOf(e[STORE_VALUE])) && t !== Object.prototype ? c.bind(T) : c;
-            } else if (getObserver() && !n) {
-                return read(getNode(e, o, t, isWrappable(c) ? wrap(c, e) : c, isEqual, e[STORE_SNAPSHOT_PROPS]));
-            }
-        }
-        // Untracked fall-through (tracked reads already threw via their node in
-        // read(); the dev strictRead error above wins first for memo parity).
-        // Observer-present reads must NOT re-consult the flag here: during the
-        // settle flush the firewall has recomputed (first values live on the
-        // pending rail, served by read() above) but its UNINITIALIZED clear is
-        // deferred to batch commit — vetoing read()'s verdict with the stale flag
-        // threw a fresh NotReadyError for an already-settled source, which no
-        // sweep would ever release (#2938: projection over an async store wedged
-        // its Loading boundary on `undefined`).
-                if (!n && !getObserver()) throwIfUnreadable(e);
-        return isWrappable(c) ? wrap(c, e) : c;
-    },
-    has(e, t) {
-        if (t === $PROXY || t === $TRACK || t === "__proto__") return true;
-        if (pendingCheckActive) witnessAffectsMark(e, t);
-        const r = getOverlayLayer(e, t);
-        const n = r ? r[t] !== $DELETED : t in e[STORE_VALUE];
-        if (writeOnly(e[$PROXY]) || getObserver() === e[STORE_FIREWALL]) return n;
-        const o = getNodes(e, STORE_HAS);
-        // If a has-node already exists, it carries the batched presence — `read()`
-        // returns `_value` (committed) for untracked reads and the pending value for
-        // downstream computes. This keeps `in` consistent with value reads.
-                if (o[t]) return read(o[t]);
-        // No node yet: `has` reflects committed presence (no pending write could change
-        // it without first upserting a has-node at the write site). Create + read only
-        // when tracking; leave untracked reads node-free.
-                if (getObserver()) {
-            return read(getNode(e, o, t, n));
-        }
-        throwIfUnreadable(e);
-        return n;
-    },
-    set(e, t, r) {
-        if (t === "__proto__") return true;
-        const n = e[$PROXY];
-        if (writeOnly(n)) {
-            untrack(() => {
-                const {base: o, overrideKey: i, state: O} = prepareStoreWrite(e, n, t);
-                const s = getOverlayLayer(e, t);
-                const E = s ? s[t] : o;
-                const S = s ? s[t] !== $DELETED : t in e[STORE_VALUE];
-                // Shallow slots hold store proxies verbatim (pass-through reference,
-                // never raw-marked — see markRawOne/#2932); everything else unwraps
-                // and marks as usual.
-                                const T = !!e[STORE_SHALLOW] && r?.[$TARGET] !== undefined;
-                const c = T ? r : unwrapStoreValue(r);
-                if (e[STORE_SHALLOW] && !T && isWrappable(c)) {
-                    // Flip the live gate too: a bare add was inert unless something else
-                    // had already marked a raw somewhere (wrap() checks rawValuesUsed
-                    // first), so the documented set-trap ingest mark silently no-oped in
-                    // apps whose only shallow data arrived through writes.
-                    rawValuesUsed = true;
-                    rawValues.add(c);
-                }
-                // Symbol-keyed writes on arrays are metadata, not index writes — never run
-                // them through the numeric index/length machinery (`parseInt` on a symbol
-                // throws). #2769
-                                const f = typeof t === "string" ? Number(t) : -1;
-                const R = Array.isArray(O) && Number.isInteger(f) && f >= 0 && f < 4294967295 && String(f) === t;
-                const u = R ? f + 1 : 0;
-                const a = R && (getOverlayLayer(e, "length") ?? O).length;
-                const l = R && u > a ? u : undefined;
-                if (E === c && l === undefined) return true;
-                armOptimisticStoreWrite(e, n);
-                if (c !== undefined && c === o && l === undefined) {
-                    delete e[i]?.[t];
-                    if (i === STORE_OPTIMISTIC_OVERRIDE) delete e[STORE_OPTIMISTIC_OWNERS]?.[t];
-                } else {
-                    const r = e[i] || (e[i] = Object.create(null));
-                    r[t] = c;
-                    stampOptimisticOwner(e, i, t);
-                    if (l !== undefined) {
-                        r.length = l;
-                        stampOptimisticOwner(e, i, "length");
-                    }
-                }
-                notifyStoreProperty(e, t, "set", c, E, S);
-                // Shrinking an array's length must remove the truncated indices, otherwise
-                // they leak through `has`, `ownKeys`, and (tracked) index reads from the
-                // underlying value. Mark each as deleted and notify so reactive reads update. #2768
-                                if (Array.isArray(O) && t === "length" && typeof c === "number" && typeof E === "number" && c < E) {
-                    const t = e[i] || (e[i] = Object.create(null));
-                    for (let r = c; r < E; r++) {
-                        if (t[r] === $DELETED) continue;
-                        const n = r in t ? t[r] : O[r];
-                        if (!(r in t) && !(r in O)) continue;
-                        t[r] = $DELETED;
-                        stampOptimisticOwner(e, i, r);
-                        notifyStoreProperty(e, r, "delete", undefined, n, true);
-                    }
-                }
-                // notify length change
-                                if (Array.isArray(O) && t !== "length" && l !== undefined) {
-                    const t = getNodes(e, STORE_NODE);
-                    if (t.length) {
-                        setSignal(t.length, l);
-                    } else if (!projectionWriteActive && !e[STORE_OPTIMISTIC]) {
-                        const r = upsertStoreNode(e, t, "length", a, e[STORE_SNAPSHOT_PROPS]);
-                        setSignal(r, l);
-                    }
-                }
-                if (false) ;
-            });
-        }
-        return true;
-    },
-    defineProperty(e, t, r) {
-        if (t === "__proto__") return true;
-        const n = e[$PROXY];
-        if (writeOnly(n)) {
-            untrack(() => {
-                const {base: o, overrideKey: i} = prepareStoreWrite(e, n, t);
-                armOptimisticStoreWrite(e, n);
-                const O = "value" in r ? {
-                    ...r,
-                    value: unwrapStoreValue(r.value)
-                } : r;
-                Object.defineProperty(e[i] || (e[i] = Object.create(null)), t, O);
-                stampOptimisticOwner(e, i, t);
-                notifyStoreProperty(e, t, "invalidate");
-                if (false) ;
-            });
-        }
-        return true;
-    },
-    deleteProperty(e, t) {
-        if (t === "__proto__") return true;
-        // Check both optimistic and regular override for existing $DELETED
-                const r = e[STORE_OPTIMISTIC_OVERRIDE]?.[t] === $DELETED;
-        const n = e[STORE_OVERRIDE]?.[t] === $DELETED;
-        if (writeOnly(e[$PROXY]) && !r && !n) {
-            untrack(() => {
-                const r = e[STORE_OPTIMISTIC] && !projectionWriteActive;
-                const n = r ? STORE_OPTIMISTIC_OVERRIDE : STORE_OVERRIDE;
-                const o = getOverlayLayer(e, t);
-                const i = o ? o[t] : e[STORE_VALUE][t];
-                if (t in e[STORE_VALUE] || e[STORE_OVERRIDE] && t in e[STORE_OVERRIDE]) {
-                    armOptimisticStoreWrite(e, e[$PROXY]);
-                    (e[n] || (e[n] = Object.create(null)))[t] = $DELETED;
-                    stampOptimisticOwner(e, n, t);
-                } else if (e[n] && t in e[n]) {
-                    armOptimisticStoreWrite(e, e[$PROXY]);
-                    delete e[n][t];
-                    if (n === STORE_OPTIMISTIC_OVERRIDE) delete e[STORE_OPTIMISTIC_OWNERS]?.[t];
-                } else return true;
-                notifyStoreProperty(e, t, "delete", undefined, i, true);
-            });
-        }
-        return true;
-    },
-    ownKeys(e) {
-        if (pendingCheckActive) witnessAffectsMark(e);
-        if (getObserver() !== e[STORE_FIREWALL]) {
-            trackSelf(e);
-            // trackSelf no-ops untracked, so enumeration of an unresolved derived
-            // store would otherwise leak the seed's structure (#2897). The write
-            // path is exempt (like the get/has traps' writeOnly early returns):
-            // the first landing's reconcile enumerates the store while
-            // STATUS_UNINITIALIZED is still set — it IS the initialization.
-                        if (!getObserver() && !writeOnly(e[$PROXY])) throwIfUnreadable(e);
-        }
-        // Merge optimistic override with regular override for key enumeration
-                let t = getKeys(e[STORE_VALUE], e[STORE_OVERRIDE], false);
-        if (e[STORE_OPTIMISTIC_OVERRIDE]) {
-            const r = new Set(t);
-            for (const t of Reflect.ownKeys(e[STORE_OPTIMISTIC_OVERRIDE])) {
-                if (e[STORE_OPTIMISTIC_OVERRIDE][t] !== $DELETED) r.add(t); else r.delete(t);
-            }
-            t = Array.from(r);
-        }
-        return t;
-    },
-    getOwnPropertyDescriptor(e, t) {
-        if (t === $PROXY) return {
-            value: e[$PROXY],
-            writable: true,
-            configurable: true
-        };
-        // Check optimistic override first, but use base descriptor structure for compatibility
-                if (e[STORE_OPTIMISTIC_OVERRIDE] && t in e[STORE_OPTIMISTIC_OVERRIDE]) {
-            if (e[STORE_OPTIMISTIC_OVERRIDE][t] === $DELETED) return undefined;
-            const r = Reflect.getOwnPropertyDescriptor(e[STORE_OPTIMISTIC_OVERRIDE], t);
-            if (r?.get || r?.set || !(t in e[STORE_VALUE])) return r;
-            // Get base descriptor structure, override just the value
-                        const n = getPropertyDescriptor(e[STORE_VALUE], e[STORE_OVERRIDE], t);
-            if (n) {
-                const r = Reflect.getOwnPropertyDescriptor(e, t);
-                const o = !r || r.configurable ? true : n.configurable;
-                return {
-                    ...n,
-                    configurable: o,
-                    value: e[STORE_OPTIMISTIC_OVERRIDE][t]
-                };
-            }
-            return {
-                value: e[STORE_OPTIMISTIC_OVERRIDE][t],
-                writable: true,
-                enumerable: true,
-                configurable: true
-            };
-        }
-        const r = getPropertyDescriptor(e[STORE_VALUE], e[STORE_OVERRIDE], t);
-        // The proxy target is an internal node object, not the original source. When the
-        // source has a non-configurable property that does not also exist as non-configurable
-        // on the proxy target, the proxy invariant is violated: the engine requires that a
-        // property reported as non-configurable must actually be non-configurable on the
-        // target object. Override configurable to true only in that case.
-                if (r && !r.configurable) {
-            const n = Reflect.getOwnPropertyDescriptor(e, t);
-            if (!n || n.configurable) return {
-                ...r,
-                configurable: true
-            };
-        }
-        return r;
-    },
-    getPrototypeOf(e) {
-        return Object.getPrototypeOf(e[STORE_VALUE]);
-    }
-};
-
-function storeSetter(e, t) {
-    const r = Writing;
-    Writing = new Set;
-    Writing.add(e);
-    try {
-        const r = t(e);
-        if (r !== e && r !== undefined) {
-            if (Array.isArray(r)) {
-                for (let t = 0, n = r.length; t < n; t++) e[t] = r[t];
-                e.length = r.length;
-            } else {
-                const t = new Set([ ...ownEnumerableKeys(e), ...ownEnumerableKeys(r) ]);
-                t.forEach(t => {
-                    if (t in r) e[t] = r[t]; else delete e[t];
-                });
-            }
-        }
-    } finally {
-        Writing.clear();
-        Writing = r;
-    }
-}
-
-function createStore(e, t, r) {
-    const n = typeof e === "function", o = n ? createProjectionInternal(e, t, r).store : t?.shallow ? wrapShallow(e) : wrap(e);
-    return [ o, n ? e => {
-        // Mark the projection as manually written before notifying property nodes.
-        suppressComputedRecompute(o[$REFRESH]);
-        storeSetter(o, e);
-    } : e => storeSetter(o, e) ];
+    r.scope.add(e[STORE_VALUE]);
+    if (e.pb) r.scope.add(e.pb);
+    return [ o ];
 }
 
-export { $AFFECTS, $DELETED, $PROXY, $TARGET, $TRACK, STORE_CUSTOM_PROTO, STORE_DESC, STORE_FIREWALL, STORE_HAS, STORE_LOOKUP, STORE_NODE, STORE_OPTIMISTIC, STORE_OPTIMISTIC_OVERRIDE, STORE_OPTIMISTIC_OWNERS, STORE_OVERRIDE, STORE_PARENT, STORE_SHALLOW, STORE_VALUE, STORE_WRAP, createStore, createStoreProxy, getKeys, getOverlayLayer, getPropertyDescriptor, getStoreAffectsNodes, getStoreKeys, getStoreSymbols, isRawValue, isWrappable, lookupTarget, markRawIngest, mergedOverlay, notifySelf, ownEnumerableKeys, rawValuesUsed, setWriteOverride, storeLookup, storeSetter, storeTraps, symbolKeyedRecords, trackSelf, visibleNodeValue, witnessAffectsMark, wrap, wrapShallow };
+export { $AFFECTS, $PROXY, $RECORD, $TARGET, $TRACK, STORE_HAS, STORE_NODE, STORE_VALUE, affectsScopesLive, getStoreAffectsNodes, getWriteOverride, inheritAffectsMarks, isRawValue, isWrappable, markRawIngest, markRawOne, nextAffectsNodeResolver, nextOptimisticViewResolver, ownEnumerableKeys, rawValuesUsed, setNextAffectsNodeResolver, setNextOptimisticViewResolver, setWriteOverride, witnessAffectsMark };