@solidjs/signals 2.0.0-beta.24 → 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,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,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;
 }
 
@@ -115,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 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) {
@@ -207,10 +283,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 +306,28 @@ function getNode(e, t, r, n, o = isEqual, i) {
         }
     }, e[STORE_FIREWALL]);
     if (e[STORE_OPTIMISTIC]) {
-        E.Ee = NOT_PENDING;
+        O.Ee = NOT_PENDING;
     }
     if (i && r in i) {
         const e = i[r];
-        E.Ve = e === undefined ? NO_SNAPSHOT : e;
-        snapshotSources?.add(E);
+        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(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 +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 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);
         }
     }
 }
@@ -514,10 +590,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 +627,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 +661,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 +704,72 @@ 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 c = i ? E || !S ? read(o[t]) : (read(o[t]), f[t]) : f[t];
+        c === $DELETED && (c = undefined);
         if (!i) {
-            if (!s && typeof T === "function" && !Object.prototype.hasOwnProperty.call(c, 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 ? T.bind(c) : T;
+                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(T) ? wrap(T, e) : T, 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(T) ? wrap(T, e) : T;
+        return isWrappable(c) ? wrap(c, e) : c;
     },
     has(e, t) {
         if (t === $PROXY || t === $TRACK || t === "__proto__") return true;
@@ -703,56 +796,57 @@ 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];
+                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 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 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 (c !== undefined && c === 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] = c;
+                    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", c, s, S);
+                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(E) && t === "length" && typeof c === "number" && typeof s === "number" && c < s) {
+                                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 = c; r < s; r++) {
+                    for (let r = f; 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" && 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) ;
@@ -767,11 +861,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 +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]);
@@ -907,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 };

package/dist/prod/store/utils.js

@@ -12,14 +12,14 @@ import "../core/effect.js";
 
 import { createMemo } from "../signals.js";
 
-import { ownEnumerableKeys, $PROXY, isWrappable, $TARGET, trackSelf, witnessAffectsMark, mergedOverlay, STORE_VALUE, storeLookup, STORE_LOOKUP, $DELETED, wrap, getStoreSymbols, getPropertyDescriptor, getStoreKeys, getKeys, $TRACK } from "./store.js";
+import { ownEnumerableKeys, $PROXY, isWrappable, $TARGET, lookupTarget, trackSelf, witnessAffectsMark, mergedOverlay, STORE_VALUE, storeLookup, STORE_LOOKUP, $DELETED, wrap, getStoreSymbols, getPropertyDescriptor, getStoreKeys, getKeys, $TRACK, rawValuesUsed, isRawValue } from "./store.js";
 
 function snapshotImpl(e, t, r, n) {
     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;
-    if (o = e[$TARGET] || n?.get(e)?.[$TARGET]) {
+    if (o = e[$TARGET] || lookupTarget(e, n)) {
         if (t) {
             trackSelf(o, $TRACK);
             // A tracked walk reads THROUGH the record without touching the proxy
@@ -49,24 +49,24 @@ function snapshotImpl(e, t, r, n) {
     }
     if (s) {
         const s = i?.length ?? e.length;
-        for (let p = 0; p < s; p++) {
-            u = i && p in i ? i[p] : e[p];
+        for (let a = 0; a < s; a++) {
+            u = i && a in i ? i[a] : e[a];
             if (u === $DELETED) continue;
-            if (t && isWrappable(u)) wrap(u, o);
+            if (t && isWrappable(u) && !(rawValuesUsed && isRawValue(u))) wrap(u, o);
             if ((f = snapshotImpl(u, t, r, n)) !== u || c) {
                 if (!c) r.set(e, c = [ ...e ]);
-                c[p] = f;
+                c[a] = 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;
+                const a = n ? getStoreSymbols(e, i) : [];
+        for (let s = 0, l = a.length; s < l; s++) {
+            const l = a[s];
+            const p = getPropertyDescriptor(e, i, l);
+            if (!p || p.get) continue;
             u = i && l in i ? i[l] : e[l];
-            if (t && isWrappable(u)) wrap(u, o);
+            if (t && isWrappable(u) && !(rawValuesUsed && isRawValue(u))) wrap(u, o);
             f = snapshotImpl(u, t, r, n);
             if (f !== u || c) {
                 if (!c) r.set(e, c = Object.assign([ ...e ], e));
@@ -83,30 +83,30 @@ function snapshotImpl(e, t, r, n) {
         // 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);
+        for (let i = 0, a = s.length; i < a; i++) {
+            const a = s[i];
+            const l = Object.getOwnPropertyDescriptor(e, a);
             if (l.get) continue;
             u = l.value;
-            if (t && isWrappable(u)) wrap(u, o);
+            if (t && isWrappable(u) && !(rawValuesUsed && isRawValue(u))) wrap(u, o);
             if ((f = snapshotImpl(u, t, r, n)) !== u || c) {
                 if (!c) {
                     c = Object.create(Object.getPrototypeOf(e));
                     Object.assign(c, e);
                 }
-                c[p] = f;
+                c[a] = f;
             }
         }
     } else {
         // 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, i, l);
-            if (a.get) continue;
+        for (let a = 0, l = s.length; a < l; a++) {
+            let l = s[a];
+            const p = getPropertyDescriptor(e, i, l);
+            if (p.get) continue;
             u = l in i ? i[l] : e[l];
-            if (t && isWrappable(u)) wrap(u, o);
+            if (t && isWrappable(u) && !(rawValuesUsed && isRawValue(u))) wrap(u, o);
             if ((f = snapshotImpl(u, t, r, n)) !== e[l] || c) {
                 if (!c) {
                     c = Object.create(Object.getPrototypeOf(e));

package/dist/types/core/core.d.ts

@@ -72,6 +72,21 @@ export declare function untrack<T>(fn: () => T, strictReadLabel?: string | false
  * date so its status flags reflect the current graph.
  */
 export declare function prepareComputed(comp: Computed<unknown>, refresh: boolean): void;
+/**
+ * Sentinel returned by readNodeFast when the plain-signal fast path does not
+ * apply and the caller must fall back to the full read().
+ */
+export declare const READ_SLOW: unique symbol;
+/**
+ * read()'s plain-signal fast path as a standalone entry for hot callers
+ * (store traps). Safe to substitute for read() only because the bail
+ * conditions mirror read()'s prelude and fast-path guard exactly: the
+ * latestRead and pendingCheck windows run side-effectful hooks before the
+ * fast path, `_fn` nodes need prepareComputed, and firewall / override /
+ * snapshot / transition / lane / dev-strictRead state all take the full
+ * resolution. Anything slow returns READ_SLOW; the caller then calls read().
+ */
+export declare function readNodeFast<T>(el: Signal<T>): T | typeof READ_SLOW;
 export declare function read<T>(el: Signal<T> | Computed<T>): T;
 export declare function setSignal<T>(el: Signal<T> | Computed<T>, v: T | ((prev: T) => T)): T;
 /**