@solidjs/signals 2.0.0-beta.23 → 2.0.0-beta.25

package/dist/prod/store/store.js

@@ -1,6 +1,6 @@
 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 { suppressComputedRecompute, isEqual, signal, pendingCheckActive, untrack, setSignal, read, readNodeFast, READ_SLOW, snapshotCaptureActive, snapshotSources } from "../core/core.js";
 
 import { DEV } from "../core/dev.js";
 
@@ -28,19 +28,45 @@ 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", STORE_OPTIMISTIC_OWNERS = "t", STORE_PARENT = "u", STORE_DESC = "d";
+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.v = e;
+        n[STORE_VALUE] = e;
+        initStoreFields(n);
     } else {
         n = {
-            v: e
+            [STORE_VALUE]: e
         };
+        initStoreFields(n);
         const t = e?.[$TARGET]?.[STORE_VALUE] ?? e;
         const r = Object.getPrototypeOf(t);
         if (r !== null && r !== Object.prototype) {
@@ -51,24 +77,99 @@ function createStoreProxy(e, t = storeTraps, r) {
     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;
 
+function lookupTarget(e, t) {
+    if (t !== undefined && t !== storeLookup) {
+        const r = t.get(e);
+        if (r !== undefined) return r[$TARGET];
+    }
+    return storeLookup.get(e);
+}
+
+// Values marked raw never acquire a proxy identity: wrap() serves them as-is
+// everywhere — deep stores hold them as leaf values replaced by reference.
+// Once raw, always raw (identity stays single, just unwrapped). Consulted
+// only on wrap-creation and ingest paths; reads never touch it.
+const rawValues = new WeakSet;
+
+/**
+ * Marks a value as raw: no store will ever wrap it — every store presents it
+ * as-is, tracked by reference at whatever slot holds it and updated by
+ * replacement. Useful for class instances and external objects (editors,
+ * scene graphs, Maps) and for record-shaped data updated wholesale. Sticky
+ * for the value's lifetime.
+ */
+// Flipped on the first mark and exported as a LIVE binding: reconcile
+// consults it on every recursable pair, and importing the boolean directly
+// lets those sites skip even the function call when no shallow store or raw
+// mark exists anywhere in the app.
+let rawValuesUsed = false;
+
+function isRawValue(e) {
+    return rawValuesUsed && rawValues.has(e);
+}
+
+function markRawOne(e) {
+    if (isWrappable(e)) {
+        rawValuesUsed = true;
+        rawValues.add(e);
+    }
+}
+
+function markRawIngest(e) {
+    if (Array.isArray(e)) {
+        for (let t = 0, r = e.length; t < r; 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;
     }
-    let r = e[$PROXY] || storeLookup.get(e);
-    if (!r) {
-        storeLookup.set(e, r = createStoreProxy(e));
-        if (t) r[$TARGET][STORE_PARENT] = t;
+    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;
 }
 
@@ -90,24 +191,24 @@ function writeOnly(e) {
 }
 
 function unwrapStoreValue(e, t, r) {
-    const n = e?.[$TARGET] || r?.get(e)?.[$TARGET];
+    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 s = Array.isArray(i);
-    const E = s ? [] : Object.create(Object.getPrototypeOf(i));
-    t.set(e, E);
+    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 (s && e === "length") continue;
+        if (O && e === "length") continue;
         const n = e in o ? o[e] : i[e];
-        if (n !== $DELETED) E[e] = unwrapStoreValue(n, t, r);
+        if (n !== $DELETED) s[e] = unwrapStoreValue(n, t, r);
     }
-    if (s) E.length = o.length ?? i.length;
-    return E;
+    if (O) s.length = o.length ?? i.length;
+    return s;
 }
 
 function isPrototypePollutionKey(e) {
@@ -182,10 +283,10 @@ function getNodes(e, t) {
 
 function getNode(e, t, r, n, o = isEqual, i) {
     if (t[r]) return t[r];
-    const s = signal(n, {
+    const O = signal(n, {
         equals: o,
         unobserved() {
-            if (t[r] === s) {
+            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
@@ -205,28 +306,28 @@ function getNode(e, t, r, n, o = isEqual, i) {
         }
     }, e[STORE_FIREWALL]);
     if (e[STORE_OPTIMISTIC]) {
-        s.Ee = NOT_PENDING;
+        O.Ee = NOT_PENDING;
     }
     if (i && r in i) {
         const e = i[r];
-        s.Ve = e === undefined ? NO_SNAPSHOT : e;
-        snapshotSources?.add(s);
+        O.Ve = 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(s, e[STORE_VALUE], r);
+        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 E = e;
-    while (E && !E[STORE_DESC]) {
-        E[STORE_DESC] = true;
-        E = E[STORE_PARENT];
+        let s = e;
+    while (s && !s[STORE_DESC]) {
+        s[STORE_DESC] = true;
+        s = s[STORE_PARENT];
     }
-    return t[r] = s;
+    return t[r] = O;
 }
 
 /**
@@ -262,43 +363,43 @@ const affectsScopes = new Map;
 // holds the root, and must still descend to pick up records added since.
 o) {
     if (!isWrappable(e)) return;
-    const i = e[$TARGET] || (n ?? storeLookup).get(e)?.[$TARGET];
-    const s = i ? i[STORE_VALUE] : e;
-    if (o.has(s)) return;
-    o.add(s);
-    t.scope.add(s);
-    let E;
+    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);
-        E = mergedOverlay(i);
+        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;
     }
-    if (Array.isArray(s)) {
-        const e = E?.length ?? s.length;
+    if (Array.isArray(O)) {
+        const e = s?.length ?? O.length;
         for (let i = 0; i < e; i++) {
-            const e = E && i in E ? E[i] : s[i];
+            const e = s && i in s ? s[i] : O[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);
+                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);
         }
     } else {
-        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;
-            walkAffectsScope(O.value, t, r, n, o);
+        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);
         }
     }
 }
@@ -489,10 +590,10 @@ function prepareStoreWrite(e, t, r) {
         }
     }
     const i = e[STORE_OPTIMISTIC] && !projectionWriteActive;
-    const s = i ? STORE_OPTIMISTIC_OVERRIDE : STORE_OVERRIDE;
+    const O = i ? STORE_OPTIMISTIC_OVERRIDE : STORE_OVERRIDE;
     return {
         base: o,
-        overrideKey: s,
+        overrideKey: O,
         state: n
     };
 }
@@ -526,42 +627,42 @@ function prepareStoreWrite(e, t, r) {
 function upsertStoreNode(e, t, r, n, o) {
     if (t[r]) return t[r];
     const i = isWrappable(n) ? wrap(n, e) : n;
-    const s = getNode(e, t, r, i, isEqual, o);
-    registerTransientStoreNode(s);
-    return s;
+    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 s = projectionWriteActive || e[STORE_OPTIMISTIC];
-    const E = r !== "delete";
-    const O = e[STORE_HAS]?.[t];
-    if (O) {
-        setSignal(O, E);
-    } else if (!s && r !== "invalidate" && i !== E) {
+    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, E);
+        setSignal(r, s);
     }
-    const c = getNodes(e, STORE_NODE);
+    const S = getNodes(e, STORE_NODE);
     if (r === "set") {
-        if (c[t]) {
-            setSignal(c[t], () => isWrappable(n) ? wrap(n, e) : n);
-        } else if (!s) {
-            const r = upsertStoreNode(e, c, t, o, e[STORE_SNAPSHOT_PROPS]);
+        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 (c[t]) {
-            setSignal(c[t], {});
-            delete c[t];
+        if (S[t]) {
+            setSignal(S[t], {});
+            delete S[t];
         }
     } else {
-        if (c[t]) {
-            setSignal(c[t], undefined);
-        } else if (!s) {
-            const r = upsertStoreNode(e, c, t, o, e[STORE_SNAPSHOT_PROPS]);
+        if (S[t]) {
+            setSignal(S[t], undefined);
+        } else if (!O) {
+            const r = upsertStoreNode(e, S, t, o, e[STORE_SNAPSHOT_PROPS]);
             setSignal(r, undefined);
         }
     }
@@ -593,50 +694,82 @@ const storeTraps = {
             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 s = e[STORE_VALUE];
-        if (!i && !e[STORE_OVERRIDE] && !e[STORE_OPTIMISTIC_OVERRIDE] && !e[STORE_CUSTOM_PROTO] && !e[STORE_OPTIMISTIC] && !e[STORE_SNAPSHOT_PROPS] && !s[$TARGET] && !(t in s) && getObserver() && !n && !writeOnly(r)) {
+        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 E = getOverlayLayer(e, t);
-        const O = !!E;
-        const c = !!e[STORE_VALUE][$TARGET];
-        const S = E ?? e[STORE_VALUE];
+        const s = getOverlayLayer(e, t);
+        const E = !!s;
+        const S = !!e[STORE_VALUE][$TARGET];
+        const f = s ?? e[STORE_VALUE];
         if (!i) {
-            const n = Object.getOwnPropertyDescriptor(S, t);
+            const n = Object.getOwnPropertyDescriptor(f, t);
             if (n && n.get) return n.get.call(r);
-            if (!n && !O && e[STORE_CUSTOM_PROTO]) {
-                const e = unwrapStoreValue(S);
+            if (!n && !E && e[STORE_CUSTOM_PROTO]) {
+                const e = unwrapStoreValue(f);
                 if (hasInheritedAccessor(e, t)) {
-                    return Reflect.get(S, t, r);
+                    return Reflect.get(f, t, r);
                 }
             }
         }
         if (writeOnly(r)) {
             if (isPrototypePollutionKey(t) && !hasOwnStoreProperty(e, t)) return undefined;
-            let r = i && (O || !c) ? visibleNodeValue(i) : S[t];
+            let r = i && (E || !S) ? visibleNodeValue(i) : f[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 f = i ? O || !c ? read(o[t]) : (read(o[t]), S[t]) : S[t];
-        f === $DELETED && (f = undefined);
+        let c = i ? E || !S ? read(o[t]) : (read(o[t]), f[t]) : f[t];
+        c === $DELETED && (c = undefined);
         if (!i) {
-            if (!O && typeof f === "function" && !Object.prototype.hasOwnProperty.call(S, t)) {
+            if (!E && typeof c === "function" && !Object.prototype.hasOwnProperty.call(f, t)) {
                 let t;
-                return !Array.isArray(e[STORE_VALUE]) && (t = Object.getPrototypeOf(e[STORE_VALUE])) && t !== Object.prototype ? f.bind(S) : f;
+                return !Array.isArray(e[STORE_VALUE]) && (t = Object.getPrototypeOf(e[STORE_VALUE])) && t !== Object.prototype ? c.bind(f) : c;
             } else if (getObserver() && !n) {
-                return read(getNode(e, o, t, isWrappable(f) ? wrap(f, e) : f, isEqual, e[STORE_SNAPSHOT_PROPS]));
+                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).
                 if (!n) throwIfUninitialized(e);
-        return isWrappable(f) ? wrap(f, e) : f;
+        return isWrappable(c) ? wrap(c, e) : c;
     },
     has(e, t) {
         if (t === $PROXY || t === $TRACK || t === "__proto__") return true;
@@ -663,56 +796,57 @@ const storeTraps = {
         const n = e[$PROXY];
         if (writeOnly(n)) {
             untrack(() => {
-                const {base: o, overrideKey: i, state: s} = prepareStoreWrite(e, n, t);
-                const E = getOverlayLayer(e, t);
-                const O = E ? E[t] : o;
-                const c = E ? E[t] !== $DELETED : t in e[STORE_VALUE];
-                const S = unwrapStoreValue(r);
+                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];
+                const f = unwrapStoreValue(r);
+                if (e[STORE_SHALLOW] && isWrappable(f)) rawValues.add(f);
                 // 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 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;
+                                const c = typeof t === "string" ? Number(t) : -1;
+                const R = Array.isArray(O) && Number.isInteger(c) && c >= 0 && c < 4294967295 && String(c) === t;
+                const T = R ? c + 1 : 0;
+                const u = R && (getOverlayLayer(e, "length") ?? O).length;
+                const a = R && T > u ? T : undefined;
+                if (E === f && a === undefined) return true;
                 armOptimisticStoreWrite(e, n);
-                if (S !== undefined && S === o && l === undefined) {
+                if (f !== undefined && f === o && a === 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] = S;
+                    r[t] = f;
                     stampOptimisticOwner(e, i, t);
-                    if (l !== undefined) {
-                        r.length = l;
+                    if (a !== undefined) {
+                        r.length = a;
                         stampOptimisticOwner(e, i, "length");
                     }
                 }
-                notifyStoreProperty(e, t, "set", S, O, c);
+                notifyStoreProperty(e, t, "set", f, 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(s) && t === "length" && typeof S === "number" && typeof O === "number" && S < O) {
+                                if (Array.isArray(O) && t === "length" && typeof f === "number" && typeof E === "number" && f < E) {
                     const t = e[i] || (e[i] = Object.create(null));
-                    for (let r = S; r < O; r++) {
+                    for (let r = f; r < E; r++) {
                         if (t[r] === $DELETED) continue;
-                        const n = r in t ? t[r] : s[r];
-                        if (!(r in t) && !(r in s)) 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(s) && t !== "length" && l !== undefined) {
+                                if (Array.isArray(O) && t !== "length" && a !== undefined) {
                     const t = getNodes(e, STORE_NODE);
                     if (t.length) {
-                        setSignal(t.length, l);
+                        setSignal(t.length, a);
                     } else if (!projectionWriteActive && !e[STORE_OPTIMISTIC]) {
                         const r = upsertStoreNode(e, t, "length", u, e[STORE_SNAPSHOT_PROPS]);
-                        setSignal(r, l);
+                        setSignal(r, a);
                     }
                 }
                 if (false) ;
@@ -727,11 +861,11 @@ const storeTraps = {
             untrack(() => {
                 const {base: o, overrideKey: i} = prepareStoreWrite(e, n, t);
                 armOptimisticStoreWrite(e, n);
-                const s = "value" in r ? {
+                const O = "value" in r ? {
                     ...r,
                     value: unwrapStoreValue(r.value)
                 } : r;
-                Object.defineProperty(e[i] || (e[i] = Object.create(null)), t, s);
+                Object.defineProperty(e[i] || (e[i] = Object.create(null)), t, O);
                 stampOptimisticOwner(e, i, t);
                 notifyStoreProperty(e, t, "invalidate");
                 if (false) ;
@@ -859,7 +993,7 @@ function storeSetter(e, t) {
 }
 
 function createStore(e, t, r) {
-    const n = typeof e === "function", o = n ? createProjectionInternal(e, t, r).store : wrap(e);
+    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]);
@@ -867,4 +1001,4 @@ function createStore(e, t, r) {
     } : e => storeSetter(o, e) ];
 }
 
-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 };
+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 };