@solidjs/signals 2.0.0-beta.24 → 2.0.0-beta.26

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,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", 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);
 
@@ -52,6 +52,7 @@ function initStoreFields(e) {
     e[STORE_SNAPSHOT_PROPS] = undefined;
     e[STORE_PARENT] = undefined;
     e[STORE_DESC] = undefined;
+    e[STORE_SHALLOW] = undefined;
     e[$PROXY] = null;
 }
 
@@ -76,24 +77,107 @@ 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)) {
+        // A store proxy is already tracked elsewhere: the shallow boundary passes
+        // it through by reference (replaced, never edited — same slot semantics
+        // as a raw) instead of claiming it raw. The sticky mark is global, so
+        // marking a live proxy would make wrap() serve it verbatim through every
+        // OTHER store too — downstream deep stores then captured it instead of
+        // wrapping it in their own family, and their writes landed in the
+        // upstream store's override layer (#2932).
+        if (e[$TARGET] !== undefined) return;
+        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;
 }
 
@@ -115,24 +199,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 E = Array.isArray(i);
-    const O = E ? [] : Object.create(Object.getPrototypeOf(i));
-    t.set(e, O);
+    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 (E && e === "length") continue;
+        if (O && e === "length") continue;
         const n = e in o ? o[e] : i[e];
-        if (n !== $DELETED) O[e] = unwrapStoreValue(n, t, r);
+        if (n !== $DELETED) s[e] = unwrapStoreValue(n, t, r);
     }
-    if (E) O.length = o.length ?? i.length;
-    return O;
+    if (O) s.length = o.length ?? i.length;
+    return s;
 }
 
 function isPrototypePollutionKey(e) {
@@ -179,7 +263,7 @@ function ownEnumerableKeysPlain(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.Ee !== undefined && e.Ee !== NOT_PENDING ? unwrapOverride(e.Ee) : e.Ne !== NOT_PENDING ? e.Ne : e.Pe;
+    return e.Ae !== undefined && e.Ae !== NOT_PENDING ? unwrapOverride(e.Ae) : e._e !== NOT_PENDING ? e._e : e.Ue;
 }
 
 function hasOwnStoreProperty(e, t) {
@@ -207,10 +291,10 @@ function getNodes(e, t) {
 
 function getNode(e, t, r, n, o = isEqual, i) {
     if (t[r]) return t[r];
-    const E = signal(n, {
+    const O = signal(n, {
         equals: o,
         unobserved() {
-            if (t[r] === E) {
+            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
@@ -230,28 +314,28 @@ function getNode(e, t, r, n, o = isEqual, i) {
         }
     }, e[STORE_FIREWALL]);
     if (e[STORE_OPTIMISTIC]) {
-        E.Ee = NOT_PENDING;
+        O.Ae = NOT_PENDING;
     }
     if (i && r in i) {
         const e = i[r];
-        E.Ve = e === undefined ? NO_SNAPSHOT : e;
-        snapshotSources?.add(E);
+        O.xe = 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(E, 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 O = e;
-    while (O && !O[STORE_DESC]) {
-        O[STORE_DESC] = true;
-        O = O[STORE_PARENT];
+        let s = e;
+    while (s && !s[STORE_DESC]) {
+        s[STORE_DESC] = true;
+        s = s[STORE_PARENT];
     }
-    return t[r] = E;
+    return t[r] = O;
 }
 
 /**
@@ -287,43 +371,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 E = i ? i[STORE_VALUE] : e;
-    if (o.has(E)) return;
-    o.add(E);
-    t.scope.add(E);
-    let O;
+    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);
-        O = 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(E)) {
-        const e = O?.length ?? E.length;
+    if (Array.isArray(O)) {
+        const e = s?.length ?? O.length;
         for (let i = 0; i < e; i++) {
-            const e = O && i in O ? O[i] : E[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 s = i || n ? getStoreSymbols(E, O) : [];
-        for (let e = 0, i = s.length; e < i; e++) {
-            const i = s[e];
-            const S = getPropertyDescriptor(E, O, i);
+                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(E, O) : getKeys(E, O);
-        for (let i = 0, s = e.length; i < s; i++) {
-            const s = getPropertyDescriptor(E, O, e[i]);
-            if (!s || s.get) continue;
-            walkAffectsScope(s.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);
         }
     }
 }
@@ -352,11 +436,11 @@ o) {
     // 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);
+    if (r?.t) GlobalQueue.Dt(r);
     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);
+            if (e !== r && e.t && o.scope.has(n) && (o.key === undefined || o.key === t)) GlobalQueue.Dt(e);
         }
     }
 }
@@ -498,8 +582,8 @@ function getPropertyDescriptor(e, t, r) {
 function prepareStoreWrite(e, t, r) {
     if (e[STORE_OPTIMISTIC]) {
         const t = e[STORE_FIREWALL];
-        if (t?.Ue) {
-            globalQueue.initTransition(t.Ue);
+        if (t?.Ie) {
+            globalQueue.initTransition(t.Ie);
         }
     }
     const n = e[STORE_VALUE];
@@ -514,10 +598,10 @@ function prepareStoreWrite(e, t, r) {
         }
     }
     const i = e[STORE_OPTIMISTIC] && !projectionWriteActive;
-    const E = i ? STORE_OPTIMISTIC_OVERRIDE : STORE_OVERRIDE;
+    const O = i ? STORE_OPTIMISTIC_OVERRIDE : STORE_OVERRIDE;
     return {
         base: o,
-        overrideKey: E,
+        overrideKey: O,
         state: n
     };
 }
@@ -551,29 +635,29 @@ 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 E = getNode(e, t, r, i, isEqual, o);
-    registerTransientStoreNode(E);
-    return E;
+    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 E = projectionWriteActive || e[STORE_OPTIMISTIC];
-    const O = r !== "delete";
-    const s = e[STORE_HAS]?.[t];
-    if (s) {
-        setSignal(s, O);
-    } else if (!E && r !== "invalidate" && i !== O) {
+    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, O);
+        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 (!E) {
+        } else if (!O) {
             const r = upsertStoreNode(e, S, t, o, e[STORE_SNAPSHOT_PROPS]);
             setSignal(r, () => isWrappable(n) ? wrap(n, e) : n);
         }
@@ -585,7 +669,7 @@ function notifyStoreProperty(e, t, r, n, o, i) {
     } else {
         if (S[t]) {
             setSignal(S[t], undefined);
-        } else if (!E) {
+        } else if (!O) {
             const r = upsertStoreNode(e, S, t, o, e[STORE_SNAPSHOT_PROPS]);
             setSignal(r, undefined);
         }
@@ -628,55 +712,79 @@ const storeTraps = {
             const r = e[STORE_NODE];
             const n = r && r[t];
             if (n !== undefined && e[STORE_VALUE][$TARGET] === undefined) {
-                let t = read(n);
+                // 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 E = e[STORE_VALUE];
-        if (!i && !e[STORE_OVERRIDE] && !e[STORE_OPTIMISTIC_OVERRIDE] && !e[STORE_CUSTOM_PROTO] && !e[STORE_OPTIMISTIC] && !e[STORE_SNAPSHOT_PROPS] && !E[$TARGET] && !(t in E) && 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 O = getOverlayLayer(e, t);
-        const s = !!O;
+        const s = getOverlayLayer(e, t);
+        const E = !!s;
         const S = !!e[STORE_VALUE][$TARGET];
-        const c = O ?? e[STORE_VALUE];
+        const f = s ?? e[STORE_VALUE];
         if (!i) {
-            const n = Object.getOwnPropertyDescriptor(c, t);
+            const n = Object.getOwnPropertyDescriptor(f, t);
             if (n && n.get) return n.get.call(r);
-            if (!n && !s && e[STORE_CUSTOM_PROTO]) {
-                const e = unwrapStoreValue(c);
+            if (!n && !E && e[STORE_CUSTOM_PROTO]) {
+                const e = unwrapStoreValue(f);
                 if (hasInheritedAccessor(e, t)) {
-                    return Reflect.get(c, t, r);
+                    return Reflect.get(f, t, r);
                 }
             }
         }
         if (writeOnly(r)) {
             if (isPrototypePollutionKey(t) && !hasOwnStoreProperty(e, t)) return undefined;
-            let r = i && (s || !S) ? visibleNodeValue(i) : c[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 T = i ? s || !S ? read(o[t]) : (read(o[t]), c[t]) : c[t];
-        T === $DELETED && (T = undefined);
+        let R = i ? E || !S ? read(o[t]) : (read(o[t]), f[t]) : f[t];
+        R === $DELETED && (R = undefined);
         if (!i) {
-            if (!s && typeof T === "function" && !Object.prototype.hasOwnProperty.call(c, t)) {
+            if (!E && typeof R === "function" && !Object.prototype.hasOwnProperty.call(f, t)) {
                 let t;
-                return !Array.isArray(e[STORE_VALUE]) && (t = Object.getPrototypeOf(e[STORE_VALUE])) && t !== Object.prototype ? T.bind(c) : T;
+                return !Array.isArray(e[STORE_VALUE]) && (t = Object.getPrototypeOf(e[STORE_VALUE])) && t !== Object.prototype ? R.bind(f) : R;
             } else if (getObserver() && !n) {
-                return read(getNode(e, o, t, isWrappable(T) ? wrap(T, e) : T, isEqual, e[STORE_SNAPSHOT_PROPS]));
+                return read(getNode(e, o, t, isWrappable(R) ? wrap(R, e) : R, 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(T) ? wrap(T, e) : T;
+        // 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()) throwIfUninitialized(e);
+        return isWrappable(R) ? wrap(R, e) : R;
     },
     has(e, t) {
         if (t === $PROXY || t === $TRACK || t === "__proto__") return true;
@@ -703,55 +811,67 @@ const storeTraps = {
         const n = e[$PROXY];
         if (writeOnly(n)) {
             untrack(() => {
-                const {base: o, overrideKey: i, state: E} = prepareStoreWrite(e, n, t);
-                const O = getOverlayLayer(e, t);
-                const s = O ? O[t] : o;
-                const S = O ? O[t] !== $DELETED : t in e[STORE_VALUE];
-                const c = 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];
+                // Shallow slots hold store proxies verbatim (pass-through reference,
+                // never raw-marked — see markRawOne/#2932); everything else unwraps
+                // and marks as usual.
+                                const f = !!e[STORE_SHALLOW] && r?.[$TARGET] !== undefined;
+                const R = f ? r : unwrapStoreValue(r);
+                if (e[STORE_SHALLOW] && !f && isWrappable(R)) {
+                    // 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(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 T = typeof t === "string" ? Number(t) : -1;
-                const R = Array.isArray(E) && Number.isInteger(T) && T >= 0 && T < 4294967295 && String(T) === t;
-                const f = R ? T + 1 : 0;
-                const u = R && (getOverlayLayer(e, "length") ?? E).length;
-                const l = R && f > u ? f : undefined;
-                if (s === c && l === undefined) return true;
+                                const c = typeof t === "string" ? Number(t) : -1;
+                const T = Array.isArray(O) && Number.isInteger(c) && c >= 0 && c < 4294967295 && String(c) === t;
+                const u = T ? c + 1 : 0;
+                const a = T && (getOverlayLayer(e, "length") ?? O).length;
+                const l = T && u > a ? u : undefined;
+                if (E === R && l === undefined) return true;
                 armOptimisticStoreWrite(e, n);
-                if (c !== undefined && c === o && l === undefined) {
+                if (R !== undefined && R === 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;
+                    r[t] = R;
                     stampOptimisticOwner(e, i, t);
                     if (l !== undefined) {
                         r.length = l;
                         stampOptimisticOwner(e, i, "length");
                     }
                 }
-                notifyStoreProperty(e, t, "set", c, s, S);
+                notifyStoreProperty(e, t, "set", R, 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(E) && t === "length" && typeof c === "number" && typeof s === "number" && c < s) {
+                                if (Array.isArray(O) && t === "length" && typeof R === "number" && typeof E === "number" && R < E) {
                     const t = e[i] || (e[i] = Object.create(null));
-                    for (let r = c; r < s; r++) {
+                    for (let r = R; r < E; r++) {
                         if (t[r] === $DELETED) continue;
-                        const n = r in t ? t[r] : E[r];
-                        if (!(r in t) && !(r in E)) 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(E) && t !== "length" && l !== undefined) {
+                                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", u, e[STORE_SNAPSHOT_PROPS]);
+                        const r = upsertStoreNode(e, t, "length", a, e[STORE_SNAPSHOT_PROPS]);
                         setSignal(r, l);
                     }
                 }
@@ -767,11 +887,11 @@ const storeTraps = {
             untrack(() => {
                 const {base: o, overrideKey: i} = prepareStoreWrite(e, n, t);
                 armOptimisticStoreWrite(e, n);
-                const E = "value" in r ? {
+                const O = "value" in r ? {
                     ...r,
                     value: unwrapStoreValue(r.value)
                 } : r;
-                Object.defineProperty(e[i] || (e[i] = Object.create(null)), t, E);
+                Object.defineProperty(e[i] || (e[i] = Object.create(null)), t, O);
                 stampOptimisticOwner(e, i, t);
                 notifyStoreProperty(e, t, "invalidate");
                 if (false) ;
@@ -899,7 +1019,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]);
@@ -907,4 +1027,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 };