@solidjs/signals 2.0.0-beta.19 → 2.0.0-beta.20

package/dist/prod/store/store.js

@@ -1,12 +1,14 @@
-import { $REFRESH, STORE_SNAPSHOT_PROPS, NOT_PENDING, STATUS_PENDING, NO_SNAPSHOT } from "../core/constants.js";
+import { $REFRESH, STORE_SNAPSHOT_PROPS, NOT_PENDING, unwrapOverride, STATUS_UNINITIALIZED, STATUS_PENDING, NO_SNAPSHOT } from "../core/constants.js";
 
 import { suppressComputedRecompute, isEqual, signal, pendingCheckActive, untrack, setSignal, read, 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, globalQueue } from "../core/scheduler.js";
+import { GlobalQueue, registerTransientStoreNode, projectionWriteActive, activeTransition, globalQueue } from "../core/scheduler.js";
 
 import "../core/invariants.js";
 
@@ -26,7 +28,7 @@ import { createProjectionInternal } from "./projection.js";
 // 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";
+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";
 
 const STORE_SELF_PENDING = Symbol(0);
 
@@ -56,9 +58,17 @@ const storeLookup = new WeakMap;
 const symbolKeyedRecords = new WeakSet;
 
 function wrap(e, t) {
-    if (t?.[STORE_WRAP]) return t[STORE_WRAP](e, t);
+    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;
+    }
     let r = e[$PROXY] || storeLookup.get(e);
-    if (!r) storeLookup.set(e, r = createStoreProxy(e));
+    if (!r) {
+        storeLookup.set(e, r = createStoreProxy(e));
+        if (t) r[$TARGET][STORE_PARENT] = t;
+    }
     return r;
 }
 
@@ -91,7 +101,7 @@ function unwrapStoreValue(e, t, r) {
     const E = s ? [] : Object.create(Object.getPrototypeOf(i));
     t.set(e, E);
     r = n[STORE_LOOKUP] ?? storeLookup;
-    for (const e of getKeys(i, o)) {
+    for (const e of getStoreKeys(i, o)) {
         if (s && e === "length") continue;
         const n = e in o ? o[e] : i[e];
         if (n !== $DELETED) E[e] = unwrapStoreValue(n, t, r);
@@ -109,6 +119,23 @@ 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
@@ -127,7 +154,7 @@ function ownEnumerableKeys(e) {
  * 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.be !== undefined && e.be !== NOT_PENDING ? e.be : e.ge !== NOT_PENDING ? e.ge : e.Ue;
+    return e.be !== undefined && e.be !== NOT_PENDING ? unwrapOverride(e.be) : e.ge !== NOT_PENDING ? e.ge : e.Ue;
 }
 
 function hasOwnStoreProperty(e, t) {
@@ -186,24 +213,34 @@ function getNode(e, t, r, n, o = isEqual, i) {
         snapshotSources?.add(s);
     }
     if (typeof r === "symbol" && r !== $TRACK && r !== $AFFECTS) symbolKeyedRecords.add(t);
-    // A node born inside a live keyless mark's identity scope inherits the mark
+    // 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(s, e[STORE_VALUE]);
+        if (r !== $AFFECTS && affectsScopes.size) inheritAffectsMarks(s, 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 E = e;
+    while (E && !E[STORE_DESC]) {
+        E[STORE_DESC] = true;
+        E = E[STORE_PARENT];
+    }
     return t[r] = s;
 }
 
 /**
- * Scope inheritance for late-created nodes: every live keyless mark whose
- * identity scope contains the owning record's raw 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) {
+ * 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) {
     // A live scope exists, so affects.ts already installed the mark engine.
-    for (const [r, n] of affectsScopes) {
-        if (r.P && n.scope.has(t)) {
+    for (const [n, o] of affectsScopes) {
+        if (n.M && o.scope.has(t) && (o.key === undefined || o.key === r)) {
             GlobalQueue.D(e);
-            n.inherited.push(e);
+            o.inherited.push(e);
         }
     }
 }
@@ -235,7 +272,10 @@ o) {
         collectRecordNodes(i[STORE_NODE], r);
         collectRecordNodes(i[STORE_HAS], r);
         E = mergedOverlay(i);
-        n = i[STORE_LOOKUP] ?? n;
+        // 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;
     }
     if (Array.isArray(s)) {
         const e = E?.length ?? s.length;
@@ -243,8 +283,18 @@ o) {
             const e = E && i in E ? E[i] : s[i];
             if (e !== $DELETED) walkAffectsScope(e, t, r, n, o);
         }
+        // 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 O = i || n ? getStoreSymbols(s, E) : [];
+        for (let e = 0, i = O.length; e < i; e++) {
+            const i = O[e];
+            const c = getPropertyDescriptor(s, E, i);
+            if (!c || c.get) continue;
+            walkAffectsScope(c.value, t, r, n, o);
+        }
     } else {
-        const e = getKeys(s, E);
+        const e = i || n ? getStoreKeys(s, E) : getKeys(s, E);
         for (let i = 0, O = e.length; i < O; i++) {
             const O = getPropertyDescriptor(s, E, e[i]);
             if (!O || O.get) continue;
@@ -273,15 +323,15 @@ o) {
  * Callers guard on `pendingCheckActive`, so plain reads never pay for this.
  *
  * @internal
- */ function witnessAffectsMark(e) {
+ */ function witnessAffectsMark(e, t) {
     // Callers guard on `pendingCheckActive`, which only flips inside
     // isPending() — the verdict layer is loaded and its hook installed.
-    const t = e[STORE_NODE]?.[$AFFECTS];
-    if (t?.P) GlobalQueue.Zt(t);
+    const r = e[STORE_NODE]?.[$AFFECTS];
+    if (r?.M) GlobalQueue.wt(r);
     if (affectsScopes.size) {
-        const r = e[STORE_VALUE];
-        for (const [e, n] of affectsScopes) {
-            if (e !== t && e.P && n.scope.has(r)) GlobalQueue.Zt(e);
+        const n = e[STORE_VALUE];
+        for (const [e, o] of affectsScopes) {
+            if (e !== r && e.M && o.scope.has(n) && (o.key === undefined || o.key === t)) GlobalQueue.wt(e);
         }
     }
 }
@@ -298,14 +348,14 @@ o) {
  * @internal
  */ function getStoreAffectsNodes(e, t) {
     const r = getNodes(e, STORE_NODE);
+    GlobalQueue.T ||= e => {
+        const t = affectsScopes.get(e);
+        if (!t) return;
+        affectsScopes.delete(e);
+        for (let e = 0; e < t.inherited.length; e++) GlobalQueue.F(t.inherited[e]);
+    };
     if (t === undefined) {
         const t = getNode(e, r, $AFFECTS, undefined, false);
-        GlobalQueue.T ||= e => {
-            const t = affectsScopes.get(e);
-            if (!t) return;
-            affectsScopes.delete(e);
-            for (let e = 0; e < t.inherited.length; e++) GlobalQueue.F(t.inherited[e]);
-        };
         let n = affectsScopes.get(t);
         if (!n) affectsScopes.set(t, n = {
             scope: new Set,
@@ -315,11 +365,25 @@ o) {
         walkAffectsScope(e[$PROXY], n, o, e[STORE_LOOKUP], new Set);
         return o;
     }
-    if (r[t]) return [ r[t] ];
-    const n = getOverlayLayer(e, t);
-    const o = n ? n[t] : e[STORE_VALUE][t];
-    const i = o === $DELETED ? undefined : o;
-    return [ upsertStoreNode(e, r, t, i, e[STORE_SNAPSHOT_PROPS]) ];
+    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]);
+    }
+    // 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 = {
+        scope: new Set,
+        inherited: [],
+        key: t
+    });
+    o.scope.add(e[STORE_VALUE]);
+    return [ n ];
 }
 
 function trackSelf(e, t = $TRACK) {
@@ -354,17 +418,36 @@ function notifySelf(e) {
     } : r ?? t;
 }
 
-function getKeys(e, t, r = true) {
+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 n = e[$TARGET] ? untrack(() => r ? Object.keys(e) : Reflect.ownKeys(e)) : r ? Object.keys(e) : Reflect.ownKeys(e);
-    if (!t) return n;
-    const o = new Set(n);
-    const i = Reflect.ownKeys(t);
-    for (const e of i) {
-        if (t[e] !== $DELETED) o.add(e); else o.delete(e);
+    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(o);
+    return Array.from(n);
 }
 
 function getPropertyDescriptor(e, t, r) {
@@ -424,10 +507,22 @@ function prepareStoreWrite(e, t, r) {
     // STORE_OPTIMISTIC is only set by createOptimisticStore, which installs the
     // optimistic engine before wrapping.
     if (e[STORE_OPTIMISTIC] && !projectionWriteActive) {
-        GlobalQueue.Vt(t);
+        GlobalQueue.mn(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 that clears at plain flush end.
+ * 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;
@@ -475,12 +570,25 @@ function notifyStoreProperty(e, t, r, n, o, i) {
 
 let Writing = null;
 
+/**
+ * A derived store's seed is a draft for the derive function, never an
+ * observable value (#2897): 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).
+ */ function throwIfUninitialized(e) {
+    const t = e[STORE_FIREWALL];
+    if (t && t.i & STATUS_UNINITIALIZED) throw t.k ?? 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);
+        if (pendingCheckActive) witnessAffectsMark(e, t);
         if (t === $TRACK) {
             trackSelf(e);
             return r;
@@ -495,41 +603,44 @@ const storeTraps = {
         const E = getOverlayLayer(e, t);
         const O = !!E;
         const c = !!e[STORE_VALUE][$TARGET];
-        const f = E ?? e[STORE_VALUE];
+        const S = E ?? e[STORE_VALUE];
         if (!i) {
-            const n = Object.getOwnPropertyDescriptor(f, t);
+            const n = Object.getOwnPropertyDescriptor(S, t);
             if (n && n.get) return n.get.call(r);
             if (!n && !O && e[STORE_CUSTOM_PROTO]) {
-                const e = unwrapStoreValue(f);
+                const e = unwrapStoreValue(S);
                 if (hasInheritedAccessor(e, t)) {
-                    return Reflect.get(f, t, r);
+                    return Reflect.get(S, t, r);
                 }
             }
         }
         if (writeOnly(r)) {
             if (isPrototypePollutionKey(t) && !hasOwnStoreProperty(e, t)) return undefined;
-            let r = i && (O || !c) ? visibleNodeValue(i) : f[t];
+            let r = i && (O || !c) ? visibleNodeValue(i) : S[t];
             r === $DELETED && (r = undefined);
             if (!isWrappable(r)) return r;
             const n = wrap(r, e);
             Writing?.add(n);
             return n;
         }
-        let S = i ? O || !c ? read(o[t]) : (read(o[t]), f[t]) : f[t];
-        S === $DELETED && (S = undefined);
+        let f = i ? O || !c ? read(o[t]) : (read(o[t]), S[t]) : S[t];
+        f === $DELETED && (f = undefined);
         if (!i) {
-            if (!O && typeof S === "function" && !Object.prototype.hasOwnProperty.call(f, t)) {
+            if (!O && typeof f === "function" && !Object.prototype.hasOwnProperty.call(S, t)) {
                 let t;
-                return !Array.isArray(e[STORE_VALUE]) && (t = Object.getPrototypeOf(e[STORE_VALUE])) && t !== Object.prototype ? S.bind(f) : S;
+                return !Array.isArray(e[STORE_VALUE]) && (t = Object.getPrototypeOf(e[STORE_VALUE])) && t !== Object.prototype ? f.bind(S) : f;
             } else if (getObserver() && !n) {
-                return read(getNode(e, o, t, isWrappable(S) ? wrap(S, e) : S, isEqual, e[STORE_SNAPSHOT_PROPS]));
+                return read(getNode(e, o, t, isWrappable(f) ? wrap(f, e) : f, isEqual, e[STORE_SNAPSHOT_PROPS]));
             }
         }
-        return isWrappable(S) ? wrap(S, e) : S;
+        // Untracked fall-through (tracked reads already threw via their node in
+        // read(); the dev strictRead error above wins first for memo parity).
+                if (!n) throwIfUninitialized(e);
+        return isWrappable(f) ? wrap(f, e) : f;
     },
     has(e, t) {
         if (t === $PROXY || t === $TRACK || t === "__proto__") return true;
-        if (pendingCheckActive) witnessAffectsMark(e);
+        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;
@@ -544,6 +655,7 @@ const storeTraps = {
                 if (getObserver()) {
             return read(getNode(e, o, t, n));
         }
+        throwIfUninitialized(e);
         return n;
     },
     set(e, t, r) {
@@ -555,33 +667,41 @@ const storeTraps = {
                 const E = getOverlayLayer(e, t);
                 const O = E ? E[t] : o;
                 const c = E ? E[t] !== $DELETED : t in e[STORE_VALUE];
-                const f = unwrapStoreValue(r);
+                const S = unwrapStoreValue(r);
                 // 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 S = typeof t === "string" ? Number(t) : -1;
-                const R = Array.isArray(s) && Number.isInteger(S) && S >= 0 && S < 4294967295 && String(S) === t;
-                const T = R ? S + 1 : 0;
-                const u = R && (getOverlayLayer(e, "length") ?? s).length;
-                const l = R && T > u ? T : undefined;
-                if (O === f && l === undefined) return true;
+                                const f = typeof t === "string" ? Number(t) : -1;
+                const T = Array.isArray(s) && Number.isInteger(f) && f >= 0 && f < 4294967295 && String(f) === t;
+                const R = T ? f + 1 : 0;
+                const u = T && (getOverlayLayer(e, "length") ?? s).length;
+                const l = T && R > u ? R : undefined;
+                if (O === S && l === undefined) return true;
                 armOptimisticStoreWrite(e, n);
-                if (f !== undefined && f === o && l === undefined) delete e[i]?.[t]; else {
+                if (S !== undefined && S === 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] = f;
-                    if (l !== undefined) r.length = l;
+                    r[t] = S;
+                    stampOptimisticOwner(e, i, t);
+                    if (l !== undefined) {
+                        r.length = l;
+                        stampOptimisticOwner(e, i, "length");
+                    }
                 }
-                notifyStoreProperty(e, t, "set", f, O, c);
+                notifyStoreProperty(e, t, "set", S, O, c);
                 // 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(s) && t === "length" && typeof f === "number" && typeof O === "number" && f < O) {
+                                if (Array.isArray(s) && t === "length" && typeof S === "number" && typeof O === "number" && S < O) {
                     const t = e[i] || (e[i] = Object.create(null));
-                    for (let r = f; r < O; r++) {
+                    for (let r = S; r < O; r++) {
                         if (t[r] === $DELETED) continue;
                         const n = r in t ? t[r] : s[r];
                         if (!(r in t) && !(r in s)) continue;
                         t[r] = $DELETED;
+                        stampOptimisticOwner(e, i, r);
                         notifyStoreProperty(e, r, "delete", undefined, n, true);
                     }
                 }
@@ -612,6 +732,7 @@ const storeTraps = {
                     value: unwrapStoreValue(r.value)
                 } : r;
                 Object.defineProperty(e[i] || (e[i] = Object.create(null)), t, s);
+                stampOptimisticOwner(e, i, t);
                 notifyStoreProperty(e, t, "invalidate");
                 if (false) ;
             });
@@ -632,9 +753,11 @@ const storeTraps = {
                 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);
             });
@@ -643,7 +766,15 @@ const storeTraps = {
     },
     ownKeys(e) {
         if (pendingCheckActive) witnessAffectsMark(e);
-        if (getObserver() !== e[STORE_FIREWALL]) trackSelf(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])) throwIfUninitialized(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]) {
@@ -736,4 +867,4 @@ function createStore(e, t, r) {
     } : e => storeSetter(o, e) ];
 }
 
-export { $AFFECTS, $DELETED, $PROXY, $TARGET, $TRACK, STORE_CUSTOM_PROTO, STORE_FIREWALL, STORE_HAS, STORE_LOOKUP, STORE_NODE, STORE_OPTIMISTIC, STORE_OPTIMISTIC_OVERRIDE, STORE_OVERRIDE, STORE_VALUE, STORE_WRAP, createStore, createStoreProxy, getKeys, getOverlayLayer, getPropertyDescriptor, getStoreAffectsNodes, isWrappable, mergedOverlay, notifySelf, ownEnumerableKeys, setWriteOverride, storeLookup, storeSetter, storeTraps, symbolKeyedRecords, trackSelf, visibleNodeValue, witnessAffectsMark, wrap };
+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_VALUE, STORE_WRAP, createStore, createStoreProxy, getKeys, getOverlayLayer, getPropertyDescriptor, getStoreAffectsNodes, getStoreKeys, getStoreSymbols, isWrappable, mergedOverlay, notifySelf, ownEnumerableKeys, setWriteOverride, storeLookup, storeSetter, storeTraps, symbolKeyedRecords, trackSelf, visibleNodeValue, witnessAffectsMark, wrap };

package/dist/prod/store/utils.js

@@ -12,10 +12,10 @@ import "../core/effect.js";
 
 import { createMemo } from "../signals.js";
 
-import { ownEnumerableKeys, $PROXY, isWrappable, $TARGET, trackSelf, witnessAffectsMark, mergedOverlay, STORE_VALUE, storeLookup, STORE_LOOKUP, $DELETED, wrap, getKeys, getPropertyDescriptor, $TRACK } from "./store.js";
+import { ownEnumerableKeys, $PROXY, isWrappable, $TARGET, trackSelf, witnessAffectsMark, mergedOverlay, STORE_VALUE, storeLookup, STORE_LOOKUP, $DELETED, wrap, getStoreSymbols, getPropertyDescriptor, getStoreKeys, getKeys, $TRACK } from "./store.js";
 
 function snapshotImpl(e, t, r, n) {
-    let o, s, c, i, f, u;
+    let o, s, i, c, f, u;
     if (!isWrappable(e)) return e;
     if (r && r.has(e)) return r.get(e);
     if (!r) r = new Map;
@@ -26,9 +26,9 @@ function snapshotImpl(e, t, r, n) {
             // traps — witness the record's affects() channel like a trap read would.
                         if (pendingCheckActive) witnessAffectsMark(o);
         }
-        c = mergedOverlay(o);
+        i = mergedOverlay(o);
         s = Array.isArray(o[STORE_VALUE]);
-        r.set(e, c ? i = s ? [] : Object.create(Object.getPrototypeOf(o[STORE_VALUE])) : o[STORE_VALUE]);
+        r.set(e, i ? c = s ? [] : Object.create(Object.getPrototypeOf(o[STORE_VALUE])) : o[STORE_VALUE]);
         e = o[STORE_VALUE];
         n = o[STORE_LOOKUP] ?? storeLookup;
     } else {
@@ -36,56 +36,75 @@ function snapshotImpl(e, t, r, n) {
         r.set(e, e);
     }
     if (s) {
-        const s = c?.length ?? e.length;
+        const s = i?.length ?? e.length;
         for (let p = 0; p < s; p++) {
-            u = c && p in c ? c[p] : e[p];
+            u = i && p in i ? i[p] : e[p];
             if (u === $DELETED) continue;
             if (t && isWrappable(u)) wrap(u, o);
-            if ((f = snapshotImpl(u, t, r, n)) !== u || i) {
-                if (!i) r.set(e, i = [ ...e ]);
-                i[p] = f;
+            if ((f = snapshotImpl(u, t, r, n)) !== u || c) {
+                if (!c) r.set(e, c = [ ...e ]);
+                c[p] = f;
+            }
+        }
+        // Enumerate array symbols separately to avoid scanning indices twice.
+        // Spread copies omit symbols, so assign them after the numeric walk.
+                const p = n ? getStoreSymbols(e, i) : [];
+        for (let s = 0, l = p.length; s < l; s++) {
+            const l = p[s];
+            const a = getPropertyDescriptor(e, i, l);
+            if (!a || a.get) continue;
+            u = i && l in i ? i[l] : e[l];
+            if (t && isWrappable(u)) wrap(u, o);
+            f = snapshotImpl(u, t, r, n);
+            if (f !== u || c) {
+                if (!c) r.set(e, c = Object.assign([ ...e ], e));
+                c[l] = f;
             }
         }
         // Deleted trailing slots are skipped above, so restore length to preserve
         // holes instead of truncating the copy (#2846) — mirrors unwrapStoreValue.
-                if (i) i.length = s;
-    } else if (!c) {
+                if (c) c.length = s;
+    } else if (!i) {
         // Specialized walk for the common no-overlay case (from #2756): the own
         // descriptor gives the value directly, so each property is read once with
         // no overlay membership checks.
-        const s = getKeys(e, undefined);
-        for (let c = 0, p = s.length; c < p; c++) {
-            const p = s[c];
+        // A lookup means this object belongs to an immutable store backing tree,
+        // even if that nested value has not needed its own proxy yet.
+        const s = n ? getStoreKeys(e, undefined) : getKeys(e, undefined);
+        for (let i = 0, p = s.length; i < p; i++) {
+            const p = s[i];
             const l = Object.getOwnPropertyDescriptor(e, p);
             if (l.get) continue;
             u = l.value;
             if (t && isWrappable(u)) wrap(u, o);
-            if ((f = snapshotImpl(u, t, r, n)) !== u || i) {
-                if (!i) {
-                    i = Object.create(Object.getPrototypeOf(e));
-                    Object.assign(i, e);
+            if ((f = snapshotImpl(u, t, r, n)) !== u || c) {
+                if (!c) {
+                    c = Object.create(Object.getPrototypeOf(e));
+                    Object.assign(c, e);
                 }
-                i[p] = f;
+                c[p] = f;
             }
         }
     } else {
-        const s = getKeys(e, c);
+        // An override only exists on a store record, and the target branch above
+        // always set `lookup` alongside it — so this branch is always store-keyed.
+        const s = getStoreKeys(e, i);
         for (let p = 0, l = s.length; p < l; p++) {
             let l = s[p];
-            const a = getPropertyDescriptor(e, c, l);
+            const a = getPropertyDescriptor(e, i, l);
             if (a.get) continue;
-            u = l in c ? c[l] : e[l];
+            u = l in i ? i[l] : e[l];
             if (t && isWrappable(u)) wrap(u, o);
-            if ((f = snapshotImpl(u, t, r, n)) !== e[l] || i) {
-                if (!i) {
-                    i = Object.create(Object.getPrototypeOf(e));
-                    Object.assign(i, e);
+            if ((f = snapshotImpl(u, t, r, n)) !== e[l] || c) {
+                if (!c) {
+                    c = Object.create(Object.getPrototypeOf(e));
+                    Object.assign(c, e);
                 }
-                i[l] = f;
+                c[l] = f;
             }
         }
     }
-    return i || e;
+    return c || e;
 }
 
 function snapshot(e, t, r) {
@@ -218,14 +237,14 @@ const $SOURCES = Symbol(0);
             e === s && s--;
             continue;
         }
-        const c = Object.getOwnPropertyNames(t);
-        for (let r = c.length - 1; r >= 0; r--) {
-            const i = c[r];
-            if (i === "__proto__" || i === "constructor") continue;
-            if (!n[i]) {
+        const i = Object.getOwnPropertyNames(t);
+        for (let r = i.length - 1; r >= 0; r--) {
+            const c = i[r];
+            if (c === "__proto__" || c === "constructor") continue;
+            if (!n[c]) {
                 o = o || e !== s;
-                const r = Object.getOwnPropertyDescriptor(t, i);
-                n[i] = r.get ? {
+                const r = Object.getOwnPropertyDescriptor(t, c);
+                n[c] = r.get ? {
                     enumerable: true,
                     configurable: true,
                     get: r.get.bind(t)
@@ -234,14 +253,14 @@ const $SOURCES = Symbol(0);
         }
     }
     if (!o) return r[s];
-    const c = {};
-    const i = Object.keys(n);
-    for (let e = i.length - 1; e >= 0; e--) {
-        const t = i[e], r = n[t];
-        if (r.get) Object.defineProperty(c, t, r); else c[t] = r.value;
+    const i = {};
+    const c = Object.keys(n);
+    for (let e = c.length - 1; e >= 0; e--) {
+        const t = c[e], r = n[t];
+        if (r.get) Object.defineProperty(i, t, r); else i[t] = r.value;
     }
-    c[$SOURCES] = r;
-    return c;
+    i[$SOURCES] = r;
+    return i;
 }
 
 /**